IRawElementProviderSimple[] ISelectionProvider.GetSelection()
{
EnsureEnabled();
if (this.OwningDataGrid != null &&
this.OwningDataGridPeer != null &&
this.OwningDataGrid.SelectedItems != null &&
_group.ItemCount > 0)
{
DataGridRowGroupInfo groupInfo = this.OwningDataGrid.RowGroupInfoFromCollectionViewGroup(_group);
if (groupInfo != null)
{
// See which of the selected items are contained within this group
List <IRawElementProviderSimple> selectedProviders = new List <IRawElementProviderSimple>();
int startRowIndex = groupInfo.Slot - this.OwningDataGrid.RowGroupHeadersTable.GetIndexCount(0, groupInfo.Slot) + 1;
foreach (object item in this.OwningDataGrid.GetSelectionInclusive(startRowIndex, startRowIndex + _group.ItemCount - 1))
{
DataGridItemAutomationPeer peer = this.OwningDataGridPeer.GetOrCreateItemPeer(item);
if (peer != null)
{
selectedProviders.Add(ProviderFromPeer(peer));
}
}
return(selectedProviders.ToArray());
}
}
return(null);
}
internal DataGridItemAutomationPeer GetOrCreateItemPeer(object item)
{
DataGridItemAutomationPeer peer = null;
if (item != null)
{
if (_itemPeers.ContainsKey(item))
{
peer = _itemPeers[item];
}
else
{
peer = new DataGridItemAutomationPeer(item, this.OwningDataGrid);
_itemPeers.Add(item, peer);
}
DataGridRowAutomationPeer rowPeer = peer.OwningRowPeer;
if (rowPeer != null)
{
rowPeer.EventsSource = peer;
}
}
return(peer);
}
internal void RaiseAutomationInvokeEvents(DataGridEditingUnit editingUnit, DataGridColumn column, DataGridRow row)
{
switch (editingUnit)
{
case DataGridEditingUnit.Cell:
{
DataGridCell cell = row.Cells[column.Index];
AutomationPeer peer = FromElement(cell);
if (peer != null)
{
peer.InvalidatePeer();
}
else
{
peer = CreatePeerForElement(cell);
}
if (peer != null)
{
peer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
}
break;
}
case DataGridEditingUnit.Row:
{
DataGridItemAutomationPeer peer = GetOrCreateItemPeer(row.DataContext);
peer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
break;
}
}
}
// Token: 0x06002604 RID: 9732 RVA: 0x000B5F50 File Offset: 0x000B4150
protected override List <AutomationPeer> GetChildrenCore()
{
DataGridCellsPresenter cellsPresenter = this.OwningDataGridRow.CellsPresenter;
if (cellsPresenter != null && cellsPresenter.ItemsHost != null)
{
List <AutomationPeer> list = new List <AutomationPeer>(3);
AutomationPeer rowHeaderAutomationPeer = this.RowHeaderAutomationPeer;
if (rowHeaderAutomationPeer != null)
{
list.Add(rowHeaderAutomationPeer);
}
DataGridItemAutomationPeer dataGridItemAutomationPeer = base.EventsSource as DataGridItemAutomationPeer;
if (dataGridItemAutomationPeer != null)
{
list.AddRange(dataGridItemAutomationPeer.GetCellItemPeers());
}
AutomationPeer detailsPresenterAutomationPeer = this.DetailsPresenterAutomationPeer;
if (detailsPresenterAutomationPeer != null)
{
list.Add(detailsPresenterAutomationPeer);
}
return(list);
}
return(base.GetChildrenCore());
}
override internal void AddToParentProxyWeakRefCache()
{
DataGridItemAutomationPeer owningItemPeer = this.OwningItemPeer;
if (owningItemPeer != null)
{
owningItemPeer.AddProxyToWeakRefStorage(this.ElementProxyWeakReference, this);
}
}
// This method is called from DataGrid.OnBeginningEdit/OnCommittingEdit/OnCancelingEdit
// Raises Invoked event when row begin/cancel/commit edit
internal void RaiseAutomationRowInvokeEvents(DataGridRow row)
{
DataGridItemAutomationPeer dataGridItemAutomationPeer = FindOrCreateItemAutomationPeer(row.Item) as DataGridItemAutomationPeer;
if (dataGridItemAutomationPeer != null)
{
dataGridItemAutomationPeer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
}
}
// Token: 0x06002577 RID: 9591 RVA: 0x000B4338 File Offset: 0x000B2538
private DataGridCellItemAutomationPeer GetCellItemPeer(DataGridCellInfo cellInfo)
{
if (cellInfo.IsValid)
{
DataGridItemAutomationPeer dataGridItemAutomationPeer = this.FindOrCreateItemAutomationPeer(cellInfo.Item) as DataGridItemAutomationPeer;
if (dataGridItemAutomationPeer != null)
{
return(dataGridItemAutomationPeer.GetOrCreateCellItemPeer(cellInfo.Column));
}
}
return(null);
}
// 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 = FindOrCreateItemAutomationPeer(row.Item) as DataGridItemAutomationPeer;
if (dataGridItemAutomationPeer != null)
{
DataGridCellItemAutomationPeer cellPeer = dataGridItemAutomationPeer.GetOrCreateCellItemPeer(column);
if (cellPeer != null)
{
cellPeer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
}
}
}
IRawElementProviderSimple[] ISelectionProvider.GetSelection()
{
if (this.OwningDataGrid != null &&
this.OwningDataGrid.SelectedItems != null)
{
List <IRawElementProviderSimple> selectedProviders = new List <IRawElementProviderSimple>();
foreach (object item in this.OwningDataGrid.SelectedItems)
{
DataGridItemAutomationPeer peer = GetOrCreateItemPeer(item);
selectedProviders.Add(ProviderFromPeer(peer));
}
return(selectedProviders.ToArray());
}
return(null);
}
internal void RaiseAutomationSelectionEvents(SelectionChangedEventArgs e)
{
// If the result of an AddToSelection or RemoveFromSelection is a single selected item,
// then all we raise is the ElementSelectedEvent for single item
if (AutomationPeer.ListenerExists(AutomationEvents.SelectionItemPatternOnElementSelected) &&
this.OwningDataGrid.SelectedItems.Count == 1)
{
if (this.OwningDataGrid.SelectedItem != null && _itemPeers.ContainsKey(this.OwningDataGrid.SelectedItem))
{
DataGridItemAutomationPeer peer = _itemPeers[this.OwningDataGrid.SelectedItem];
peer.RaiseAutomationEvent(AutomationEvents.SelectionItemPatternOnElementSelected);
}
}
else
{
int i;
if (AutomationPeer.ListenerExists(AutomationEvents.SelectionItemPatternOnElementAddedToSelection))
{
for (i = 0; i < e.AddedItems.Count; i++)
{
if (e.AddedItems[i] != null && _itemPeers.ContainsKey(e.AddedItems[i]))
{
DataGridItemAutomationPeer peer = _itemPeers[e.AddedItems[i]];
peer.RaiseAutomationEvent(AutomationEvents.SelectionItemPatternOnElementAddedToSelection);
}
}
}
if (AutomationPeer.ListenerExists(AutomationEvents.SelectionItemPatternOnElementRemovedFromSelection))
{
for (i = 0; i < e.RemovedItems.Count; i++)
{
if (e.RemovedItems[i] != null && _itemPeers.ContainsKey(e.RemovedItems[i]))
{
DataGridItemAutomationPeer peer = _itemPeers[e.RemovedItems[i]];
peer.RaiseAutomationEvent(AutomationEvents.SelectionItemPatternOnElementRemovedFromSelection);
}
}
}
}
}
/// <summary>Retrieves the UI Automation provider for the specified cell.</summary>
/// <param name="row">The ordinal number of the row of interest.</param>
/// <param name="column">The ordinal number of the column of interest.</param>
/// <returns>The UI Automation provider for the specified cell.</returns>
// Token: 0x0600256F RID: 9583 RVA: 0x000B40E0 File Offset: 0x000B22E0
IRawElementProviderSimple IGridProvider.GetItem(int row, int column)
{
if (row >= 0 && row < this.OwningDataGrid.Items.Count && column >= 0 && column < this.OwningDataGrid.Columns.Count)
{
object item = this.OwningDataGrid.Items[row];
DataGridColumn column2 = this.OwningDataGrid.Columns[column];
this.OwningDataGrid.ScrollIntoView(item, column2);
this.OwningDataGrid.UpdateLayout();
DataGridItemAutomationPeer dataGridItemAutomationPeer = this.FindOrCreateItemAutomationPeer(item) as DataGridItemAutomationPeer;
if (dataGridItemAutomationPeer != null)
{
DataGridCellItemAutomationPeer orCreateCellItemPeer = dataGridItemAutomationPeer.GetOrCreateCellItemPeer(column2);
if (orCreateCellItemPeer != null)
{
return(base.ProviderFromPeer(orCreateCellItemPeer));
}
}
}
return(null);
}
/// <summary>Retrieves a collection of UI Automation providers representing all the row headers associated with a table item or cell.</summary>
/// <returns>A collection of UI Automation providers. </returns>
// Token: 0x060025A7 RID: 9639 RVA: 0x000B4CE0 File Offset: 0x000B2EE0
IRawElementProviderSimple[] ITableItemProvider.GetRowHeaderItems()
{
if (this.OwningDataGrid != null && (this.OwningDataGrid.HeadersVisibility & DataGridHeadersVisibility.Row) == DataGridHeadersVisibility.Row)
{
DataGridAutomationPeer dataGridAutomationPeer = UIElementAutomationPeer.CreatePeerForElement(this.OwningDataGrid) as DataGridAutomationPeer;
DataGridItemAutomationPeer dataGridItemAutomationPeer = dataGridAutomationPeer.FindOrCreateItemAutomationPeer(this.Item) as DataGridItemAutomationPeer;
if (dataGridItemAutomationPeer != null)
{
AutomationPeer rowHeaderAutomationPeer = dataGridItemAutomationPeer.RowHeaderAutomationPeer;
if (rowHeaderAutomationPeer != null)
{
return(new List <IRawElementProviderSimple>(1)
{
base.ProviderFromPeer(rowHeaderAutomationPeer)
}.ToArray());
}
}
}
return(null);
}
internal void PopulateItemPeers()
{
Dictionary <object, DataGridItemAutomationPeer> oldChildren = new Dictionary <object, DataGridItemAutomationPeer>(_itemPeers);
_itemPeers.Clear();
if (this.OwningDataGrid.ItemsSource != null)
{
foreach (object item in this.OwningDataGrid.ItemsSource)
{
if (item != null)
{
DataGridItemAutomationPeer peer = null;
if (oldChildren.ContainsKey(item))
{
peer = oldChildren[item] as DataGridItemAutomationPeer;
}
else
{
peer = new DataGridItemAutomationPeer(item, this.OwningDataGrid);
}
if (peer != null)
{
DataGridRowAutomationPeer rowPeer = peer.OwningRowPeer;
if (rowPeer != null)
{
rowPeer.EventsSource = peer;
}
}
// This guards against the addition of duplicate items
if (!_itemPeers.ContainsKey(item))
{
_itemPeers.Add(item, peer);
}
}
}
}
}
/// <summary>Retrieves a collection of UI Automation providers that represents all row headers in the table.</summary>
/// <returns>A collection of UI Automation providers.</returns>
// Token: 0x06002575 RID: 9589 RVA: 0x000B4284 File Offset: 0x000B2484
IRawElementProviderSimple[] ITableProvider.GetRowHeaders()
{
if ((this.OwningDataGrid.HeadersVisibility & DataGridHeadersVisibility.Row) == DataGridHeadersVisibility.Row)
{
List <IRawElementProviderSimple> list = new List <IRawElementProviderSimple>();
foreach (object item in ((IEnumerable)this.OwningDataGrid.Items))
{
DataGridItemAutomationPeer dataGridItemAutomationPeer = this.FindOrCreateItemAutomationPeer(item) as DataGridItemAutomationPeer;
AutomationPeer rowHeaderAutomationPeer = dataGridItemAutomationPeer.RowHeaderAutomationPeer;
if (rowHeaderAutomationPeer != null)
{
list.Add(base.ProviderFromPeer(rowHeaderAutomationPeer));
}
}
if (list.Count > 0)
{
return(list.ToArray());
}
}
return(null);
}
///
protected override List <AutomationPeer> GetChildrenCore()
{
// see whether the DataGridRow uses the standard control template
DataGridCellsPresenter cellsPresenter = OwningDataGridRow.CellsPresenter;
if (cellsPresenter != null && cellsPresenter.ItemsHost != null)
{
// this is the normal case
List <AutomationPeer> children = new List <AutomationPeer>(3);
// Step 1: Add row header if exists
AutomationPeer dataGridRowHeaderAutomationPeer = RowHeaderAutomationPeer;
if (dataGridRowHeaderAutomationPeer != null)
{
children.Add(dataGridRowHeaderAutomationPeer);
}
// Step 2: Add all cells
DataGridItemAutomationPeer itemPeer = this.EventsSource as DataGridItemAutomationPeer;
if (itemPeer != null)
{
children.AddRange(itemPeer.GetCellItemPeers());
}
// Step 3: Add DetailsPresenter last if exists
AutomationPeer dataGridDetailsPresenterAutomationPeer = DetailsPresenterAutomationPeer;
if (dataGridDetailsPresenterAutomationPeer != null)
{
children.Add(dataGridDetailsPresenterAutomationPeer);
}
return(children);
}
else
{
// in the unusual case where the app uses a non-standard control template
// for the DataGridRow, fall back to the base implementation
return(base.GetChildrenCore());
}
}
// Token: 0x0600257C RID: 9596 RVA: 0x000B4578 File Offset: 0x000B2778
private void AddSelectedCells(List <IRawElementProviderSimple> cellProviders)
{
if (cellProviders == null)
{
throw new ArgumentNullException("cellProviders");
}
if (this.OwningDataGrid.SelectedCells != null)
{
foreach (DataGridCellInfo dataGridCellInfo in this.OwningDataGrid.SelectedCells)
{
DataGridItemAutomationPeer dataGridItemAutomationPeer = this.FindOrCreateItemAutomationPeer(dataGridCellInfo.Item) as DataGridItemAutomationPeer;
if (dataGridItemAutomationPeer != null)
{
IRawElementProviderSimple rawElementProviderSimple = base.ProviderFromPeer(dataGridItemAutomationPeer.GetOrCreateCellItemPeer(dataGridCellInfo.Column));
if (rawElementProviderSimple != null)
{
cellProviders.Add(rawElementProviderSimple);
}
}
}
}
}
private void AddSelectedCells(List <IRawElementProviderSimple> cellProviders)
{
if (cellProviders == null)
{
throw new ArgumentNullException("cellProviders");
}
// Add selected cells to selection
if (this.OwningDataGrid.SelectedCells != null)
{
foreach (DataGridCellInfo cellInfo in this.OwningDataGrid.SelectedCells)
{
DataGridItemAutomationPeer itemPeer = this.FindOrCreateItemAutomationPeer(cellInfo.Item) as DataGridItemAutomationPeer;
if (itemPeer != null)
{
IRawElementProviderSimple provider = ProviderFromPeer(itemPeer.GetOrCreateCellItemPeer(cellInfo.Column));
if (provider != null)
{
cellProviders.Add(provider);
}
}
}
}
}
public void DataGridItem_IScrollItemProvider()
{
List<Customer> boundList = CreateCustomerList(25);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
dataGrid.ColumnWidth = new DataGridLength(100.0);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
AutomationPeer peer;
IScrollItemProvider scrollItem;
int index = boundList.Count;
for (int i = 0; i < boundList.Count; i++)
{
EnqueueCallback(delegate
{
index--;
peer = new DataGridItemAutomationPeer(boundList[index], dataGrid);
Assert.IsNotNull(peer);
scrollItem = peer.GetPattern(PatternInterface.ScrollItem) as IScrollItemProvider;
Assert.IsNotNull(scrollItem);
scrollItem.ScrollIntoView();
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.IsTrue(dataGrid.IsSlotVisible(dataGrid.SlotFromRowIndex(index)));
});
}
EnqueueTestComplete();
}
public void DataGridItem_IInvokeProvider()
{
List<Customer> boundList = CreateCustomerList(5);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 200;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
AutomationPeer peer;
IInvokeProvider invoker;
int index = 0;
for (int i = 0; i < boundList.Count; i++)
{
EnqueueCallback(delegate
{
Assert.IsNull(dataGrid.EditingRow);
Assert.AreEqual(-1, dataGrid.EditingColumnIndex);
peer = new DataGridItemAutomationPeer(boundList[index], dataGrid);
Assert.IsNotNull(peer);
invoker = (IInvokeProvider)peer.GetPattern(PatternInterface.Invoke);
Assert.IsNotNull(invoker);
invoker.Invoke();
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.AreEqual(0, dataGrid.EditingColumnIndex);
Assert.IsNotNull(dataGrid.EditingRow);
Assert.AreEqual(index, dataGrid.EditingRow.Index);
peer = new DataGridItemAutomationPeer(boundList[index], dataGrid);
Assert.IsNotNull(peer);
invoker = (IInvokeProvider)peer.GetPattern(PatternInterface.Invoke);
Assert.IsNotNull(invoker);
invoker.Invoke();
index++;
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.IsNull(dataGrid.EditingRow);
Assert.AreEqual(-1, dataGrid.EditingColumnIndex);
});
}
EnqueueTestComplete();
}
public void DataGridItem_AutomationPeer()
{
List<Customer> boundList = CreateCustomerList(1);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
AutomationPeer peer = new DataGridItemAutomationPeer(boundList[0], dataGrid);
Assert.IsNotNull(peer);
Assert.AreEqual(AutomationControlType.DataItem, peer.GetAutomationControlType(), "Incorrect ControlType value");
Assert.AreEqual(true, peer.IsContentElement(), "Incorrect IsContentElement value");
Assert.AreEqual(true, peer.IsControlElement(), "Incorrect IsControlElement value");
Assert.AreEqual(false, peer.IsKeyboardFocusable(), "Incorrect IsKeyBoardFocusable value");
Assert.AreEqual(boundList[0].ToString(), peer.GetName(), "Incorrect Name value");
Assert.IsNotNull(peer.GetChildren(), "GetChildren should never return null");
});
EnqueueTestComplete();
}
public void DataGridGroupItem_ISelectionProvider()
{
PagedCollectionView customers = CreateGroupedCustomerCollectionView();
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = customers;
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
AutomationPeer peer;
ISelectionProvider selector = null;
TestPeer testPeer = new TestPeer(dataGrid);
EnqueueCallback(delegate
{
CollectionViewGroup group = customers.Groups[1] as CollectionViewGroup;
Assert.IsNotNull(group, "PagedCollectionView did not return CollectionViewGroup");
peer = new DataGridGroupItemAutomationPeer(group, dataGrid);
Assert.IsNotNull(peer);
selector = peer.GetPattern(PatternInterface.Selection) as ISelectionProvider;
Assert.IsNotNull(selector);
Assert.AreEqual(0, selector.GetSelection().Length, "There should not be any selected items within this group");
// Select an item within group 1
peer = new DataGridItemAutomationPeer(customers[3], dataGrid);
Assert.IsNotNull(peer);
ISelectionItemProvider selectionItem = peer.GetPattern(PatternInterface.SelectionItem) as ISelectionItemProvider;
Assert.IsNotNull(selectionItem);
selectionItem.AddToSelection();
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.IsNotNull(selector);
Assert.AreEqual(1, selector.GetSelection().Length, "There should be a single selected item within this group");
peer = testPeer.GetPeerFromProvider(selector.GetSelection()[0]);
Assert.AreEqual(typeof(DataGridRow).Name, peer.GetClassName(), "GetSelection did not return DataGridRow");
});
this.EnqueueYieldThread();
EnqueueTestComplete();
}
internal void PopulateItemPeers()
{
Dictionary<object, DataGridItemAutomationPeer> oldChildren = new Dictionary<object, DataGridItemAutomationPeer>(_itemPeers);
_itemPeers.Clear();
if (this.OwningDataGrid.ItemsSource != null)
{
foreach (object item in this.OwningDataGrid.ItemsSource)
{
if (item != null)
{
DataGridItemAutomationPeer peer = null;
if (oldChildren.ContainsKey(item))
{
peer = oldChildren[item] as DataGridItemAutomationPeer;
}
else
{
peer = new DataGridItemAutomationPeer(item, this.OwningDataGrid);
}
if (peer != null)
{
DataGridRowAutomationPeer rowPeer = peer.OwningRowPeer;
if (rowPeer != null)
{
rowPeer.EventsSource = peer;
}
}
// This guards against the addition of duplicate items
if (!_itemPeers.ContainsKey(item))
{
_itemPeers.Add(item, peer);
}
}
}
}
}
public void DataGridItem_ISelectionItemProvider()
{
List<Customer> boundList = CreateCustomerList(5);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
dataGrid.ColumnWidth = new DataGridLength(100.0);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
List<DataGridRow> rows = new List<DataGridRow>();
AutomationPeer peer;
List<ISelectionItemProvider> selectionItems = new List<ISelectionItemProvider>();
EnqueueCallback(delegate
{
for (int i = 0; i < boundList.Count; i++)
{
rows.Add(dataGrid.GetRowFromItem(boundList[i]));
peer = new DataGridItemAutomationPeer(boundList[i], dataGrid);
Assert.IsNotNull(peer);
selectionItems.Add(peer.GetPattern(PatternInterface.SelectionItem) as ISelectionItemProvider);
Assert.IsNotNull(selectionItems[i]);
selectionItems[i].AddToSelection();
}
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
foreach (DataGridRow row in rows)
{
Assert.IsTrue(row.IsSelected);
}
foreach (ISelectionItemProvider select in selectionItems)
{
select.RemoveFromSelection();
}
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
foreach (DataGridRow row in rows)
{
Assert.IsFalse(row.IsSelected);
}
selectionItems[0].Select();
selectionItems[3].Select();
selectionItems[3].Select();
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.IsFalse(rows[0].IsSelected);
Assert.IsTrue(rows[3].IsSelected);
dataGrid.SelectionMode = DataGridSelectionMode.Single;
selectionItems[4].AddToSelection();
//
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.IsFalse(rows[2].IsSelected);
Assert.IsTrue(rows[4].IsSelected);
});
EnqueueTestComplete();
}
public void DataGridItem_ISelectionProvider()
{
List<Customer> boundList = CreateCustomerList(5);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
dataGrid.ColumnWidth = new DataGridLength(100.0);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
AutomationPeer peer;
ISelectionProvider selector;
TestPeer testPeer = new TestPeer(dataGrid);
EnqueueCallback(delegate
{
peer = new DataGridItemAutomationPeer(boundList[0], dataGrid);
Assert.IsNotNull(peer);
selector = peer.GetPattern(PatternInterface.Selection) as ISelectionProvider;
Assert.IsNotNull(selector);
Assert.AreEqual(1, selector.GetSelection().Length);
peer = testPeer.GetPeerFromProvider(selector.GetSelection()[0]);
Assert.AreEqual(typeof(DataGridCell).Name, peer.GetClassName(), "GetSelection did not return DataGridCell");
});
this.EnqueueYieldThread();
EnqueueTestComplete();
}
internal DataGridItemAutomationPeer GetOrCreateItemPeer(object item)
{
DataGridItemAutomationPeer peer = null;
if (item != null)
{
if (_itemPeers.ContainsKey(item))
{
peer = _itemPeers[item];
}
else
{
peer = new DataGridItemAutomationPeer(item, this.OwningDataGrid);
_itemPeers.Add(item, peer);
}
DataGridRowAutomationPeer rowPeer = peer.OwningRowPeer;
if (rowPeer != null)
{
rowPeer.EventsSource = peer;
}
}
return peer;
}
