void ReplaceDependencySources()
{
if (!ParentBindingExpression.IsDetaching)
{
int size = PW.Length;
if (PW.NeedsDirectNotification)
{
++size;
}
WeakDependencySource[] newSources = new WeakDependencySource[size];
int n = 0;
if (IsDynamic)
{
for (int k = 0; k < PW.Length; ++k)
{
DependencyProperty dp = PW.GetAccessor(k) as DependencyProperty;
if (dp != null)
{
DependencyObject d = PW.GetItem(k) as DependencyObject;
if (d != null)
{
newSources[n++] = new WeakDependencySource(d, dp);
}
}
}
if (PW.NeedsDirectNotification)
{
// subproperty notifications can only arise from Freezables
// (as of today - 11/14/08), so we only need to propagate
// them when the raw value is a Freezable.
DependencyObject d = PW.RawValue() as Freezable;
if (d != null)
{
newSources[n++] = new WeakDependencySource(d, DependencyObject.DirectDependencyProperty);
}
}
}
ParentBindingExpression.ChangeWorkerSources(newSources, n);
}
}
// Token: 0x0600748C RID: 29836 RVA: 0x002158A8 File Offset: 0x00213AA8
private void ReplaceDependencySources()
{
if (!base.ParentBindingExpression.IsDetaching)
{
int num = this.PW.Length;
if (this.PW.NeedsDirectNotification)
{
num++;
}
WeakDependencySource[] array = new WeakDependencySource[num];
int n = 0;
if (base.IsDynamic)
{
for (int i = 0; i < this.PW.Length; i++)
{
DependencyProperty dependencyProperty = this.PW.GetAccessor(i) as DependencyProperty;
if (dependencyProperty != null)
{
DependencyObject dependencyObject = this.PW.GetItem(i) as DependencyObject;
if (dependencyObject != null)
{
array[n++] = new WeakDependencySource(dependencyObject, dependencyProperty);
}
}
}
if (this.PW.NeedsDirectNotification)
{
DependencyObject dependencyObject2 = this.PW.RawValue() as Freezable;
if (dependencyObject2 != null)
{
array[n++] = new WeakDependencySource(dependencyObject2, DependencyObject.DirectDependencyProperty);
}
}
}
base.ParentBindingExpression.ChangeWorkerSources(array, n);
}
}
/// <summary>
/// Change the dependency sources for the given child expression.
/// </summary>
internal override void ChangeSourcesForChild(BindingExpressionBase bindingExpression, WeakDependencySource[] newSources)
{
// BindingExpression does not support child bindings
}
// worker calls here if it changes its dependency sources
// n is the number of real entries in newWorkerSources (which may be longer)
internal void ChangeWorkerSources(WeakDependencySource[] newWorkerSources, int n)
{
int offset = 0;
int size = n;
// create the new sources array, and add the context and CollectionViewSource elements
DependencyObject contextElement = ContextElement;
CollectionViewSource cvs = CollectionViewSource;
bool usesLanguage = UsesLanguage;
if (contextElement != null)
++size;
if (cvs != null)
++size;
if (usesLanguage)
++size;
WeakDependencySource[] newSources = (size > 0) ? new WeakDependencySource[size] : null;
if (contextElement != null)
{
newSources[offset++] = new WeakDependencySource(_ctxElement, FrameworkElement.DataContextProperty);
}
if (cvs != null)
{
WeakReference wr = GetValue(Feature.CollectionViewSource, null) as WeakReference;
newSources[offset++] =
(wr != null) ? new WeakDependencySource(wr, CollectionViewSource.ViewProperty)
: new WeakDependencySource(cvs, CollectionViewSource.ViewProperty);
}
if (usesLanguage)
{
newSources[offset++] = new WeakDependencySource(TargetElementReference, FrameworkElement.LanguageProperty);
}
// add the worker's sources
if (n > 0)
Array.Copy(newWorkerSources, 0, newSources, offset, n);
// tell the property engine
ChangeSources(newSources);
}
/// <summary> /// Change the dependency sources for the given child expression. /// </summary> internal abstract void ChangeSourcesForChild(BindingExpressionBase bindingExpression, WeakDependencySource[] newSources);
/// <summary>
/// combine the sources of BindingExpressions, using new sources for
/// the BindingExpression at the given index
/// </summary>
/// <param name="index">-1 to indicate no new sources</param>
/// <param name="bindingExpressions">collection of child binding expressions </param>
/// <param name="count">how many child expressions to include</param>
/// <param name="newSources">use null when no new sources</param>
/// <returns></returns>
internal static WeakDependencySource[] CombineSources(int index, Collection<BindingExpressionBase> bindingExpressions, int count, WeakDependencySource[] newSources)
{
if (index == count)
{
// Be sure to include newSources if they are being appended
count++;
}
Collection<WeakDependencySource> tempList = new Collection<WeakDependencySource>();
for (int i = 0; i < count; ++i)
{
BindingExpressionBase bindExpr = bindingExpressions[i];
WeakDependencySource[] sources = (i==index) ? newSources :
(bindExpr != null) ? bindExpr.WeakSources :
null;
int m = (sources == null) ? 0 : sources.Length;
for (int j = 0; j < m; ++j)
{
WeakDependencySource candidate = sources[j];
// don't add duplicate source
for (int k = 0; k < tempList.Count; ++k)
{
WeakDependencySource prior = tempList[k];
if (candidate.DependencyObject == prior.DependencyObject &&
candidate.DependencyProperty == prior.DependencyProperty)
{
candidate = null;
break;
}
}
if (candidate != null)
tempList.Add(candidate);
}
}
WeakDependencySource[] result;
if (tempList.Count > 0)
{
result = new WeakDependencySource[tempList.Count];
tempList.CopyTo(result, 0);
tempList.Clear();
}
else
{
result = null;
}
return result;
}
// change WeakDependencySources to (strong) DependencySources, and notify
// the property engine about the new sources
void ChangeSources(DependencyObject target, DependencyProperty dp, WeakDependencySource[] newSources)
{
DependencySource[] sources;
if (newSources != null)
{
// convert weak reference to strong
sources = new DependencySource[newSources.Length];
int n = 0;
for (int i = 0; i < newSources.Length; ++i)
{
DependencyObject sourceDO = newSources[i].DependencyObject;
if (sourceDO != null)
{
// only include sources that are still alive
sources[n++] = new DependencySource(sourceDO, newSources[i].DependencyProperty);
}
}
// if any of the sources were no longer alive, trim the array
if (n < newSources.Length)
{
DependencySource[] temp;
if (n > 0)
{
temp = new DependencySource[n];
Array.Copy(sources, 0, temp, 0, n);
}
else
{
temp = null;
}
sources = temp;
}
}
else
{
sources = null;
}
// notify property engine
ChangeSources(target, dp, sources);
}
internal void ChangeSources(WeakDependencySource[] newSources)
{
if (IsInBindingExpressionCollection)
ParentBindingExpressionBase.ChangeSourcesForChild(this, newSources);
else
ChangeSources(TargetElement, TargetProperty, newSources);
// store the sources with weak refs, so they don't cause memory leaks (bug 980041)
_sources = newSources;
}
/// <summary>
/// Change the dependency sources for the given child expression.
/// </summary>
internal override void ChangeSourcesForChild(BindingExpressionBase bindingExpression, WeakDependencySource[] newSources)
{
int index = MutableBindingExpressions.IndexOf(bindingExpression);
if (index >= 0)
{
WeakDependencySource[] combinedSources = CombineSources(index, MutableBindingExpressions, AttentiveBindingExpressions, newSources);
ChangeSources(combinedSources);
}
}
/// <summary>
/// Change the dependency sources for the given child expression.
/// </summary>
internal override void ChangeSourcesForChild(BindingExpressionBase bindingExpression, WeakDependencySource[] newSources)
{
int index = MutableBindingExpressions.IndexOf(bindingExpression);
if (index >= 0)
{
WeakDependencySource[] commonSources = null;
if (UsesLanguage)
{
commonSources = new WeakDependencySource[] { new WeakDependencySource(TargetElement, FrameworkElement.LanguageProperty) };
}
WeakDependencySource[] combinedSources = CombineSources(index, MutableBindingExpressions, MutableBindingExpressions.Count, newSources, commonSources);
ChangeSources(combinedSources);
}
}
// Attach to things that may require tree context (parent, root, etc.)
void AttachToContext(bool lastChance)
{
DependencyObject target = TargetElement;
if (target == null)
return;
Debug.Assert(ParentMultiBinding.Converter != null || !String.IsNullOrEmpty(EffectiveStringFormat),
"MultiBindingExpression should not exist if its bind does not have a valid converter.");
bool isExtendedTraceEnabled = TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.AttachToContext);
_converter = ParentMultiBinding.Converter;
if (_converter == null && String.IsNullOrEmpty(EffectiveStringFormat))
{
TraceData.Trace(TraceEventType.Error, TraceData.MultiBindingHasNoConverter, ParentMultiBinding);
}
if (isExtendedTraceEnabled)
{
TraceData.Trace(TraceEventType.Warning,
TraceData.AttachToContext(
TraceData.Identify(this),
lastChance ? " (last chance)" : String.Empty));
}
TransferIsDeferred = true;
bool attached = true; // true if all child bindings have attached
int count = MutableBindingExpressions.Count;
for (int i = 0; i < count; ++i)
{
if (MutableBindingExpressions[i].StatusInternal == BindingStatusInternal.Unattached)
attached = false;
}
// if the child bindings aren't ready yet, try again later. Leave
// TransferIsDeferred set, to indicate we're not ready yet.
if (!attached && !lastChance)
{
if (isExtendedTraceEnabled)
{
TraceData.Trace(TraceEventType.Warning,
TraceData.ChildNotAttached(
TraceData.Identify(this)));
}
return;
}
// listen to the Language property, if needed
if (UsesLanguage)
{
WeakDependencySource[] commonSources = new WeakDependencySource[] { new WeakDependencySource(TargetElement, FrameworkElement.LanguageProperty) };
WeakDependencySource[] newSources = CombineSources(-1, MutableBindingExpressions, MutableBindingExpressions.Count, null, commonSources);
ChangeSources(newSources);
}
// initial transfer
bool initialTransferIsUpdate = IsOneWayToSource;
object currentValue;
if (ShouldUpdateWithCurrentValue(target, out currentValue))
{
initialTransferIsUpdate = true;
ChangeValue(currentValue, /*notify*/false);
NeedsUpdate = true;
}
SetStatus(BindingStatusInternal.Active);
if (!initialTransferIsUpdate)
{
UpdateTarget(false);
}
else
{
UpdateValue();
}
}
void ReplaceDependencySources()
{
if (!ParentBindingExpression.IsDetaching)
{
int size = PW.Length;
if (PW.NeedsDirectNotification)
++size;
WeakDependencySource[] newSources = new WeakDependencySource[size];
int n = 0;
if (IsDynamic)
{
for (int k=0; k<PW.Length; ++k)
{
DependencyProperty dp = PW.GetAccessor(k) as DependencyProperty;
if (dp != null)
{
DependencyObject d = PW.GetItem(k) as DependencyObject;
if (d != null)
newSources[n++] = new WeakDependencySource(d, dp);
}
}
if (PW.NeedsDirectNotification)
{
// subproperty notifications can only arise from Freezables
// (as of today - 11/14/08), so we only need to propagate
// them when the raw value is a Freezable.
DependencyObject d = PW.RawValue() as Freezable;
if (d != null)
newSources[n++] = new WeakDependencySource(d, DependencyObject.DirectDependencyProperty);
}
}
ParentBindingExpression.ChangeWorkerSources(newSources, n);
}
}