public virtual void TreeViewPeerSupportsScrolling()
{
// Note: This test fails if ItemsSource isn't set because it
// requires a container to find the ItemsHost and ScrollHost.
TreeView view = new TreeView {
ItemsSource = new int[] { 1, 2, 3 }
};
TreeViewAutomationPeer peer = null;
IScrollProvider provider = null;
TestAsync(
view,
() => peer = FrameworkElementAutomationPeer.CreatePeerForElement(view) as TreeViewAutomationPeer,
() => provider = peer.GetPattern(PatternInterface.Scroll) as IScrollProvider,
() => Assert.IsNotNull(provider, "IScrollProvider peer should not be null!"),
() =>
{
FrameworkElementAutomationPeer scroll = provider as FrameworkElementAutomationPeer;
Assert.IsNotNull(scroll, "IScrollProvider should be an automation peer!");
Assert.IsInstanceOfType(scroll.Owner, typeof(ScrollViewer), "IScrollProvider should wrap a ScrollViewer!");
for (UIElement current = scroll.Owner; current != null; current = VisualTreeHelper.GetParent(current) as UIElement)
{
if (current == view)
{
return;
}
}
Assert.Fail("IScrollProvider should be an automation peer for a child of the TreeView!");
});
}
public void ScrollableControlProviderTest()
{
Panel panel = new Panel();
Form.Controls.Add(panel);
IRawElementProviderSimple provider
= GetProviderFromControl(panel);
panel.AutoScrollMinSize = new System.Drawing.Size(5000, 5000);
panel.AutoScroll = true;
IScrollProvider scrollProvider
= provider.GetPatternProvider(ScrollPatternIdentifiers.Pattern.Id)
as IScrollProvider;
Assert.IsNotNull(scrollProvider,
"Does not implement IScrollProvider");
panel.AutoScrollMinSize = new System.Drawing.Size(50, 50);
scrollProvider = provider.GetPatternProvider(
ScrollPatternIdentifiers.Pattern.Id) as IScrollProvider;
Assert.IsNull(scrollProvider,
"Implements IScrollProvider");
}
/// <summary>
/// Gets the control pattern that is associated with the specified System.Windows.Automation.Peers.PatternInterface.
/// </summary>
/// <param name="patternInterface">A value from the System.Windows.Automation.Peers.PatternInterface enumeration.</param>
/// <returns>The object that supports the specified pattern, or null if unsupported.</returns>
public override object GetPattern(PatternInterface patternInterface)
{
switch (patternInterface)
{
case PatternInterface.Grid:
case PatternInterface.Selection:
case PatternInterface.Table:
return(this);
case PatternInterface.Scroll:
{
ScrollViewer scrollViewer = this.OwningDataGrid.InternalScrollHost;
if (scrollViewer != null)
{
AutomationPeer scrollPeer = UIElementAutomationPeer.CreatePeerForElement(scrollViewer);
IScrollProvider scrollProvider = scrollPeer as IScrollProvider;
if (scrollPeer != null && scrollProvider != null)
{
scrollPeer.EventsSource = this;
return(scrollProvider);
}
}
break;
}
}
return(base.GetPattern(patternInterface));
}
/// <summary>
/// Handles the MouseWheel event of the AssociatedObject control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Input.MouseWheelEventArgs"/> instance containing the event data.</param>
void AssociatedObject_MouseWheel(object sender, MouseWheelEventArgs e)
{
this.AssociatedObject.Focus();
int direction = Math.Sign(e.Delta);
ScrollAmount scrollAmount =
(direction < 0) ? ScrollAmount.SmallIncrement : ScrollAmount.SmallDecrement;
if (this.Peer != null)
{
IScrollProvider scrollProvider =
this.Peer.GetPattern(PatternInterface.Scroll) as IScrollProvider;
bool shiftKey = (Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift;
if (scrollProvider != null && scrollProvider.VerticallyScrollable && !shiftKey)
{
scrollProvider.Scroll(ScrollAmount.NoAmount, scrollAmount);
}
else if (scrollProvider != null && scrollProvider.VerticallyScrollable && shiftKey)
{
scrollProvider.Scroll(scrollAmount, ScrollAmount.NoAmount);
}
}
}
private void EnsureAutomationPeer()
{
if (scrollPresenterAutomationPeer == null)
{
scrollPresenterAutomationPeer = FrameworkElementAutomationPeer.CreatePeerForElement(scrollPresenter) as IScrollProvider;
}
}
/// <summary>Returns the object that supports the specified control pattern of the element that is associated with this automation peer.</summary>
/// <param name="patternInterface">A value in the enumeration.</param>
/// <returns>If <paramref name="patternInterface" /> is <see cref="F:System.Windows.Automation.Peers.PatternInterface.Grid" />, <see cref="F:System.Windows.Automation.Peers.PatternInterface.Selection" />, or <see cref="F:System.Windows.Automation.Peers.PatternInterface.Table" />, this method returns a <see langword="this" /> pointer; otherwise, this method returns <see langword="null" />.</returns>
// Token: 0x06002569 RID: 9577 RVA: 0x000B4048 File Offset: 0x000B2248
public override object GetPattern(PatternInterface patternInterface)
{
if (patternInterface <= PatternInterface.Scroll)
{
if (patternInterface != PatternInterface.Selection)
{
if (patternInterface != PatternInterface.Scroll)
{
goto IL_45;
}
ScrollViewer internalScrollHost = this.OwningDataGrid.InternalScrollHost;
if (internalScrollHost == null)
{
goto IL_45;
}
AutomationPeer automationPeer = UIElementAutomationPeer.CreatePeerForElement(internalScrollHost);
IScrollProvider scrollProvider = automationPeer as IScrollProvider;
if (automationPeer != null && scrollProvider != null)
{
automationPeer.EventsSource = this;
return(scrollProvider);
}
goto IL_45;
}
}
else if (patternInterface != PatternInterface.Grid && patternInterface != PatternInterface.Table)
{
goto IL_45;
}
return(this);
IL_45:
return(base.GetPattern(patternInterface));
}
private void InvokeScrollBar(int mouseDelta)
{
if (!Focused || mouseDelta == 0)
{
return;
}
short mouseNum = (short)(mouseDelta / 120);
ScrollAmount scrollAmount = ScrollAmount.NoAmount;
if (mouseNum < 0)
{
//向下滑动
if (mouseNum >= -2)
{
scrollAmount = ScrollAmount.SmallIncrement;
}
else
{
scrollAmount = ScrollAmount.LargeIncrement;
}
}
else if (mouseNum > 0)
{
//向上滑动
if (mouseNum <= 2)
{
scrollAmount = ScrollAmount.SmallDecrement;
}
else
{
scrollAmount = ScrollAmount.LargeDecrement;
}
}
if (scrollAmount == ScrollAmount.NoAmount)
{
return;
}
//修复滚轮滚动Bug
//取得AutomationPeer
AutomationPeer automationPeer = FrameworkElementAutomationPeer.FromElement(this);
if (automationPeer == null)
{
automationPeer = FrameworkElementAutomationPeer.CreatePeerForElement(this);
}
//得到scroll provider
IScrollProvider scrollProvider = automationPeer.GetPattern(PatternInterface.Scroll) as IScrollProvider;
if (scrollProvider != null)
{
if (scrollProvider.VerticallyScrollable)
{
scrollProvider.Scroll(ScrollAmount.NoAmount, scrollAmount);
}
}
}
// Token: 0x060027D3 RID: 10195 RVA: 0x000BAACC File Offset: 0x000B8CCC
internal override void SetValueCore(double val)
{
double horizontalPercent = -1.0;
double verticalPercent = -1.0;
ScrollBar scrollBar = base.Owner as ScrollBar;
ScrollViewer scrollViewer = scrollBar.TemplatedParent as ScrollViewer;
if (scrollViewer == null)
{
base.SetValueCore(val);
return;
}
if (scrollBar.Orientation == Orientation.Horizontal)
{
horizontalPercent = val / (scrollViewer.ExtentWidth - scrollViewer.ViewportWidth) * 100.0;
}
else
{
verticalPercent = val / (scrollViewer.ExtentHeight - scrollViewer.ViewportHeight) * 100.0;
}
ScrollViewerAutomationPeer scrollViewerAutomationPeer = UIElementAutomationPeer.FromElement(scrollViewer) as ScrollViewerAutomationPeer;
IScrollProvider scrollProvider = scrollViewerAutomationPeer;
scrollProvider.SetScrollPercent(horizontalPercent, verticalPercent);
}
///
internal override void SetValueCore(double val)
{
double horizontalPercent = -1;
double verticalPercent = -1;
ScrollBar sb = Owner as ScrollBar;
ScrollViewer sv = sb.TemplatedParent as ScrollViewer;
if (sv == null)
{
base.SetValueCore(val);
}
else
{
if (sb.Orientation == Orientation.Horizontal)
{
horizontalPercent = (val / (sv.ExtentWidth - sv.ViewportWidth)) * 100;
}
else
{
verticalPercent = (val / (sv.ExtentHeight - sv.ViewportHeight)) * 100;
}
ScrollViewerAutomationPeer svAP = UIElementAutomationPeer.FromElement(sv) as ScrollViewerAutomationPeer;
IScrollProvider scrollProvider = svAP as IScrollProvider;
scrollProvider.SetScrollPercent(horizontalPercent, verticalPercent);
}
}
private void PrintLog(string message)
{
if (!Log.Dispatcher.CheckAccess())
{
this.Dispatcher.Invoke(new PrintLogDelegate(PrintLog), message);
return;
}
Log.Items.Add(DateTime.Now.ToString("HH:mm:ss") + " " + message);
try
{
ListBoxAutomationPeer svAutomation = (ListBoxAutomationPeer)ScrollViewerAutomationPeer.CreatePeerForElement(Log);
IScrollProvider scrollInterface = (IScrollProvider)svAutomation.GetPattern(PatternInterface.Scroll);
System.Windows.Automation.ScrollAmount scrollVertical = System.Windows.Automation.ScrollAmount.LargeIncrement;
System.Windows.Automation.ScrollAmount scrollHorizontal = System.Windows.Automation.ScrollAmount.NoAmount;
if (scrollInterface.VerticallyScrollable)
{
scrollInterface.Scroll(scrollHorizontal, scrollVertical);
}
}
catch
{
// 하단 내리기 실패.
}
}
private void CacheScrollbarPeers()
{
IScrollProvider provider = (IScrollProvider)this;
ScrollBar hscrollbar = scrollViewer.ElementHorizontalScrollBar;
hCachedProperty = new CachedProperty();
SetAutomationEvents(provider,
hscrollbar,
GetHorizontallyScrollable,
delegate { return(scrollViewer.ComputedHorizontalScrollBarVisibility); },
delegate { return(provider.HorizontalScrollPercent); },
delegate { return(provider.HorizontalViewSize); },
ScrollPatternIdentifiers.HorizontalScrollPercentProperty,
ScrollPatternIdentifiers.HorizontallyScrollableProperty,
ScrollPatternIdentifiers.HorizontalViewSizeProperty,
AutomationOrientation.Horizontal);
ScrollBar vscrollbar = scrollViewer.ElementVerticalScrollBar;
vCachedProperty = new CachedProperty();
SetAutomationEvents(
provider,
vscrollbar,
GetVerticallyScrollable,
delegate { return(scrollViewer.ComputedVerticalScrollBarVisibility); },
delegate { return(provider.VerticalScrollPercent); },
delegate { return(provider.VerticalViewSize); },
ScrollPatternIdentifiers.VerticalScrollPercentProperty,
ScrollPatternIdentifiers.VerticallyScrollableProperty,
ScrollPatternIdentifiers.VerticalViewSizeProperty,
AutomationOrientation.Vertical);
}
private void GetScrollProviderFromParent()
{
Adapter parentAdapter = Parent as Adapter;
if (parentAdapter != null)
{
parentScrollProvider = (IScrollProvider)parentAdapter.Provider.GetPatternProvider(ScrollPatternIdentifiers.Pattern.Id);
}
}
private static void HandleVerticalViewSizeProperty(ProxySimple el, IntPtr hwnd, int eventId)
{
IScrollProvider scroll = el.GetPatternProvider(ScrollPattern.Pattern) as IScrollProvider;
if (scroll == null)
{
return;
}
RaisePropertyChangedEvent(el, ScrollPattern.VerticalViewSizeProperty, scroll.VerticalViewSize);
}
private static void HandleHorizontalScrollPercentProperty(ProxySimple el, IntPtr hwnd, int eventId)
{
IScrollProvider scroll = el.GetPatternProvider(ScrollPattern.Pattern) as IScrollProvider;
if (scroll == null || scroll.HorizontalScrollPercent == ScrollPattern.NoScroll)
{
return;
}
RaisePropertyChangedEvent(el, ScrollPattern.HorizontalScrollPercentProperty, scroll.HorizontalScrollPercent);
}
// from https://stackoverflow.com/a/18305272
private void ListBoxScrollToBottom(ListBox listBox)
{
ListBoxAutomationPeer svAutomation = (ListBoxAutomationPeer)UIElementAutomationPeer.CreatePeerForElement(chatMessages);
IScrollProvider scrollInterface = (IScrollProvider)svAutomation.GetPattern(PatternInterface.Scroll);
System.Windows.Automation.ScrollAmount scrollVertical = System.Windows.Automation.ScrollAmount.LargeIncrement;
System.Windows.Automation.ScrollAmount scrollHorizontal = System.Windows.Automation.ScrollAmount.NoAmount;
if (scrollInterface.VerticallyScrollable)
{
scrollInterface.Scroll(scrollHorizontal, scrollVertical);
}
}
public virtual void TreeViewPeerSupportsScrollingNoHost()
{
TreeView view = new TreeView();
TreeViewAutomationPeer peer = null;
IScrollProvider provider = null;
TestAsync(
view,
() => peer = FrameworkElementAutomationPeer.CreatePeerForElement(view) as TreeViewAutomationPeer,
() => provider = peer.GetPattern(PatternInterface.Scroll) as IScrollProvider,
() => Assert.IsNull(provider, "IScrollProvider peer should be null!"));
}
public void IScrollProviderSetScrollPercentTest()
{
PrintPreviewControl printPreviewControl = new PrintPreviewControl();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(printPreviewControl);
IScrollProvider scrollProvider = (IScrollProvider)
provider.GetPatternProvider(ScrollPatternIdentifiers.Pattern.Id);
Assert.IsNotNull(scrollProvider,
"Not returning ScrollPatternIdentifiers.");
}
internal void RaiseAutomationEvents(double extentX,
double extentY,
double viewportX,
double viewportY,
double offsetX,
double offsetY)
{
IScrollProvider isp = (IScrollProvider)this;
if (AutomationIsScrollable(extentX, viewportX) != isp.HorizontallyScrollable)
{
RaisePropertyChangedEvent(
ScrollPatternIdentifiers.HorizontallyScrollableProperty,
AutomationIsScrollable(extentX, viewportX),
isp.HorizontallyScrollable);
}
if (AutomationIsScrollable(extentY, viewportY) != isp.VerticallyScrollable)
{
RaisePropertyChangedEvent(
ScrollPatternIdentifiers.VerticallyScrollableProperty,
AutomationIsScrollable(extentY, viewportY),
isp.VerticallyScrollable);
}
if (AutomationGetViewSize(extentX, viewportX) != isp.HorizontalViewSize)
{
RaisePropertyChangedEvent(
ScrollPatternIdentifiers.HorizontalViewSizeProperty,
AutomationGetViewSize(extentX, viewportX),
isp.HorizontalViewSize);
}
if (AutomationGetViewSize(extentY, viewportY) != isp.VerticalViewSize)
{
RaisePropertyChangedEvent(
ScrollPatternIdentifiers.VerticalViewSizeProperty,
AutomationGetViewSize(extentY, viewportY),
isp.VerticalViewSize);
}
if (AutomationGetScrollPercent(extentX, viewportX, offsetX) != isp.HorizontalScrollPercent)
{
RaisePropertyChangedEvent(
ScrollPatternIdentifiers.HorizontalScrollPercentProperty,
AutomationGetScrollPercent(extentX, viewportX, offsetX),
isp.HorizontalScrollPercent);
}
if (AutomationGetScrollPercent(extentY, viewportY, offsetY) != isp.VerticalScrollPercent)
{
RaisePropertyChangedEvent(
ScrollPatternIdentifiers.VerticalScrollPercentProperty,
AutomationGetScrollPercent(extentY, viewportY, offsetY),
isp.VerticalScrollPercent);
}
}
public static void ScrollToBottom(this ListBox source)
{
ListBoxAutomationPeer svAutomation = (ListBoxAutomationPeer)UIElementAutomationPeer.CreatePeerForElement(source);
IScrollProvider scrollInterface = (IScrollProvider)svAutomation.GetPattern(PatternInterface.Scroll);
ScrollAmount scrollVertical = ScrollAmount.LargeIncrement;
ScrollAmount scrollHorizontal = ScrollAmount.NoAmount;
// If the vertical scroller is not available, the operation cannot be performed, which will raise an exception.
if (scrollInterface.VerticallyScrollable)
{
scrollInterface.Scroll(scrollHorizontal, scrollVertical);
}
}
public void AddLog(string log)
{
this.theListBox.Items.Add(log);
ListBoxAutomationPeer listBoxAutomationPeer = (ListBoxAutomationPeer)UIElementAutomationPeer.CreatePeerForElement(this.theListBox);
IScrollProvider pattern = (IScrollProvider)listBoxAutomationPeer.GetPattern(PatternInterface.Scroll);
ScrollAmount scrollAmount = ScrollAmount.LargeIncrement;
ScrollAmount scrollAmount1 = ScrollAmount.NoAmount;
if (pattern.VerticallyScrollable)
{
pattern.Scroll(scrollAmount1, scrollAmount);
}
}
private void HotReloadingPadControl_Loaded(object sender, RoutedEventArgs e)
{
ListBoxAutomationPeer svAutomation = (ListBoxAutomationPeer)ScrollViewerAutomationPeer.CreatePeerForElement(listBox);
IScrollProvider scrollInterface = (IScrollProvider)svAutomation.GetPattern(PatternInterface.Scroll);
System.Windows.Automation.ScrollAmount scrollVertical = System.Windows.Automation.ScrollAmount.LargeIncrement;
System.Windows.Automation.ScrollAmount scrollHorizontal = System.Windows.Automation.ScrollAmount.NoAmount;
//If the vertical scroller is not available, the operation cannot be performed, which will raise an exception.
if (scrollInterface.VerticallyScrollable)
{
scrollInterface.Scroll(scrollHorizontal, scrollVertical);
}
}
private void WriteResponseLine(string responseLine)
{
listBox_Responses.Items.Add(responseLine);
ListBoxAutomationPeer svAutomation = (ListBoxAutomationPeer)ScrollViewerAutomationPeer.CreatePeerForElement(listBox_Responses);
IScrollProvider scrollInterface = (IScrollProvider)svAutomation.GetPattern(PatternInterface.Scroll);
ScrollAmount scrollVertical = ScrollAmount.LargeIncrement;
ScrollAmount scrollHorizontal = ScrollAmount.NoAmount;
if (scrollInterface.VerticallyScrollable)
{
scrollInterface.Scroll(scrollHorizontal, scrollVertical);
}
}
private void scrollToBottom()
{
IScrollProvider scrollInterface = (IScrollProvider)svAutomation.GetPattern(PatternInterface.Scroll);
ScrollAmount scrollVertical = ScrollAmount.LargeIncrement;
ScrollAmount scrollHorizontal = ScrollAmount.NoAmount;
try
{
scrollInterface.Scroll(scrollHorizontal, scrollVertical);
}
catch (Exception)
{
}
}
private void UpdateDOMEventHandlers(bool activate)
{
if (_activated != activate)
{
_activated = activate;
if (activate)
{
IScrollProvider scrollProvider = null;
AutomationPeer automationPeer = FrameworkElementAutomationPeer.CreatePeerForElement(AssociatedObject);
if (automationPeer != null)
{
scrollProvider = (IScrollProvider)automationPeer.GetPattern(PatternInterface.Scroll);
}
if (scrollProvider == null)
{
ScrollViewer scrollViewer = GetChildScrollViewer(AssociatedObject);
if (scrollViewer != null)
{
automationPeer = FrameworkElementAutomationPeer.CreatePeerForElement(scrollViewer);
if (automationPeer != null)
{
scrollProvider = (IScrollProvider)automationPeer.GetPattern(PatternInterface.Scroll);
}
}
}
if ((scrollProvider != null) && scrollProvider.VerticallyScrollable)
{
_scrollProvider = scrollProvider;
HtmlPage.Document.AttachEvent("DOMMouseScroll", OnBrowserDOMMouseScroll);
HtmlPage.Document.AttachEvent("onmousewheel", OnBrowserMouseWheel);
}
}
else
{
if (_scrollProvider != null)
{
_scrollProvider = null;
HtmlPage.Document.DetachEvent("DOMMouseScroll", OnBrowserDOMMouseScroll);
HtmlPage.Document.DetachEvent("onmousewheel", OnBrowserMouseWheel);
}
}
}
}
private void ConsoleLog_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
var listview = this.ConsoleBox;
if (listview.Items.Count > 5)
{
ListBoxAutomationPeer svAutomation = (ListBoxAutomationPeer)ScrollViewerAutomationPeer.CreatePeerForElement(listview);
IScrollProvider scrollInterface = (IScrollProvider)svAutomation.GetPattern(PatternInterface.Scroll);
System.Windows.Automation.ScrollAmount scrollVertical = System.Windows.Automation.ScrollAmount.LargeIncrement;
System.Windows.Automation.ScrollAmount scrollHorizontal = System.Windows.Automation.ScrollAmount.NoAmount;
if (scrollInterface.VerticallyScrollable)
{
scrollInterface.Scroll(scrollHorizontal, scrollVertical);
}
}
}
private void Items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
ListBoxAutomationPeer svAutomation = ScrollViewerAutomationPeer.CreatePeerForElement(this.ListBox) as ListBoxAutomationPeer;
IScrollProvider scrollInterface = svAutomation.GetPattern(PatternInterface.Scroll) as IScrollProvider;
ScrollAmount scrollVertical = ScrollAmount.LargeIncrement;
ScrollAmount scrollHorizontal = ScrollAmount.NoAmount;
// If the vertical scroller is not available, the operation cannot be performed, which will raise an exception.
if (scrollInterface != null && scrollInterface.VerticallyScrollable)
{
scrollInterface.Scroll(scrollHorizontal, scrollVertical);
}
}
}
public void NavigationTest()
{
PrintPreviewControl printPreviewControl = (PrintPreviewControl)GetControlInstance();
IRawElementProviderFragmentRoot rootProvider;
IRawElementProviderFragment childProvider;
rootProvider = (IRawElementProviderFragmentRoot)GetProviderFromControl(printPreviewControl);
IScrollProvider scrollProvider = (IScrollProvider)
rootProvider.GetPatternProvider(ScrollPatternIdentifiers.Pattern.Id);
Assert.IsNotNull(scrollProvider,
"Not returning ScrollPatternIdentifiers.");
childProvider = rootProvider.Navigate(NavigateDirection.FirstChild);
Assert.IsNotNull(childProvider, "We must have a child");
}
/// <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));
}
public void IScrollProviderHorizontalScrollPercentTest()
{
PrintPreviewControl printPreviewControl = new PrintPreviewControl();
printPreviewControl.Size = new System.Drawing.Size(100, 100);
printPreviewControl.Document = new System.Drawing.Printing.PrintDocument();
printPreviewControl.Zoom = 0.1;
IRawElementProviderFragmentRoot provider =
(IRawElementProviderFragmentRoot)GetProviderFromControl(printPreviewControl);
// IRawElementProviderSimple provider =
// ProviderFactory.GetProvider (printPreviewControl);
IScrollProvider scrollProvider = (IScrollProvider)
provider.GetPatternProvider(ScrollPatternIdentifiers.Pattern.Id);
Assert.IsNotNull(scrollProvider,
"Not returning ScrollPatternIdentifiers.");
}
public MainWindow()
{
InitializeComponent();
this.DataContext = new MainWindowViewModel();
ViewModel.Messages.CollectionChanged += (s, e) =>
{
ListBoxAutomationPeer svAutomation = (ListBoxAutomationPeer)ScrollViewerAutomationPeer.CreatePeerForElement(lstMessages);
IScrollProvider scrollInterface = (IScrollProvider)svAutomation.GetPattern(PatternInterface.Scroll);
System.Windows.Automation.ScrollAmount scrollVertical = System.Windows.Automation.ScrollAmount.LargeIncrement;
System.Windows.Automation.ScrollAmount scrollHorizontal = System.Windows.Automation.ScrollAmount.NoAmount;
//If the vertical scroller is not available, the operation cannot be performed, which will raise an exception.
if (scrollInterface.VerticallyScrollable)
{
scrollInterface.Scroll(scrollHorizontal, scrollVertical);
}
};
}
private void GetScrollProviderFromParent ()
{
Adapter parentAdapter = Parent as Adapter;
if (parentAdapter != null)
parentScrollProvider = (IScrollProvider)parentAdapter.Provider.GetPatternProvider (ScrollPatternIdentifiers.Pattern.Id);
}
private void Processor_PointerUp(object sender, TouchPanels.PointerEventArgs e)
{
WriteStatus(e, "Up");
currentScrollItem = null;
}
private void SetAutomationEvents (IScrollProvider provider,
ScrollBar scrollbar,
Func<bool> scrollableDelegate,
Func<Visibility> computedVisibilityDelegate,
Func<double> scrollPercentDelegate,
Func<double> viewSizeDelegate,
AutomationProperty scrollPercentProperty,
AutomationProperty scrollableProperty,
AutomationProperty viewSizeProperty,
AutomationOrientation orientation)
{
CachedProperty cachedProperty;
if (orientation == AutomationOrientation.Horizontal)
cachedProperty = hCachedProperty;
else
cachedProperty = vCachedProperty;
cachedProperty.Scrollable = scrollableDelegate ();
cachedProperty.Visible = computedVisibilityDelegate () == Visibility.Visible;
cachedProperty.ScrollPercent = scrollPercentDelegate ();
cachedProperty.ViewSize = viewSizeDelegate ();
cachedProperty.ScrollPercentProperty = scrollPercentProperty;
cachedProperty.ScrollableProperty = scrollableProperty;
cachedProperty.ViewSizeProperty = viewSizeProperty;
cachedProperty.Orientation = orientation;
cachedProperty.ScrollBar = scrollbar;
cachedProperty.ScrollPercentDelegate = scrollPercentDelegate;
cachedProperty.ScrollableDelegate = scrollableDelegate;
scrollViewer.UIAVisibilityChanged += (o, e) => {
if (cachedProperty.Orientation != e.Orientation) {
RaiseStructureChanged (cachedProperty, computedVisibilityDelegate);
RaiseScrollableProperty (cachedProperty, scrollableDelegate);
RaiseViewSizeProperty (cachedProperty, viewSizeDelegate);
RaiseScrollPercentProperty (cachedProperty, scrollPercentDelegate);
}
};
scrollViewer.UIAViewportChanged += (o, e) => {
if (cachedProperty.Orientation == AutomationOrientation.Horizontal)
RaiseViewSizeProperty (cachedProperty,
viewSizeDelegate,
provider.HorizontalViewSize);
else
RaiseViewSizeProperty (cachedProperty,
viewSizeDelegate,
provider.VerticalViewSize);
};
scrollViewer.SizeChanged += (o, e) => {
RaiseViewSizeProperty (cachedProperty, viewSizeDelegate);
};
scrollViewer.UIAOffsetChanged += (o, e) => {
if (e.Orientation == cachedProperty.Orientation)
RaiseScrollPercentProperty (cachedProperty, scrollPercentDelegate);
};
scrollViewer.UIAScrollBarSet += (o, e) => {
if (e.Orientation == cachedProperty.Orientation) {
if (cachedProperty.ScrollBar != null) {
cachedProperty.ScrollBar.IsEnabledChanged -= ScrollBar_IsEnabledChanged;
cachedProperty.ScrollBar.ValueChanged -= ScrollBar_ValueChanged;
}
cachedProperty.ScrollBar = e.NewValue;
if (cachedProperty.ScrollBar != null) {
cachedProperty.ScrollBar.IsEnabledChanged += ScrollBar_IsEnabledChanged;
cachedProperty.ScrollBar.ValueChanged += ScrollBar_ValueChanged;
}
SetScrollBarAutomationPeer (cachedProperty.ScrollBar, cachedProperty.Orientation);
}
};
if (cachedProperty.ScrollBar != null) {
cachedProperty.ScrollBar.IsEnabledChanged += ScrollBar_IsEnabledChanged;
cachedProperty.ScrollBar.ValueChanged += ScrollBar_ValueChanged;
}
SetScrollBarAutomationPeer (cachedProperty.ScrollBar, cachedProperty.Orientation);
}
private void Processor_PointerDown(object sender, TouchPanels.PointerEventArgs e)
{
WriteStatus(e, "Down");
currentScrollItem = FindElementsToInvoke(e.Position);
lastPosition = e.Position;
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
private ScrollProviderWrapper( AutomationPeer peer, IScrollProvider iface )
{
_peer = peer;
_iface = iface;
}
public ScrollPatternWrapper (IScrollProvider provider)
{
this.provider = provider;
}
