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; }