internal Group( GroupGeneratorNode node, CollectionViewGroup group, IList<GroupLevelDescription> groupLevelDescriptions, DataGridContext dataGridContext ) { if( node == null ) throw new ArgumentNullException( "node" ); if( group == null ) throw new ArgumentNullException( "group" ); if( groupLevelDescriptions == null ) throw new ArgumentNullException( "groupLevelDescriptions" ); if( dataGridContext == null ) throw new ArgumentNullException( "dataGridContext" ); m_generatorNode = node; m_collectionViewGroup = group; m_groupDescriptionsCollection = groupLevelDescriptions; m_dataGridContext = dataGridContext; //In case no late bingding is to happen, and if we already have everything to get the groupLevelDescription immediately, let's do! int level = m_generatorNode.Level; if( m_groupDescriptionsCollection.Count > level ) { m_groupLevelDescription = m_groupDescriptionsCollection[ level ]; } m_lateGroupLevelDescriptionBindingPerformed = false; m_generatorNode.TotalLeafCountChanged += OnTotalItemCountChanged; m_generatorNode.IsExpandedChanged += OnIsExpandedChanged; }
public ColumnStretchingManager( DataGridContext dataGridContext ) { if( dataGridContext == null ) throw new ArgumentNullException( "dataGridContext" ); m_dataGridContext = dataGridContext; }
public static bool HasGroup( DataGridContext dataGridContext ) { if( dataGridContext.GroupLevelDescriptions.Count > 0 ) return true; return GroupingHelper.HasGroup( dataGridContext.DetailConfigurations ); }
internal static int GetNextVisibleFocusableColumnIndex( DataGridContext dataGridContext, Row targetRow, ColumnBase targetColumn ) { if( ( dataGridContext == null ) || ( targetRow == null ) || ( targetColumn == null ) ) return -1; var columns = dataGridContext.VisibleColumns; if( ( columns == null ) || ( columns.Count <= 0 ) ) return -1; var columnIndex = columns.IndexOf( targetColumn ); if( columnIndex < 0 ) return -1; if( !dataGridContext.IsAFlattenDetail ) return NavigationHelper.GetNextVisibleFocusableColumnIndex( dataGridContext, targetRow, columnIndex + 1 ); var columnMap = dataGridContext.ItemPropertyMap; var masterColumnName = default( string ); if( !columnMap.TryGetColumnFieldName( targetColumn, out masterColumnName ) ) return -1; var masterDataGridContext = dataGridContext.RootDataGridContext; var masterColumn = masterDataGridContext.Columns[ masterColumnName ]; if( masterColumn == null ) return -1; var masterColumnIndex = masterDataGridContext.VisibleColumns.IndexOf( masterColumn ); if( masterColumnIndex < 0 ) return -1; return NavigationHelper.GetNextVisibleFocusableDetailColumnIndexFromMasterColumnIndex( dataGridContext, targetRow, masterColumnIndex + 1 ); }
internal static CustomItemContainerGenerator CreateGenerator( DataGridControl parentGridControl, CollectionView collectionView, DataGridContext dataGridContext ) { CustomItemContainerGenerator newGenerator = new CustomItemContainerGenerator( collectionView, dataGridContext, parentGridControl ); dataGridContext.SetGenerator( newGenerator ); return newGenerator; }
internal static int GetLastVisibleFocusableColumnIndex( DataGridContext dataGridContext ) { if( dataGridContext == null ) return -1; return NavigationHelper.GetLastVisibleFocusableColumnIndex( dataGridContext, dataGridContext.CurrentRow ); }
internal DataGridContextAutomationPeer( DataGridControl dataGridControl, DataGridContext parentDataGridContext, object parentItem, DetailConfiguration detailConfiguration ) { if( dataGridControl == null ) throw new ArgumentNullException( "dataGridControl" ); if( parentDataGridContext == null ) { m_dataGridContext = dataGridControl.DataGridContext; } else { m_dataGridContext = parentDataGridContext.GetChildContext( parentItem, detailConfiguration ); } if( m_dataGridContext != null ) m_dataGridContext.Peer = this; m_dataGridControl = dataGridControl; m_parentDataGridContext = parentDataGridContext; m_parentItem = parentItem; m_detailConfiguration = detailConfiguration; m_dataChildren = new Hashtable( 0 ); m_headerFooterChildren = new Hashtable( 0 ); }
internal Group( GroupGeneratorNode node, CollectionViewGroup group, LateGroupLevelDescription groupLevelDescription, DataGridContext dataGridContext ) { if( node == null ) throw new ArgumentNullException( "node" ); if( group == null ) throw new ArgumentNullException( "group" ); if( groupLevelDescription == null ) throw new ArgumentNullException( "groupLevelDescription" ); if( dataGridContext == null ) throw new ArgumentNullException( "dataGridContext" ); m_collectionViewGroup = group; // Initialization is done through setters to register for events. this.DataGridContext = dataGridContext; this.GeneratorNode = node; this.GroupLevelDescription = groupLevelDescription; }
public void Visit( DataGridContext sourceContext, int sourceDataItemIndex, object item, ref bool stopVisit ) { if( !m_isTableFlowView ) { m_item = item; m_parentDataGridContext = sourceContext; m_success = true; stopVisit = true; return; } UIElement dataRow = sourceContext.CustomItemContainerGenerator.ContainerFromItem( item ) as UIElement; if( dataRow != null ) { if( !ScrollTip.IsItemInView( dataRow, sourceContext.DataGridControl.ItemsHost ) ) { stopVisit = true; } else if( !ScrollTip.IsDataItemHiddenBySticky( sourceContext, item ) ) { m_item = item; m_parentDataGridContext = sourceContext; m_success = true; stopVisit = true; } } }
public void Visit( DataGridContext sourceContext, ref bool stopVisit ) { object[] items; CollectionView itemsCollection = sourceContext.Items; int count = itemsCollection.Count; if( count == 0 ) return; if( sourceContext.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase ) { items = null; } else { items = new object[ count ]; for( int i = 0; i < count; i++ ) { items[ i ] = itemsCollection.GetItemAt( i ); } } SelectionRange itemRange = new SelectionRange( 0, count - 1 ); if( sourceContext.DataGridControl.SelectionUnit == SelectionUnit.Row ) { sourceContext.DataGridControl.SelectionChangerManager.SelectItems( sourceContext, new SelectionRangeWithItems( itemRange, items ) ); } else { HashedLinkedList<ColumnBase> columnsByVisiblePosition = sourceContext.ColumnsByVisiblePosition; SelectedItemsStorage selectedColumnStore = new SelectedItemsStorage( null, 8 ); SelectionRange fullColumnRange = new SelectionRange( 0, columnsByVisiblePosition.Count - 1 ); selectedColumnStore.Add( new SelectionRangeWithItems( fullColumnRange, null ) ); int index = 0; foreach( ColumnBase column in columnsByVisiblePosition ) { if( !column.Visible ) { selectedColumnStore.Remove( new SelectionRangeWithItems( new SelectionRange( index ), null ) ); } index++; } int columnRangeCount = selectedColumnStore.Count; for( int i = 0; i < columnRangeCount; i++ ) { sourceContext.DataGridControl.SelectionChangerManager.SelectCells( sourceContext, new SelectionCellRangeWithItems( itemRange, items, selectedColumnStore[ i ].Range ) ); } } }
protected override void StartDataItem( DataGridContext dataGridContext, object dataItem ) { if (!string.IsNullOrEmpty(_indentationString)) WriteToBaseStream(_indentationString); // The next StartDataItemField will be considered as first column _isFirstColumn = true; }
internal void Prepare( DataGridContext dataGridContext, object dataItem ) { m_containersPrepared = true; m_dataGridContext = dataGridContext; m_dataItem = dataItem; this.Update(); }
internal DataGridCurrentChangedEventArgs( DataGridContext oldDataGridContext, object oldCurrent, DataGridContext newDataGridContext, object newCurrent ) : base( DataGridControl.CurrentChangedEvent ) { this.OldDataGridContext = oldDataGridContext; this.OldCurrent = oldCurrent; this.NewDataGridContext = newDataGridContext; this.NewCurrent = newCurrent; }
internal DataGridCurrentChangingEventArgs( DataGridContext oldDataGridContext, object oldCurrent, DataGridContext newDataGridContext, object newCurrent, bool isCancelable ) : base( DataGridControl.CurrentChangingEvent ) { this.IsCancelable = isCancelable; this.OldDataGridContext = oldDataGridContext; this.OldCurrent = oldCurrent; this.NewDataGridContext = newDataGridContext; this.NewCurrent = newCurrent; }
public void Visit( DataGridContext sourceContext, int startSourceDataItemIndex, int endSourceDataItemIndex, ref bool stopVisit ) { SelectionManager selectionChangerManager = sourceContext.DataGridControl.SelectionChangerManager; if( m_selectedColumns != null ) { int columnCount = sourceContext.Columns.Count; if( columnCount == 0 ) return; SelectionRange contextColumnMaxRange = new SelectionRange( 0, columnCount - 1 ); for( int i = 0; i < m_selectedColumns.Length; i++ ) { SelectionRange selectionRange = m_selectedColumns[ i ]; SelectionRange intersectionSelectionRange = selectionRange.Intersect( contextColumnMaxRange ); if( intersectionSelectionRange.IsEmpty ) continue; #if DEBUG string action = ( m_unselect ) ? "Removing" : "Adding"; Debug.WriteLine( "Selection : " + action + " cell : (" + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString() + ") - (" + intersectionSelectionRange.StartIndex.ToString() + " - " + intersectionSelectionRange.EndIndex.ToString() + ")" ); #endif var cellRange = new SelectionCellRangeWithItems( new SelectionRange( startSourceDataItemIndex, endSourceDataItemIndex ), null, intersectionSelectionRange ); if( m_unselect ) { selectionChangerManager.UnselectCells( sourceContext, cellRange ); } else { selectionChangerManager.SelectCells( sourceContext, cellRange ); } } } else { #if DEBUG string action = ( m_unselect ) ? "Removing" : "Adding"; Debug.WriteLine( "Selection : " + action + " Adding item : " + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString() ); #endif var itemRange = new SelectionRangeWithItems( new SelectionRange( startSourceDataItemIndex, endSourceDataItemIndex ), null ); if( m_unselect ) { selectionChangerManager.UnselectItems( sourceContext, itemRange ); } else { selectionChangerManager.SelectItems( sourceContext, itemRange ); } } }
internal static int GetLastVisibleFocusableColumnIndex( DataGridContext dataGridContext, Row targetRow ) { if( dataGridContext == null ) return -1; if( dataGridContext.IsAFlattenDetail ) return NavigationHelper.GetPreviousVisibleFocusableDetailColumnIndexFromMasterColumnIndex( dataGridContext, targetRow, int.MaxValue ); return NavigationHelper.GetPreviousVisibleFocusableColumnIndex( dataGridContext, targetRow, int.MaxValue ); }
public override void EndInit() { base.EndInit(); _context = DataGridControl.GetDataGridContext(this); _context.DataGridControl.Columns.CollectionChanged += Columns_CollectionChanged; AddColumns(_context.DataGridControl.Columns); ObservableCollection<MergedHeader> mergedHeaders = DataGridControlBehaviors.GetMergedHeaders(_context.DataGridControl); mergedHeaders.CollectionChanged += mergedHeaders_CollectionChanged; AddMergedHeaders(mergedHeaders); }
public SelectionChanger( DataGridContext owner ) { m_owner = owner; m_itemsToSelect = new SelectedItemsStorage( owner, 2 ); m_itemsToUnselect = new SelectedItemsStorage( owner, 2 ); m_cellsToSelect = new SelectedCellsStorage( owner, 2 ); m_cellsToUnselect = new SelectedCellsStorage( owner, 2 ); m_toDeferSelect = new List<object>( 1 ); m_sourceChanges = new List<SourceChangeInfo>( 2 ); }
protected override void StartDataItemField(DataGridContext dataGridContext, Column column, object fieldValue) { // We always insert the separator before the value except for the first item if( !_isFirstColumn ) WriteToBaseStream(FormatSettings.Separator); else _isFirstColumn = false; string fieldValueString = FormatCsvData(null, fieldValue); WriteToBaseStream(fieldValueString); }
public void Visit( DataGridContext sourceContext, System.Windows.Data.CollectionViewGroup group, object[] namesTree, int groupLevel, bool isExpanded, bool isComputedExpanded, ref bool stopVisit ) { if( this.Group == null ) { GroupNamesTreeKey currentGroupKey = new GroupNamesTreeKey( namesTree ); if( currentGroupKey.Equals( m_groupNamesTreeKey ) == true ) this.Group = group; } }
public DataGridItemAutomationPeer( object item, DataGridContext dataGridContext, int index ) { // if index = -1, it will be calculated later calling indexof on dataGridContext.Items. if( dataGridContext == null ) throw new ArgumentNullException( "dataGridContext" ); m_item = item; m_dataGridContext = dataGridContext; m_index = index; m_dataChildren = new Hashtable( 0 ); }
public DetailGeneratorNode( DataGridContext context, CustomItemContainerGenerator generator ) : base( null ) { if( generator == null ) throw new ArgumentNullException( "generator" ); if( context == null ) throw new ArgumentNullException( "context" ); m_generator = generator; m_context = context; m_itemCount = generator.ItemCount; }
public HeaderFooterItemAutomationPeer( DataGridContext dataGridContext, object owner ) { if( dataGridContext == null ) throw new ArgumentNullException( "dataGridContext" ); if( owner == null ) throw new ArgumentNullException( "owner" ); Debug.Assert( ( owner is GroupHeaderFooterItem ) || ( owner is DataTemplate ) || ( owner is HeaderFooterItem ) ); m_owner = owner; m_dataGridContext = dataGridContext; }
internal DetailConfiguration( DataGridContext synchronizedParent ) : this( true ) { m_shouldCreateColumns = false; this.SetColumns( synchronizedParent.Columns ); this.SetVisibleColumns( synchronizedParent.VisibleColumns ); m_columnsByVisiblePosition = synchronizedParent.ColumnsByVisiblePosition; m_sortDescriptions = synchronizedParent.Items.SortDescriptions; m_groupDescriptions = synchronizedParent.Items.GroupDescriptions; this.SetGroupLevelDescriptions( synchronizedParent.GroupLevelDescriptions ); }
public ColumnVirtualizationManager( DataGridContext dataGridContext ) { Debug.Assert( dataGridContext != null ); m_dataGridContext = dataGridContext; // Assign the ColumnVirtualizationManager to the DataGridContext ColumnVirtualizationManager.SetColumnVirtualizationManager( m_dataGridContext, this ); this.Initialize(); unchecked { m_version++; } }
internal SelectionInfo( DataGridContext dataGridContext, SelectedItemsStorage removedItems, SelectedItemsStorage addedItems, SelectedCellsStorage removedCells, SelectedCellsStorage addedCells ) { this.DataGridContext = dataGridContext; this.AddedItems = new ReadOnlyCollection<object>( new SelectionItemCollection( addedItems ) ); this.RemovedItems = new ReadOnlyCollection<object>( new SelectionItemCollection( removedItems ) ); this.AddedItemRanges = new ReadOnlyCollection<SelectionRange>( new SelectionItemRangeCollection( addedItems ) ); this.RemovedItemRanges = new ReadOnlyCollection<SelectionRange>( new SelectionItemRangeCollection( removedItems ) ); this.AddedCellRanges = new ReadOnlyCollection<SelectionCellRange>( new SelectionCellRangeCollection( addedCells ) ); this.RemovedCellRanges = new ReadOnlyCollection<SelectionCellRange>( new SelectionCellRangeCollection( removedCells ) ); }
public CurrencyManager( DataGridContext dataGridContext, CollectionView collectionView ) { if( dataGridContext == null ) throw new ArgumentNullException( "dataGridContext" ); if( collectionView == null ) throw new ArgumentNullException( "collectionView" ); m_dataGridContext = dataGridContext; m_collectionView = collectionView; System.Diagnostics.Debug.Assert( m_dataGridContext.CurrentItem == m_collectionView.CurrentItem ); this.RegisterListeners(); }
public static IEnumerable <ColumnBase> EnumerateColumns(this DataGridContext gridContext, SelectionRange columnRange) { var startIndex = Math.Min(columnRange.StartIndex, columnRange.EndIndex); var endIndex = Math.Max(columnRange.StartIndex, columnRange.EndIndex); for (var i = startIndex; i <= endIndex; i++) { foreach (var column in gridContext.Columns) { if (column.VisiblePosition == i) { yield return(column); } } } }
public static void SelectItem(this DataGridContext gridContext, object item) { var gridControl = gridContext.DataGridControl; if (gridControl.SelectionUnit == SelectionUnit.Row) { } else { gridContext.SelectedCellRanges.Clear(); var index = gridContext.Items.IndexOf(item); var columnCount = gridContext.VisibleColumns.Count; var range = new SelectionCellRange(new SelectionRange(index), new SelectionRange(0, columnCount - 1)); gridContext.SelectedCellRanges.Add(range); } }
public static ModernDataCell GetCurrentCell(this DataGridContext gridContext) { if (gridContext.CurrentItem == null || gridContext.CurrentColumn == null) { return(null); } var row = gridContext.GetContainerFromItem(gridContext.CurrentItem) as ModernDataRow; if (row == null) { return(null); } return(row.Cells[gridContext.CurrentColumn] as ModernDataCell); }
private void RecursiveSaveDataGridContextsState( DataGridContext dataGridContext ) { SaveRestoreDataGridContextStateVisitor saveRestoreDataGridContextStateVisitor = new SaveRestoreDataGridContextStateVisitor( true, int.MaxValue, m_stopAtFirstCollapsedGroup ); saveRestoreDataGridContextStateVisitor.SaveState( dataGridContext as IDataGridContextVisitable ); m_dataGridContextsStateDictionary.Add( new WeakDataGridContextKey( dataGridContext ), saveRestoreDataGridContextStateVisitor ); IEnumerable<DataGridContext> subDataGridContexts = dataGridContext.GetChildContexts(); foreach( DataGridContext subDataGridContext in subDataGridContexts ) { this.RecursiveSaveDataGridContextsState( subDataGridContext ); } }
public static SelectionRangePoint TryCreateFromCurrent(DataGridContext dataGridContext) { if (dataGridContext == null) { return(null); } var column = dataGridContext.CurrentColumn; int columnIndex = (column != null) ? column.VisiblePosition : -1; var oldPosition = SelectionRangePoint.TryCreateRangePoint( dataGridContext, dataGridContext.CurrentItem, dataGridContext.CurrentItemIndex, columnIndex); return(oldPosition); }
private void UpdateContentTemplate() { Column mainColumn = this.MainColumn as Column; if (mainColumn == null) { return; } DataGridContext dataGridContext = DataGridControl.GetDataGridContext(this); UIViewBase uiViewBase = null; if (dataGridContext != null) { DataGridControl dataGridControl = dataGridContext.DataGridControl; if (dataGridControl != null) { uiViewBase = dataGridControl.GetView() as UIViewBase; } } if (uiViewBase != null) { if (uiViewBase.ScrollTipContentTemplate != null) { this.ContentTemplate = uiViewBase.ScrollTipContentTemplate; } else { this.ContentTemplateSelector = uiViewBase.ScrollTipContentTemplateSelector; } } if ((this.ContentTemplate == null) && (this.ContentTemplateSelector == null)) { if (mainColumn.CellContentTemplate != null) { this.ContentTemplate = mainColumn.CellContentTemplate; } else { this.ContentTemplateSelector = mainColumn.CellContentTemplateSelector; } } }
// Parse all the expanded details recursively private void GetVisiblePositionsForContextDetailLevel( DataGridContext dataGridContext, int desiredDetailLevel, HashSet <int> exportedColumnPositions) { int dataGridContextDetailLevel = dataGridContext.DetailLevel; // The detail level is too deep, return immediately if (dataGridContextDetailLevel > desiredDetailLevel) { return; } // The desired detail level is reached get the exportedColumnPositions if (dataGridContextDetailLevel == desiredDetailLevel) { DataGridContext parentDataGridContext = dataGridContext.ParentDataGridContext; if (parentDataGridContext == null) { this.GetVisibleColumnsVisiblePositionForDataGridContext(dataGridContext, exportedColumnPositions); } else { foreach (DataGridContext childContext in parentDataGridContext.GetChildContexts()) { if (this.GetVisibleColumnsVisiblePositionForDataGridContext(childContext, exportedColumnPositions)) { // All columns need to be exported, stop parsing child DataGridContexts break; } } } } else { // The detail level differs, parse the child contexts recursively foreach (DataGridContext childContext in dataGridContext.GetChildContexts()) { this.GetVisiblePositionsForContextDetailLevel(childContext, desiredDetailLevel, exportedColumnPositions); } } }
internal bool CanDoSort() { ColumnManagerRow parentRow = this.ParentRow as ColumnManagerRow; if (parentRow != null) { if (!parentRow.AllowSort) { return(false); } } DataGridContext dataGridContext = this.DataGridContext; if (dataGridContext == null) { return(false); } // When details are flatten, only the ColumnManagerCell at the master level may do the sort. if (dataGridContext.IsAFlattenDetail) { return(false); } if (dataGridContext.SourceDetailConfiguration == null) { if (!dataGridContext.Items.CanSort) { return(false); } } if (!this.IsEnabled) { return(false); } ColumnBase parentColumn = this.ParentColumn; if ((parentColumn == null) || (!parentColumn.AllowSort)) { return(false); } return(true); }
private HashSet <int> GetIntersectedRangesForIndex(DataGridContext dataGridContext, int itemIndex, int[] exportedVisiblePositions, int correctedExportedVisiblePositionsCount) { HashSet <int> intersectedIndexes = null; if (correctedExportedVisiblePositionsCount == 0) { return(intersectedIndexes); } SelectionItemRangeCollection selectedRanges = dataGridContext.SelectedItemRanges as SelectionItemRangeCollection; if (selectedRanges.Contains(itemIndex)) { intersectedIndexes = new HashSet <int>(exportedVisiblePositions); } else { intersectedIndexes = new HashSet <int>(); SelectionCellRange columnsRange = new SelectionCellRange(itemIndex, exportedVisiblePositions[0], itemIndex, exportedVisiblePositions[correctedExportedVisiblePositionsCount - 1]); IEnumerable <SelectionRange> intersectedRanges = dataGridContext.SelectedCellsStore.GetIntersectedColumnRanges(columnsRange); foreach (SelectionRange range in intersectedRanges) { int startIndex = range.StartIndex; int endIndex = range.EndIndex; if (startIndex > endIndex) { startIndex = range.EndIndex; endIndex = range.StartIndex; } for (int i = startIndex; i <= endIndex; i++) { if (!intersectedIndexes.Contains(i)) { intersectedIndexes.Add(i); } } } } return(intersectedIndexes); }
protected override void StartHeaderField(DataGridContext dataGridContext, Column column) { // We always insert the separator before the value except for the first item if (!m_isFirstColumn) { this.WriteToBaseStream(this.FormatSettings.Separator); } else { m_isFirstColumn = false; } object columnHeader = ((this.UseFieldNamesInHeader) || (column.Title == null)) ? column.FieldName : column.Title; string fieldValueString = UnicodeCsvClipboardExporter.FormatCsvData(null, columnHeader, this.FormatSettings); this.WriteToBaseStream(fieldValueString); }
public static IEnumerable <DiffItemInfo> GetVisibleItems(DataGridContext gridContext) { foreach (var item in gridContext.Headers) { yield return(new DiffItemInfo(gridContext, item)); } foreach (var item in gridContext.Items) { yield return(new DiffItemInfo(gridContext, item)); } foreach (var item in gridContext.Footers) { yield return(new DiffItemInfo(gridContext, item)); } }
public void CopyTo(object[] array, int arrayIndex) { DataGridContext dataGridContext = m_list.DataGridContext; int count = m_list.Count; for (int i = 0; i < count; i++) { SelectionRangeWithItems rangeWithItems = m_list[i]; int rangeLength = rangeWithItems.Length; for (int j = 0; j < rangeLength; j++) { array[arrayIndex] = rangeWithItems.GetItem(dataGridContext, j); arrayIndex++; } } }
void ICollection.CopyTo(Array array, int arrayIndex) { DataGridContext dataGridContext = m_list.DataGridContext; int count = m_list.Count; for (int i = 0; i < count; i++) { SelectionRangeWithItems rangeWithItems = m_list[i]; int rangeLength = rangeWithItems.Length; for (int j = 0; j < rangeLength; j++) { array.SetValue(rangeWithItems.GetItem(dataGridContext, j), arrayIndex); arrayIndex++; } } }
public HeaderFooterItemAutomationPeer(DataGridContext dataGridContext, object owner) { if (dataGridContext == null) { throw new ArgumentNullException("dataGridContext"); } if (owner == null) { throw new ArgumentNullException("owner"); } Debug.Assert((owner is GroupHeaderFooterItem) || (owner is DataTemplate) || (owner is HeaderFooterItem)); m_owner = owner; m_dataGridContext = dataGridContext; }
internal static bool IsDataItemHiddenBySticky( DataGridContext dataGridContext, object tempValue ) { // We only want to do special handling for a TableflowItemsHost. TableflowViewItemsHost itemsHost = dataGridContext.DataGridControl.ItemsHost as TableflowViewItemsHost; if( itemsHost == null ) return false; int index = dataGridContext.CustomItemContainerGenerator.FindIndexForItem( tempValue, dataGridContext ); if( index > -1 ) { return itemsHost.IsDataItemHiddenBySticky( index ); } return false; }
private static void TestMinimapItem(object item, DataGridContext gridContext, List <DiffMinimapItemInfo> itemInfoList, ref DiffMinimapItemInfo itemInfo) { var rowState = GetDiffState(item); if (rowState != itemInfo.DiffState || itemInfo.GridContext != gridContext) { if (itemInfo.Count != 0) { itemInfoList.Add(itemInfo); itemInfo = new DiffMinimapItemInfo(); } } itemInfo.GridContext = gridContext; itemInfo.DiffState = rowState; itemInfo.Count++; }
private void ExportDetailForMasterIndex( DataGridContext dataGridContext, int detailLevel, int masterIndexForDetail) { object item = dataGridContext.Items.GetItemAt(masterIndexForDetail); IEnumerable <DataGridContext> dataGridContexts = dataGridContext.CustomItemContainerGenerator.GetChildContextsForMasterItem(item); foreach (DataGridContext childContext in dataGridContexts) { this.Export(childContext); } this.UpdateExporterIndentation(detailLevel); }
public static IEnumerable <object> GetScrollableItems(this DataGridContext gridContext) { foreach (var item in gridContext.Headers) { yield return(item); } foreach (var item in gridContext.Items) { yield return(item); } foreach (var item in gridContext.Footers) { yield return(item); } }
public DetailGeneratorNode(DataGridContext context, CustomItemContainerGenerator generator) : base(null) { if (generator == null) { throw new ArgumentNullException("generator"); } if (context == null) { throw new ArgumentNullException("context"); } m_generator = generator; m_context = context; m_itemCount = generator.ItemCount; }
public ColumnSortDirectionChangingEventArgs(RoutedEvent routedEvent, ColumnBase column, DataGridContext dataGridContext, SortDirection currentSortDirection, SortDirection nextSortDirection) : base(routedEvent, column) { if (column == null) { throw new ArgumentNullException("column"); } if (dataGridContext == null) { throw new ArgumentNullException("dataGridContext"); } m_dataGridContext = dataGridContext; m_current = currentSortDirection; m_next = nextSortDirection; }
protected async override void PrepareContainer(DataGridContext dataGridContext, object item) { base.PrepareContainer(dataGridContext, item); var gridControl = dataGridContext.DataGridControl as DomainDataGridControl; if (this.domain == null) { var domain = gridControl.Domain; if (domain != null) { await domain.Dispatcher.InvokeAsync(() => { this.domain = domain; this.domain.MemberLocationChanged += Domain_MemberLocationChanged; this.domain.MemberEditBegun += Domain_MemberEditBegun; this.domain.MemberEditEnded += Domain_MemberEditEnded; this.domain.MemberRemoved += Domain_MemberRemoved; this.domain.Deleted += Domain_Deleted; // if (this.domain.GetService(typeof(ICremaHost)) is ICremaHost cremaHost) // { // this.UserID = cremaHost.UserID; // } }); } } this.UserInfos.Clear(); if (this.domain != null) { var domain = this.domain; var infos = await domain.Dispatcher.InvokeAsync(() => domain.Members.Select(i => new DomainMemberMetaData() { DomainMemberInfo = i.DomainMemberInfo, DomainMemberState = i.DomainMemberState, }).ToArray()); foreach (var i in infos) { if (HashUtility.Equals(this.keys, i.DomainLocationInfo.Keys) == true && this.tableName == i.DomainLocationInfo.TableName) { this.UserInfos.Set(i.DomainMemberInfo, i.DomainMemberState, i.DomainLocationInfo); } } } }
public SelectionRangePoint(DataGridContext dataGridContext, object item, int itemIndex, int columnPosition) { if (dataGridContext == null) { throw new ArgumentNullException(); } if (item == null) { throw new ArgumentNullException(); } m_localIndex = itemIndex; this.Item = item; this.ColumnIndex = columnPosition; this.DataGridContext = dataGridContext; }
private void ShowDropMark(Point mousePosition, DropMarkAlignment defaultAlignment, bool forceDefaultAlignment) { if (m_dropMarkAdorner == null) { DataGridContext dataGridContext = DataGridControl.GetDataGridContext(this); DataGridControl grid = (dataGridContext != null) ? dataGridContext.DataGridControl : null; Pen pen = UIViewBase.GetDropMarkPen(this); if ((pen == null) && (grid != null)) { UIViewBase uiViewBase = grid.GetView() as UIViewBase; pen = uiViewBase.DefaultDropMarkPen; } DropMarkOrientation orientation = Nequeo.Wpf.DataGrid.Views.UIViewBase.GetDropMarkOrientation(this); if ((orientation == DropMarkOrientation.Default) && (grid != null)) { UIViewBase uiViewBase = grid.GetView() as UIViewBase; orientation = uiViewBase.DefaultDropMarkOrientation; } m_dropMarkAdorner = new DropMarkAdorner(this, pen, orientation); AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this); if (adornerLayer != null) { adornerLayer.Add(m_dropMarkAdorner); } } if (forceDefaultAlignment) { m_dropMarkAdorner.ForceAlignment(defaultAlignment); } else { m_dropMarkAdorner.UpdateAlignment(mousePosition); } }
protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e) { // m_dragSourceManager.ProcessMouseLeftButtonUp() will release the capture, // so we need to check the IsMouseCaptured and IsPressed states before calling it. bool isMouseCaptured = this.IsMouseCaptured; bool isPressed = this.IsPressed; if (m_dragSourceManager != null) { m_dragSourceManager.ProcessMouseLeftButtonUp(e); } if (isMouseCaptured) { bool click = isPressed; this.ReleaseMouseCapture(); this.SetIsPressed(false); if (click) { this.DoSort(((Keyboard.Modifiers & ModifierKeys.Shift) != ModifierKeys.Shift)); } e.Handled = true; } // Focus must be done only on mouse up ( after the sort is done ... etc ) // we have to focus the grid. // We don't need to set PreserveEditorFocus to true since clicking on another element will automatically // set the Cell/Row IsBeingEdited to false and try to make it leave edition. DataGridContext dataGridContext = DataGridControl.GetDataGridContext(this); if (dataGridContext != null) { DataGridControl dataGridControl = dataGridContext.DataGridControl; if ((dataGridControl != null) && (!dataGridControl.IsKeyboardFocusWithin)) { dataGridControl.Focus(); } } base.OnMouseLeftButtonUp(e); }
protected override Size MeasureOverride(Size availableSize) { Size restrictedMeasureSize; DataGridContext dataGridContext = DataGridControl.GetDataGridContext(this); if (this.Orientation == Orientation.Vertical) { restrictedMeasureSize = new Size(availableSize.Width, double.PositiveInfinity); if (availableSize.Width != Double.PositiveInfinity) { dataGridContext.FixedHeaderFooterViewPortSize = restrictedMeasureSize; } } else { restrictedMeasureSize = new Size(double.PositiveInfinity, availableSize.Height); if (availableSize.Height != Double.PositiveInfinity) { dataGridContext.FixedHeaderFooterViewPortSize = restrictedMeasureSize; } } foreach (UIElement child in this.Children) { if ((child is HeaderFooterItem) && (typeof(Row).IsAssignableFrom((( HeaderFooterItem )child).VisualRootElementType))) { dataGridContext.ColumnStretchingManager.ColumnStretchingCalculated = false; // Calling Measure with the Viewport's width will have the effect of // distributing the extra space (see FixedCellPanel's MeasureOverride). // Eventually, the FixedCellPanel will receive an adjusted viewport // width (where GroupLevelIndicator's width et al will be substracted). child.Measure(restrictedMeasureSize); if (dataGridContext.ColumnStretchingManager.ColumnStretchingCalculated) { break; } } } return(base.MeasureOverride(availableSize)); }
private void DragScrollBegin(Orientation orientation) { DataGridContext dataGridContext = DataGridControl.GetDataGridContext(this); if (dataGridContext == null) { return; } DataGridControl parentGridControl = dataGridContext.DataGridControl; if (parentGridControl == null || dataGridContext.DataGridControl.ScrollViewer == null) { return; } if (parentGridControl.ItemScrollingBehavior == ItemScrollingBehavior.Deferred) { IDeferableScrollInfoRefresh panel = this.ScrollInfo as IDeferableScrollInfoRefresh; if (panel != null) { if (m_deferScrollInfoRefresh != null) { foreach (IDeferableScrollChanged deferable in m_deferableChilds) { deferable.DeferScrollChanged = false; } m_deferScrollInfoRefresh.Dispose(); m_deferScrollInfoRefresh = null; } m_deferScrollInfoRefresh = panel.DeferScrollInfoRefresh(orientation); if (m_deferScrollInfoRefresh != null) { foreach (IDeferableScrollChanged deferable in m_deferableChilds) { deferable.DeferScrollChanged = true; } } } } }
public void RemoveAt(int index) { if ((index < 0) || (index >= m_list.ItemsCount)) { throw new ArgumentOutOfRangeException("index", index, "index must be greater than or equal to zero and less than Count."); } int oldIndexOffset = 0; int indexOffset = 0; int count = m_list.Count; SelectionRangeWithItems rangeWithItemsFound = SelectionRangeWithItems.Empty; for (int i = 0; i < count; i++) { SelectionRangeWithItems rangeWithItems = m_list[i]; indexOffset += rangeWithItems.Length; if (index < indexOffset) { rangeWithItemsFound = rangeWithItems; // .GetItem( dataGridContext, index - oldIndexOffset ); break; } oldIndexOffset = indexOffset; } if (!rangeWithItemsFound.IsEmpty) { DataGridContext dataGridContext = m_list.DataGridContext; SelectionManager selectionManager = dataGridContext.DataGridControl.SelectionChangerManager; selectionManager.Begin(); try { selectionManager.UnselectItems(dataGridContext, new SelectionRangeWithItems( rangeWithItemsFound.Range.GetIndexFromItemOffset(index - oldIndexOffset), rangeWithItemsFound.GetItem(dataGridContext, index - oldIndexOffset))); } finally { selectionManager.End(false, true, true); } } }
// This function fills a list of objects of type 'DataGridContext' // This object is similar in members to the type 'Process' but it has nullable integer types public List <DataGridContext> CreateDataGridContext() { List <DataGridContext> dgcList = new List <DataGridContext>(); idCounter = 1; for (int i = 0; i < originalProcesses.Count; i++) { DataGridContext dgc = new DataGridContext(originalProcesses[i].ID, originalProcesses[i].ArrivalTime, originalProcesses[i].ProccesingTime, originalProcesses[i].Priority); dgcList.Add(dgc); idCounter++; } return(dgcList); }
public DomainTextClipboardPaster(DataGridContext gridContext) { this.gridContext = gridContext; this.columns = gridContext.GetSelectedColumns().ToArray(); this.items = gridContext.GetSelectedItems().ToArray(); var typedList = gridContext.Items.SourceCollection as ITypedList; if (typedList == null) { var source = (gridContext.Items.SourceCollection as CollectionView).SourceCollection; typedList = source as ITypedList; } this.props = typedList.GetItemProperties(null); this.tableName = CremaDataTable.GetTableName(typedList.GetListName(null)); this.columnNames = CremaDataRowUtility.GetColumnNames(typedList); }
private void ColumnResizerThumb_DragStarted(object sender, DragStartedEventArgs e) { ColumnBase parentColumn = this.ParentColumn; if (parentColumn == null) { return; } m_originalWidth = parentColumn.ActualWidth; DataGridContext dataGridContext = DataGridControl.GetDataGridContext(this); if ((dataGridContext != null) && (TableView.GetRemoveColumnStretchingOnResize(dataGridContext))) { dataGridContext.ColumnStretchingManager.DisableColumnStretching(); } }
public ModernTextClipboardParser(DataGridContext gridContext) { this.gridContext = gridContext; this.Columns = gridContext.Columns.ToArray(); if (gridContext.Items.SourceCollection is not ITypedList typedList) { var source = (gridContext.Items.SourceCollection as CollectionView).SourceCollection; typedList = source as ITypedList; } this.props = typedList.GetItemProperties(null); this.columnNames = new string[props.Count]; for (var i = 0; i < props.Count; i++) { this.columnNames[i] = props[i].Name; } }
public WeakDataGridContextKey( DataGridContext dataGridContext ) { DataGridContext parentDataGridContext = dataGridContext.ParentDataGridContext; int level = 0; while( parentDataGridContext != null ) { level++; parentDataGridContext = parentDataGridContext.ParentDataGridContext; } System.Diagnostics.Debug.Assert( ( ( level == 0 ) || ( dataGridContext.SourceDetailConfiguration != null ) ), "A child dataGridContext must have a SourceDetailConfiguration." ); m_sourceDetailConfigurationRelationName = ( dataGridContext.SourceDetailConfiguration != null ) ? dataGridContext.SourceDetailConfiguration.RelationName : string.Empty; if( level > 0 ) { // We are NOT dealing with the root DataGridContext. // Build the tree of master items. m_weakItemsTree = new WeakReference[ level ]; DataGridContext tempDataGridContext = dataGridContext; for( int i = level - 1; i >= 0; i-- ) { // Ensure to get a reference to the System.Data.DataRow when doing a // save/restore of a System.Data.DataRowView since the view is recreated // for every detail views object parentItem = ItemsSourceHelper.TryGetDataRowFromDataItem( tempDataGridContext.ParentItem ); m_weakItemsTree[ i ] = new WeakReference( parentItem ); tempDataGridContext = tempDataGridContext.ParentDataGridContext; } } this.Initialize(); }
internal static SelectionRange GetRange( this CollectionViewGroup collectionViewGroup, DataGridContext dataGridContext ) { int startIndex = -1; int endIndex = -1; DataGridVirtualizingCollectionViewGroupBase dataGridVirtualizingCollectionViewGroupBase = collectionViewGroup as DataGridVirtualizingCollectionViewGroupBase; DataGridCollectionViewGroup dataGridCollectionViewGroup = collectionViewGroup as DataGridCollectionViewGroup; if( dataGridVirtualizingCollectionViewGroupBase != null ) { startIndex = dataGridVirtualizingCollectionViewGroupBase.StartGlobalIndex; endIndex = startIndex + dataGridVirtualizingCollectionViewGroupBase.VirtualItemCount - 1; } else if( dataGridCollectionViewGroup != null ) { startIndex = dataGridCollectionViewGroup.GetFirstRawItemGlobalSortedIndex(); endIndex = startIndex + dataGridCollectionViewGroup.GlobalRawItemCount - 1; } else if(collectionViewGroup.ItemCount > 0) { if( dataGridContext == null ) throw new DataGridInternalException( "This collectionViewGroup require a DataGridContext instance" ); var firstItem = collectionViewGroup.GetFirstLeafItem(); var lastItem = collectionViewGroup.GetLastLeafItem(); if( firstItem != null && lastItem != null ) { startIndex = dataGridContext.Items.IndexOf( firstItem ); endIndex = dataGridContext.Items.IndexOf( lastItem ); } } return (startIndex >= 0 ) && (startIndex <= endIndex) ? new SelectionRange(startIndex, endIndex) : SelectionRange.Empty; }