// This method returns the StatFunction properties as defined by the "parent"
// DataGridCollectionView as well as the other "standard" properties for this class.
// The StatFunction properties are NOT filtered by the specified attributes.
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
{
if (attributes == null)
{
// We only cache the full property list.
if (m_classProperties == null)
{
DataGridCollectionView view = this.GetCollectionView();
Debug.Assert(view != null, "A group should always have a parent CollectionView for the StatFunctions to work.");
if (view == null)
{
return(TypeDescriptor.GetProperties(typeof(DataGridCollectionViewGroup)));
}
PropertyDescriptorCollection classProperties = TypeDescriptor.GetProperties(typeof(DataGridCollectionViewGroup));
PropertyDescriptor[] properties = new PropertyDescriptor[classProperties.Count];
classProperties.CopyTo(properties, 0);
m_classProperties = new PropertyDescriptorCollection(properties);
}
return(m_classProperties);
}
else
{
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(this, attributes);
DataGridCollectionView view = this.GetCollectionView();
return(props);
}
}
internal SourceItemCollection( DataGridCollectionView parentCollectionView )
{
if( parentCollectionView == null )
throw new ArgumentNullException( "parentCollectionView" );
m_parentCollectionView = parentCollectionView;
}
private void LoadCollectionView()
{
var vm = (WordListsViewModel) DataContext;
WordListsGrid.CurrentColumn = null;
WordListsGrid.CurrentItem = null;
WordListsGrid.Columns.Clear();
var view = new DataGridCollectionView(vm.Varieties, typeof(WordListsVarietyViewModel), false, false);
view.ItemProperties.Add(new DataGridItemProperty("Variety", ".", typeof(WordListsVarietyViewModel)));
IComparer sortComparer = ProjectionComparer<WordListsVarietyMeaningViewModel>.Create(meaning => meaning.StrRep);
for (int i = 0; i < vm.Meanings.Count; i++)
view.ItemProperties.Add(new DataGridItemProperty("Meaning" + i, string.Format("Meanings[{0}]", i), typeof(WordListsVarietyMeaningViewModel)) {SortComparer = sortComparer});
vm.VarietiesView = view;
WordListsGrid.Items.SortDescriptions.Clear();
var headerColumn = new Column {FieldName = "Variety"};
DataGridControlBehaviors.SetIsRowHeader(headerColumn, true);
DataGridControlBehaviors.SetAutoSize(headerColumn, true);
DataGridControlBehaviors.SetAutoSizePadding(headerColumn, 18);
WordListsGrid.Columns.Add(headerColumn);
for (int i = 0; i < vm.Meanings.Count; i++)
{
var column = new Column {FieldName = "Meaning" + i, Width = 100, CellEditor = WordListsGrid.DefaultCellEditors[typeof(WordListsVarietyMeaningViewModel)]};
var titleBinding = new Binding(string.Format("DataGridControl.DataContext.Meanings[{0}].Gloss", i)) {RelativeSource = RelativeSource.Self};
BindingOperations.SetBinding(column, ColumnBase.TitleProperty, titleBinding);
WordListsGrid.Columns.Add(column);
}
}
private void LoadCollectionView()
{
var vm = (SimilarityMatrixViewModel)DataContext;
SimMatrixGrid.Columns.Clear();
var view = new DataGridCollectionView(vm.Varieties, typeof(SimilarityMatrixVarietyViewModel), false, false);
view.ItemProperties.Add(new DataGridItemProperty("Variety", ".", typeof(SimilarityMatrixVarietyViewModel)));
for (int i = 0; i < vm.Varieties.Count; i++)
{
view.ItemProperties.Add(new DataGridItemProperty("Variety" + i, string.Format("VarietyPairs[{0}]", i), typeof(SimilarityMatrixVarietyPairViewModel)));
}
SimMatrixGrid.ItemsSource = view;
var headerColumn = new Column {
FieldName = "Variety", Title = ""
};
DataGridControlBehaviors.SetIsRowHeader(headerColumn, true);
DataGridControlBehaviors.SetAutoSize(headerColumn, true);
DataGridControlBehaviors.SetAutoSizePadding(headerColumn, 18);
SimMatrixGrid.Columns.Add(headerColumn);
for (int i = 0; i < vm.Varieties.Count; i++)
{
var column = new Column {
FieldName = "Variety" + i, Width = 30
};
var titleBinding = new Binding(string.Format("DataGridControl.DataContext.Varieties[{0}].Name", i))
{
RelativeSource = RelativeSource.Self
};
BindingOperations.SetBinding(column, ColumnBase.TitleProperty, titleBinding);
SimMatrixGrid.Columns.Add(column);
}
}
private void LoadCollectionView()
{
var vm = (SegmentMappingsChartViewModel) DataContext;
SegmentsDataGrid.CurrentColumn = null;
SegmentsDataGrid.Columns.Clear();
var view = new DataGridCollectionView(vm.Segments.Reverse(), typeof (SegmentMappingsChartSegmentViewModel), false, false);
view.ItemProperties.Add(new DataGridItemProperty("Segment", ".", typeof(SegmentMappingsChartSegmentViewModel)));
for (int i = 0; i < vm.Segments.Count; i++)
view.ItemProperties.Add(new DataGridItemProperty(vm.Segments[i].StrRep, string.Format("SegmentPairs[{0}]", i), typeof(SegmentMappingsChartSegmentPairViewModel)));
SegmentsDataGrid.ItemsSource = view;
var headerColumn = new Column {FieldName = "Segment"};
DataGridControlBehaviors.SetIsRowHeader(headerColumn, true);
headerColumn.Width = 30;
headerColumn.CellVerticalContentAlignment = VerticalAlignment.Center;
headerColumn.CellHorizontalContentAlignment = HorizontalAlignment.Center;
SegmentsDataGrid.Columns.Add(headerColumn);
foreach (SegmentMappingsChartSegmentViewModel segment in vm.Segments)
{
SegmentsDataGrid.Columns.Add(new Column
{
FieldName = segment.StrRep,
Title = segment.StrRep,
Width = 30,
AllowSort = false,
CellHorizontalContentAlignment = HorizontalAlignment.Center,
CellVerticalContentAlignment = VerticalAlignment.Center,
CellContentTemplate = (DataTemplate) SegmentsDataGrid.Resources["SegmentPairTemplate"],
CellEditor = SegmentsDataGrid.DefaultCellEditors[typeof(SegmentMappingsChartSegmentPairViewModel)]
});
}
}
private void LoadCollectionView()
{
var vm = (SegmentsViewModel)DataContext;
SegmentsDataGrid.CurrentColumn = null;
SegmentsDataGrid.Columns.Clear();
var view = new DataGridCollectionView(vm.Varieties, typeof(SegmentsVarietyViewModel), false, false);
view.ItemProperties.Add(new DataGridItemProperty("Variety", ".", typeof(SegmentsVarietyViewModel)));
for (int i = 0; i < vm.Segments.Count; i++)
{
view.ItemProperties.Add(new DataGridItemProperty(vm.Segments[i].StrRep, string.Format("Segments[{0}].Frequency", i), typeof(int)));
}
SegmentsDataGrid.ItemsSource = view;
SegmentsDataGrid.Items.SortDescriptions.Clear();
var headerColumn = new Column {
FieldName = "Variety"
};
DataGridControlBehaviors.SetIsRowHeader(headerColumn, true);
DataGridControlBehaviors.SetAutoSize(headerColumn, true);
DataGridControlBehaviors.SetAutoSizePadding(headerColumn, 18);
SegmentsDataGrid.Columns.Add(headerColumn);
foreach (SegmentViewModel segment in vm.Segments)
{
SegmentsDataGrid.Columns.Add(new Column {
FieldName = segment.StrRep, Title = segment.StrRep, Width = 67, CellHorizontalContentAlignment = HorizontalAlignment.Center
});
}
}
private void InitializeComponent()
{
AvaloniaXamlLoader.Load(this);
grid = this.FindControl <Grid>("Grid");
testItems = new List <TestItem>();
for (int i = 0; i < 2; i++)
{
testItems.Add(new TestItem());
}
collectionView = new DataGridCollectionView(testItems);
dataGrid = new DataGrid()
{
//HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Stretch,
//VerticalAlignment = Avalonia.Layout.VerticalAlignment.Stretch,
Background = new SolidColorBrush(Colors.White),
RowBackground = new SolidColorBrush(Colors.White),
AlternatingRowBackground = new SolidColorBrush(Colors.White),
Items = collectionView,
AutoGenerateColumns = true,
};
//TestsStackPanel(); // resizes correctly
TestGrid(); // doesn't resize correctly
this.Tapped += MainWindow_Tapped;
}
public void updateDesign()
{
tableSelect.ItemsSource = _controller.Tables;
tableSelect.SelectedItem = _controller.Tables[0];
DataGridCollectionView dcg = new DataGridCollectionView(_controller.ResearchDesignOutput.Tables[0].DefaultView);
DesignTable.ItemsSource = dcg;
}
public DataGridCollectionViewEnumerator(DataGridCollectionView collectionView)
{
m_collectionView = collectionView;
m_version = m_collectionView.SortedItemVersion;
this.Reset();
}
public DataGridCollectionViewEnumerator( DataGridCollectionView collectionView )
{
m_collectionView = collectionView;
m_version = m_collectionView.SortedItemVersion;
this.Reset();
}
public GeneratorNode CreateItemsGeneratorNode(
IList collection,
GeneratorNode parent,
GeneratorNode previous,
GeneratorNode next)
{
Debug.Assert(collection != null, "collection cannot be null for CreateItemsGeneratorNode()");
INotifyCollectionChanged notifyCollection = collection as INotifyCollectionChanged;
Debug.Assert(notifyCollection != null, "collection must be a INotifyCollectionChanged for CreateItemsGeneratorNode()");
ItemCollection itemCollection = collection as ItemCollection;
if (itemCollection != null)
{
DataGridCollectionView dgcv = itemCollection.SourceCollection as DataGridCollectionView;
if (dgcv != null)
{
collection = dgcv;
}
}
ItemsGeneratorNode node = new ItemsGeneratorNode(collection, parent);
this.SetupCollectionGeneratorNode(node, parent, previous, next);
node.AdjustLeafCount(node.Items.Count);
return(node);
}
public ControlDetailsViewModel(IVisual control, string propertyFilter)
{
_control = control;
var properties = GetAvaloniaProperties(control)
.Concat(GetClrProperties(control))
.OrderBy(x => x, PropertyComparer.Instance)
.ThenBy(x => x.Name)
.ToList();
_propertyIndex = properties.GroupBy(x => x.Key).ToDictionary(x => x.Key, x => x.ToList());
_propertyFilter = propertyFilter;
var view = new DataGridCollectionView(properties);
view.GroupDescriptions.Add(new DataGridPathGroupDescription(nameof(AvaloniaPropertyViewModel.Group)));
view.Filter = FilterProperty;
PropertiesView = view;
if (control is INotifyPropertyChanged inpc)
{
inpc.PropertyChanged += ControlPropertyChanged;
}
if (control is AvaloniaObject ao)
{
ao.PropertyChanged += ControlPropertyChanged;
}
}
internal bool Contains(object item)
{
var group = item as DataGridCollectionViewGroup;
if (group != null)
{
//Must make sure the group the group is ref equals, because there can be groups with a null name at more than one level.
DataGridCollectionViewGroup foundGroup;
if (m_subGroups.TryGetValue(DataGridCollectionViewGroup.GetHashKeyFromName(group.Name), out foundGroup))
{
return(foundGroup == group);
}
return(false);
}
DataGridCollectionView collectionView = this.GetCollectionView();
if (collectionView != null)
{
RawItem rawItem = collectionView.GetFirstRawItemFromDataItem(item);
if (rawItem != null)
{
return(rawItem.ParentGroup == this);
}
}
return(false);
}
public void init3D()
{
try
{
string path = checkOrCreateDirectory();
DataTable dt = new DataTable();
dt.Columns.Add("Image", typeof(BitmapImage));
foreach (string f in Directory.GetFiles(path))
{
if (isItImage(f))
{
dt.Rows.Add(new BitmapImage(new Uri(f)));
}
}
DataGridCollectionView dataGridCollectionView = new DataGridCollectionView(dt.DefaultView);
dataGridCollectionView.AutoFilterMode = AutoFilterMode.And;
dataGridCollectionView.DistinctValuesConstraint = DistinctValuesConstraint.Filtered;
grid.ItemsSource = dataGridCollectionView;
}
catch (Exception ex)
{
MessageBox.Show("خطا در حین نمایش تصاویر رخ داده است ", "خطا", MessageBoxButton.OK, MessageBoxImage.Error);
MessageBox.Show("لطفا متن زیر را به پشتیبانی برنامه اعلام بفرمایید \n\n" + ex.Message, "متن تکنیکی خطا", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public DataGridPage()
{
this.InitializeComponent();
var dataGridSortDescription = DataGridSortDescription.FromPath(nameof(Country.Region), ListSortDirection.Ascending, new ReversedStringComparer());
var collectionView1 = new DataGridCollectionView(Countries.All);
collectionView1.SortDescriptions.Add(dataGridSortDescription);
var dg1 = this.Get <DataGrid>("dataGrid1");
dg1.IsReadOnly = true;
dg1.LoadingRow += Dg1_LoadingRow;
dg1.Sorting += (s, a) =>
{
var binding = (a.Column as DataGridBoundColumn)?.Binding as Binding;
if (binding?.Path is string property &&
property == dataGridSortDescription.PropertyPath &&
!collectionView1.SortDescriptions.Contains(dataGridSortDescription))
{
collectionView1.SortDescriptions.Add(dataGridSortDescription);
}
};
dg1.Items = collectionView1;
var dg2 = this.Get <DataGrid>("dataGridGrouping");
dg2.IsReadOnly = true;
var collectionView2 = new DataGridCollectionView(Countries.All);
collectionView2.GroupDescriptions.Add(new DataGridPathGroupDescription("Region"));
dg2.Items = collectionView2;
var dg3 = this.Get <DataGrid>("dataGridEdit");
dg3.IsReadOnly = false;
var items = new List <Person>
{
new Person {
FirstName = "John", LastName = "Doe", Age = 30
},
new Person {
FirstName = "Elizabeth", LastName = "Thomas", IsBanned = true, Age = 40
},
new Person {
FirstName = "Zack", LastName = "Ward", Age = 50
}
};
var collectionView3 = new DataGridCollectionView(items);
dg3.Items = collectionView3;
var addButton = this.Get <Button>("btnAdd");
addButton.Click += (a, b) => collectionView3.AddNew();
}
public void updateDesign()
{
tableSelect.ItemsSource = _controller.Tables;
tableSelect.SelectedItem = _controller.Tables[0];
DataGridCollectionView dcg = new DataGridCollectionView(_controller.ResearchDesignOutput.Tables[0].DefaultView);
DesignTable.ItemsSource = dcg;
}
public DataGridCollectionViewGroupRoot( DataGridCollectionView parentCollectionView )
: base( null, null, 0 )
{
if( parentCollectionView == null )
throw new ArgumentNullException( "parentCollectionView" );
m_parentCollectionView = parentCollectionView;
}
protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
{
DataGridCollectionView oldCollectionView = oldValue as DataGridCollectionView;
bool state = IsGroupByAreaVisible;
base.OnItemsSourceChanged(oldValue, newValue);
Cursor = null; //Workaround for sticky wait cursor when filtering
DataGridCollectionView newCollectionView = newValue as DataGridCollectionView;
ApplyFilters(oldCollectionView, newCollectionView);
IsGroupByAreaVisible = state;
if (newValue == null || newCollectionView.Count == 0)
{
IsExportEnabled = false;
}
else
{
if (_dataExportContainer == null)
{
IsExportEnabled = true;
}
}
//Fix sorting to stick to database sorting when a new search is done
if (SavedSortDescriptions.Count > 0)
{
newCollectionView.SortDescriptions.Clear();
newCollectionView.SortDescriptions.Add(new SortDescription("SortIndex_GUI", ListSortDirection.Ascending));
foreach (SortDescription sortDesc in SavedSortDescriptions)
{
newCollectionView.SortDescriptions.Add(sortDesc);
}
SavedSortDescriptions.Clear();
}
else //Copy sort descriptions when a new partition is added
{
if (newCollectionView != null)
{
newCollectionView.SortDescriptions.Clear();
if (oldCollectionView != null)
{
foreach (SortDescription sortDesc in oldCollectionView.SortDescriptions)
{
newCollectionView.SortDescriptions.Add(sortDesc);
}
}
}
}
}
private void tableSelect_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
int index = (sender as ComboBox).SelectedIndex;
string table = (string)(sender as ComboBox).Items[index];
DataGridCollectionView dcg = new DataGridCollectionView(_controller.ResearchDesignOutput.Tables[table].DefaultView);
DesignTable.ItemsSource = dcg;
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
DataGridCollectionView dataGridCollectionView = new DataGridCollectionView(dt.DefaultView);
dataGridCollectionView.AutoFilterMode = AutoFilterMode.And;
dataGridCollectionView.DistinctValuesConstraint = DistinctValuesConstraint.Filtered;
grid.ItemsSource = dataGridCollectionView;
loaded = true;
}
private void CreateRecordsView()
{
_recordsView = new DataGridCollectionView(_database.Records);
_recordsView.Filter = FilterRecords;
_rowsDataGrid.Items = _recordsView;
_recordsFilter = _filterRecordsText?.Text;
_recordsView?.Refresh();
}
internal SourceItemCollection(DataGridCollectionView parentCollectionView)
{
if (parentCollectionView == null)
{
throw new ArgumentNullException("parentCollectionView");
}
m_parentCollectionView = parentCollectionView;
}
/// <param name="allowSlow">When "allowSlow" is false, method will not use Linq.Count() method and will return 0 or 1 instead.</param>
private int GetCount(bool allowSlow)
{
return(DataSource switch
{
ICollection collection => collection.Count,
DataGridCollectionView cv => cv.Count,
IEnumerable enumerable when allowSlow => enumerable.Cast <object>().Count(),
IEnumerable enumerable when !allowSlow => enumerable.Cast <object>().Any() ? 1 : 0,
_ => 0
});
public static void RemoveListener( DataGridCollectionView source, IWeakEventListener listener )
{
if( source == null )
throw new ArgumentNullException( "source" );
if( listener == null )
throw new ArgumentNullException( "listener" );
CurrentManager.ProtectedRemoveListener( source, listener );
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
DataGridCollectionView dataGridCollectionView = new DataGridCollectionView(dt.DefaultView);
dataGridCollectionView.AutoFilterMode = AutoFilterMode.And;
dataGridCollectionView.DistinctValuesConstraint = DistinctValuesConstraint.Filtered;
grid.ItemsSource = dataGridCollectionView;
loaded = true;
}
private void tableSelect_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
int index = (sender as ComboBox).SelectedIndex;
string table = (string)(sender as ComboBox).Items[index];
DataGridCollectionView dcg = new DataGridCollectionView(_controller.ResearchDesignOutput.Tables[table].DefaultView);
DesignTable.ItemsSource = dcg;
}
public DataGridCollectionViewGroupRoot(DataGridCollectionView parentCollectionView)
: base(null, null, 0)
{
if (parentCollectionView == null)
{
throw new ArgumentNullException("parentCollectionView");
}
m_parentCollectionView = parentCollectionView;
}
public DataTask()
{
InitializeComponent();
var dg1 = this.FindControl <DataGrid>("dataGrid1");
dg1.IsReadOnly = true;
var collectionView1 = new DataGridCollectionView(GetCountries().ToList().AsReadOnly());
dg1.Items = collectionView1;
}
internal StatResult GetStatFunctionResult(StatFunction statFunction, DataGridCollectionView view)
{
StatResult result;
if (!m_statFunctionValues.TryGetValue(statFunction, out result))
{
result = null;
m_statFunctionValues[statFunction] = result;
}
return(result);
}
private void LoadCollectionView()
{
var vm = (MultipleWordAlignmentViewModel) DataContext;
AlignmentGrid.Columns.Clear();
var view = new DataGridCollectionView(vm.Words, typeof(MultipleWordAlignmentWordViewModel), false, false);
view.ItemProperties.Add(new DataGridItemProperty("Variety", "Variety", typeof(VarietyViewModel)) {SortComparer = ProjectionComparer<VarietyViewModel>.Create(v => v.Name)});
view.ItemProperties.Add(new DataGridItemProperty("StrRep", "StrRep", typeof(string)));
view.ItemProperties.Add(new DataGridItemProperty("CognateSetIndex", "CognateSetIndex", typeof(int)));
view.ItemProperties.Add(new DataGridItemProperty("Prefix", "Prefix", typeof(string)));
for (int i = 0; i < vm.ColumnCount; i++)
view.ItemProperties.Add(new DataGridItemProperty("Column" + i, string.Format("Columns[{0}]", i), typeof(string)));
view.ItemProperties.Add(new DataGridItemProperty("Suffix", "Suffix", typeof(string)));
if (vm.GroupByCognateSet)
{
Debug.Assert(view.GroupDescriptions != null);
view.GroupDescriptions.Add(new DataGridGroupDescription("CognateSetIndex"));
}
vm.WordsView = view;
var headerColumn = new Column {FieldName = "Variety"};
DataGridControlBehaviors.SetIsRowHeader(headerColumn, true);
DataGridControlBehaviors.SetAutoSize(headerColumn, true);
DataGridControlBehaviors.SetAutoSizePadding(headerColumn, 18);
AlignmentGrid.Columns.Add(headerColumn);
object fontSizeObj = System.Windows.Application.Current.FindResource("PhoneticFontSize");
Debug.Assert(fontSizeObj != null);
var fontSize = (double) fontSizeObj;
var prefixColumn = new Column {FieldName = "Prefix", ReadOnly = true, CanBeCurrentWhenReadOnly = false};
DataGridControlBehaviors.SetAutoSize(prefixColumn, true);
DataGridControlBehaviors.SetAutoSizePadding(prefixColumn, 9);
DataGridControlBehaviors.SetFontSizeHint(prefixColumn, fontSize);
AlignmentGrid.Columns.Add(prefixColumn);
for (int i = 0; i < vm.ColumnCount; i++)
{
var column = new Column {FieldName = "Column" + i};
DataGridControlBehaviors.SetAutoSize(column, true);
DataGridControlBehaviors.SetAutoSizePadding(column, 9);
DataGridControlBehaviors.SetFontSizeHint(column, fontSize);
AlignmentGrid.Columns.Add(column);
}
var suffixColumn = new Column {FieldName = "Suffix", ReadOnly = true, CanBeCurrentWhenReadOnly = false};
DataGridControlBehaviors.SetAutoSize(suffixColumn, true);
DataGridControlBehaviors.SetAutoSizePadding(suffixColumn, 9);
DataGridControlBehaviors.SetFontSizeHint(suffixColumn, fontSize);
AlignmentGrid.Columns.Add(suffixColumn);
AlignmentGrid.CurrentItem = null;
}
/// <summary>Try get number of DataSource itmes.</summary>
/// <param name="allowSlow">When "allowSlow" is false, method will not use Linq.Count() method and will return 0 or 1 instead.</param>
/// <param name="getAny">If "getAny" is true, method can use Linq.Any() method to speedup.</param>
/// <param name="count">number of DataSource itmes.</param>
/// <returns>true if able to retrieve number of DataSource itmes; otherwise, false.</returns>
internal bool TryGetCount(bool allowSlow, bool getAny, out int count)
{
bool result;
(result, count) = DataSource switch
{
ICollection collection => (true, collection.Count),
DataGridCollectionView cv => (true, cv.Count),
IEnumerable enumerable when allowSlow&& !getAny => (true, enumerable.Cast <object>().Count()),
IEnumerable enumerable when getAny => (true, enumerable.Cast <object>().Any() ? 1 : 0),
_ => (false, 0)
};
return(result);
}
public static void RemoveListener(DataGridCollectionView source, IWeakEventListener listener)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (listener == null)
{
throw new ArgumentNullException("listener");
}
CurrentManager.ProtectedRemoveListener(source, listener);
}
internal override void ApplyExtraPropertiesToView(DataGridCollectionViewBase currentView)
{
base.ApplyExtraPropertiesToView(currentView);
DataGridCollectionView dataGridCollectionView = currentView as DataGridCollectionView;
dataGridCollectionView.StatFunctions.Clear();
foreach (var statFunction in m_statFunctions)
{
dataGridCollectionView.StatFunctions.Add(statFunction);
}
dataGridCollectionView.UpdateChangedPropertyStatsOnly = this.UpdateChangedPropertyStatsOnly;
}
internal bool Contains(object dataItem)
{
DataGridCollectionView collectionView = this.GetCollectionView();
if (collectionView != null)
{
RawItem rawItem = collectionView.GetFirstRawItemFromDataItem(dataItem);
if (rawItem != null)
{
return(rawItem.ParentGroup == this);
}
}
return(false);
}
private void LoadCollectionView()
{
var vm = (WordListsViewModel)DataContext;
if (vm == null)
{
return;
}
WordListsGrid.CurrentColumn = null;
WordListsGrid.CurrentItem = null;
WordListsGrid.Columns.Clear();
var view = new DataGridCollectionView(vm.Varieties, typeof(WordListsVarietyViewModel), false, false);
view.ItemProperties.Add(new DataGridItemProperty("Variety", ".", typeof(WordListsVarietyViewModel)));
IComparer sortComparer = ProjectionComparer <WordListsVarietyMeaningViewModel> .Create(meaning => meaning.StrRep);
for (int i = 0; i < vm.Meanings.Count; i++)
{
view.ItemProperties.Add(new DataGridItemProperty("Meaning" + i, $"Meanings[{i}]", typeof(WordListsVarietyMeaningViewModel))
{
SortComparer = sortComparer
});
}
vm.VarietiesView = view;
WordListsGrid.Items.SortDescriptions.Clear();
var headerColumn = new Column {
FieldName = "Variety"
};
DataGridControlBehaviors.SetIsRowHeader(headerColumn, true);
DataGridControlBehaviors.SetAutoSize(headerColumn, true);
DataGridControlBehaviors.SetAutoSizePadding(headerColumn, 18);
WordListsGrid.Columns.Add(headerColumn);
for (int i = 0; i < vm.Meanings.Count; i++)
{
var column = new Column {
FieldName = "Meaning" + i, Width = 100, CellEditor = WordListsGrid.DefaultCellEditors[typeof(WordListsVarietyMeaningViewModel)]
};
var titleBinding = new Binding($"DataGridControl.DataContext.Meanings[{i}].Gloss")
{
RelativeSource = RelativeSource.Self
};
BindingOperations.SetBinding(column, ColumnBase.TitleProperty, titleBinding);
WordListsGrid.Columns.Add(column);
}
}
internal override void ApplyExtraPropertiesToView(DataGridCollectionViewBase currentView)
{
base.ApplyExtraPropertiesToView(currentView);
DataGridCollectionView dataGridCollectionView = currentView as DataGridCollectionView;
dataGridCollectionView.StatFunctions.Clear();
int count = m_statFunctions.Count;
for (int i = 0; i < count; i++)
{
dataGridCollectionView.StatFunctions.Add(m_statFunctions[i]);
}
dataGridCollectionView.UpdateChangedPropertyStatsOnly = this.UpdateChangedPropertyStatsOnly;
}
public DataGridPage()
{
this.InitializeComponent();
var dg1 = this.FindControl <DataGrid>("dataGrid1");
dg1.IsReadOnly = true;
var collectionView1 = new DataGridCollectionView(Countries.All);
//collectionView.GroupDescriptions.Add(new PathGroupDescription("Region"));
dg1.Items = collectionView1;
var dg2 = this.FindControl <DataGrid>("dataGridGrouping");
dg2.IsReadOnly = true;
var collectionView2 = new DataGridCollectionView(Countries.All);
collectionView2.GroupDescriptions.Add(new DataGridPathGroupDescription("Region"));
dg2.Items = collectionView2;
var dg3 = this.FindControl <DataGrid>("dataGridEdit");
dg3.IsReadOnly = false;
var items = new List <Person>
{
new Person {
FirstName = "John", LastName = "Doe"
},
new Person {
FirstName = "Elizabeth", LastName = "Thomas"
},
new Person {
FirstName = "Zack", LastName = "Ward"
}
};
var collectionView3 = new DataGridCollectionView(items);
dg3.Items = collectionView3;
var addButton = this.FindControl <Button>("btnAdd");
addButton.Click += (a, b) => collectionView3.AddNew();
}
internal int IndexOf(object dataItem)
{
DataGridCollectionView collectionView = this.GetCollectionView();
if (collectionView != null)
{
RawItem rawItem = collectionView.GetFirstRawItemFromDataItem(dataItem);
if ((rawItem != null) &&
(rawItem.ParentGroup == this))
{
return(rawItem.SortedIndex);
}
}
return(-1);
}
async Task <bool> StartServerAsync()
{
try
{
var cardanoServerConsoleProcess = _cardanoServer.Start(_nodePort);
var allWallets = await _walletClient.GetAllWalletsAsync();
AllWallets = new ObservableCollection <Wallet>(allWallets);
var allPools = await _walletClient.GetAllPoolsAsync();
BlockChainCache = new BlockChainCache();
BlockChainCache.StakePools = new ObservableCollection <StakePool>(allPools);
BlockChainCache.CacheDate = DateTime.Now;
string jsonString = JsonConvert.SerializeObject(BlockChainCache);
byte[] jsonUtf8Bytes;
var options = new JsonSerializerOptions
{
WriteIndented = true
};
jsonUtf8Bytes = JsonSerializer.SerializeToUtf8Bytes(BlockChainCache, options);
await File.WriteAllBytesAsync(StakePoolListDatabase, jsonUtf8Bytes);
//var allPoolsGrouped = allPools.GroupBy(g=>g.LifeTimeBlocks == 0).ToDictionary(x => x.Key, x => x.ToList());
var allStakePoolsGroups = new DataGridCollectionView(allPools);
//allStakePoolsGroups.GroupDescriptions.Add(new DataGridPathGroupDescription("LifeTimeBlocks"));
//allStakePoolsGroups.Filter = FilterProperty;
AllStakePools = new ObservableCollection <StakePool>(allPools);
if (BlockChainCache.StakePools.Any())
{
BlockChainCache.StakePools.Clear();
}
OnPropertyChanged("BlockChainCache");
return(true);
}
catch (Exception e)
{
Log.Logger.Fatal(e.Message);
return(false);
}
}
internal void InvokeStatFunctionsPropertyChanged(DataGridCollectionView view)
{
if (view.CalculateChangedPropertyStatsOnly)
{
foreach (Stats.StatFunction statFunction in view.InvalidatedStatFunctions)
{
{
this.OnPropertyChanged(new PropertyChangedEventArgs(statFunction.ResultPropertyName));
}
}
}
else
{
foreach (PropertyDescriptor statFunctionPropertyDescriptor in view.GetStatFunctionProperties())
{
this.OnPropertyChanged(new PropertyChangedEventArgs(statFunctionPropertyDescriptor.Name));
}
}
}
private void LoadCollectionView()
{
var vm = (SegmentsViewModel) DataContext;
SegmentsDataGrid.CurrentColumn = null;
SegmentsDataGrid.Columns.Clear();
var view = new DataGridCollectionView(vm.Varieties, typeof(SegmentsVarietyViewModel), false, false);
view.ItemProperties.Add(new DataGridItemProperty("Variety", ".", typeof(SegmentsVarietyViewModel)));
for (int i = 0; i < vm.Segments.Count; i++)
view.ItemProperties.Add(new DataGridItemProperty(vm.Segments[i].StrRep, string.Format("Segments[{0}].Frequency", i), typeof(int)));
SegmentsDataGrid.ItemsSource = view;
SegmentsDataGrid.Items.SortDescriptions.Clear();
var headerColumn = new Column {FieldName = "Variety"};
DataGridControlBehaviors.SetIsRowHeader(headerColumn, true);
DataGridControlBehaviors.SetAutoSize(headerColumn, true);
DataGridControlBehaviors.SetAutoSizePadding(headerColumn, 18);
SegmentsDataGrid.Columns.Add(headerColumn);
foreach (SegmentViewModel segment in vm.Segments)
SegmentsDataGrid.Columns.Add(new Column {FieldName = segment.StrRep, Title = segment.StrRep, Width = 67, CellHorizontalContentAlignment = HorizontalAlignment.Center});
}
private void LoadCollectionView()
{
var vm = (SimilarityMatrixViewModel) DataContext;
SimMatrixGrid.Columns.Clear();
var view = new DataGridCollectionView(vm.Varieties, typeof(SimilarityMatrixVarietyViewModel), false, false);
view.ItemProperties.Add(new DataGridItemProperty("Variety", ".", typeof(SimilarityMatrixVarietyViewModel)));
for (int i = 0; i < vm.Varieties.Count; i++)
view.ItemProperties.Add(new DataGridItemProperty("Variety" + i, string.Format("VarietyPairs[{0}]", i), typeof(SimilarityMatrixVarietyPairViewModel)));
SimMatrixGrid.ItemsSource = view;
var headerColumn = new Column {FieldName = "Variety", Title = ""};
DataGridControlBehaviors.SetIsRowHeader(headerColumn, true);
DataGridControlBehaviors.SetAutoSize(headerColumn, true);
DataGridControlBehaviors.SetAutoSizePadding(headerColumn, 18);
SimMatrixGrid.Columns.Add(headerColumn);
for (int i = 0; i < vm.Varieties.Count; i++)
{
var column = new Column {FieldName = "Variety" + i, Width = 30};
var titleBinding = new Binding(string.Format("DataGridControl.DataContext.Varieties[{0}].Name", i)) {RelativeSource = RelativeSource.Self};
BindingOperations.SetBinding(column, ColumnBase.TitleProperty, titleBinding);
SimMatrixGrid.Columns.Add(column);
}
}
public void init3D()
{
try
{
string path = checkOrCreateDirectory();
DataTable dt = new DataTable();
dt.Columns.Add("Image", typeof(BitmapImage));
foreach (string f in Directory.GetFiles(path))
{
if (isItImage(f))
{
dt.Rows.Add(new BitmapImage(new Uri(f)));
}
}
DataGridCollectionView dataGridCollectionView = new DataGridCollectionView(dt.DefaultView);
dataGridCollectionView.AutoFilterMode = AutoFilterMode.And;
dataGridCollectionView.DistinctValuesConstraint = DistinctValuesConstraint.Filtered;
grid.ItemsSource = dataGridCollectionView;
}
catch (Exception ex)
{
MessageBox.Show("خطا در حین نمایش تصاویر رخ داده است ", "خطا", MessageBoxButton.OK, MessageBoxImage.Error);
MessageBox.Show("لطفا متن زیر را به پشتیبانی برنامه اعلام بفرمایید \n\n" + ex.Message, "متن تکنیکی خطا", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
internal Stats.StatResult GetStatFunctionResult( Stats.StatFunction statFunction, DataGridCollectionView view )
{
if( !m_statFunctionValues.ContainsKey( statFunction ) )
this.CalculateStatFunctionValue( statFunction, view );
return m_statFunctionValues[ statFunction ];
}
internal void SetContext( DataGridCollectionView collectionView )
{
if( collectionView == null )
{
m_contextProperty = null;
}
else
{
string propertyName = m_propertyGroupDescription.PropertyName;
if( string.IsNullOrEmpty( propertyName ) )
{
m_contextProperty = null;
}
else
{
m_contextProperty = collectionView.ItemProperties[ propertyName ];
}
}
}
internal void InvokeStatFunctionsPropertyChanged( DataGridCollectionView view )
{
if( view.CalculateChangedPropertyStatsOnly )
{
foreach( Stats.StatFunction statFunction in view.InvalidatedStatFunctions )
{
{
this.OnPropertyChanged( new PropertyChangedEventArgs( statFunction.ResultPropertyName ) );
}
}
}
else
{
foreach( PropertyDescriptor statFunctionPropertyDescriptor in view.GetStatFunctionProperties() )
{
this.OnPropertyChanged( new PropertyChangedEventArgs( statFunctionPropertyDescriptor.Name ) );
}
}
}
/// <summary>
/// Subscribe to grid's items source events.
/// </summary>
private void _SubscribeToItemsSourceEvents()
{
// If data grid items source was set to null
// we don't need to subscribe to events.
if (_dataGrid.ItemsSource == null)
return;
// Remember collection to unsubscribe from its items in future.
_dataGridCollectionView = _dataGrid.ItemsSource as DataGridCollectionView;
// Check that collection's type.
Debug.Assert(_dataGridCollectionView != null);
// Subscribing to data grid source collection events.
(_dataGridCollectionView as INotifyCollectionChanged).CollectionChanged +=
new NotifyCollectionChangedEventHandler(_SourceItemsCollectionChanged);
// If user is adding new item we need to close popup and subscribe to
// property changed event.
_dataGridCollectionView.NewItemCreated += new EventHandler<DataGridItemEventArgs>
(_CollectionViewSourceCreatingNewItem);
// If user is editing existence item, need to close popup, subscribe to
// property changed event and open popup for item invalid property.
_dataGridCollectionView.BeginningEdit += new EventHandler<DataGridItemCancelEventArgs>
(_CollectionViewSourceBeginningEdit);
// When user finish/editing item, we need
// to re-validate data grid's source collection.
_dataGridCollectionView.NewItemCommitted += new EventHandler<DataGridItemEventArgs>
(_CollectionViewSourceNewItemFinishEdit);
_dataGridCollectionView.NewItemCanceled += new EventHandler<DataGridItemEventArgs>
(_CollectionViewSourceNewItemFinishEdit);
_dataGridCollectionView.CommittingEdit += new EventHandler<DataGridItemCancelEventArgs>
(_CollectionViewSourceFinishEdit);
_dataGridCollectionView.CancelingEdit += new EventHandler<DataGridItemHandledEventArgs>
(_CollectionViewSourceFinishEdit);
}
internal DataGridCollectionViewGroupRoot( DataGridCollectionView parentCollectionView )
: base( 128 )
{
m_parentCollectionView = parentCollectionView;
}
private void CalculateStatFunctionValue( Stats.StatFunction statFunction, DataGridCollectionView view )
{
m_statFunctionValues[ statFunction ] = new Stats.StatResult(
new InvalidOperationException( Log.NotToolkitStr( "Statistical functions" ) )
);
}
