private void UpdateListBinding() { BindingBase bindBase = BindingOperations.GetBindingBase(lstvItems, ListView.ItemsSourceProperty); BindingOperations.ClearBinding(lstvItems, ListView.ItemsSourceProperty); lstvItems.SetBinding(ListView.ItemsSourceProperty, bindBase); }
public static List <BindingBase> GetBindingObjects(this DependencyObject element) { Console.WriteLine("GetBindingObjects -> {0}", element); List <BindingBase> bindings = new List <BindingBase>(); List <DependencyProperty> dpList = new List <DependencyProperty>(); dpList.AddRange(GetDependencyProperties(element)); //dpList.AddRange(GetAttachedProperties(element)); foreach (DependencyProperty dp in dpList) { Console.WriteLine("{1}.{0}", dp.Name, element); BindingBase b = BindingOperations.GetBindingBase(element as DependencyObject, dp); if (b != null) { bindings.Add(b); } } int childrenCount = VisualTreeHelper.GetChildrenCount(element); Console.WriteLine("{1}.ChildrenCount: {0}", childrenCount, element); if (childrenCount > 0) { for (int i = 0; i < childrenCount; i++) { DependencyObject child = VisualTreeHelper.GetChild(element, i); bindings.AddRange(GetBindingObjects(child)); } } return(bindings); }
/// <summary> /// Frameworks the element on data context changed. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="DependencyPropertyChangedEventArgs"/> instance containing the event data.</param> private void FrameworkElementOnDataContextChanged(object sender, DependencyPropertyChangedEventArgs e) { OnDataContextDetaching(e.OldValue); var properties = GetDependencyProperties(this); foreach (var dependencyProperty in properties) { var bindingBase = BindingOperations.GetBindingBase(this, dependencyProperty); switch (bindingBase) { case Binding binding: { if (binding.Source != null || binding.RelativeSource != null || binding.ElementName != null) { continue; } BindingOperations.ClearBinding(this, dependencyProperty); BindingOperations.SetBinding(this, dependencyProperty, binding); break; } } } OnDataContextAttached(e.NewValue); }
/// <summary> /// Tries to resolve path binding and to set whole binding accordingly. /// </summary> /// <param name="serviceProvider">Service provider given by the framework.</param> private void Initialize(IServiceProvider serviceProvider = null) { if (initialized) { return; } if (ResolveBoundPathBinding(serviceProvider)) { if (!providing_value) // set binding only if we are not called by the ProvideValue method. { no_target_update = true; BindingOperations.SetBinding(TargetObject, TargetProperty, boundPathBinding); no_target_update = false; } initialized = true; } else if (!providing_value && TargetObject != null) // if unresolved and target object is identified, try to clear property binding. { if (BindingOperations.GetBindingBase(TargetObject, TargetProperty) != null) { no_target_update = true; BindingOperations.ClearBinding(TargetObject, TargetProperty); // may fail in datatemplates, but self binding is at least maintained. no_target_update = false; } } }
/// <summary> /// Эту процедуру нужно привязать к событию GotFocus для всех TextBox, в которых используются Binding и StrToIntConverter, StrToFloatConverter /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected virtual void txt_GotFocus(object sender, RoutedEventArgs e) { TextBoxEx txt = sender as TextBoxEx; if (txt != null && txt.Modified && txt.IsRightInput) { BindingBase bindBase = BindingOperations.GetBindingBase(txt, TextBox.TextProperty); if (bindBase != null) { Binding bind = bindBase as Binding; if (bind != null) { if (bind.Converter is StrToIntConverter) { ((StrToIntConverter)bind.Converter).m_PrevVal = int.Parse(txt.Text); } else if (bind.Converter is StrToFloatConverter) { ((StrToFloatConverter)bind.Converter).m_PrevVal = float.Parse(txt.Text); } } } } }
public override void Desynchronize() { var targetColumn = this.DetailColumn; var dp = ColumnBase.VisibleProperty; var oldLocalValue = m_localValue; m_localValue = DependencyProperty.UnsetValue; if (BindingOperations.GetBindingBase(targetColumn, dp) != null) { return; } if (!object.Equals(targetColumn.ReadLocalValue(dp), false)) { return; } var oldBinding = oldLocalValue as BindingBase; if (oldBinding != null) { BindingOperations.SetBinding(targetColumn, dp, oldBinding); } else if (oldLocalValue != DependencyProperty.UnsetValue) { targetColumn.SetValue(dp, oldLocalValue); } else { targetColumn.ClearValue(dp); } }
public override void SetProperties(UserControl[] _controls) { var tb = BindingOperations.GetBindingBase(this, TextProperty); BindingOperations.ClearBinding(this, TextProperty); if (Items == null) { Items = new ObservableCollection <string>(); } Items.Clear(); foreach (var item in (_controls.OfType <ListControl>().First()).Items) { Items.Add(item.Value); } UpdateBinding(); DataSource = new Triple <string, string, bool>(); DataSource.A = _controls.OfType <DataSourceControl>().First().DataSource; DataSource.B = _controls.OfType <DataSourceControl>().First().DataProperty; DataSource.C = _controls.OfType <DataSourceControl>().First().Active; UpdateBinding(); if (tb != null) { BindingOperations.SetBinding(this, TextProperty, tb); } base.SetProperties(_controls); }
/// <summary> /// Property changed callback for DataContext property /// </summary> private static void OnDataContextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { // Selector has a bug regarding DataContext change and SelectedItem property, // where if the SelectedItem due to old DataContext is a valid item in ItemsSource // but the SelectedItem due to new DataContext is not a valid item in ItemsSource, // the SelectedIndex remains that of old context instead of changing to -1. // This method is a workaround to that problem, since it is of high impact to DataGrid. TextBlockComboBox combo = (TextBlockComboBox)d; bool isLocalValue = (DependencyPropertyHelper.GetValueSource(combo, SelectedItemProperty).BaseValueSource == BaseValueSource.Local); if (isLocalValue) { // Clear the selection and re-apply the binding. BindingBase binding = BindingOperations.GetBindingBase(combo, SelectedItemProperty); if (binding != null) { combo.ClearValue(SelectedItemProperty); DataGridPactComboBoxColumn.ApplyBinding(binding, combo, SelectedItemProperty); } } else { // Clear the selection by setting the local value // and re-evaluate the property by clearing the local value. combo.SelectedItem = null; combo.ClearValue(SelectedItemProperty); } }
/// <summary> /// Sets or unsets the inner binding regarding to the passed source element value. /// </summary> /// <param name="sourceElement">The binding source element that must be assessed.</param> private void ToggleBinding(object sourceElement) { if (TargetObject != null && TargetProperty != null && SourceType != null) { // If has binding while should not have, clear binding: var currentBinding = BindingOperations.GetBindingBase(TargetObject, TargetProperty); if (currentBinding != null && (sourceElement == null || SourceType == null || sourceElement?.GetType() != SourceType && !sourceElement.GetType().GetTypeInfo().IsSubclassOf(SourceType))) { BindingOperations.ClearBinding(TargetObject, TargetProperty); if (BindingOperations.IsDataBound(TargetObject, TargetProperty)) // clearing may fail happen when called from datatemplate { BindingOperations.SetBinding(TargetObject, TargetProperty, selfPropertyBinding); // set set "null" value. } init_to_empty = true; } // If has no binding while should have, set binding: else if (sourceElement != null && (currentBinding == null || ((currentBinding as Binding)?.IsEquivalentTo(selfPropertyBinding) == true)) && (sourceElement.GetType() == SourceType || sourceElement.GetType().GetTypeInfo().IsSubclassOf(SourceType))) { BindingOperations.SetBinding(TargetObject, TargetProperty, innerBinding ?? InnerBinding); init_to_empty = false; } } }
/// <summary> /// Prepares this class to filter data based on resolved (or unresolved source). /// </summary> /// <param name="source">A source object to assess.</param> private void Initialize(object source) { if (initialized) { return; } // If source is resolved then set binding up: if (source != null) { ToggleBinding(source); initialized = true; // Check if source is a datacontext, in which case subscribe to datacontext changed event: if (IsInnerSourceDatacontext && TargetObject != null) { (TargetObject as FrameworkElement).DataContextChanged += DatacontextTarget_DataContextChanged; } } // else clear current binding since we cannot know if source type is correct: else if (TargetObject != null) // but only if target object is identified. { // Try to clear current binding while source isn't resolved, since it could be of another // type as the accepted one and to free the identity binding processing: if (BindingOperations.GetBindingBase(TargetObject, TargetProperty) != null) { BindingOperations.ClearBinding(TargetObject, TargetProperty); } } }
public override void Synchronize() { var targetColumn = this.DetailColumn; var dp = ColumnBase.VisibleProperty; var currentBinding = BindingOperations.GetBindingBase(targetColumn, dp); if (currentBinding != null) { m_localValue = currentBinding; BindingOperations.ClearBinding(targetColumn, dp); } else { var localValue = targetColumn.ReadLocalValue(dp); // The appropriate value is still in place. if (object.Equals(localValue, false)) { return; } m_localValue = localValue; } // Hide the column. targetColumn.SetValue(dp, false); }
private static void StoreLocalValue(Dictionary <DependencyProperty, object> store, ColumnBase column, DependencyProperty property) { Debug.Assert(store != null); Debug.Assert(column != null); Debug.Assert(property != null); var binding = BindingOperations.GetBindingBase(column, property); if (binding != null) { store[property] = binding; } else { var value = column.ReadLocalValue(property); if (value != DependencyProperty.UnsetValue) { store[property] = value; } else { store.Remove(property); } } }
/// <summary> /// Determines whether a particular dependency property already has a binding on the provided element. /// </summary> public static bool HasBinding(FrameworkElement element, DependencyProperty property) { #if NET return(BindingOperations.GetBindingBase(element, property) != null); #else return(element.GetBindingExpression(property) != null); #endif }
public static void TransferPropertyTo(this DependencyObject original, DependencyObject clone, DependencyProperty originalProperty, DependencyProperty cloneProperty = null, bool templateBoundOnly = false) { if (original == null) { throw new ArgumentNullException(nameof(original)); } if (clone == null) { throw new ArgumentNullException(nameof(clone)); } if (originalProperty == null) { throw new ArgumentNullException(nameof(originalProperty)); } cloneProperty = cloneProperty ?? originalProperty; var originalValueSource = DependencyPropertyHelper.GetValueSource(original, originalProperty).BaseValueSource; var performTransfer = templateBoundOnly ? originalValueSource >= BaseValueSource.ParentTemplate : originalValueSource > BaseValueSource.Default; if (!performTransfer) { return; } var binding = BindingOperations.GetBindingBase(original, originalProperty); if (binding != null) { // Transfer Bindings BindingOperations.SetBinding(clone, cloneProperty, binding); } else { if (original.ReadLocalValue(originalProperty) is Expression expression) { // Transfer DynamicResource if (ResourceReferenceExpressionConverter.ConvertTo(expression, typeof(MarkupExtension)) is DynamicResourceExtension dynamicResource) { clone.SetValue(cloneProperty, dynamicResource.ProvideValue(null)); } } else { // Transfer other DPs var originalValue = original.GetValue(originalProperty); clone.SetValue(cloneProperty, originalValue); } } }
protected override void OnDropDownOpened(EventArgs e) { base.OnDropDownOpened(e); BindingBase bindingBase = BindingOperations.GetBindingBase((DependencyObject)this, OnDemandComboBox.ItemsListProperty); if (bindingBase == null) { return; } BindingOperations.SetBinding((DependencyObject)this, ItemsControl.ItemsSourceProperty, bindingBase); }
static void RelativeVisibilityPropertyChangedCallback(DependencyObject target, DependencyPropertyChangedEventArgs e) { var obj = target as UIElement; obj.Visibility = (Visibility)e.NewValue; var binding = (IRelativeBinding)BindingOperations.GetBindingBase(obj, RelativeVisibilityProperty); if (binding != null) { UpdateSpecifiedAncestorTypeVisibility(obj, binding.AncestorType, binding.AncestorLevel); } }
public override void SetProperties(UserControl[] _controls) { var tb = BindingOperations.GetBindingBase(this, TextProperty); BindingOperations.ClearBinding(this, TextProperty); if (Items == null) { Items = new ObservableCollection <string>(); } //Update Items instead of clearing var newItems = (_controls.OfType <ListControl>().First()).Items; for (int i = 0; i < Math.Max(Items.Count, newItems.Count); i++) { if (i < Math.Min(Items.Count, newItems.Count)) { if (Items[i] != newItems[i].Value) { Items[i] = newItems[i].Value; } } else if (Items.Count < newItems.Count) { Items.Add(newItems[i].Value); } } while (Items.Count > newItems.Count) { Items.RemoveAt(Items.Count - 1); } //UpdateBinding(); DataSource = new Triple <string, string, bool> { A = _controls.OfType <DataSourceControl>().First().DataSource, B = _controls.OfType <DataSourceControl>().First().DataProperty, C = _controls.OfType <DataSourceControl>().First().Active }; UpdateBinding(); if (tb != null) { BindingOperations.SetBinding(this, TextProperty, tb); } base.SetProperties(_controls); }
private static IEnumerable <Tuple <BindingBase, DependencyProperty> > GetLocalBindings(DependencyObject root) { var localValueEnumerator = root.GetLocalValueEnumerator(); while (localValueEnumerator.MoveNext()) { var dp = localValueEnumerator.Current.Property; var binding = BindingOperations.GetBindingBase(root, dp); if (binding != null) { yield return(Tuple.Create(binding, dp)); } } }
private bool m_isListeningEvents; //false #endregion public override void Synchronize() { this.SubscribeEvents(); var targetColumn = this.DetailColumn; foreach (var entry in m_bindings) { var dp = entry.Key; var binding = entry.Value; // The appropriate binding is still in place. var currentBinding = BindingOperations.GetBindingBase(targetColumn, dp); if (currentBinding == binding) { continue; } if (currentBinding != null) { m_localValues[dp] = currentBinding; } else { var localValue = targetColumn.ReadLocalValue(dp); if (localValue != DependencyProperty.UnsetValue) { m_localValues[dp] = localValue; } else { m_localValues.Remove(dp); } } BindingOperations.SetBinding(targetColumn, dp, binding); } var visiblePosition = this.GetTargetVisiblePosition(); if (visiblePosition.HasValue) { targetColumn.VisiblePosition = visiblePosition.Value; } else { targetColumn.ClearValue(ColumnBase.VisiblePositionProperty); } }
/// <summary> /// /// </summary> /// <param name="propertyName"></param> /// <param name="dependencyObject"></param> /// <param name="sources"></param> /// <remarks> /// Based on ASanch answer on http://stackoverflow.com/questions/3959421/wpf-find-control-that-binds-to-specific-property /// </remarks>> private static void GetDependencyObjectsWithBindingToPropertyRecursive(string propertyName, DependencyObject dependencyObject, ICollection <DependencyObject> sources) { var dependencyProperties = new List <DependencyProperty>(); dependencyProperties.AddRange(MarkupWriter.GetMarkupObjectFor(dependencyObject).Properties.Where(x => x.DependencyProperty != null).Select(x => x.DependencyProperty).ToList()); dependencyProperties.AddRange( MarkupWriter.GetMarkupObjectFor(dependencyObject).Properties.Where(x => x.IsAttached && x.DependencyProperty != null).Select(x => x.DependencyProperty).ToList()); var bindings = dependencyProperties.Select(x => BindingOperations.GetBindingBase(dependencyObject, x)).Where(x => x != null).ToList(); Predicate <Binding> condition = binding => binding != null && binding.Path.Path == propertyName && !sources.Contains(dependencyObject); foreach (var bindingBase in bindings) { if (bindingBase is Binding) { if (condition(bindingBase as Binding)) { sources.Add(dependencyObject); } } else if (bindingBase is MultiBinding) { if (((MultiBinding)bindingBase).Bindings.Any(bindingBase2 => condition(bindingBase2 as Binding))) { sources.Add(dependencyObject); } } else if (bindingBase is PriorityBinding) { if (((PriorityBinding)bindingBase).Bindings.Any(bindingBase2 => condition(bindingBase2 as Binding))) { sources.Add(dependencyObject); } } } var children = LogicalTreeHelper.GetChildren(dependencyObject).OfType <DependencyObject>().ToList(); if (children.Count == 0) { return; } foreach (var child in children) { GetDependencyObjectsWithBindingToPropertyRecursive(propertyName, child, sources); } }
protected override void SetBindings(FrameworkElement primaryBindingTarget) { if (ItemsSource != null) { BindingBase itemsSourceBinding = BindingOperations.GetBindingBase(this, ItemsSourceProperty); if (itemsSourceBinding != null) { BindingOperations.SetBinding(primaryBindingTarget, ItemsControl.ItemsSourceProperty, itemsSourceBinding); } else { primaryBindingTarget.SetValue(ItemsControl.ItemsSourceProperty, ItemsSource); } } }
public static BindingBase GetBindingOf( this DependencyObject dependencyObject, DependencyProperty dependencyProperty ) { if (dependencyObject == null) { return(null); } if (dependencyProperty == null) { return(null); } return(BindingOperations.GetBindingBase(dependencyObject, dependencyProperty)); }
/// <summary> /// Updates the binding base. /// </summary> /// <param name="target">The target.</param> /// <param name="dependencyProperty">The dependency property.</param> public static void UpdateBindingBase([NotNull] this DependencyObject target, [NotNull] DependencyProperty dependencyProperty) { if (target == null) { throw new ArgumentNullException(nameof(target)); } if (dependencyProperty == null) { throw new ArgumentNullException(nameof(dependencyProperty)); } var bindingBase = BindingOperations.GetBindingBase(target, dependencyProperty); if (bindingBase == null) { return; } UpdateBindingBase(target, dependencyProperty, bindingBase); }
/// <summary> /// Returns all direct bindings for a given object /// </summary> /// <param name="element">The object to check</param> /// <returns>List of bindings</returns> public static List <BindingBase> GetBindingObjects(Object element) { List <BindingBase> bindings = new List <BindingBase>(); List <DependencyProperty> dpList = new List <DependencyProperty>(); dpList.AddRange(GetDependencyProperties(element)); dpList.AddRange(GetAttachedProperties(element)); foreach (DependencyProperty dp in dpList) { BindingBase b = BindingOperations.GetBindingBase(element as DependencyObject, dp); if (b != null) { bindings.Add(b); } } return(bindings); }
private object GetPropertyValue(DependencyProperty property) { object result = null; if (BindingOperations.IsDataBound(this, property)) { result = BindingOperations.GetBindingBase(this, property); if (result == null) { result = BindingOperations.GetBindingExpressionBase(this, property); } } else { result = GetValue(property); } return(result); }
private static void OnDummyImagePropertyChanged(DependencyObject dpo, DependencyPropertyChangedEventArgs e) { Image animatedImage = (Image)dpo; if (!animatedImage.GetIsAnimationChangingFrame()) { BindingBase originalBinding = BindingOperations.GetBindingBase(dpo, DummyImageProperty); if (originalBinding != null) { BindingOperations.SetBinding(dpo, Image.SourceProperty, originalBinding); BindingOperations.ClearBinding(animatedImage, DummyImageProperty); } animatedImage.SetIsAnimationChangingFrame(false); } else { animatedImage.SetIsAnimationChangingFrame(false); } animatedImage.SetIsAnimationChangingFrame(false); }
/// <summary> /// Creates Window-specific bindings (e.g. Title) between Window and its ViewModel /// </summary> /// <param name="viewModel">ViewModel to bind to</param> /// <param name="window">Window to attach handlers for</param> /// <param name="isDialog">True if Window is modal dialog, false if it's independent Window</param> protected virtual void BindWindow(object viewModel, Window window, bool isDialog) { if (viewModel == null) { throw new ArgumentNullException(nameof(viewModel)); } if (window == null) { throw new ArgumentNullException(nameof(window)); } if (viewModel is IHaveTitle && string.IsNullOrEmpty(window.Title) && BindingOperations.GetBindingBase(window, Window.TitleProperty) == null) { window.SetBinding(Window.TitleProperty, new Binding(nameof(IHaveTitle.Title)) { Mode = BindingMode.OneWay, }); } }
public override void Desynchronize() { this.UnsubscribeEvents(); var targetColumn = this.DetailColumn; foreach (var entry in m_bindings) { var dp = entry.Key; var binding = entry.Value; // The appropriate binding is still in place. var currentBinding = BindingOperations.GetBindingBase(targetColumn, dp); if (currentBinding == binding) { object oldValue; if (m_localValues.TryGetValue(dp, out oldValue)) { var oldBinding = oldValue as BindingBase; if (oldBinding != null) { BindingOperations.SetBinding(targetColumn, dp, oldBinding); } else { targetColumn.SetValue(dp, oldValue); } } else { BindingOperations.ClearBinding(targetColumn, dp); } } m_localValues.Remove(dp); } targetColumn.ClearValue(ColumnBase.VisiblePositionProperty); }
/// <summary> /// Update the current image source to the relevant frame. /// </summary> /// <param name="dpo"></param> /// <param name="e"></param> private static void OnCurrentFrameIndexChanged(DependencyObject dpo, DependencyPropertyChangedEventArgs e) { Image animatedImage = (Image)dpo; if (!animatedImage.GetIsAnimationChangingFrame()) { animatedImage.SetIsAnimationChangingFrame(true); bool hasBinding = BindingOperations.IsDataBound(animatedImage, Image.SourceProperty); if (hasBinding) { BindingBase originalBinding = BindingOperations.GetBindingBase(animatedImage, Image.SourceProperty); BindingOperations.SetBinding(animatedImage, DummyImageProperty, originalBinding); } animatedImage.Source = ((BitmapFrame)animatedImage.Source).Decoder.Frames[(int)e.NewValue]; if (!hasBinding) { animatedImage.SetIsAnimationChangingFrame(false); } } }
/// <summary> /// Given a ViewModel, create its View, ensure that it's a Window, and set it up /// </summary> /// <param name="viewModel">ViewModel to create the window for</param> /// <param name="isDialog">True if the window will be used as a dialog</param> /// <param name="ownerViewModel">Optionally the ViewModel which owns the view which should own this window</param> /// <returns>Window which was created and set up</returns> protected virtual Window CreateWindow(object viewModel, bool isDialog, IViewAware ownerViewModel) { var view = this.viewManager.CreateAndBindViewForModelIfNecessary(viewModel); var window = view as Window; if (window == null) { var e = new StyletInvalidViewTypeException(String.Format("WindowManager.ShowWindow or .ShowDialog tried to show a View of type '{0}', but that View doesn't derive from the Window class. " + "Make sure any Views you display using WindowManager.ShowWindow or .ShowDialog derive from Window (not UserControl, etc)", view == null ? "(null)" : view.GetType().Name)); logger.Error(e); throw e; } // Only set this it hasn't been set / bound to anything var haveDisplayName = viewModel as IHaveDisplayName; if (haveDisplayName != null && (String.IsNullOrEmpty(window.Title) || window.Title == view.GetType().Name) && BindingOperations.GetBindingBase(window, Window.TitleProperty) == null) { var binding = new Binding("DisplayName") { Mode = BindingMode.TwoWay }; window.SetBinding(Window.TitleProperty, binding); } if (ownerViewModel?.View is Window explicitOwner) { window.Owner = explicitOwner; } else if (isDialog) { var owner = this.InferOwnerOf(window); if (owner != null) { // We can end up in a really weird situation if they try and display more than one dialog as the application's closing // Basically the MainWindow's no long active, so the second dialog chooses the first dialog as its owner... But the first dialog // hasn't yet been shown, so we get an exception ("cannot set owner property to a Window which has not been previously shown"). try { window.Owner = owner; } catch (InvalidOperationException e) { logger.Error(e, "This can occur when the application is closing down"); } } } if (isDialog) { logger.Info("Displaying ViewModel {0} with View {1} as a Dialog", viewModel, window); } else { logger.Info("Displaying ViewModel {0} with View {1} as a Window", viewModel, window); } // If and only if they haven't tried to position the window themselves... // Has to be done after we're attempted to set the owner if (window.WindowStartupLocation == WindowStartupLocation.Manual && Double.IsNaN(window.Top) && Double.IsNaN(window.Left) && BindingOperations.GetBinding(window, Window.TopProperty) == null && BindingOperations.GetBinding(window, Window.LeftProperty) == null) { window.WindowStartupLocation = window.Owner == null ? WindowStartupLocation.CenterScreen : WindowStartupLocation.CenterOwner; } // This gets itself retained by the window, by registering events // ReSharper disable once ObjectCreationAsStatement new WindowConductor(window, viewModel); return(window); }