private void Focus(DependencyObject focus, bool askOld, bool askNew, bool forceToNullIfFailed) { // Make sure that the element is valid for receiving focus. bool isValid = true; if (focus != null) { isValid = Keyboard.IsFocusable(focus); if (!isValid && forceToNullIfFailed) { focus = null; isValid = true; } } if (isValid) { // Get the keyboard input provider that provides input for the active source. IKeyboardInputProvider keyboardInputProvider = null; DependencyObject containingVisual = InputElement.GetContainingVisual(focus); if (containingVisual != null) { PresentationSource source = PresentationSource.CriticalFromVisual(containingVisual); if (source != null) { keyboardInputProvider = (IKeyboardInputProvider)source.GetInputProvider(typeof(KeyboardDevice)); } } // Start the focus-change operation. TryChangeFocus(focus, keyboardInputProvider, askOld, askNew, forceToNullIfFailed); } }
private void OnReevaluateCapturedWithinAsync() { if (_captured == null) { return; } bool killCapture = false; // // First, check things like IsEnabled, IsVisible, etc. on a // UIElement vs. ContentElement basis. // UIElement uiElement; ContentElement contentElement; UIElement3D uiElement3D; CastInputElement(_captured, out uiElement, out contentElement, out uiElement3D); if (uiElement != null) { killCapture = !uiElement.IsEnabled || !uiElement.IsVisible || !uiElement.IsHitTestVisible; } else if (contentElement != null) { killCapture = !contentElement.IsEnabled; } else if (uiElement3D != null) { killCapture = !uiElement3D.IsEnabled || !uiElement3D.IsVisible || !uiElement3D.IsHitTestVisible; } else { killCapture = true; } // // Second, if we still haven't thought of a reason to kill capture, validate // it on a Visual basis for things like still being in the right tree. // if (killCapture == false) { DependencyObject containingVisual = InputElement.GetContainingVisual(_captured as DependencyObject); killCapture = !ValidateVisualForCapture(containingVisual); } // // Lastly, if we found any reason above, kill capture. // if (killCapture) { Capture(null); } // Refresh AreAnyTouchCapturesWithinProperty so that ReverseInherited flags are updated. if ((_capturedWithinTreeState != null) && !_capturedWithinTreeState.IsEmpty) { UpdateReverseInheritedProperty(/* capture = */ true, _captured, _captured); } }
private void GetRootTransforms(IInputElement relativeTo, out GeneralTransform elementToRoot, out GeneralTransform rootToElement) { elementToRoot = rootToElement = null; DependencyObject containingVisual = InputElement.GetContainingVisual(relativeTo as DependencyObject); if (containingVisual != null) { PresentationSource relativePresentationSource = PresentationSource.CriticalFromVisual(containingVisual); Visual rootVisual = (relativePresentationSource != null) ? relativePresentationSource.RootVisual : null; Visual containingVisual2D = VisualTreeHelper.GetContainingVisual2D(containingVisual); if ((rootVisual != null) && (containingVisual2D != null)) { elementToRoot = containingVisual2D.TransformToAncestor(rootVisual); rootToElement = rootVisual.TransformToDescendant(containingVisual2D); } } }
/// <summary> /// Gets the transform relative to a particular element in the visual tree. /// </summary> internal static GeneralTransform GetElementTransform(IInputElement relativeTo) { GeneralTransform elementTransform = Transform.Identity; DependencyObject doRelativeTo = relativeTo as DependencyObject; if (doRelativeTo != null) { Visual visualFirstAncestor = VisualTreeHelper.GetContainingVisual2D(InputElement.GetContainingVisual(doRelativeTo)); Visual visualRoot = VisualTreeHelper.GetContainingVisual2D(InputElement.GetRootVisual(doRelativeTo)); GeneralTransform g = visualRoot.TransformToDescendant(visualFirstAncestor); if (g != null) { elementTransform = g; } } return(elementTransform); }
private PresentationSource GetSourceForElement(IInputElement element) { PresentationSource source = null; DependencyObject elementDO = element as DependencyObject; // Use internal helpers to try to find the source of the element. // Because IInputElements can move around without notification we need to // look up the source every time. if (elementDO != null) { DependencyObject containingVisual = InputElement.GetContainingVisual(elementDO); if (containingVisual != null) { source = PresentationSource.CriticalFromVisual(containingVisual); } } // NOTE: source can be null but IsTargetable(element) == true if the // element is in an orphaned tree but the tree has not yet been garbage collected. return(source); }
public static int GetIntermediatePoints(IInputElement relativeTo, Point[] points) { // Security Mitigation: do not give out input state if the device is not active. if (Mouse.PrimaryDevice.IsActive) { if (relativeTo != null) { PresentationSource inputSource = PresentationSource.FromDependencyObject(InputElement.GetContainingVisual(relativeTo as DependencyObject)); if (inputSource != null) { IMouseInputProvider mouseInputProvider = inputSource.GetInputProvider(typeof(MouseDevice)) as IMouseInputProvider; if (null != mouseInputProvider) { return(mouseInputProvider.GetIntermediatePoints(relativeTo, points)); } } } } return(-1); }
/// <summary> /// Determines if we can remain focused on the element we think has focus /// </summary> /// <remarks> /// Invoked asynchronously by ReevaluateFocusAsync. /// Confirms that the element we think has focus is: /// - still enabled /// - still visible /// - still in the tree /// </remarks> private object ReevaluateFocusCallback(object arg) { _reevaluateFocusOperation = null; if (_focus == null) { return(null); } // // Reevaluate the eligability of the focused element to actually // have focus. If that element is no longer focusable, then search // for an ancestor that is. // DependencyObject element = _focus; while (element != null) { if (Keyboard.IsFocusable(element)) { break; } // Walk the current tree structure. element = DeferredElementTreeState.GetCoreParent(element, null); } // Get the PresentationSource that contains the element to be focused. PresentationSource presentationSource = null; DependencyObject visualContainer = InputElement.GetContainingVisual(element); if (visualContainer != null) { presentationSource = PresentationSource.CriticalFromVisual(visualContainer); } // The default action is to reset focus to the root element // of the active presentation source. bool moveFocus = true; DependencyObject moveFocusTo = null; if (presentationSource != null) { IKeyboardInputProvider keyboardProvider = presentationSource.GetInputProvider(typeof(KeyboardDevice)) as IKeyboardInputProvider; if (keyboardProvider != null) { // Confirm with the keyboard provider for this // presentation source that it has acquired focus. if (keyboardProvider.AcquireFocus(true)) { if (element == _focus) { // The focus element is still good. moveFocus = false; } else { // The focus element is no longer focusable, but we found // an ancestor that is, so move focus there. moveFocus = true; moveFocusTo = element; } } } } if (moveFocus) { if (moveFocusTo == null && _activeSource != null) { moveFocusTo = _activeSource.Value.RootVisual as DependencyObject; } Focus(moveFocusTo, /*askOld=*/ false, /*askNew=*/ true, /*forceToNullIfFailed=*/ true); } else { // Refresh FocusWithinProperty so that ReverseInherited Flags are updated. // // We only need to do this if there is any information about the old // tree structure. if (_focusTreeState != null && !_focusTreeState.IsEmpty) { UIElement.FocusWithinProperty.OnOriginValueChanged(_focus, _focus, ref _focusTreeState); } } return(null); }
internal static Point TranslatePoint(Point pt, DependencyObject from, DependencyObject to, out bool translated) { translated = false; Point ptTranslated = pt; // Get the containing and root visuals we are coming from. DependencyObject vFromAsDO = InputElement.GetContainingVisual(from); Visual rootFrom = InputElement.GetRootVisual(from) as Visual; Visual vFrom = vFromAsDO as Visual; if (vFromAsDO != null && vFrom == null) { // must be a Visual3D - get it's 2D visual parent vFrom = VisualTreeHelper.GetContainingVisual2D(vFromAsDO); } if (vFrom != null && rootFrom != null) { GeneralTransform gUp; Matrix mUp; bool isUpSimple = false; isUpSimple = vFrom.TrySimpleTransformToAncestor(rootFrom, false, /* do not apply inverse */ out gUp, out mUp); if (isUpSimple) { ptTranslated = mUp.Transform(ptTranslated); } else if (gUp.TryTransform(ptTranslated, out ptTranslated) == false) { // Error. Out parameter has been set false. return(new Point()); } // If no element was specified to translate to, we leave the coordinates // translated to the root. if (to != null) { // Get the containing and root visuals we are going to. DependencyObject vTo = InputElement.GetContainingVisual(to); Visual rootTo = InputElement.GetRootVisual(to) as Visual; if (vTo != null && rootTo != null) { // If both are under the same root visual, we can easily translate the point // between them by translating up to the root, and then back down. // // However, if both are under different roots, we can only translate // between them if we know how to relate the two root visuals. Currently // we only know how to do that if both roots are sourced in HwndSources. if (rootFrom != rootTo) { HwndSource sourceFrom = PresentationSource.CriticalFromVisual(rootFrom) as HwndSource; HwndSource sourceTo = PresentationSource.CriticalFromVisual(rootTo) as HwndSource; if (sourceFrom != null && sourceFrom.CriticalHandle != IntPtr.Zero && sourceFrom.CompositionTarget != null && sourceTo != null && sourceTo.CriticalHandle != IntPtr.Zero && sourceTo.CompositionTarget != null) { // Translate the point into client coordinates. ptTranslated = PointUtil.RootToClient(ptTranslated, sourceFrom); // Translate the point into screen coordinates. Point ptScreen = PointUtil.ClientToScreen(ptTranslated, sourceFrom); // Translate the point back the the client coordinates of the To window. ptTranslated = PointUtil.ScreenToClient(ptScreen, sourceTo); // Translate the point back to the root element. ptTranslated = PointUtil.ClientToRoot(ptTranslated, sourceTo); } else { // Error. Out parameter has been set false. return(new Point()); } } // Translate the point from the root to the visual. GeneralTransform gDown; Matrix mDown; Visual vToAsVisual = vTo as Visual; if (vToAsVisual == null) { // must be a Visual3D vToAsVisual = VisualTreeHelper.GetContainingVisual2D(vTo); } bool isDownSimple = vToAsVisual.TrySimpleTransformToAncestor(rootTo, true, /* apply inverse */ out gDown, out mDown); if (isDownSimple) { ptTranslated = mDown.Transform(ptTranslated); } else if (gDown != null) { if (gDown.TryTransform(ptTranslated, out ptTranslated) == false) { // Error. Out parameter has been set false. return(new Point()); } } else { // Error. Out parameter has been set false. return(new Point()); } } else { // Error. Out parameter has been set false. return(new Point()); } } } else { // Error. Out parameter has been set false. return(new Point()); } translated = true; return(ptTranslated); }