예제 #1
0
        private void ClearChangeIndicator()
        {
            DataGridAutomationPeer automationPeer = (DataGridAutomationPeer)DataGridAutomationPeer.CreatePeerForElement(NodeMetadataDataGrid);

            // Get the DataGridRowsPresenterAutomationPeer so we can find the rows in the data grid...
            DataGridRowsPresenterAutomationPeer dataGridRowsPresenterAutomationPeer = automationPeer.GetChildren().
                                                                                      Where(a => (a is DataGridRowsPresenterAutomationPeer)).
                                                                                      Select(a => (a as DataGridRowsPresenterAutomationPeer)).
                                                                                      FirstOrDefault();

            if (null != dataGridRowsPresenterAutomationPeer)
            {
                foreach (var item in dataGridRowsPresenterAutomationPeer.GetChildren())
                {
                    // loop to find the DataGridCellAutomationPeer from which we can interrogate the owner -- which is a DataGridRow
                    foreach (var subitem in (item as DataGridItemAutomationPeer).GetChildren())
                    {
                        if ((subitem is DataGridCellAutomationPeer))
                        {
                            // At last -- the only public method for finding a row....
                            DataGridRow row = DataGridRow.GetRowContainingElement(((subitem as DataGridCellAutomationPeer).Owner as FrameworkElement));
                            row.Foreground = new SolidColorBrush(Colors.Black);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Scrolls a DataGridRow into view.
        /// </summary>
        /// <param name="itemsControl">The DataGrid containing the row.</param>
        /// <param name="itemContainer">The DataGridRow object.</param>
        protected override void ScrollIntoView(DataGrid itemsControl, DataGridRow itemContainer)
        {
            IScrollProvider scrollInfo = (IScrollProvider)DataGridAutomationPeer.CreatePeerForElement(itemsControl);

            double horizontalScrollPercentBeforeScroll = scrollInfo.HorizontalScrollPercent;
            double verticalScrollPercentBeforeScroll   = scrollInfo.VerticalScrollPercent;

            itemsControl.ScrollIntoView(itemContainer.DataContext, null);

            double horizontalScrollPercentAfterScroll = scrollInfo.HorizontalScrollPercent;
            double verticalScrollPercentAfterScroll   = scrollInfo.VerticalScrollPercent;

            double horizontalDiff = horizontalScrollPercentAfterScroll - horizontalScrollPercentBeforeScroll;
            double verticalDiff   = verticalScrollPercentAfterScroll - verticalScrollPercentBeforeScroll;

            scrollInfo.SetScrollPercent(scrollInfo.HorizontalScrollPercent + (horizontalDiff / 2.0), scrollInfo.VerticalScrollPercent + (verticalDiff / 2.0));
        }
 static void EnsureRowVisible(DataGrid grid, int itemIndex)
 {
     grid.ScrollIntoView(grid.Items[itemIndex]);
     grid.UpdateLayout();
     if (grid.ItemContainerGenerator.ContainerFromIndex(itemIndex) == null)
     {
         DataGridAutomationPeer peer = new DataGridAutomationPeer(grid);
         var scroll = peer.GetPattern(PatternInterface.Scroll) as IScrollProvider;
         scroll.SetScrollPercent(scroll.HorizontalScrollPercent, 0);
         grid.UpdateLayout();
         while (grid.ItemContainerGenerator.ContainerFromIndex(itemIndex) == null)
         {
             scroll.Scroll(ScrollAmount.NoAmount, ScrollAmount.LargeIncrement);
             grid.UpdateLayout();
         }
     }
 }
예제 #4
0
        public DataGridRow GetDataGridRowByDataContext(DataGrid dataGrid, object dataContext)
        {
            if (null != dataContext)
            {
                DataGridAutomationPeer automationPeer = (DataGridAutomationPeer)DataGridAutomationPeer.CreatePeerForElement(dataGrid);

                // Get the DataGridRowsPresenterAutomationPeer so we can find the rows in the data grid...
                DataGridRowsPresenterAutomationPeer dataGridRowsPresenterAutomationPeer = automationPeer.GetChildren().
                                                                                          Where(a => (a is DataGridRowsPresenterAutomationPeer)).
                                                                                          Select(a => (a as DataGridRowsPresenterAutomationPeer)).
                                                                                          FirstOrDefault();

                if (null != dataGridRowsPresenterAutomationPeer)
                {
                    foreach (var item in dataGridRowsPresenterAutomationPeer.GetChildren())
                    {
                        // loop to find the DataGridCellAutomationPeer from which we can interrogate the owner -- which is a DataGridRow
                        foreach (var subitem in (item as DataGridItemAutomationPeer).GetChildren())
                        {
                            if ((subitem is DataGridCellAutomationPeer))
                            {
                                // At last -- the only public method for finding a row....
                                DataGridRow row = DataGridRow.GetRowContainingElement(((subitem as DataGridCellAutomationPeer).Owner as FrameworkElement));

                                // check this row to see if it is bound to the requested dataContext.
                                if ((row.DataContext) == dataContext)
                                {
                                    return(row);
                                }

                                break; // Only need to check one cell in each row
                            }
                        }
                    }
                }
            }

            return(null);
        }
예제 #5
0
        private static void OnIsSelectedChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            DataGridRow row        = (DataGridRow)sender;
            bool        isSelected = (bool)e.NewValue;

            if (isSelected && !row.IsSelectable)
            {
                throw new InvalidOperationException(SR.Get(SRID.DataGridRow_CannotSelectRowWhenCells));
            }

            DataGrid grid = row.DataGridOwner;

            if (grid != null && row.DataContext != null)
            {
                DataGridAutomationPeer gridPeer = UIElementAutomationPeer.FromElement(grid) as DataGridAutomationPeer;
                if (gridPeer != null)
                {
                    DataGridItemAutomationPeer rowItemPeer = gridPeer.GetOrCreateItemPeer(row.DataContext);
                    if (rowItemPeer != null)
                    {
                        rowItemPeer.RaisePropertyChangedEvent(
                            System.Windows.Automation.SelectionItemPatternIdentifiers.IsSelectedProperty,
                            (bool)e.OldValue,
                            isSelected);
                    }
                }
            }

            // Update the header's IsRowSelected property
            row.NotifyPropertyChanged(row, e, NotificationTarget.Rows | NotificationTarget.RowHeaders);

            // This will raise the appropriate selection event, which will
            // bubble to the DataGrid. The base class Selector code will listen
            // for these events and will update SelectedItems as necessary.
            row.RaiseSelectionChangedEvent(isSelected);
        }
        private void ProcessSort()
        {
            if (this.OwningColumn != null &&
                this.OwningGrid != null &&
                this.OwningGrid.EditingRow == null &&
                this.OwningColumn != this.OwningGrid.ColumnsInternal.FillerColumn &&
                this.OwningGrid.CanUserSortColumns &&
                this.OwningColumn.CanUserSort)
            {
                DataGridColumnEventArgs ea = new DataGridColumnEventArgs(this.OwningColumn);
                this.OwningGrid.OnColumnSorting(ea);

#if FEATURE_ICOLLECTIONVIEW_SORT
                if (!ea.Handled && this.OwningGrid.DataConnection.AllowSort && this.OwningGrid.DataConnection.SortDescriptions != null)
                {
                    // - DataConnection.AllowSort is true, and
                    // - SortDescriptionsCollection exists, and
                    // - the column's data type is comparable
                    DataGrid          owningGrid = this.OwningGrid;
                    ListSortDirection newSortDirection;
                    SortDescription   newSort;

                    bool ctrl;
                    bool shift;

                    KeyboardHelper.GetMetaKeyState(out ctrl, out shift);

                    SortDescription?sort           = this.OwningColumn.GetSortDescription();
                    ICollectionView collectionView = owningGrid.DataConnection.CollectionView;
                    Debug.Assert(collectionView != null);
                    try
                    {
                        owningGrid.OnUserSorting();
                        using (collectionView.DeferRefresh())
                        {
                            // If shift is held down, we multi-sort, therefore if it isn't, we'll clear the sorts beforehand
                            if (!shift || owningGrid.DataConnection.SortDescriptions.Count == 0)
                            {
                                if (collectionView.CanGroup && collectionView.GroupDescriptions != null)
                                {
                                    // Make sure we sort by the GroupDescriptions first
                                    for (int i = 0; i < collectionView.GroupDescriptions.Count; i++)
                                    {
                                        PropertyGroupDescription groupDescription = collectionView.GroupDescriptions[i] as PropertyGroupDescription;
                                        if (groupDescription != null && collectionView.SortDescriptions.Count <= i || collectionView.SortDescriptions[i].PropertyName != groupDescription.PropertyName)
                                        {
                                            collectionView.SortDescriptions.Insert(Math.Min(i, collectionView.SortDescriptions.Count), new SortDescription(groupDescription.PropertyName, ListSortDirection.Ascending));
                                        }
                                    }
                                    while (collectionView.SortDescriptions.Count > collectionView.GroupDescriptions.Count)
                                    {
                                        collectionView.SortDescriptions.RemoveAt(collectionView.GroupDescriptions.Count);
                                    }
                                }
                                else if (!shift)
                                {
                                    owningGrid.DataConnection.SortDescriptions.Clear();
                                }
                            }

                            if (sort.HasValue)
                            {
                                // swap direction
                                switch (sort.Value.Direction)
                                {
                                case ListSortDirection.Ascending:
                                    newSortDirection = ListSortDirection.Descending;
                                    break;

                                default:
                                    newSortDirection = ListSortDirection.Ascending;
                                    break;
                                }

                                newSort = new SortDescription(sort.Value.PropertyName, newSortDirection);

                                // changing direction should not affect sort order, so we replace this column's
                                // sort description instead of just adding it to the end of the collection
                                int oldIndex = owningGrid.DataConnection.SortDescriptions.IndexOf(sort.Value);
                                if (oldIndex >= 0)
                                {
                                    owningGrid.DataConnection.SortDescriptions.Remove(sort.Value);
                                    owningGrid.DataConnection.SortDescriptions.Insert(oldIndex, newSort);
                                }
                                else
                                {
                                    owningGrid.DataConnection.SortDescriptions.Add(newSort);
                                }
                            }
                            else
                            {
                                // start new sort
                                newSortDirection = ListSortDirection.Ascending;

                                string propertyName = this.OwningColumn.GetSortPropertyName();

                                // no-opt if we couldn't find a property to sort on
                                if (string.IsNullOrEmpty(propertyName))
                                {
                                    return;
                                }

                                newSort = new SortDescription(propertyName, newSortDirection);

                                owningGrid.DataConnection.SortDescriptions.Add(newSort);
                            }
                        }
                    }
                    finally
                    {
                        owningGrid.OnUserSorted();
                    }

                    sortProcessed = true;
                }
#endif

                // Send the Invoked event for the column header's automation peer.
                DataGridAutomationPeer.RaiseAutomationInvokeEvent(this);
            }
        }