override protected Point GetClickablePointCore() { Point pt = new Point(double.NaN, double.NaN); PresentationSource presentationSource = PresentationSource.CriticalFromVisual(_owner); // If there's no source, the element is not visible, return (double.NaN, double.NaN) point if (presentationSource == null) { return(pt); } HwndSource hwndSource = presentationSource as HwndSource; // If the source isn't an HwnSource, there's not much we can do, return (double.NaN, double.NaN) point if (hwndSource == null) { return(pt); } Rect rectElement = new Rect(new Point(0, 0), _owner.RenderSize); Rect rectRoot = PointUtil.ElementToRoot(rectElement, _owner, presentationSource); Rect rectClient = PointUtil.RootToClient(rectRoot, presentationSource); Rect rectScreen = PointUtil.ClientToScreen(rectClient, hwndSource); pt = new Point(rectScreen.Left + rectScreen.Width * 0.5, rectScreen.Top + rectScreen.Height * 0.5); return(pt); }
private bool OnEnterMenuMode(object sender, EventArgs e) { // Don't enter menu mode if someone has capture if (Mouse.Captured != null) { return(false); } // Need to check that ALT/F10 happened in our source. PresentationSource source = sender as PresentationSource; PresentationSource mySource = null; mySource = PresentationSource.CriticalFromVisual(this); if (source == mySource) { // Give focus to the first possible element in the ItemsControl for (int i = 0; i < Items.Count; i++) { MenuItem menuItem = ItemContainerGenerator.ContainerFromIndex(i) as MenuItem; if (menuItem != null && !(Items[i] is Separator)) { if (menuItem.Focus()) { return(true); } } } } return(false); }
private static void GetClippedPositionOffsets(TextEditor This, ITextPointer position, LogicalDirection direction, out double horizontalOffset, out double verticalOffset) { Rect characterRect = position.GetCharacterRect(direction); horizontalOffset = characterRect.X; verticalOffset = characterRect.Y + characterRect.Height; FrameworkElement frameworkElement = This.TextView.RenderScope as FrameworkElement; if (frameworkElement != null) { GeneralTransform generalTransform = frameworkElement.TransformToAncestor(This.UiScope); if (generalTransform != null) { TextEditorContextMenu.ClipToElement(frameworkElement, generalTransform, ref horizontalOffset, ref verticalOffset); } } for (Visual visual = This.UiScope; visual != null; visual = (VisualTreeHelper.GetParent(visual) as Visual)) { frameworkElement = (visual as FrameworkElement); if (frameworkElement != null) { GeneralTransform generalTransform2 = visual.TransformToDescendant(This.UiScope); if (generalTransform2 != null) { TextEditorContextMenu.ClipToElement(frameworkElement, generalTransform2, ref horizontalOffset, ref verticalOffset); } } } PresentationSource presentationSource = PresentationSource.CriticalFromVisual(This.UiScope); IWin32Window win32Window = presentationSource as IWin32Window; if (win32Window != null) { IntPtr handle = IntPtr.Zero; new UIPermission(UIPermissionWindow.AllWindows).Assert(); try { handle = win32Window.Handle; } finally { CodeAccessPermission.RevertAssert(); } NativeMethods.RECT rect = new NativeMethods.RECT(0, 0, 0, 0); SafeNativeMethods.GetClientRect(new HandleRef(null, handle), ref rect); Point point = new Point((double)rect.left, (double)rect.top); Point point2 = new Point((double)rect.right, (double)rect.bottom); CompositionTarget compositionTarget = presentationSource.CompositionTarget; point = compositionTarget.TransformFromDevice.Transform(point); point2 = compositionTarget.TransformFromDevice.Transform(point2); GeneralTransform generalTransform3 = compositionTarget.RootVisual.TransformToDescendant(This.UiScope); if (generalTransform3 != null) { generalTransform3.TryTransform(point, out point); generalTransform3.TryTransform(point2, out point2); horizontalOffset = TextEditorContextMenu.ClipToBounds(point.X, horizontalOffset, point2.X); verticalOffset = TextEditorContextMenu.ClipToBounds(point.Y, verticalOffset, point2.Y); } } }
private void SetContainer(IInputElement newContainer) { // unsubscribe from LayoutUpdated UnsubscribeFromLayoutUpdated(); // clear cached values _containerPivotPoint = new Point(); _containerSize = new Size(); _root = null; // remember the new container _currentContainer = newContainer; if (newContainer != null) { // get the new root PresentationSource presentationSource = PresentationSource.CriticalFromVisual((Visual)newContainer); if (presentationSource != null) { _root = presentationSource.RootVisual as UIElement; } // subscribe to LayoutUpdated if (_containerLayoutUpdated != null) { SubscribeToLayoutUpdated(); } } }
override protected Rect GetBoundingRectangleCore() { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(_owner); // If there's no source, the element is not visible, return empty rect if (presentationSource == null) { return(Rect.Empty); } HwndSource hwndSource = presentationSource as HwndSource; // If the source isn't an HwnSource, there's not much we can do, return empty rect if (hwndSource == null) { return(Rect.Empty); } Rect rectElement = new Rect(new Point(0, 0), _owner.RenderSize); Rect rectRoot = PointUtil.ElementToRoot(rectElement, _owner, presentationSource); Rect rectClient = PointUtil.RootToClient(rectRoot, presentationSource); Rect rectScreen = PointUtil.ClientToScreen(rectClient, hwndSource); return(rectScreen); }
internal override Rect GetVisibleBoundingRectCore() { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(_owner); // If there's no source, the element is not visible, return empty rect if (presentationSource == null) { return(Rect.Empty); } HwndSource hwndSource = presentationSource as HwndSource; // If the source isn't an HwnSource, there's not much we can do, return empty rect if (hwndSource == null) { return(Rect.Empty); } Rect rectElement = CalculateVisibleBoundingRect(_owner); Rect rectRoot = PointUtil.ElementToRoot(rectElement, _owner, presentationSource); Rect rectClient = PointUtil.RootToClient(rectRoot, presentationSource); Rect rectScreen = PointUtil.ClientToScreen(rectClient, hwndSource); return(rectScreen); }
protected unsafe virtual IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) { this.DemandIfUntrusted(); if (msg != 61) { if (msg != 70) { if (msg == 130) { this._hwnd = new HandleRef(null, IntPtr.Zero); } } else { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(this, false); if (presentationSource != null) { NativeMethods.RECT rect = this.CalculateAssignedRC(presentationSource); NativeMethods.WINDOWPOS *ptr = (NativeMethods.WINDOWPOS *)((void *)lParam); ptr->cx = rect.right - rect.left; ptr->cy = rect.bottom - rect.top; ptr->flags &= -2; ptr->x = rect.left; ptr->y = rect.top; ptr->flags &= -3; ptr->flags |= 256; } } return(IntPtr.Zero); } handled = true; return(this.OnWmGetObject(wParam, lParam)); }
/// <summary> /// Return the property value of FocusedElement property. The return value is validated /// to be in the subtree of element. If FocusedElement element is not a descendant of element this method return null /// </summary> /// <param name="element"></param> /// <param name="validate"></param> /// <returns></returns> internal static IInputElement GetFocusedElement(DependencyObject element, bool validate) { if (element == null) { throw new ArgumentNullException("element"); } DependencyObject focusedElement = (DependencyObject)element.GetValue(FocusedElementProperty); // Validate FocusedElement wrt to its FocusScope. If the two do not belong to the same PresentationSource // then sever this link between them. The classic scenario for this is when an element with logical focus is // dragged out into a floating widow. We want to prevent the MainWindow (focus scope) to point to the // element in the floating window as its logical FocusedElement. if (validate && focusedElement != null) { DependencyObject focusScope = element; if (PresentationSource.CriticalFromVisual(focusScope) != PresentationSource.CriticalFromVisual(focusedElement)) { SetFocusedElement(focusScope, null); focusedElement = null; } } return((IInputElement)focusedElement); }
public void UpdateWindowPos() { if (this._isDisposed) { return; } PresentationSource presentationSource = null; CompositionTarget compositionTarget = null; if (this.CriticalHandle != IntPtr.Zero && base.IsVisible) { presentationSource = PresentationSource.CriticalFromVisual(this, false); if (presentationSource != null) { compositionTarget = presentationSource.CompositionTarget; } } if (compositionTarget != null && compositionTarget.RootVisual != null) { NativeMethods.RECT rc = this.CalculateAssignedRC(presentationSource); Rect rcBoundingBox = PointUtil.ToRect(rc); this.OnWindowPositionChanged(rcBoundingBox); UnsafeNativeMethods.ShowWindowAsync(this._hwnd, 5); return; } UnsafeNativeMethods.ShowWindowAsync(this._hwnd, 0); }
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); } }
/// <summary> /// This is the method that responds to the TextInput event. /// </summary> /// <param name="e">Event arguments</param> protected override void OnTextInput(TextCompositionEventArgs e) { base.OnTextInput(e); if (e.Handled) { return; } // We don't use win32 menu's, so we need to emulate the win32 // behavior for hitting Space while in menu mode. Alt+Space // will be handled as a SysKey by the DefaultWindowProc, but // Alt, then Space needs to be special cased here because we prevent win32. // from entering menu mode. In WPF the equiv. of win32 menu mode is having // a main menu with focus and no menu items opened. if (e.UserInitiated && e.Text == " " && IsMainMenu && (CurrentSelection == null || !CurrentSelection.IsSubmenuOpen)) { // We need to exit menu mode because it holds capture and prevents // the system menu from showing. IsMenuMode = false; System.Windows.Interop.HwndSource source = PresentationSource.CriticalFromVisual(this) as System.Windows.Interop.HwndSource; if (source != null) { source.ShowSystemMenu(); e.Handled = true; } } }
protected override Rect GetBoundingRectangleCore() { TextElement textElement = (TextElement)base.Owner; ITextView textView = textElement.TextContainer.TextView; if (textView == null || !textView.IsValid) { return(Rect.Empty); } Geometry tightBoundingGeometryFromTextPositions = textView.GetTightBoundingGeometryFromTextPositions(textElement.ContentStart, textElement.ContentEnd); if (tightBoundingGeometryFromTextPositions == null) { return(Rect.Empty); } PresentationSource presentationSource = PresentationSource.CriticalFromVisual(textView.RenderScope); if (presentationSource == null) { return(Rect.Empty); } HwndSource hwndSource = presentationSource as HwndSource; if (hwndSource == null) { return(Rect.Empty); } Rect bounds = tightBoundingGeometryFromTextPositions.Bounds; Rect rectRoot = PointUtil.ElementToRoot(bounds, textView.RenderScope, presentationSource); Rect rectClient = PointUtil.RootToClient(rectRoot, presentationSource); return(PointUtil.ClientToScreen(rectClient, hwndSource)); }
private bool ComputeBoundingRectangle(out Rect rect) { rect = Rect.Empty; PresentationSource presentationSource = PresentationSource.CriticalFromVisual(_owner); // If there's no source, the element is not visible, return empty rect if (presentationSource == null) { return(false); } HwndSource hwndSource = presentationSource as HwndSource; // If the source isn't an HwndSource, there's not much we can do, return empty rect if (hwndSource == null) { return(false); } Rect rectElement = _owner.Visual2DContentBounds; // we use VisualTreeHelper.GetContainingVisual2D to transform from the containing Viewport3DVisual Rect rectRoot = PointUtil.ElementToRoot(rectElement, VisualTreeHelper.GetContainingVisual2D(_owner), presentationSource); Rect rectClient = PointUtil.RootToClient(rectRoot, presentationSource); rect = PointUtil.ClientToScreen(rectClient, hwndSource); return(true); }
/// <summary> /// is this visual connected to presentation source ? /// i.e. is it "renderable" ? ///</summary> internal static bool IsConnectedToPresentationSource(Visual visual) { bool isConnected = false; isConnected = PresentationSource.CriticalFromVisual(visual) != null; return(isConnected); }
private void PushMenuMode(bool isAcquireFocusMenuMode) { Debug.Assert(_pushedMenuMode == null); _pushedMenuMode = PresentationSource.CriticalFromVisual(this); Debug.Assert(_pushedMenuMode != null); IsAcquireFocusMenuMode = isAcquireFocusMenuMode; InputManager.UnsecureCurrent.PushMenuMode(_pushedMenuMode); }
internal static bool IsFocusable(DependencyObject element) { // CODE if (element == null) { return(false); } UIElement uie = element as UIElement; if (uie != null) { if (uie.IsVisible == false) { return(false); } } if ((bool)element.GetValue(UIElement.IsEnabledProperty) == false) { return(false); } // CODE bool hasModifiers = false; BaseValueSourceInternal valueSource = element.GetValueSource(UIElement.FocusableProperty, null, out hasModifiers); bool focusable = (bool)element.GetValue(UIElement.FocusableProperty); if (!focusable && valueSource == BaseValueSourceInternal.Default && !hasModifiers) { // The Focusable property was not explicitly set to anything. // The default value is generally false, but true in a few cases. if (FocusManager.GetIsFocusScope(element)) { // Focus scopes are considered focusable, even if // the Focusable property is false. return(true); } else if (uie != null && uie.InternalVisualParent == null) { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(uie); if (presentationSource != null) { // A UIElements that is the root of a PresentationSource is considered focusable. return(true); } } } return(focusable); }
private void LoadedHandler(object sender, RoutedEventArgs args) { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(this); if (presentationSource != null && presentationSource.RootVisual is PopupRoot) { throw new InvalidOperationException(SR.Get("CannotBeInsidePopup")); } }
internal static bool IsFocusable(DependencyObject element) { // This should really be its own property, but it is hard to do efficiently. if (element == null) { return(false); } UIElement uie = element as UIElement; if (uie != null) { if (uie.IsVisible == false) { return(false); } } if ((bool)element.GetValue(UIElement.IsEnabledProperty) == false) { return(false); } // There are too many conflicting desires for whether or not // an element is focusable. We need to differentiate between // a false default value, and the user specifying false // explicitly. // bool hasModifiers = false; BaseValueSourceInternal valueSource = element.GetValueSource(UIElement.FocusableProperty, null, out hasModifiers); bool focusable = (bool)element.GetValue(UIElement.FocusableProperty); if (!focusable && valueSource == BaseValueSourceInternal.Default && !hasModifiers) { // The Focusable property was not explicitly set to anything. // The default value is generally false, but true in a few cases. if (FocusManager.GetIsFocusScope(element)) { // Focus scopes are considered focusable, even if // the Focusable property is false. return(true); } else if (uie != null && uie.InternalVisualParent == null) { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(uie); if (presentationSource != null) { // A UIElements that is the root of a PresentationSource is considered focusable. return(true); } } } return(focusable); }
private ManipulationDevice(UIElement element) : base() { _target = element; _activeSource = PresentationSource.CriticalFromVisual(element); _inputManager = InputManager.UnsecureCurrent; _inputManager.PostProcessInput += new ProcessInputEventHandler(PostProcessInput); _manipulationLogic = new ManipulationLogic(this); }
private bool ValidateVisualForCapture(DependencyObject visual) { if (visual == null) { return(false); } PresentationSource presentationSource = PresentationSource.CriticalFromVisual(visual); return((presentationSource != null) && (presentationSource == _activeSource)); }
internal override void UpdateState(UIElement element) { bool unhookPenContexts = true; // Disable processing of the queue during blocking operations to prevent unrelated reentrancy // which a call to Lock() can cause. using (element.Dispatcher.DisableProcessing()) { // See if we should be enabled if (element.IsVisible && element.IsEnabled && element.IsHitTestVisible) { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(element as Visual); if (presentationSource != null) { unhookPenContexts = false; // Are we currently hooked up? If not then hook up. if (_penContexts == null) { InputManager inputManager = (InputManager)element.Dispatcher.InputManager; PenContexts penContexts = StylusLogic.GetCurrentStylusLogicAs <WispLogic>().GetPenContextsFromHwnd(presentationSource); // _penContexts must be non null or don't do anything. if (penContexts != null) { _penContexts = penContexts; lock (penContexts.SyncRoot) { penContexts.AddStylusPlugInCollection(Wrapper); foreach (StylusPlugIn spi in Wrapper) { spi.InvalidateIsActiveForInput(); // Uses _penContexts being set to determine active state. } // NTRAID:WINDOWSOS#1677277-2006/06/05-WAYNEZEN, // Normally the Rect will be updated when we receive the LayoutUpdate. // However there could be a race condition which the LayoutUpdate gets received // before the properties like IsVisible being set. // So we should always force to call OnLayoutUpdated whenever the input is active. Wrapper.OnLayoutUpdated(this.Wrapper, EventArgs.Empty); } } } } } if (unhookPenContexts) { Unhook(); } } }
internal static void ShowFindUnsuccessfulMessage(FindToolBar findToolBar) { string text = findToolBar.SearchUp ? SR.Get("DocumentViewerSearchUpCompleteLabel") : SR.Get("DocumentViewerSearchDownCompleteLabel"); text = string.Format(CultureInfo.CurrentCulture, text, new object[] { findToolBar.SearchText }); HwndSource hwndSource = PresentationSource.CriticalFromVisual(findToolBar) as HwndSource; IntPtr parentHwnd = (hwndSource != null) ? hwndSource.CriticalHandle : IntPtr.Zero; SecurityHelper.ShowMessageBoxHelper(parentHwnd, text, SR.Get("DocumentViewerSearchCompleteTitle"), MessageBoxButton.OK, MessageBoxImage.Asterisk); }
private Point ClientToScreen(Point point, Visual visual) { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(visual); if (presentationSource != null) { GeneralTransform transform = visual.TransformToAncestor(presentationSource.RootVisual); if (transform != null) { point = transform.Transform(point); } } return(PointUtil.ClientToScreen(point, presentationSource)); }
//---------------------------------------------- // // Private Methods // //---------------------------------------------- #region Private Methods private void LoadedHandler(object sender, RoutedEventArgs args) { PresentationSource pSource = PresentationSource.CriticalFromVisual(this); // Note that we cannot assert this condition here. The reason is that this element might have // been disconnected from the tree through one of its parents even while it waited for the // pending Loaded event to fire. More details for this scenario can be found in the // Windows OS Bug#1981485. // Invariant.Assert(pSource != null, "Loaded has fired. PresentationSource shouldn't be null"); if (pSource != null && pSource.RootVisual is PopupRoot) { throw new InvalidOperationException(SR.Get(SRID.CannotBeInsidePopup)); } }
/// <summary> /// Call Win32 SetForegroundWindow to set the drop target as the foreground window. /// </summary> private void Win32SetForegroundWindow() { PresentationSource source = null; IntPtr hwnd = IntPtr.Zero; source = PresentationSource.CriticalFromVisual(_textEditor.UiScope); if (source != null) { hwnd = (source as IWin32Window).Handle; } if (hwnd != IntPtr.Zero) { UnsafeNativeMethods.SetForegroundWindow(new HandleRef(null, hwnd)); } }
internal static Point ClientToScreen(UIElement relativeTo, Point point) { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(relativeTo); if (presentationSource == null) { return(new Point(double.NaN, double.NaN)); } GeneralTransform generalTransform = relativeTo.TransformToAncestor(presentationSource.RootVisual); Point point2; generalTransform.TryTransform(point, out point2); Point pointClient = PointUtil.RootToClient(point2, presentationSource); return(PointUtil.ClientToScreen(pointClient, presentationSource)); }
protected override Rect GetBoundingRectangleCore() { UIElement uielement; Rect rect = this.CalculateBoundingRect(false, out uielement); if (rect != Rect.Empty && uielement != null) { HwndSource hwndSource = PresentationSource.CriticalFromVisual(uielement) as HwndSource; if (hwndSource != null) { rect = PointUtil.ElementToRoot(rect, uielement, hwndSource); rect = PointUtil.RootToClient(rect, hwndSource); rect = PointUtil.ClientToScreen(rect, hwndSource); } } return(rect); }
private void OnSourceChanged(object sender, SourceChangedEventArgs e) { IKeyboardInputSite keyboardInputSite = ((IKeyboardInputSink)this).KeyboardInputSite; if (keyboardInputSite != null) { if (this._fTrusted.Value) { new UIPermission(PermissionState.Unrestricted).Assert(); } try { ((IKeyboardInputSink)this).KeyboardInputSite = null; keyboardInputSite.Unregister(); } finally { if (this._fTrusted.Value) { CodeAccessPermission.RevertAssert(); } } } IKeyboardInputSink keyboardInputSink = PresentationSource.CriticalFromVisual(this, false) as IKeyboardInputSink; if (keyboardInputSink != null) { if (this._fTrusted.Value) { new UIPermission(PermissionState.Unrestricted).Assert(); } try { ((IKeyboardInputSink)this).KeyboardInputSite = keyboardInputSink.RegisterKeyboardInputSink(this); } finally { if (this._fTrusted.Value) { CodeAccessPermission.RevertAssert(); } } } this.BuildOrReparentWindow(); }
internal override Point GetPosition(IInputElement relativeTo) { VerifyAccess(); // Validate that relativeTo is either a UIElement or a ContentElement if (relativeTo != null && !InputElement.IsValid(relativeTo)) { throw new InvalidOperationException(); } PresentationSource relativePresentationSource = null; if (relativeTo != null) { DependencyObject dependencyObject = relativeTo as DependencyObject; DependencyObject containingVisual = InputElement.GetContainingVisual(dependencyObject); if (containingVisual != null) { relativePresentationSource = PresentationSource.CriticalFromVisual(containingVisual); } } else { if (_inputSource != null) { relativePresentationSource = _inputSource.Value; } } // Verify that we have a valid PresentationSource with a valid RootVisual // - if we don't we won't be able to invoke ClientToRoot or TranslatePoint and // we will just return 0,0 if (relativePresentationSource == null || relativePresentationSource.RootVisual == null) { return(new Point(0, 0)); } Point curPoint = new Point(_pointerData.Info.ptPixelLocationRaw.X, _pointerData.Info.ptPixelLocationRaw.Y); Point ptClient = PointUtil.ScreenToClient(curPoint, relativePresentationSource); Point ptRoot = PointUtil.ClientToRoot(ptClient, relativePresentationSource); Point ptRelative = InputElement.TranslatePoint(ptRoot, relativePresentationSource.RootVisual, (DependencyObject)relativeTo); return(ptRelative); }
internal static Point ClientToScreen(UIElement relativeTo, Point point) { GeneralTransform transform; PresentationSource source = PresentationSource.CriticalFromVisual(relativeTo); if (source == null) { return(new Point(double.NaN, double.NaN)); } transform = relativeTo.TransformToAncestor(source.RootVisual); Point ptRoot; transform.TryTransform(point, out ptRoot); Point ptClient = PointUtil.RootToClient(ptRoot, source); Point ptScreen = PointUtil.ClientToScreen(ptClient, source); return(ptScreen); }