public void Initialize(IGridProvider<string> dataProvider)
{
_scroller = new VisualGridScroller();
DataProvider = dataProvider;
_gridPoints = new GridPoints(RowCount, ColumnCount);
RowHeader.RowCount = RowCount;
RowHeader.ColumnCount = 1;
RowHeader.Points = _gridPoints;
RowHeader.DataProvider = DataProvider;
ColumnHeader.RowCount = 1;
ColumnHeader.ColumnCount = ColumnCount;
ColumnHeader.Points = _gridPoints;
ColumnHeader.DataProvider = DataProvider;
Data.RowCount = RowCount;
Data.ColumnCount = ColumnCount;
Data.Points = _gridPoints;
Data.DataProvider = DataProvider;
_scroller.Points = _gridPoints;
_scroller.ColumnHeader = ColumnHeader;
_scroller.RowHeader = RowHeader;
_scroller.DataGrid = Data;
_scroller.DataProvider = DataProvider;
}
internal void Initialize(IGridProvider <string> dataProvider)
{
if (Points != null)
{
Points.PointChanged -= Points_PointChanged;
}
Points = new GridPoints(dataProvider.RowCount, dataProvider.ColumnCount, Data.RenderSize);
Points.PointChanged += Points_PointChanged;
ColumnHeader.Clear();
RowHeader.Clear();
Data.Clear();
DataProvider = dataProvider;
_scroller?.StopScroller();
_scroller = new VisualGridScroller(this);
Refresh(); // initial refresh
// reset scroll bar position to zero
HorizontalScrollBar.Value = HorizontalScrollBar.Minimum;
VerticalScrollBar.Value = VerticalScrollBar.Minimum;
SetScrollBar(ScrollDirection.Both);
}
internal void Initialize(IGridProvider<string> dataProvider) {
if (Points != null) {
Points.PointChanged -= Points_PointChanged;
}
Points = new GridPoints(dataProvider.RowCount, dataProvider.ColumnCount, Data.RenderSize);
Points.PointChanged += Points_PointChanged;
ColumnHeader.Clear();
RowHeader.Clear();
Data.Clear();
DataProvider = dataProvider;
_scroller?.StopScroller();
_scroller = new VisualGridScroller(this);
Refresh(); // initial refresh
// reset scroll bar position to zero
HorizontalScrollBar.Value = HorizontalScrollBar.Minimum;
VerticalScrollBar.Value = VerticalScrollBar.Minimum;
SetScrollBar(ScrollDirection.Both);
CanSort = dataProvider.CanSort;
}
public void TestGridProvider(IRawElementProviderSimple provider)
{
IGridProvider gridProvider = (IGridProvider)
provider.GetPatternProvider(GridPatternIdentifiers.Pattern.Id);
Assert.AreEqual(daysInWeek, gridProvider.ColumnCount);
Assert.AreEqual(6, gridProvider.RowCount);
DateTime date = calendar.GetDisplayRange(false).Start;
for (int r = 0; r < 6; r++)
{
for (int c = 0; c < daysInWeek; c++)
{
IRawElementProviderSimple child
= gridProvider.GetItem(r, c);
TestProperty(child,
AutomationElementIdentifiers.ControlTypeProperty,
ControlType.ListItem.Id);
TestProperty(child,
AutomationElementIdentifiers.NameProperty,
date.Day.ToString());
date = date.AddDays(1);
}
}
}
private readonly ITextProvider2 publicITextProvider2; // AccessibleObject as ITextProvider2
/// <summary>
/// Create a new wrapper.
/// </summary>
internal InternalAccessibleObject(AccessibleObject accessibleImplemention)
{
// Get all the casts done here to catch any issues early
publicIAccessible = (IAccessible)accessibleImplemention;
publicIEnumVariant = (Oleaut32.IEnumVariant)accessibleImplemention;
publicIOleWindow = (Ole32.IOleWindow)accessibleImplemention;
publicIReflect = (IReflect)accessibleImplemention;
publicIServiceProvider = (Ole32.IServiceProvider)accessibleImplemention;
publicIAccessibleEx = (IAccessibleEx)accessibleImplemention;
publicIRawElementProviderSimple = (IRawElementProviderSimple)accessibleImplemention;
publicIRawElementProviderFragment = (IRawElementProviderFragment)accessibleImplemention;
publicIRawElementProviderFragmentRoot = (IRawElementProviderFragmentRoot)accessibleImplemention;
publicIInvokeProvider = (IInvokeProvider)accessibleImplemention;
publicIValueProvider = (IValueProvider)accessibleImplemention;
publicIRangeValueProvider = (IRangeValueProvider)accessibleImplemention;
publicIExpandCollapseProvider = (IExpandCollapseProvider)accessibleImplemention;
publicIToggleProvider = (IToggleProvider)accessibleImplemention;
publicITableProvider = (ITableProvider)accessibleImplemention;
publicITableItemProvider = (ITableItemProvider)accessibleImplemention;
publicIGridProvider = (IGridProvider)accessibleImplemention;
publicIGridItemProvider = (IGridItemProvider)accessibleImplemention;
publicILegacyIAccessibleProvider = (ILegacyIAccessibleProvider)accessibleImplemention;
publicISelectionProvider = (ISelectionProvider)accessibleImplemention;
publicISelectionItemProvider = (ISelectionItemProvider)accessibleImplemention;
publicIScrollItemProvider = (IScrollItemProvider)accessibleImplemention;
publicIRawElementProviderHwndOverride = (IRawElementProviderHwndOverride)accessibleImplemention;
publicIMultiViewProvider = (IMultipleViewProvider)accessibleImplemention;
publicITextProvider = (ITextProvider)accessibleImplemention;
publicITextProvider2 = (ITextProvider2)accessibleImplemention;
// Note: Deliberately not holding onto AccessibleObject to enforce all access through the interfaces
}
public void IGridProviderEventTest()
{
StatusStrip statusStrip = new StatusStrip();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(statusStrip);
IGridProvider gridProvider = (IGridProvider)
provider.GetPatternProvider(GridPatternIdentifiers.Pattern.Id);
Assert.IsNotNull(gridProvider,
"Not returning GridPatternIdentifiers.");
bool eventInvoked = false;
statusStrip.ItemAdded += delegate(object sender, ToolStripItemEventArgs e) {
eventInvoked = true;
};
statusStrip.Items.Add("Item");
Assert.IsTrue(eventInvoked,
"Event should be invoked when items added.");
eventInvoked = false;
statusStrip.ItemRemoved += delegate(object sender, ToolStripItemEventArgs e) {
eventInvoked = true;
};
statusStrip.Items.RemoveAt(0);
Assert.IsTrue(eventInvoked,
"Event should be invoked when items removed.");
}
/// <summary>
/// IGridProvider implementation.
/// </summary>
public IRawElementProviderSimple GetItem(int rowIndex, int columnIndex)
{
IGridProvider gridProvider = (IGridProvider)this;
int rowCount = gridProvider.RowCount;
int columnCount = gridProvider.ColumnCount;
if (rowIndex < 0 || rowIndex >= rowCount)
{
throw new ArgumentOutOfRangeException("row");
}
if (columnIndex < 0 || columnIndex >= columnCount)
{
throw new ArgumentOutOfRangeException("column");
}
var cellsForRow = this.OwnerDataGrid.Model.CellsController.GetCellsForRow(rowIndex);
if (cellsForRow.Count() > 0)
{
var cell = cellsForRow.Where(a => a.Column.ItemInfo.Slot == columnIndex).FirstOrDefault();
if (cell != null)
{
var gridCellInfoPeer = this.childrenCache.Where(a => a.Row == cell.ParentRow.ItemInfo.Slot && a.Column == cell.Column.ItemInfo.Slot).First() as DataGridCellInfoAutomationPeer;
if (gridCellInfoPeer != null)
{
return(this.ProviderFromPeer(gridCellInfoPeer));
}
}
}
return(null);
}
public void IGridProvider_Methods()
{
Calendar calendar = CreateConcreteFrameworkElement() as Calendar;
AutomationPeer peer = FrameworkElementAutomationPeer.CreatePeerForElement(calendar);
IGridProvider gridProvider = null;
IRawElementProviderSimple cell = null;
AutomationPeer cellPeer = null;
CreateAsyncTest(calendar,
() => {
Assert.IsNotNull(peer, "#0");
gridProvider = peer.GetPattern(PatternInterface.Grid) as IGridProvider;
Assert.IsNotNull(gridProvider, "#1");
// IGridProvider.RowCount
calendar.DisplayMode = CalendarMode.Month;
Assert.AreEqual(6, gridProvider.RowCount, "RowCount #0"); // First row displays day titles
calendar.DisplayMode = CalendarMode.Decade;
Assert.AreEqual(3, gridProvider.RowCount, "RowCount #1");
calendar.DisplayMode = CalendarMode.Year;
Assert.AreEqual(3, gridProvider.RowCount, "RowCount #2");
// IGridProvider.ColumnCount
calendar.DisplayMode = CalendarMode.Month;
Assert.AreEqual(7, gridProvider.ColumnCount, "ColumnCount #0");
calendar.DisplayMode = CalendarMode.Decade;
Assert.AreEqual(4, gridProvider.ColumnCount, "ColumnCount #1");
calendar.DisplayMode = CalendarMode.Year;
Assert.AreEqual(4, gridProvider.ColumnCount, "ColumnCount #2");
// IGridProvider.GetItem
calendar.DisplayMode = CalendarMode.Month;
cell = gridProvider.GetItem(0, 3);
Assert.IsNotNull(cell, "GetItem #0");
cellPeer = new PeerFromProvider().GetPeerFromProvider(cell);
Assert.AreEqual(typeof(CalendarDayButton).Name, cellPeer.GetClassName(), "GetItem.ClassName #0");
calendar.DisplayMode = CalendarMode.Year;
cell = gridProvider.GetItem(2, 3);
Assert.IsNotNull(cell, "GetItem #1");
cellPeer = new PeerFromProvider().GetPeerFromProvider(cell);
Assert.AreEqual(typeof(CalendarButton).Name, cellPeer.GetClassName(), "GetItem.ClassName #1");
calendar.DisplayMode = CalendarMode.Decade;
cell = gridProvider.GetItem(2, 3);
Assert.IsNotNull(cell, "GetItem #2");
cellPeer = new PeerFromProvider().GetPeerFromProvider(cell);
Assert.AreEqual(typeof(CalendarButton).Name, cellPeer.GetClassName(), "GetItem.ClassName #2");
cell = gridProvider.GetItem(10, 10);
Assert.IsNull(cell, "GetItem #3");
});
}
private static void HandleRowCountProperty(ProxySimple el, IntPtr hwnd, int eventId)
{
IGridProvider grid = el.GetPatternProvider(GridPattern.Pattern) as IGridProvider;
if (grid == null)
{
return;
}
RaisePropertyChangedEvent(el, GridPattern.RowCountProperty, grid.RowCount);
}
private static void RenderPath(int width, int height, Vector2Int start, Vector2Int goal, IList <Cell> path,
AStarSearch search, IGridProvider grid, int runIndex, TimeSpan elapsed)
{
var scalar = 10;
var verdana = new FontFamily("Verdana");
var statsFont = new Font(verdana, 36, FontStyle.Bold, GraphicsUnit.Pixel);
using (var image = new Bitmap(width * scalar, height * scalar, PixelFormat.Format32bppArgb)) {
using (var graphics = Graphics.FromImage(image)) {
graphics.Clear(Color.White);
int closedCount = 0;
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
if (grid[new Vector2Int(x, y)].Blocked)
{
graphics.FillRectangle(new SolidBrush(Color.DarkGray), x * scalar - scalar / 2,
y * scalar - scalar / 2, scalar, scalar);
}
else if (grid[new Vector2Int(x, y)].Closed)
{
closedCount++;
CircleAtPoint(graphics,
new PointF(x * scalar, y * scalar), 4,
Color.IndianRed);
}
}
}
graphics.DrawLines(new Pen(new SolidBrush(Color.LimeGreen), 8),
path.Select(n => new PointF(n.Location.X * scalar, n.Location.Y * scalar)).ToArray());
CircleAtPoint(graphics, new PointF(start.X * scalar, start.Y * scalar), 5, Color.Red);
CircleAtPoint(graphics, new PointF(goal.X * scalar, goal.Y * scalar), 5, Color.Green);
graphics.DrawString(
$"Elapsed: {elapsed.TotalMilliseconds:000}ms Closed: {closedCount:00000}",
statsFont, new SolidBrush(Color.Black), 2, height * scalar - (statsFont.GetHeight(graphics) + 2));
image.Save(
$"Paths\\{start.X}_{start.Y}-{goal.X}_{goal.Y}_{runIndex}.png",
ImageFormat.Png);
}
}
}
public void ListItemIGridItemProviderTest()
{
IRawElementProviderFragmentRoot dataGridProvider;
IRawElementProviderFragment child;
GetDataGridAndFirstListItem(out dataGridProvider, out child);
IGridProvider gridProvider = (IGridProvider)
dataGridProvider.GetPatternProvider(GridPatternIdentifiers.Pattern.Id);
SelectionRange range = calendar.GetDisplayRange(false);
int numChildren = (range.End - range.Start).Days;
for (int i = 0; i < numChildren && child != null; i++)
{
TestProperty(child,
AutomationElementIdentifiers.ControlTypeProperty,
ControlType.ListItem.Id);
IGridItemProvider itemProvider = child.GetPatternProvider(
GridItemPatternIdentifiers.Pattern.Id) as IGridItemProvider;
Assert.IsNotNull(itemProvider,
"Does not implement IGridItemProvider");
int row = itemProvider.Row;
int col = itemProvider.Column;
Assert.AreEqual(gridProvider.GetItem(row, col),
child, "Child found via navigation is reporting incorrect row and/or column values");
Assert.AreEqual(1, itemProvider.RowSpan,
"Child reporting larger RowSpan than expected");
Assert.AreEqual(1, itemProvider.ColumnSpan,
"Child reporting larger ColumnSpan than expected");
Assert.AreEqual(dataGridProvider, itemProvider.ContainingGrid,
"Child's ContainingGrid is not its DataGrid parent.");
child = ((IRawElementProviderFragment)child)
.Navigate(NavigateDirection.NextSibling);
}
}
private static void HandleStructureChangedEventClient(ProxySimple el, IntPtr hwnd, int eventId)
{
if (eventId == NativeMethods.EventObjectCreate)
{
AutomationInteropProvider.RaiseStructureChangedEvent(el, new StructureChangedEventArgs(StructureChangeType.ChildAdded, el.MakeRuntimeId()));
}
else if (eventId == NativeMethods.EventObjectDestroy)
{
AutomationInteropProvider.RaiseStructureChangedEvent(el, new StructureChangedEventArgs(StructureChangeType.ChildRemoved, el.MakeRuntimeId()));
}
else if (eventId == NativeMethods.EventObjectReorder)
{
IGridProvider grid = el.GetPatternProvider(GridPattern.Pattern) as IGridProvider;
if (grid == null)
{
return;
}
AutomationInteropProvider.RaiseStructureChangedEvent(el, new StructureChangedEventArgs(StructureChangeType.ChildrenInvalidated, el.MakeRuntimeId()));
}
}
public void IGridProviderColumnCountTest()
{
StatusBar statusBar = new StatusBar();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(statusBar);
IGridProvider gridProvider = (IGridProvider)
provider.GetPatternProvider(GridPatternIdentifiers.Pattern.Id);
Assert.IsNotNull(gridProvider,
"Not returning GridPatternIdentifiers.");
int index = 0, elements = 10;
for (; index < elements; ++index)
{
statusBar.Panels.Add(string.Format("Panel: {0}", index));
}
int value = elements;
Assert.AreEqual(value, gridProvider.ColumnCount, "ColumnCount value");
}
public void IGridProviderRowCountTest()
{
StatusStrip statusStrip = new StatusStrip();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(statusStrip);
IGridProvider gridProvider = (IGridProvider)
provider.GetPatternProvider(GridPatternIdentifiers.Pattern.Id);
Assert.IsNotNull(gridProvider,
"Not returning GridPatternIdentifiers.");
int index = 0, elements = 10;
for (; index < elements; ++index)
{
statusStrip.Items.Add(string.Format("Item: {0}", index));
}
int value = 1;
Assert.AreEqual(value, gridProvider.RowCount, "RowCount value");
}
public void IGridProviderGetItemTest()
{
StatusStrip statusStrip = new StatusStrip();
IRawElementProviderFragmentRoot provider =
(IRawElementProviderFragmentRoot)GetProviderFromControl(statusStrip);
IGridProvider gridProvider = (IGridProvider)
provider.GetPatternProvider(GridPatternIdentifiers.Pattern.Id);
Assert.IsNotNull(gridProvider,
"Not returning GridPatternIdentifiers.");
int rowValue = 0;
int columnValue = 0;
statusStrip.Items.Add("Item");
IRawElementProviderSimple panelProvider = (IRawElementProviderSimple)
provider.Navigate(NavigateDirection.FirstChild);
IRawElementProviderSimple itemProvider =
gridProvider.GetItem(rowValue, columnValue);
Assert.AreSame(panelProvider, itemProvider, "GetItem method");
try {
rowValue = gridProvider.RowCount;
columnValue = gridProvider.ColumnCount;
itemProvider = gridProvider.GetItem(rowValue, columnValue);
Assert.Fail("ArgumentOutOfRangeException not thrown.");
} catch (ArgumentOutOfRangeException) { }
try {
rowValue = -1;
columnValue = -1;
itemProvider = gridProvider.GetItem(rowValue, columnValue);
Assert.Fail("ArgumentOutOfRangeException not thrown.");
} catch (ArgumentOutOfRangeException) { }
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
private GridProviderWrapper( AutomationPeer peer, IGridProvider iface )
{
_peer = peer;
_iface = iface;
}
public GridPatternWrapper(IGridProvider provider)
{
this.provider = provider;
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
private GridProviderWrapper( AutomationPeer peer, IGridProvider iface )
{
_peer = peer;
_iface = iface;
}
private void RenderPath(int width, int height, Vector2Int start, Vector2Int goal, IList <Cell> greedyPath, IList <Cell> path,
AStarSearch search, IGridProvider grid, int runIndex, TimeSpan elapsed)
{
var scalar = 10;
var verdana = new FontFamily("Verdana");
var statsFont = new Font(verdana, 36, FontStyle.Bold, GraphicsUnit.Pixel);
using (var image = new Bitmap(width * scalar, height * scalar, PixelFormat.Format32bppArgb))
{
using (var graphics = Graphics.FromImage(image))
{
graphics.Clear(Color.White);
int closedCount = 0;
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
if (grid[new Vector2Int(x, y)].Blocked)
{
graphics.FillRectangle(new SolidBrush(Color.Black), x * scalar - scalar / 2,
y * scalar - scalar / 2, scalar, scalar);
}
else
{
if (grid[new Vector2Int(x, y)].Value == 1)
{
graphics.FillRectangle(new SolidBrush(Color.DarkGray), x * scalar - scalar / 2,
y * scalar - scalar / 2, scalar, scalar);
}
else if (grid[new Vector2Int(x, y)].Value == 2)
{
graphics.FillRectangle(new SolidBrush(Color.DarkGreen), x * scalar - scalar / 2,
y * scalar - scalar / 2, scalar, scalar);
}
else if (grid[new Vector2Int(x, y)].Value == 3)
{
graphics.FillRectangle(new SolidBrush(Color.LightYellow), x * scalar - scalar / 2,
y * scalar - scalar / 2, scalar, scalar);
}
}
}
}
Console.WriteLine(closedCount);
PointF[] greedyPathh = greedyPath.Select(n => new PointF(n.Location.X * scalar, n.Location.Y * scalar)).ToArray();
if (greedyPathh.Count() > 1)
{
graphics.DrawLines(new Pen(new SolidBrush(Color.Red), 4),
greedyPathh);
}
if (path != null)
{
PointF[] pathh = path.Select(n => new PointF(n.Location.X * scalar, n.Location.Y * scalar)).ToArray();
if (pathh.Count() > 1)
{
graphics.DrawLines(new Pen(new SolidBrush(Color.Blue), 4),
pathh);
}
}
CircleAtPoint(graphics, new PointF(start.X * scalar, start.Y * scalar), 10, Color.Red);
CircleAtPoint(graphics, new PointF(goal.X * scalar, goal.Y * scalar), 10, Color.Blue);
graphics.DrawString(
$"Elapsed: {elapsed.TotalMilliseconds:000}ms Closed: {closedCount:00000}",
statsFont, new SolidBrush(Color.Black), 2, height * scalar - (statsFont.GetHeight(graphics) + 2));
image.Save(
$"Paths\\{start.X}_{start.Y}-{goal.X}_{goal.Y}_{runIndex}_{_renderCount}.png",
ImageFormat.Png);
pictureBox1.Image = Image.FromFile($"Paths\\{start.X}_{start.Y}-{goal.X}_{goal.Y}_{runIndex}_{_renderCount}.png");
_renderCount++;
}
}
}
public AStarSearch(IGridProvider grid)
{
_grid = grid;
_open = new FastPriorityQueue(_grid.Size.X * _grid.Size.Y);
}
public GridPatternWrapper (IGridProvider provider)
{
this.provider = provider;
}
