void VirtualEarthBase_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { UIElement target = e.TargetObject as UIElement; while (target != null && target != this && (GetLatitude(target) == 0.0 || GetLongitude(target) == 0.0)) { target = VisualTreeHelper.GetParent(target) as UIElement; } if (target != null && target != this) { double lat = GetLatitude(target); double lon = GetLongitude(target); WorldCoordinate bottomRight = ClientToWorld(new Point(ActualWidth, ActualHeight)); if (lat > CornerLatitude || lat < bottomRight.Latitude || lon < CornerLongitude || lon > bottomRight.Longitude) { ViewLatitude = lat; ViewLongitude = lon; } } }
private void method_0(object sender, RequestBringIntoViewEventArgs e) { if (!this.AllowBringIntoView) { e.Handled = true; } }
private void AusleihvorgaengeTab_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { if (ZinssatzComboBox.ItemsSource == null) { ZinssatzComboBox.ItemsSource = _kundeDetailPresenter.GetAlleZinssaetze(); AusleihUebersichtAktualisieren(); } }
private void OnRequestBringIntoView(object sender, sw.RequestBringIntoViewEventArgs e) { var h = Handler as IGridHandler; if (h == null) { return; } e.Handled = h.DisableAutoScrollToSelection; }
void DiagramDesignerItem_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { // no need for a diagram link to be brought into view, since it will not be done correctly anyways if (IsDiagramLink) e.Handled = true; else { e.Handled = false; DiagramRubberbandSelector.IgnoreRubberbandSelectionOnce = true; //ParentCanvas.CancelRubberbandSelection(); } }
/// <summary> /// Attempts to bring this element into view by originating a RequestBringIntoView event. /// </summary> public void BringIntoView() { RequestBringIntoViewEventArgs args = new RequestBringIntoViewEventArgs(this, Rect.Empty); args.RoutedEvent=FrameworkElement.RequestBringIntoViewEvent; RaiseEvent(args); }
private void renderingTab_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { CustomVisualisationExpander.IsExpanded = false; ItemsExpander.IsExpanded = false; }
private void DataGrid_HandBringIntoView(object sender, RequestBringIntoViewEventArgs e) { e.Handled = true; }
private void HandleBringIntoView(RequestBringIntoViewEventArgs e) { TreeViewItem parent = ParentTreeViewItem; while (parent != null) { if (!parent.IsExpanded) { parent.SetCurrentValueInternal(IsExpandedProperty, BooleanBoxes.TrueBox); } parent = parent.ParentTreeViewItem; } // See FrameworkElement.BringIntoView() comments //dmitryt, bug 1126518. On new/updated elements RenderSize isn't yet computed //so we need to postpone the rect computation until layout is done. //this is accomplished by passing Empty rect here and then asking for RenderSize //in IScrollInfo when it actually executes an async MakeVisible command. if (e.TargetRect.IsEmpty) { FrameworkElement header = HeaderElement; if (header != null) { e.Handled = true; header.BringIntoView(); } else { // Header is not generated yet. Could happen if BringIntoView is called on container before layout. Try later. Dispatcher.BeginInvoke(DispatcherPriority.Loaded, new DispatcherOperationCallback(BringItemIntoView), null); } } }
private void TreeViewItem_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { e.Handled = true; }
private void DesignerCanvas_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { e.Handled = true; }
private void RibbonTabBlockModel_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { string ss = e.ToString(); return; }
public void BringIntoView(Rect targetRectangle) { RequestBringIntoViewEventArgs intoViewEventArgs = new RequestBringIntoViewEventArgs((DependencyObject) this, targetRectangle); intoViewEventArgs.RoutedEvent = FrameworkElement.RequestBringIntoViewEvent; this.RaiseEvent((RoutedEventArgs) intoViewEventArgs); }
private void TabItem_RequestBringIntoView_1(object sender, RequestBringIntoViewEventArgs e) { Preset selectedPreset = presetList.SelectedItem as Preset; if (selectedPreset != null) { updateSectors(selectedPreset); updateSectorGui(selectedPreset); } }
private void OnRequestBringIntoView( object sender, RequestBringIntoViewEventArgs e ) { TableViewItemsHost.ProcessRequestBringIntoView( this, Orientation.Vertical, 0.5, // Default StableScrollingProportion e ); }
/// <summary> /// Note: this needs an interactive element (Button, TextBox etc.) in the view to fire. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void UserControl_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { if (this.DataContext == null) this.DataContext = new ViewModels.StringConstants(); }
private void OnRequestBringIntoView( object sender, RequestBringIntoViewEventArgs e ) { if( e.Handled ) return; Debug.Assert( this == sender ); var dataGridControl = this.ParentDataGridControl; if( dataGridControl == null ) return; // Prevent a BringIntoView to be requested twice when setting the focus on a cell. if( dataGridControl.SettingFocusOnCell ) { e.Handled = true; return; } // Let the ScrollViewer handle this if the grid isn't virtualized. var scrollViewer = TreeHelper.FindParent<ScrollViewer>( this ); if( ( scrollViewer == null ) || !scrollViewer.CanContentScroll ) return; var targetVisual = e.TargetObject as Visual; if( targetVisual == null ) return; // Let the ScrollViewer handle this if the target is the container (i.e. HeaderFooterItem). var container = this.GetContainerFromElement( targetVisual ); if( ( container == null ) || ( container == targetVisual ) ) return; Debug.Assert( this.Children.Contains( container ) ); e.Handled = true; var targetRect = e.TargetRect; if( targetRect.IsEmpty ) { var uiElement = TreeHelper.FindParent<UIElement>( targetVisual, true ); // If we have a container, we surely have a UIElement. Debug.Assert( uiElement != null ); targetVisual = uiElement; targetRect = new Rect( 0d, 0d, Math.Min( uiElement.RenderSize.Width, scrollViewer.ViewportWidth ), 0d ); } var area = targetVisual.TransformToAncestor( container ).TransformBounds( targetRect ); if( area.Left < scrollViewer.HorizontalOffset ) { scrollViewer.ScrollToHorizontalOffset( area.Left ); } else if( area.Right > scrollViewer.HorizontalOffset + scrollViewer.ViewportWidth ) { scrollViewer.ScrollToHorizontalOffset( Math.Min( area.Left, ( area.Right - scrollViewer.ViewportWidth ) ) ); } }
private void setComboBindingAndHanldeUnsetValue(object sender, RequestBringIntoViewEventArgs e) { ComboBox combo = sender as ComboBox; DataGridComboBoxColumn column = AssignedDataGridColumn as DataGridComboBoxColumn; if (column.ItemsSource == null) { if (combo.ItemsSource != null) { IList list = combo.ItemsSource.Cast<object>().ToList(); if (list.Count > 0 && list[0] != DependencyProperty.UnsetValue) { combo.RequestBringIntoView -= new RequestBringIntoViewEventHandler(setComboBindingAndHanldeUnsetValue); list.Insert(0, DependencyProperty.UnsetValue); combo.DisplayMemberPath = column.DisplayMemberPath; combo.SelectedValuePath = column.SelectedValuePath; combo.ItemsSource = list; } } } else { combo.RequestBringIntoView -= new RequestBringIntoViewEventHandler(setComboBindingAndHanldeUnsetValue); IList comboList = null; IList columnList = null; if (combo.ItemsSource != null) { comboList = combo.ItemsSource.Cast<object>().ToList(); } columnList = column.ItemsSource.Cast<object>().ToList(); if (comboList == null || (columnList.Count > 0 && columnList.Count + 1 != comboList.Count)) { columnList = column.ItemsSource.Cast<object>().ToList(); columnList.Insert(0, DependencyProperty.UnsetValue); combo.ItemsSource = columnList; } combo.RequestBringIntoView += new RequestBringIntoViewEventHandler(setComboBindingAndHanldeUnsetValue); } }
static void tv_VerticalRequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { var tv = sender as WPFControls.TreeView; if (tv == null) return; var scrollViewer = tv.FindVisualDescendant<WPFControls.ScrollViewer>(); if (scrollViewer == null) return; SetCancelNextVerticalScrollEvent(tv, true); SetOriginalVerticalOffset(tv, scrollViewer.VerticalOffset); }
private void TreeViewItemRequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { if (_treeViewScrollViewer == null) { _treeViewScrollViewer = TheNavigationView.Navigation.Template.FindName("_tv_scrollviewer_", TheNavigationView.Navigation) as ScrollViewer; if (_treeViewScrollViewer != null) _treeViewScrollViewer.ScrollChanged += TreeViewScrollViewerScrollChanged; } _treeViewResetHorizScroll = true; var treeViewScrollViewer = _treeViewScrollViewer; if (treeViewScrollViewer != null) { _treeViewHorizScrollPos = treeViewScrollViewer.HorizontalOffset; } }
/// <summary> /// Attempts to bring the given rectangle of this element into view by originating a RequestBringIntoView event. /// </summary> public void BringIntoView(Rect targetRectangle) { RequestBringIntoViewEventArgs args = new RequestBringIntoViewEventArgs(this, targetRectangle); args.RoutedEvent=RequestBringIntoViewEvent; RaiseEvent(args); }
private void AppRibbon_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { int x = 0; }
private void TreeViewItem_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { if (_swallowsRequestBringIntoView) { // This prevents the tree view for scrolling horizontally to make the // selected item as visibile as possible. This is useful for // "SearchCode", as text extracts are usually wide enough to make tree // view navigation annoying when they are selected. e.Handled = true; return; } // Find the scroll viewer and hook up scroll changed event handler. if (this._treeViewScrollViewer == null) { this._treeViewScrollViewer = this.FileTreeView.Template.FindName("_tv_scrollviewer_", this.FileTreeView) as ScrollViewer; if (_treeViewScrollViewer != null) { this._treeViewScrollViewer.ScrollChanged += this.TreeViewScrollViewer_ScrollChanged; } } // If we got a scroll viewer, remember the horizontal offset so we can // restore it in the scroll changed event. if (_treeViewScrollViewer != null) { this._treeViewResetHorizScroll = true; this._treeViewHorizScrollPos = this._treeViewScrollViewer.HorizontalOffset; } e.Handled = false; }
/// <summary> /// stop this event from bubbling so that a scrollviewer doesn't try to BringIntoView.. /// </summary> static void SwallowBringIntoViewRequest(object sender, RequestBringIntoViewEventArgs e) { e.Handled = true; }
void OnRequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { bool? targetIsOnFrontSide = GetIsOnFrontSide(e.TargetObject); if (!targetIsOnFrontSide.HasValue) return; if (targetIsOnFrontSide.Value) this.BringFrontSideIntoView(); else this.BringBackSideIntoView(); }
private static void OnRequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { if (e.TargetObject == sender) { ((TreeViewItem)sender).HandleBringIntoView(e); } }
/// <summary> /// OnRequestBringIntoView is called from the event handler ScrollViewer registers for the event. /// The default implementation checks to make sure the visual is a child of the IScrollInfo, and then /// delegates to a method there /// </summary> /// <param name="sender">The instance handling the event.</param> /// <param name="e">RequestBringIntoViewEventArgs indicates the element and region to scroll into view.</param> private static void OnRequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { ScrollViewer sv = sender as ScrollViewer; Visual child = e.TargetObject as Visual; if (child != null) { //the event starts from the elemetn itself, so if it is an SV.BringINtoView we would //get an SV trying to bring into view itself - this does not work obviously //so don't handle if the request is about ourselves, the event will bubble if (child != sv && child.IsDescendantOf(sv)) { e.Handled = true; sv.MakeVisible(child, e.TargetRect); } } else { ContentElement contentElement = e.TargetObject as ContentElement; if (contentElement != null) { // We need to find the containing Visual and the bounding box for this element. IContentHost contentHost = ContentHostHelper.FindContentHost(contentElement); child = contentHost as Visual; if (child != null && child.IsDescendantOf(sv)) { ReadOnlyCollection<Rect> rects = contentHost.GetRectangles(contentElement); if (rects.Count > 0) { e.Handled = true; sv.MakeVisible(child, rects[0]); } } } } }
//Marking e.Handled = true to avoid scrolling in large workflows to bring the //area of a connector in the center of the view region. //Area covered by a connector includes the region between 0,0 of the panel and the edges of the connector. void OnConnectorRequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { e.Handled = true; }
/// <summary> /// Handles the RequestBringIntoView routed event in the case where the element to be /// brought into view is DocumentGrid itself, as is the case when the TextEditor's IP moves. /// In this case we use the incoming target rectangle /// and ensure that rect is made visible inside of DocumentGrid. /// </summary> /// <param name="sender">The sender of this routed event, expected to be a DocumentGrid.</param> /// <param name="args">The RequestBringIntoView event args associated with this event.</param> private static void OnRequestBringIntoView(object sender, RequestBringIntoViewEventArgs args) { //We only handle this here if the sender and the target of this event are both the same //DocumentGrid. DocumentGrid senderGrid = sender as DocumentGrid; DocumentGrid targetGrid = args.TargetObject as DocumentGrid; if (senderGrid != null && targetGrid != null && senderGrid == targetGrid) { //Bring the IP into view and mark the event as handled. args.Handled = true; targetGrid.MakeIPVisible(args.TargetRect); } else { args.Handled = false; } }
private void Popup_ScrollViewer_RequestBringIntoView(object sender, RequestBringIntoViewEventArgs e) { e.Handled = true; }
private void OnRequestBringIntoView( object sender, RequestBringIntoViewEventArgs e ) { // Only perform this if we are virtualizing. // If not, the ScrollViewer will take care of bringing the item into view. if( ( this.ScrollOwner == null ) || ( !this.ScrollOwner.CanContentScroll ) ) return; // Only perform this if the StableScrolling feature is enabled. if( !this.StableScrollingEnabled ) return; // If we are explicitly setting the focus on a cell, we don't want to bring it into view. // A bringIntoView would cause the HorizontalOffset to change is not a wanted behavior. // Therefore, flag the Request as handled and do nothing. DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this ); DataGridControl dataGridControl = ( dataGridContext != null ) ? dataGridContext.DataGridControl : null; if( ( dataGridControl != null ) && ( dataGridControl.SettingFocusOnCell ) ) { e.Handled = true; return; } // Only perform this if the object is NOT a Cell and was not passed a specific rectangle. if( ( e.TargetObject is Cell ) || ( e.TargetRect != Rect.Empty ) ) return; // Before performing calculations, ensure that the element is a UIElement. FrameworkElement target = e.TargetObject as FrameworkElement; if( ( target == null ) || ( target.IsDescendantOf( this ) == false ) ) return; Orientation orientation = this.Orientation; //mark the routed event as handled, since under even the worst circumstances, a new event will be raised. e.Handled = true; double acceptableThreshold; double actualVisibleValue; GeneralTransform itemToPanel = target.TransformToAncestor( this ); Point itemOrigin = itemToPanel.Transform( new Point( 0, 0 ) ); //Calculate the VisibleWidth/Height of the object within the Viewport. if( orientation == Orientation.Vertical ) { acceptableThreshold = this.ViewportWidth * this.StableScrollingProportion; //item offset is positive in the viewport. if( itemOrigin.X >= 0 ) { //if the item is totally visible if( target.ActualWidth + itemOrigin.X <= this.ViewportWidth ) { //this will force the function to "cancel" the BringIntoView actualVisibleValue = this.ViewportWidth; } else { //item is not totally visible, calculate how much place it occupies in the viewport. actualVisibleValue = this.ViewportWidth - itemOrigin.X; } } //item offset is negative else { actualVisibleValue = target.ActualWidth - itemOrigin.X; if( actualVisibleValue > this.ViewportWidth ) { //limit the value of actualVisibleValue to the Viewport size (to prevent eventual bugs [even if nothing is visible on the horizon for this]) actualVisibleValue = this.ViewportWidth; } } } else { acceptableThreshold = this.ViewportHeight * this.StableScrollingProportion; //item offset is positive in the viewport. if( itemOrigin.Y >= 0 ) { //if the item is totally visible if( target.ActualHeight + itemOrigin.Y <= this.ViewportHeight ) { //this will force the function to "cancel" the BringIntoView actualVisibleValue = this.ViewportHeight; } else { //item is not totally visible, calculate how much place it occupies in the viewport. actualVisibleValue = this.ViewportHeight - itemOrigin.Y; } } //item offset is negative else { actualVisibleValue = target.ActualHeight - itemOrigin.Y; if( actualVisibleValue > this.ViewportHeight ) { //limit the value of actualVisibleValue to the Viewport size (to prevent eventual bugs [even if nothing is visible on the horizon for this]) actualVisibleValue = this.ViewportHeight; } } } bool needBringIntoView = false; Rect newRect = new Rect( 0, 0, target.ActualWidth, target.ActualHeight ); //After the proportion visible from the object is calculated, compare with threshold if( actualVisibleValue < acceptableThreshold ) { needBringIntoView = true; //the required threshold is not visible, modify the bounds of the rectangle //to bring at Max, the desired threshold. if( orientation == Orientation.Vertical ) { if( itemOrigin.X >= 0 ) { newRect.Width = Math.Min( acceptableThreshold, target.ActualWidth ); } else { newRect.X = target.ActualWidth - acceptableThreshold; if( newRect.X < 0 ) { newRect.X = 0; } } } else { if( itemOrigin.Y >= 0 ) { newRect.Height = Math.Min( acceptableThreshold, target.ActualHeight ); } else { newRect.Y = target.ActualHeight - acceptableThreshold; if( newRect.Y < 0 ) { newRect.Y = 0; } } }//end else orientation is Horizontal } // end if actuallyVisible < acceptable threshold else { //Determine if the item is totally or partially visible on the main scrolling axis. if( orientation == Orientation.Vertical ) { //If the Offset is negative, then it's sure its not totally visible if( itemOrigin.Y < 0 ) { needBringIntoView = true; } else if( ( ( itemOrigin.Y + target.DesiredSize.Height ) > this.RenderSize.Height ) && ( target.DesiredSize.Height < this.RenderSize.Height ) ) { needBringIntoView = true; } } else { //If the Offset is negative, then it's sure its not totally visible if( itemOrigin.X < 0 ) { needBringIntoView = true; } else if( ( ( itemOrigin.X + target.DesiredSize.Width ) > this.RenderSize.Width ) && ( target.DesiredSize.Width < this.RenderSize.Width ) ) { needBringIntoView = true; } } //if the item need to be scrolled in view if( needBringIntoView == true ) { //the goal is to preserve the actual opposed axis scrolling if( orientation == Orientation.Vertical ) { //calculate the starting point of the rectangle to view. newRect.X = itemOrigin.X * -1; if( newRect.X < 0 ) { newRect.X = 0; } //if the item to be brough into view is part of the elements in a TableView that do no scroll if( ( dataGridControl != null ) && ( dataGridControl.GetView() is TableView ) && ( this.ComputedCanScrollHorizontally( target ) == false ) ) { //then do not change the HorizontalOffset... set the same on the object as previously availlable. newRect.X = this.HorizontalOffset; } //if the rectangle of the object goes beyond the Viewport if( newRect.Right > this.ViewportWidth ) { //subtract what goes beyond! newRect.Width = newRect.Width - ( newRect.Width - this.ViewportWidth ) - Math.Max( itemOrigin.X, 0 ); } } else { //calculate the staring point if the rectangle to view. newRect.Y = itemOrigin.Y * -1; if( newRect.Y < 0 ) { newRect.Y = 0; } //if the rectangle of the object goes beyond the Viewport if( newRect.Bottom > this.ViewportHeight ) { //subtract what goes beyond! newRect.Height = newRect.Height - ( newRect.Height - this.ViewportHeight ) - Math.Max( itemOrigin.Y, 0 ); } } } // end if needBringIntoView == true } // end else //Call a new BringIntoView on the target element if( needBringIntoView == true ) target.BringIntoView( newRect ); }