//-------------------------------------------------------------------- // // Public Properties // //--------------------------------------------------------------------- #region Static methods public static FixedSOMElement CreateFixedSOMElement(FixedPage page, UIElement uiElement, FixedNode fixedNode, int startIndex, int endIndex) { FixedSOMElement element = null; if (uiElement is Glyphs) { Glyphs glyphs = uiElement as Glyphs; if (glyphs.UnicodeString.Length > 0) { GlyphRun glyphRun = glyphs.ToGlyphRun(); Rect alignmentBox = glyphRun.ComputeAlignmentBox(); alignmentBox.Offset(glyphs.OriginX, glyphs.OriginY); GeneralTransform transform = glyphs.TransformToAncestor(page); if (startIndex < 0) { startIndex = 0; } if (endIndex < 0) { endIndex = glyphRun.Characters == null ? 0 : glyphRun.Characters.Count; } element = FixedSOMTextRun.Create(alignmentBox, transform, glyphs, fixedNode, startIndex, endIndex, false); } } else if (uiElement is Image) { element = FixedSOMImage.Create(page, uiElement as Image, fixedNode); } else if (uiElement is Path) { element = FixedSOMImage.Create(page, uiElement as Path, fixedNode); } return element; }
public void BuildNameHashTable(String Name, UIElement e, int indexToFixedNodes) { if (!_nameHashTable.ContainsKey(Name)) { _nameHashTable.Add(Name, new NameHashFixedNode(e,indexToFixedNodes)); } }
public static UIElement GetFocusScope(UIElement element) { while (element != null && !GetIsFocusScope(element)) { element = (UIElement)(element.LogicalParent ?? element.VisualParent); } return element; }
/// <summary> /// Create an instance of the DragValidator class /// </summary> /// <param name="targetElement">UIElement that represents the source of the drag operation</param> public DragValidator(UIElement targetElement) { Debug.Assert(targetElement != null); _targetElement = targetElement; _targetElement.MouseLeftButtonDown += new MouseButtonEventHandler(TargetElement_MouseLeftButtonDown); _targetElement.MouseLeftButtonUp += new MouseButtonEventHandler(TargetElement_MouseLeftButtonUp); _targetElement.MouseMove += new MouseEventHandler(TargetElement_MouseMove); }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors /// <summary> /// C'tor for adorner /// </summary> /// <param name="scope"> /// FramwerokElement with TextView to which this element is attached /// as adorner. /// </param> internal ColumnResizeAdorner(UIElement scope) : base(scope) { Debug.Assert(scope != null); // position _pen = new Pen(new SolidColorBrush(Colors.LightSlateGray), 2.0); _x = Double.NaN; _top = Double.NaN; _height = Double.NaN; }
//------------------------------------------------------------------- // // Connstructors // //---------------------------------------------------------------------- #region Constructors /// <summary> /// Create a new FixedHighlight for a Glyphs with character offset of /// beginOffset to endOffset, to be rendered with a given brush. /// </summary> internal FixedHighlight(UIElement element, int beginOffset, int endOffset, FixedHighlightType t, Brush foreground, Brush background) { Debug.Assert(element != null && beginOffset >= 0 && endOffset >= 0); _element = element; _gBeginOffset = beginOffset; _gEndOffset = endOffset; _type = t; _foregroundBrush = foreground; _backgroundBrush = background; }
/// <summary> /// The colleciton is the children collection of the visualParent. The logicalParent /// is used to do logical parenting. The flags is used to invalidate /// the resource properties in the child tree, if an Application object exists. /// </summary> /// <param name="visualParent">The element of whom this is a children collection</param> /// <param name="logicalParent">The logicalParent of the elements of this collection. /// if overriding Panel.CreateUIElementCollection, pass the logicalParent parameter of that method here. /// </param> public UIElementCollection(UIElement visualParent, FrameworkElement logicalParent) { if (visualParent == null) { throw new ArgumentNullException(SR.Get(SRID.Panel_NoNullVisualParent, "visualParent", this.GetType())); } _visualChildren = new VisualCollection(visualParent); _visualParent = visualParent; _logicalParent = logicalParent; }
public static IDisposable Focus(UIElement element) { if (!element.Focusable) { return null; } UIElement focusScope = GetFocusScope(element); if (focusScope != null) { SetFocusedElement(focusScope, element); return new Disposable(() => { if (GetFocusedElement(focusScope) == element) { SetFocusedElement(focusScope, null); } }); } return null; }
internal static Point Translate(this UIElement fromElement, UIElement toElement, Point fromPoint) { return fromElement.TransformToVisual(toElement).Transform(fromPoint); }
/// <summary> /// Writes the attached property Dock to the given element. /// </summary> /// <param name="element">UIElement to which to write the attached property.</param> /// <param name="dock">The property value to set</param> /// <seealso cref="DockPanel.DockProperty" /> public static void SetDock(UIElement element, Dock dock) { if (element == null) { throw new ArgumentNullException("element"); } element.SetValue(DockProperty, dock); }
public static Dock GetDock(UIElement element) { if (element == null) { throw new ArgumentNullException("element"); } return (Dock) element.GetValue(DockProperty); }
//------------------------------------------------------ // // Private Methods // //------------------------------------------------------ #region Private Methods // hit testing to find the inner most UIElement that was hit // as well as the containing fixed page. private bool _HitTest(Point pt, out UIElement e) { e = null; HitTestResult result = VisualTreeHelper.HitTest(this.FixedPage, pt); DependencyObject v = (result != null) ? result.VisualHit : null; while (v != null) { DependencyObjectType t = v.DependencyObjectType; if (t == UIElementType || t.IsSubclassOf(UIElementType)) { e = (UIElement) v; return true; } v = VisualTreeHelper.GetParent(v); } return false; }
// This is internal as an optimization for VirtualizingStackPanel (so it doesn't need to re-query InternalChildren repeatedly) internal static void InsertInternalChild(UIElementCollection children, int index, UIElement child) { children.InsertInternal(index, child); }
private void AddFixedNodeInFlow(int index, UIElement e) { if (_visitedArray[index]) { // this has already been added to the document structure // Debug.Assert(false, "An element is referenced in the document structure multiple times"); return; // ignore this reference } FixedNode fn = (FixedNode)_fixedNodes[index]; if (e == null) { e = _fixedPage.GetElement(fn) as UIElement; } _visitedArray[index] = true; FixedSOMElement somElement = FixedSOMElement.CreateFixedSOMElement(_fixedPage, e, fn, -1, -1); if (somElement != null) { _flowBuilder.AddElement(somElement); } }
/// <summary> /// Lets the page recalculate the rectangles for this element when its desired /// size has changed. /// </summary> public void OnChildDesiredSizeChanged(UIElement child) { if (_basePage != null) { _basePage.OnChildDesiredSizeChanged(child); } }
private static void OnOwnerMouseLeftButtonDown(object sender, MouseButtonEventArgs e) { if ((ToolTipService._lastEnterSource != null) && object.ReferenceEquals(ToolTipService._lastEnterSource, e.OriginalSource)) { return; } if (ToolTipService._owner != sender) { return; } // close the opened ToolTip or cancel mouse hover if (ToolTipService._currentToolTip == null) { ToolTipService._openTimer.Stop(); ToolTipService._owner = null; ToolTipService._lastEnterSource = null; return; } CloseAutomaticToolTip(null, EventArgs.Empty); }
// This method should be executed on the UI thread private static void CloseAutomaticToolTip(object sender, EventArgs e) { ToolTipService._closeTimer.Stop(); Debug.Assert(ToolTipService._currentToolTip != null, "no ToolTip to close"); ToolTipService._currentToolTip.IsOpen = false; ToolTipService._currentToolTip = null; ToolTipService._owner = null; ToolTipService._lastEnterSource = null; // set last opened timestamp only if the ToolTip is opened by a mouse movement ToolTipService._lastToolTipOpenedTime = DateTime.Now; }
internal static void OnOwnerMouseLeave(object sender, MouseEventArgs e) { if (ToolTipService._currentToolTip == null) { // ToolTip had not been opened yet ToolTipService._openTimer.Stop(); ToolTipService._owner = null; ToolTipService._lastEnterSource = null; return; } CloseAutomaticToolTip(null, EventArgs.Empty); }
internal static void OnOwnerMouseEnterInternal(object sender, object source) { if ((ToolTipService._lastEnterSource != null) && object.ReferenceEquals(ToolTipService._lastEnterSource, source)) { // ToolTipService had processed this event once before, when it fired on the child // skip it now return; } UIElement senderElement = (UIElement)sender; if (ToolTipService._currentToolTip != null) { if (ToolTipService._toolTipDictionary[senderElement] != ToolTipService._currentToolTip) { // first close the previous ToolTip if entering nested elements with tooltips CloseAutomaticToolTip(null, EventArgs.Empty); } else { // reentering the same element return; } } ToolTipService._owner = senderElement; ToolTipService._lastEnterSource = source; Debug.Assert(ToolTipService._currentToolTip == null); SetRootVisual(); TimeSpan sinceLastOpen = DateTime.Now - ToolTipService._lastToolTipOpenedTime; if (TimeSpan.Compare(sinceLastOpen, new TimeSpan(0, 0, 0, 0, TOOLTIPSERVICE_betweenShowDelay)) <= 0) { // open the ToolTip immediately OpenAutomaticToolTip(null, EventArgs.Empty); } else { // open the ToolTip after the InitialShowDelay interval expires if (ToolTipService._openTimer == null) { ToolTipService._openTimer = new DispatcherTimer(); ToolTipService._openTimer.Tick += new EventHandler(OpenAutomaticToolTip); } ToolTipService._openTimer.Interval = new TimeSpan(0, 0, 0, 0, TOOLTIPSERVICE_initialShowDelay); ToolTipService._openTimer.Start(); } }
/// <summary> /// Called when a UIElement-derived class which is hosted by a IContentHost changes its DesiredSize /// </summary> /// <param name="child"> /// Child element whose DesiredSize has changed /// </param> protected virtual void OnChildDesiredSizeChangedCore(UIElement child) { this.OnChildDesiredSizeChanged(child); }
/// <summary> /// Called when a UIElement-derived class which is hosted by a IContentHost changes its DesiredSize /// NOTE: This method already exists for this class and is not specially implemented for IContentHost. /// If this method is called through IContentHost for this class it will fire an assert /// </summary> /// <param name="child"> /// Child element whose DesiredSize has changed /// </param> void IContentHost.OnChildDesiredSizeChanged(UIElement child) { this.OnChildDesiredSizeChangedCore(child); }
internal static bool Within(this Point referencePoint, UIElement referenceElement, FrameworkElement targetElement, bool ignoreVertical) { Point position = referenceElement.Translate(targetElement, referencePoint); return position.X > 0 && position.X < targetElement.ActualWidth && (ignoreVertical || (position.Y > 0 && position.Y < targetElement.ActualHeight) ); }
/// <summary> /// OnChildDesiredSizeChanged /// Called from FlowDocumentPage for IContentHost implementation /// internal void OnChildDesiredSizeChanged(UIElement child) { if (_structuralCache != null && _structuralCache.IsFormattedOnce && !_structuralCache.ForceReformat) { // If executed during formatting process, delay invalidation. // This may happen during formatting when text host notifies its about // baseline changes. if (_structuralCache.IsFormattingInProgress) { Dispatcher.BeginInvoke(DispatcherPriority.Normal, new DispatcherOperationCallback(OnChildDesiredSizeChangedAsync), child); return; } // Get start and end positions int childStartIndex = TextContainerHelper.GetCPFromEmbeddedObject(child, ElementEdge.BeforeStart); if (childStartIndex < 0) { return; } TextPointer childStart = new TextPointer(_structuralCache.TextContainer.Start); childStart.MoveByOffset(childStartIndex); TextPointer childEnd = new TextPointer(childStart); childEnd.MoveByOffset(TextContainerHelper.EmbeddedObjectLength); // Create new DTR for changing UIElement and add it to DRTList. DirtyTextRange dtr = new DirtyTextRange(childStartIndex, TextContainerHelper.EmbeddedObjectLength, TextContainerHelper.EmbeddedObjectLength); _structuralCache.AddDirtyTextRange(dtr); // Notify formatter about content invalidation. if (_formatter != null) { _formatter.OnContentInvalidated(true, childStart, childEnd); } } }
private static void UnregisterToolTip(UIElement owner) { Debug.Assert(owner != null, "owner element is required"); if (!ToolTipService._toolTipDictionary.ContainsKey(owner)) { return; } owner.MouseEnter -= new MouseEventHandler(OnOwnerMouseEnter); owner.MouseLeave -= new MouseEventHandler(OnOwnerMouseLeave); owner.MouseLeftButtonDown -= new MouseButtonEventHandler(OnOwnerMouseLeftButtonDown); owner.KeyDown -= new KeyEventHandler(OnOwnerKeyDown); ToolTip toolTip = ToolTipService._toolTipDictionary[owner]; if (toolTip.IsOpen) { if (toolTip == ToolTipService._currentToolTip) { // unregistering a currently open automatic toltip // thus need to stop the timer ToolTipService._closeTimer.Stop(); ToolTipService._currentToolTip = null; ToolTipService._owner = null; ToolTipService._lastEnterSource = null; } toolTip.IsOpen = false; } ToolTipService._toolTipDictionary[owner] = null; ToolTipService._toolTipDictionary.Remove(owner); }
/// <summary> /// Fetch the logical/item offset for this child with respect to the top of the /// panel. This is similar to a TransformToAncestor operation. Just works /// in logical units. /// </summary> protected virtual double GetItemOffsetCore(UIElement child) { return 0; }
public static void SetPlacementTarget(DependencyObject element, UIElement value) { if (element == null) { throw new ArgumentNullException ("element"); } element.SetValue (ToolTipService.PlacementTargetProperty, value); }
internal NameHashFixedNode(UIElement e, int i) { uiElement = e; index = i; }
/// <summary> /// Apply a template to the ToggleButton. /// </summary> public override void OnApplyTemplate() { base.OnApplyTemplate(); object root = GetTemplateChild(ElementRootName); Debug.Assert(typeof(FrameworkElement).IsInstanceOfType(root) || (root == null), "The template part RootElement is not an instance of FrameworkElement!"); _elementRoot = root as FrameworkElement; object focusVisual = GetTemplateChild(ElementFocusVisualName); Debug.Assert(typeof(UIElement).IsInstanceOfType(focusVisual) || (focusVisual == null), "The template part FocusVisualElement is not an instance of UIElement!"); _elementFocusVisual = focusVisual as UIElement; object contentFocusVisual = GetTemplateChild(ElementContentFocusVisualName); Debug.Assert(typeof(UIElement).IsInstanceOfType(contentFocusVisual) || (contentFocusVisual == null), "The template part ContentFocusVisualElement is not an instance of UIElement!"); _elementContentFocusVisual = contentFocusVisual as UIElement; // Get the states if (_elementRoot != null) { object @checked = _elementRoot.Resources[StateCheckedName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(@checked) || (@checked == null), "The template part Checked State is not an instance of Storyboard!"); _stateChecked = @checked as Storyboard; object indeterminate = _elementRoot.Resources[StateIndeterminateName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(indeterminate) || (indeterminate == null), "The template part Indeterminate State is not an instance of Storyboard!"); _stateIndeterminate = indeterminate as Storyboard; object @unchecked = _elementRoot.Resources[StateNormalName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(@unchecked) || (@unchecked == null), "The template part Normal State is not an instance of Storyboard!"); _stateNormal = @unchecked as Storyboard; object mouseOverChecked = _elementRoot.Resources[StateMouseOverCheckedName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(mouseOverChecked) || (mouseOverChecked == null), "The template part MouseOver Checked State is not an instance of Storyboard!"); _stateMouseOverChecked = mouseOverChecked as Storyboard; object mouseOverIndeterminate = _elementRoot.Resources[StateMouseOverIndeterminateName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(mouseOverIndeterminate) || (mouseOverIndeterminate == null), "The template part MouseOver Indeterminate State is not an instance of Storyboard!"); _stateMouseOverIndeterminate = mouseOverIndeterminate as Storyboard; object mouseOverUnchecked = _elementRoot.Resources[StateMouseOverUncheckedName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(mouseOverUnchecked) || (mouseOverUnchecked == null), "The template part MouseOver Unchecked State is not an instance of Storyboard!"); _stateMouseOverUnchecked = mouseOverUnchecked as Storyboard; object pressedChecked = _elementRoot.Resources[StatePressedCheckedName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(pressedChecked) || (pressedChecked == null), "The template part Pressed Checked State is not an instance of Storyboard!"); _statePressedChecked = pressedChecked as Storyboard; object pressedIndeterminate = _elementRoot.Resources[StatePressedIndeterminateName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(pressedIndeterminate) || (pressedIndeterminate == null), "The template part Pressed Indeterminate State is not an instance of Storyboard!"); _statePressedIndeterminate = pressedIndeterminate as Storyboard; object pressedUnchecked = _elementRoot.Resources[StatePressedUncheckedName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(pressedUnchecked) || (pressedUnchecked == null), "The template part Pressed Unchecked State is not an instance of Storyboard!"); _statePressedUnchecked = pressedUnchecked as Storyboard; object disabledChecked = _elementRoot.Resources[StateDisabledCheckedName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(disabledChecked) || (disabledChecked == null), "The template part Disabled Checked State is not an instance of Storyboard!"); _stateDisabledChecked = disabledChecked as Storyboard; object disabledIndeterminate = _elementRoot.Resources[StateDisabledIndeterminateName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(disabledIndeterminate) || (disabledIndeterminate == null), "The template part Disabled Indeterminate State is not an instance of Storyboard!"); _stateDisabledIndeterminate = disabledIndeterminate as Storyboard; object disabledUnchecked = _elementRoot.Resources[StateDisabledUncheckedName]; Debug.Assert(typeof(Storyboard).IsInstanceOfType(disabledUnchecked) || (disabledUnchecked == null), "The template part Disabled Unchecked State is not an instance of Storyboard!"); _stateDisabledUnchecked = disabledUnchecked as Storyboard; } // Sync the logical and visual states of the control UpdateVisualState(); }
/* private static void PositiveValueValidation(DependencyObject d, DependencyPropertyChangedEventArgs e) { if ((int)e.NewValue <= 0) { throw new ArgumentException(Resource.ToolTipService_SetTimeoutProperty_InvalidValue, "e"); } } */ private static void RegisterToolTip(UIElement owner, object toolTip) { Debug.Assert(!ToolTipService._toolTipDictionary.ContainsKey(owner), "duplicate tooltip for the same owner element"); Debug.Assert(owner != null, "ToolTip must have an owner"); Debug.Assert(toolTip != null, "ToolTip can not be null"); owner.MouseEnter += new MouseEventHandler(OnOwnerMouseEnter); owner.MouseLeave += new MouseEventHandler(OnOwnerMouseLeave); owner.MouseLeftButtonDown += new MouseButtonEventHandler(OnOwnerMouseLeftButtonDown); owner.KeyDown += new KeyEventHandler(OnOwnerKeyDown); ToolTipService._toolTipDictionary[owner] = ConvertToToolTip(toolTip); }
private static void AddAutomationPeer(List<AutomationPeer> children, UIElement child) { if (child != null) { AutomationPeer peer = FromElement(child); if (peer == null) { peer = CreatePeerForElement(child); } if (peer != null) { // In the array that GetChildrenCore returns, which is used by AutomationPeer.EnsureChildren, // no null entries are allowed or a NullReferenceException will be thrown from the guts of WPF. // This has reproducibly been observed null on certain systems so the null check was added. // This may mean that some child controls are missing for automation, but at least the // application doesn't crash in normal usage. children.Add(peer); } } }