private void OnMouseLeftButtonUp(object sender, MouseButtonEventArgs e) { _currentRoot?.ClearValue(IsTiltingProperty); TiltDownStoryboard?.Stop(_target); TiltUpStoryboard?.Begin(_target); }
/// <summary> /// Removes the specified view from the region. /// </summary> /// <param name="view">The view to remove.</param> public virtual void Remove(object view) { ItemMetadata itemMetadata = this.GetItemMetadataOrThrow(view); this.ItemMetadataCollection.Remove(itemMetadata); DependencyObject dependencyObject = view as DependencyObject; if (dependencyObject != null && Regions.RegionManager.GetRegionManager(dependencyObject) == this.RegionManager) { dependencyObject.ClearValue(Regions.RegionManager.RegionManagerProperty); } }
private void SetTextFontSize(DependencyObject textElement, DependencyProperty fontSizeProperty) { double newFontSize = this.FontSize; if (double.IsNaN(newFontSize)) { textElement.ClearValue(fontSizeProperty); } else { textElement.SetValue(fontSizeProperty, newFontSize); } }
public static object UpdateDependencyColor(this DependencyObject depo, DependencyProperty dp, Color newColor) { if (!newColor.IsDefault) { depo.SetValue(dp, newColor.ToBrush()); } else { depo.ClearValue(dp); } return(depo.GetValue(dp)); }
/// <summary> /// Synchronizes the column property. Taken from Helper code for DataGrid. /// </summary> internal static bool SyncColumnProperty(DependencyObject column, DependencyObject content, DependencyProperty columnProperty, DependencyProperty contentProperty) { if (IsDefaultValue(column, columnProperty)) { content.ClearValue(contentProperty); return(false); } else { content.SetValue(contentProperty, column.GetValue(columnProperty)); return(true); } }
private void UpdateBehavior(DependencyObject host, IBehavior behavior) { if (behavior.IsApplicable()) { behavior.Update(); } else { host.ClearValue(_property); behavior.Detach(); } }
private void UpdateBehavior(DependencyObject host, IBehavior behavior, DependencyPropertyChangedEventArgs propertyChangedEventArgs) { if (behavior.IsApplicable()) { behavior.Update(propertyChangedEventArgs); } else { host.ClearValue(_property); behavior.Detach(); } }
private static void Clear( DependencyObject target, DependencyProperty targetDP, DependencyObject source, DependencyProperty sourceDP) { var binding = BindingOperations.GetBinding(target, targetDP); if (binding != null && binding.Source == source) { target.ClearValue(targetDP); } }
// Update HasErrors and Invalidate the public ValidationErrors property whose GetOverride will return // the updated value of ValidationErrorsInternal, nicely wrapped into a ReadOnlyCollection<T> private static void OnErrorsInternalChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ValidationErrorCollection newErrors = e.NewValue as ValidationErrorCollection; if (newErrors != null) { d.SetValue(ErrorsProperty, new ReadOnlyObservableCollection <ValidationError>(newErrors)); } else { d.ClearValue(ErrorsProperty); } }
public static void ClearExpandoValue(this DependencyObject depObj, string propertyName, object value, bool skipPropertyChangedHandler) { var prop = DependencyPropertyManager.GetExpandoProperty(propertyName); if (skipPropertyChangedHandler == false) { depObj.ClearValue(prop); return; } try { depObj.SuspendPropertyChangedCallback(prop); depObj.ClearValue(prop); } finally { depObj.ResumePropertyChangedCallback(prop); } }
private static void OnToolTipChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { // clean up any old tooltip value if (null != e.OldValue) { var oldTT = d.GetValue(ToolTipService.ToolTipProperty) as ToolTip; // detach our tooltip value from the object d.ClearValue(ToolTipService.ToolTipProperty); if (null != oldTT) { NameScope.SetNameScope(oldTT, null); if (oldTT.Tag == AutoGeneratedId) { oldTT.Content = null; } oldTT.Initialized -= NewTTInitialized; } } // if we're getting a new tooltip then initialize the tooltip // property of the associated object if (null == e.NewValue) { return; } var newTT = e.NewValue as ToolTip ?? new ToolTip { Tag = AutoGeneratedId, Content = e.NewValue }; // if the value isn't a tooltip then create one around it // so we can bind the datacontext and provide a namescope d.SetValue(ToolTipService.ToolTipProperty, newTT); // provide a temporary namescope so we can handle any element name bindings NameScope.SetNameScope(newTT, new NameScopeHelper(d)); // during the BamlRecordReader's PushContext, the tooltip didn't have // a namescope so we need to make sure we remove the namescope before // the PopContext or else the reader will try to push too much off // the stack and an exception will occur. the Initialized event of // the associated element is sufficient to do this. an alternative // approach would be to use a custom tooltip that implements INameScope // so that the tooltip always has a namescope at the Push and PopContext // points. newTT.Initialized += NewTTInitialized; }
/// <summary> /// Transfer any binding from the source DP to the given target's DP. /// </summary> /// <param name="source">Source element.</param> /// <param name="path"></param> /// <param name="target">Target framework element.</param> /// <param name="dp"></param> public static void ApplyBinding(FrameworkElement source, String path, DependencyObject target, DependencyProperty dp) { var bx = source.GetBindingExpression(dp); if (bx != null) { target.ClearValue(dp); BindingOperations.SetBinding(target, dp, bx.ParentBinding); } else { BindTo(source, path, target, dp); } }
private static void OnIsEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { if ((bool)e.NewValue) { var element = (ItemsControl)d; var behavior = new ListItemMoveBehavior(element); SetBehavior(element, behavior); } else { GetBehavior(d).Dispose(); d.ClearValue(BehaviorProperty); } }
private static void OnScopeForChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { if (((InputTypeCollection)e.NewValue)?.IsInputType(d) == true) { if (GetErrors(d) == null) { SetErrors(d, ErrorNode.CreateFor(d)); } } else if (((InputTypeCollection)e.OldValue)?.IsInputType(d) == true) { d.ClearValue(ErrorsPropertyKey); } }
public static void EnsureBindingAttached(DependencyObject dependencyObject, DependencyProperty dependencyProperty) { if (!(dependencyObject.ReadLocalValue(dependencyProperty) is BindingExpression bindingExpression)) { return; } // Rebind to actual DataContext if (bindingExpression.Status == BindingStatus.Unattached) { dependencyObject.ClearValue(dependencyProperty); dependencyObject.SetBinding(dependencyProperty, bindingExpression.ParentBinding); } }
private static void ClearChildViews(IRegion region) { foreach (var view in region.Views) { DependencyObject dependencyObject = view as DependencyObject; if (dependencyObject != null) { if (GetClearChildViews(dependencyObject)) { dependencyObject.ClearValue(RegionManager.RegionManagerProperty); } } } }
/// <summary> /// Clear the bindings created when the overlay was created by MapChild /// </summary> /// <param name="mapOverlay">MapOverlay that was created by MapChild</param> /// <param name="targetObject">Target object to be used to clear the bindings</param> internal static void ClearMapOverlayBindings(MapOverlay mapOverlay, DependencyObject targetObject) { GeoCoordinate geoCoordinate; Point point; // Clear happens always in the target object. // Binding was created with MapOverlay been the source. // See code that creates the binding for more info. Debug.Assert((bool)mapOverlay.GetValue(MapChild.ToolkitCreatedProperty), "expected that we only get this calls for overlays created by the toolkit"); // It would be weird that bindings are cleared and out of the sudden the object from the client // looses the values he once provided. // They are lost because we setup the binding in a weird way. See code that creates the map overlay. // Save them to set them after clearing the binding geoCoordinate = (GeoCoordinate)targetObject.GetValue(MapChild.GeoCoordinateProperty); point = (Point)targetObject.GetValue(MapChild.PositionOriginProperty); targetObject.ClearValue(MapChild.GeoCoordinateProperty); targetObject.ClearValue(MapChild.PositionOriginProperty); targetObject.SetValue(MapChild.GeoCoordinateProperty, geoCoordinate); targetObject.SetValue(MapChild.PositionOriginProperty, point); }
public void ResetValue(DependencyObject _this, DependencyProperty dp) { var md = dp.GetMetadata(_this.GetType()); if (_this.GetValue(dp).Equals(md.DefaultValue)) { var args = new DependencyPropertyChangedEventArgs(dp, DependencyProperty.UnsetValue, md.DefaultValue); md.PropertyChangedCallback?.Invoke(_this, args); } else { _this.ClearValue(dp); } }
/// <summary>Removes the binding from a property if there is one.</summary> /// <param name="target">The object from which to remove the binding.</param> /// <param name="dp">The dependency property from which to remove the binding.</param> /// <exception cref="T:System.ArgumentNullException">The <paramref name="target" /> and <paramref name="dp" /> parameters cannot be <see langword="null" />.</exception> // Token: 0x06001A33 RID: 6707 RVA: 0x0007D1AC File Offset: 0x0007B3AC public static void ClearBinding(DependencyObject target, DependencyProperty dp) { if (target == null) { throw new ArgumentNullException("target"); } if (dp == null) { throw new ArgumentNullException("dp"); } if (BindingOperations.IsDataBound(target, dp)) { target.ClearValue(dp); } }
/// <summary> /// <see cref="PropertyMetadata.PropertyChangedCallback"/> /// </summary> /// <remarks> /// This method reflects Grid.SharedScopeProperty state by setting / clearing /// dynamic property PrivateSharedSizeScopeProperty. Value of PrivateSharedSizeScopeProperty /// is a collection of SharedSizeState objects for the scope. /// Also PrivateSharedSizeScopeProperty is FrameworkPropertyMetadataOptions.Inherits property. So that all children /// elements belonging to a certain scope can easily access SharedSizeState collection. As well /// as been norified about enter / exit a scope. /// </remarks> internal static void OnIsSharedSizeScopePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { // if ((bool)e.NewValue) { SharedSizeScope sharedStatesCollection = new SharedSizeScope(); d.SetValue(PrivateSharedSizeScopeProperty, sharedStatesCollection); } else { d.ClearValue(PrivateSharedSizeScopeProperty); } }
public static void RestoreLocalValue(this DependencyObject target, DependencyProperty dependencyProperty, object localValue) { if (localValue == DependencyProperty.UnsetValue) { target.ClearValue(dependencyProperty); } else if (localValue is BindingExpression localValueBindingExpression) { target.SetBinding(dependencyProperty, localValueBindingExpression.ParentBinding); } else { target.SetValue(dependencyProperty, localValue); } }
/// <summary> /// <see cref="PropertyMetadata.PropertyChangedCallback"/> /// </summary> /// <remarks> /// This method reflects Grid.SharedScopeProperty state by setting / clearing /// dynamic property PrivateSharedSizeScopeProperty. Value of PrivateSharedSizeScopeProperty /// is a collection of SharedSizeState objects for the scope. /// Also PrivateSharedSizeScopeProperty is FrameworkPropertyMetadataOptions.Inherits property. So that all children /// elements belonging to a certain scope can easily access SharedSizeState collection. As well /// as been norified about enter / exit a scope. /// </remarks> internal static void OnIsSharedSizeScopePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { // is it possible to optimize here something like this: // if ((bool)d.GetValue(Grid.IsSharedSizeScopeProperty) == (d.GetLocalValue(PrivateSharedSizeScopeProperty) != null) // { /* do nothing */ } if ((bool)e.NewValue) { SharedSizeScope sharedStatesCollection = new SharedSizeScope(); d.SetValue(PrivateSharedSizeScopeProperty, sharedStatesCollection); } else { d.ClearValue(PrivateSharedSizeScopeProperty); } }
/// <summary> /// Moves dependency property value from a source to target, if exists. /// </summary> /// <param name="sourceObject">The source object.</param> /// <param name="targetObject">The target object.</param> /// <param name="property">The property to copy.</param> private static void MoveProperty(DependencyObject sourceObject, DependencyObject targetObject, DependencyProperty property) { // get value from source object object propertyValue = sourceObject.ReadLocalValue(property); // if property value exists if (propertyValue != DependencyProperty.UnsetValue) { // copy value on target object targetObject.SetValue(property, propertyValue); // remove value from source object sourceObject.ClearValue(property); } }
protected override void ApplyItemContainerStyle(DependencyObject container, object item) { var style = ContainerStyle; if (null == style && ContainerStyleSelector != null) { style = ContainerStyleSelector.SelectStyle(item, container); } if (null != style) { container.SetValue(AppliedStyleProperty, KnownBoxes.FalseBox); container.SetValue(FrameworkElement.StyleProperty, style); } else { if (true.Equals(container.GetValue(AppliedStyleProperty))) { // if we don't get a style now but we applied one previously clear it container.ClearValue(AppliedStyleProperty); container.ClearValue(FrameworkElement.StyleProperty); } } }
public static void SetIsPrimaryHandPointerOver(DependencyObject obj, bool value) { if (obj == null) { throw new ArgumentNullException("obj"); } if (!value) { obj.ClearValue(IsPrimaryHandPointerOverProperty); } else { obj.SetValue(IsPrimaryHandPointerOverProperty, true); } }
public static void SetKinectRegion(DependencyObject obj, KinectRegion value) { if (obj == null) { throw new ArgumentNullException("obj"); } if (value == null) { obj.ClearValue(KinectRegionProperty); } else { obj.SetValue(KinectRegionProperty, value); } }
/// <summary> /// Invoked when the System.Windows.Media.VisualCollection of a visual object /// is modified. /// </summary> /// <param name="visualAdded"> /// The System.Windows.Media.Visual that was added to the collection. /// </param> /// <param name="visualRemoved"> /// The System.Windows.Media.Visual that was removed from the collection. /// </param> protected override void OnVisualChildrenChanged(DependencyObject visualAdded, DependencyObject visualRemoved) { if (visualRemoved == null) { return; } ItemAnimationData animationData = GetAnimationData(visualRemoved); if (animationData == null) { return; } visualRemoved.ClearValue(AnimationDataProperty); }
private static void HandleContextMenuOpeningStatic(object sender, ContextMenuEventArgs e) { DependencyObject dObjSender = sender as DependencyObject; IInputElement inputElementSender = sender as IInputElement; if (dObjSender != null && inputElementSender != null) { ContextMenu contextMenu = (ContextMenu)(dObjSender.GetValue(FrameworkElement.ContextMenuProperty)); if (contextMenu == null) { TextSelectionSettings settings = TextSelection.GetSettings(dObjSender); IEnumerable <RoutedUICommand> commands = null; if (settings != null && settings.HasContextMenuCommands) { commands = settings.ContextMenuCommands; } else { commands = TextSelectionSettings.DefaultContextMenuCommands; } contextMenu = CreateContextMenu(inputElementSender, commands); if (contextMenu != null) { // We are repacing a null ContextMenu with our built from scratch ContextMenu. // Mark the event as handled so that the built in context menu service does not // try to open the null Context menu and we can open our built from scratch menu // ourselves e.Handled = true; RoutedEventHandler handleContextMenuClosed = null; handleContextMenuClosed = (closedSender, closedArgs) => { inputElementSender.RemoveHandler(FrameworkElement.ContextMenuClosingEvent, handleContextMenuClosed); dObjSender.ClearValue(FrameworkElement.ContextMenuProperty); }; inputElementSender.AddHandler(FrameworkElement.ContextMenuClosingEvent, handleContextMenuClosed); dObjSender.SetValue(FrameworkElement.ContextMenuProperty, contextMenu); contextMenu.IsOpen = true; } } } }
public static DependencyObject GetTemplateElement(this DependencyObject dependencyObject, string elementName) { if (elementName == null) { return(null); } dependencyObject.SetBinding(ElementProperty, new Binding { ElementName = elementName, BindsDirectlyToSource = true, Mode = BindingMode.OneTime }); var element = dependencyObject.GetValue(ElementProperty); dependencyObject.ClearValue(ElementProperty); return((DependencyObject)element); }
public static FrameworkElement GetTemplatedParent(this DependencyObject dependencyObject) { #if !SILVERLIGHT if (dependencyObject is FrameworkElement fre) { return((FrameworkElement)fre.TemplatedParent); } #endif BindingOperations.SetBinding(dependencyObject, ElementProperty, TemplatedParentBinding); var element = dependencyObject.GetValue(ElementProperty); dependencyObject.ClearValue(ElementProperty); return((FrameworkElement)element); }
internal static void UnlinkContainerFromItem(DependencyObject container, object item, IGeneratorHost host) { // When a container is removed from the tree, its future takes one of // two forms: // a) [normal mode] the container becomes eligible for GC // b) [recycling mode] the container joins the recycled list, and // possibly re-enters the tree at some point, usually with a // different item. // // As Dev10 bug 452669 and some "subtle issues" that arose in the // container recycling work illustrate, it's important that the container // and its subtree sever their connection to the data item. Otherwise // you can get aliasing - a dead container reacting to the same item as a live // container. Even without aliasing, it's a perf waste for a dead container // to continue reacting to its former data item. // // On the other hand, it's a perf waste to spend too much effort cleaning // up the container and its subtree, since they will often just get GC'd // in the near future. // // WPF initially did a full cleanup of the container, removing all properties // that were set in PrepareContainerForItem. This avoided aliasing, but // was deemed too expensive, especially for scrolling. For Windows OS Bug // 1445288, all this cleanup work was removed. This sped up scrolling, but // introduced the problems cited in Dev10 452669 and the recycling "subtle // issues". A compromise is needed. // // The compromise is tell the container to attach to a sentinel item // BindingExpressionBase.DisconnectedItem. We allow this to propagate into the // conainer's subtree through properties like DataContext and // ContentControl.Content that are normally set by PrepareItemForContainer. // A Binding that sees the sentinel as the data item will disconnect its // event listeners from the former data item, but will not change its // own value or invalidate its target property. This avoids the cost // of re-measuring most of the subtree. container.ClearValue(ItemForItemContainerProperty); // TreeView virtualization requires that we call ClearContainer before setting // the DataContext to "Disconnected". This gives the TreeViewItems a chance // to save "Item values" in the look-aside table, before that table is // discarded. (See Dev10 628778) host.ClearContainerForItem(container, item); if (container != item) { DependencyProperty dp = FrameworkElement.DataContextProperty; #if DEBUG // Some ancient code at this point handled the case when DataContext // was set via an Expression (presumably a binding). I don't think // this actually happens any more. Just in case... EntryIndex entryIndex = container.LookupEntry(dp.GlobalIndex); Debug.Assert(!container.HasExpression(entryIndex, dp), "DataContext set by expression (unexpectedly)"); #endif container.SetValue(dp, BindingExpressionBase.DisconnectedItem); } }
// establish the link from the container to the corresponding item internal static void LinkContainerToItem(DependencyObject container, object item) { // always set the ItemForItemContainer property container.ClearValue(ItemForItemContainerProperty); container.SetValue(ItemForItemContainerProperty, item); // for non-direct items, set the DataContext property if (container != item) { #if DEBUG // Some ancient code at this point handled the case when DataContext // was set via an Expression (presumably a binding). I don't think // this actually happens any more. Just in case... DependencyProperty dp = FrameworkElement.DataContextProperty; EntryIndex entryIndex = container.LookupEntry(dp.GlobalIndex); Debug.Assert(!container.HasExpression(entryIndex, dp), "DataContext set by expression (unexpectedly)"); #endif container.SetValue(FrameworkElement.DataContextProperty, item); } }
static void OnAttachChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { if (e.NewValue == e.OldValue) { return; } var messageTriggers = (TriggerBase[])d.GetValue(MessageTriggersProperty); #if WinRT81 var allTriggers = Interaction.GetBehaviors(d); if (messageTriggers != null) { messageTriggers.OfType<DependencyObject>().Apply(x => allTriggers.Remove(x)); } var newTriggers = Parser.Parse(d, e.NewValue as string).ToArray(); newTriggers.OfType<DependencyObject>().Apply(allTriggers.Add); #else var allTriggers = Interaction.GetTriggers(d); if (messageTriggers != null) { messageTriggers.Apply(x => allTriggers.Remove(x)); } var newTriggers = Parser.Parse(d, e.NewValue as string).ToArray(); newTriggers.Apply(allTriggers.Add); #endif if (newTriggers.Length > 0) { d.SetValue(MessageTriggersProperty, newTriggers); } else { d.ClearValue(MessageTriggersProperty); } }
/// <summary> /// Remove data Binding (if any) from a property. /// </summary> /// <param name="target">Object from which to remove Binding</param> /// <param name="property">Property from which to remove Binding</param> public static void ClearBinding(DependencyObject target, DependencyProperty property) { if (IsDataBound(target, property)) target.ClearValue(property); }
public static void ClearFriendlyName(DependencyObject dependencyObject) { if (dependencyObject != null) { dependencyObject.ClearValue (FriendlyNameProperty); } }
public static void ClearData(DependencyObject dependencyObject) { if (dependencyObject != null) { dependencyObject.ClearValue (DataProperty); } }