protected void UpdateValue(object value)
{
if (_targetObject == null || !_targetObject.IsAlive || _targetProperty == null || !_targetProperty.IsAlive)
{
return;
}
DependencyObject obj = _targetObject.Target as DependencyObject;
object tProp = _targetProperty.Target;
if (tProp is DependencyProperty)
{
DependencyProperty prop = tProp as DependencyProperty;
Action updateAction = () => obj.SetValue(prop, value);
// Check whether the target object can be accessed from the
// current thread, and use Dispatcher.Invoke if it can't
if (obj.CheckAccess())
{
updateAction();
}
else
{
obj.Dispatcher.Invoke(updateAction);
}
}
else if (tProp is PropertyInfo)
{
PropertyInfo prop = tProp as PropertyInfo;
prop.SetValue(_targetObject, value, null);
}
}
public void GetResponse_ThreadPool()
{
WebClient wc = new WebClient();
if (new Uri(wc.BaseAddress).Scheme != "http")
{
EnqueueTestComplete();
return;
}
DependencyObject TestPanel = this.TestPanel;
Thread main_thread = Thread.CurrentThread;
bool get_response_called = false;
/* Check that the GetResponse callback is executed on a thread-pool thread */
HttpWebRequest request = (HttpWebRequest)GetWebRequest(WebClientTest.TimecodeLongWmv);
Enqueue(() =>
{
request.BeginGetResponse(delegate(IAsyncResult ar)
{
Assert.IsFalse(TestPanel.CheckAccess());
Assert.AreNotEqual(main_thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId, "Different thread ids in BeginGetResponse");
get_response_called = true;
try {
request.EndGetResponse(ar);
} catch (Exception ex) {
Console.WriteLine(ex);
}
}, request);
});
EnqueueConditional(() => get_response_called);
EnqueueTestComplete();
}
/// <summary>
/// Attempts to "safely" set the specified <see cref="DependencyProperty"/> value as <typeparamref name="T"/>
/// </summary>
/// <typeparam name="T">The type of value to retrieve</typeparam>
/// <param name="obj">The object to retrieve the value from</param>
/// <param name="property">The property to retrieve</param>
/// <param name="milliTimeout">The timeout (in milliseconds) of the dispatcher operation (if Dispatcher Use is neccesary)</param>
/// <returns></returns>
public static T GetValueSafe <T>(this DependencyObject obj, DependencyProperty property, double milliTimeout = 50d)
{
object val = null;
bool done = false;
if (!obj.CheckAccess())
{
obj.Dispatcher.Invoke(new Action <DependencyObject, DependencyProperty>((d, dp) =>
{
val = d.GetValue(dp);
done = true;
}), TimeSpan.FromMilliseconds(milliTimeout), obj, property);
}
else
{
return((T)obj.GetValue(property));
}
while (!done)
{
Thread.Sleep(0);
}
return((T)val);
}
public void GetRequestStream_ThreadPool()
{
WebClient wc = new WebClient();
if (new Uri(wc.BaseAddress).Scheme != "http")
{
EnqueueTestComplete();
return;
}
DependencyObject TestPanel = this.TestPanel;
Thread main_thread = Thread.CurrentThread;
List <Stream> streams_to_close = new List <Stream> ();
bool get_request_stream_called = false;
/* Check that the GetRequestStream callback is executed on a thread-pool thread */
HttpWebRequest request = (HttpWebRequest)GetWebRequest(WebClientTest.TimecodeLongWmv);
request.Method = "POST";
Enqueue(() =>
{
request.BeginGetRequestStream(delegate(IAsyncResult ar)
{
Assert.IsFalse(TestPanel.CheckAccess());
Assert.AreNotEqual(main_thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId, "Different thread ids in BeginGetRequestStream");
streams_to_close.Add(request.EndGetRequestStream(ar));
get_request_stream_called = true;
}, request);
});
EnqueueConditional(() => get_request_stream_called);
Enqueue(() => { streams_to_close.ForEach((v) => v.Close()); });
EnqueueTestComplete();
}
protected void UpdateValue(object value)
{
foreach (object target in _targetList)
{
// if (_target != null)
{
if (_targetProperty is DependencyProperty)
{
DependencyObject obj = target as DependencyObject;
DependencyProperty prop = _targetProperty as DependencyProperty;
Action updateAction = () => obj.SetValue(prop, value);
if (obj.CheckAccess())
{
updateAction();
}
else
{
obj.Dispatcher.Invoke(updateAction);
}
}
else
{
PropertyInfo prop = target as PropertyInfo;
prop.SetValue(target, value, null);
}
}
}
}
private void TryRegisterRegion()
{
DependencyObject targetElement = this.HostControl;
if (targetElement.CheckAccess())
{
IRegionManager regionManager = this.FindRegionManager(targetElement);
IRegionManager attachedRegionManager = this.GetAttachedRegionManager();
if (regionManager != attachedRegionManager)
{
if (attachedRegionManager != null)
{
this.attachedRegionManagerWeakReference = null;
attachedRegionManager.Regions.Remove(this.Region.Name);
}
if (regionManager != null)
{
this.attachedRegionManagerWeakReference = new WeakReference(regionManager);
regionManager.Regions.Add(this.Region);
}
}
}
}
/// <summary>
/// Gets the value synchronize.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj">The object.</param>
/// <param name="property">The property.</param>
/// <returns></returns>
public static T GetValueSync <T>(this DependencyObject obj, DependencyProperty property)
{
if (obj.CheckAccess())
{
return((T)obj.GetValue(property));
}
return((T)obj.Dispatcher.Invoke(() => obj.GetValue(property)));
}
/// <summary>
/// Gets the parent in the visual or logical tree.
/// </summary>
/// <param name="depObj">The dependency object.</param>
/// <param name="isVisualTree">True for visual tree, false for logical tree.</param>
/// <returns>The parent, if available.</returns>
public static DependencyObject GetParent(this DependencyObject depObj, bool isVisualTree)
{
if (depObj.CheckAccess())
{
return(GetParentInternal(depObj, isVisualTree));
}
return((DependencyObject)depObj.Dispatcher.Invoke(new Func <DependencyObject>(() => GetParentInternal(depObj, isVisualTree))));
}
/// <summary>
/// Sets the value thread-safe.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="property">The property.</param>
/// <param name="value">The value.</param>
/// <typeparam name="T">The type of the value.</typeparam>
public static void SetValueSync <T>(this DependencyObject obj, DependencyProperty property, T value)
{
if (obj.CheckAccess())
{
obj.SetValue(property, value);
}
else
{
obj.Dispatcher.Invoke(new Action(() => obj.SetValue(property, value)));
}
}
/// <summary>
/// Attempts to "safely" set the specified <see cref="DependencyProperty"/> value to the specified value
/// </summary>
/// <param name="obj">The object to set the value on</param>
/// <param name="property">The property to set</param>
/// <param name="value">The value to set</param>
public static void SetValueSafe(this DependencyObject obj, DependencyProperty property, object value)
{
if (!obj.CheckAccess())
{
obj.Dispatcher.Invoke(new Action <DependencyObject, DependencyProperty, object>((d, p, o) => d.SetValueSafe(p, o)), obj, property, value);
}
else
{
obj.SetValue(property, value);
}
}
public static void InvokeIfNeeded(this DependencyObject ctl, Action action)
{
if (ctl.CheckAccess())
{
action();
}
else
{
ctl.Dispatcher.BeginInvoke(action);
}
}
void RegisterRegion()
{
DependencyObject targetElement = HostControl;
if (targetElement.CheckAccess())
{
TabbedGroup tg = targetElement as TabbedGroup;
if (tg != null && RegionManager != null)
{
RegionManager.Regions.Add(Region);
}
}
}
/// <summary>
/// Gets the value thread-safe.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="property">The property.</param>
/// <typeparam name="T">The type of the value.</typeparam>
/// <returns>The value.</returns>
public static T GetValueSync <T>(this DependencyObject obj, DependencyProperty property)
{
#if SILVERLIGHT
return((T)obj.GetValue(property));
#else
if (obj.CheckAccess())
{
return((T)obj.GetValue(property));
}
else
{
return((T)obj.Dispatcher.Invoke(new Func <object>(() => obj.GetValue(property))));
}
#endif
}
/// <summary>
/// ReleaseOnChannel
/// </summary>
void DUCE.IResource.ReleaseOnChannel(DUCE.Channel channel)
{
// reconsider the need for this lock
using (CompositionEngineLock.Acquire())
{
Debug.Assert(_duceResource.IsOnChannel(channel));
//release from this channel
_duceResource.ReleaseOnChannel(channel);
if (!_duceResource.IsOnAnyChannel)
{
// If this was the last reference on the channel then clear up our state.
// Again, we assume here that if the target DependencyObject is animated that
// it will be associated with a Dispatcher and that this animation resource
// will also be associated with that Dispatcher's channel.
DependencyObject d = (DependencyObject)_dependencyObject.Target;
// DependencyObject shouldn't have been garbage collected before we've
// released all of its property animation resources.
Debug.Assert(d != null);
// The target DependencyObject should be associated with a Dispatcher.
Debug.Assert(d.Dispatcher != null);
// Make sure the target belongs to this thread
Debug.Assert(d.CheckAccess());
// If we're invalid, that means we've added our _updateResourceHandler to the
// MediaContext's ResourcesUpdated event. Since we've been entirely released
// from the channel we can cancel this update by removing the handler.
if (!_isValid)
{
MediaContext mediaContext = MediaContext.From(d.Dispatcher);
mediaContext.ResourcesUpdated -= _updateResourceHandler;
_isValid = true;
}
_updateResourceHandler = null;
}
}
}
private void TryCreateRegion()
{
DependencyObject targetElement = this.TargetElement;
if (targetElement == null)
{
this.Detach();
return;
}
if (targetElement.CheckAccess())
{
this.Detach();
if (!this.regionCreated)
{
string regionName = this.RegionManagerAccessor.GetRegionName(targetElement);
CreateRegion(targetElement, regionName);
this.regionCreated = true;
}
}
}
/// <summary>
/// Gets the value of a <see cref="DependencyProperty"/> from a specified
/// <see cref="DependencyObject"/> on the UI thread, marshalling if ncessary.
/// </summary>
/// <param name="obj">The target <see cref="DependencyObject"/>.</param>
/// <param name="dp">The desired <see cref="DependencyProperty"/>.</param>
/// <returns>The value of the <see cref="DependencyProperty"/> on the <see cref="DependencyObject"/>.</returns>
public static object SafeGetValue(this DependencyObject obj, DependencyProperty dp)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (dp == null)
{
throw new ArgumentNullException("dp");
}
if (obj.CheckAccess())
{
return(obj.GetValue(dp));
}
var self = new Func <DependencyObject, DependencyProperty, object>(SafeGetValue);
return(Dispatcher.Invoke(self, obj, dp));
}
/// <summary>
/// Sets the value of a read-only <see cref="DependencyProperty"/> on a specified
/// <see cref="DependencyObject"/> on the UI thread, marshalling if ncessary.
/// </summary>
/// <param name="obj">The target <see cref="DependencyObject"/>.</param>
/// <param name="key">The desired <see cref="DependencyPropertyKey"/>.</param>
/// <param name="value">The value to set.</param>
public static void SafeSetValue(this DependencyObject obj, DependencyPropertyKey key, object value)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (key == null)
{
throw new ArgumentNullException("key");
}
if (obj.CheckAccess())
{
obj.SetValue(key, value);
}
else
{
var self = new Action <DependencyObject, DependencyPropertyKey, object>(SafeSetValue);
Dispatcher.Invoke(self, obj, key, value);
}
}
/// <summary>
/// update language value
/// </summary>
/// <param name="value">new value</param>
public void UpdateValue(object value)
{
if (Target != null)
{
if (Property is DependencyProperty)
{
DependencyObject obj = Target as DependencyObject;
DependencyProperty prop = Property as DependencyProperty;
void updateAction() => obj.SetValue(prop, GetValue(prop.Name, value));
// Check whether the target object can be accessed from the
// current thread, and use Dispatcher.Invoke if it can't
if (obj == null)
{
return;
}
if (obj.CheckAccess())
{
updateAction();
}
else
{
obj.Dispatcher.Invoke(updateAction);
}
}
else // _targetProperty is PropertyInfo
{
if (Property is PropertyInfo prop)
{
prop.SetValue(Target, value, null);
}
else if (Property is MethodInfo method)
{
method.Invoke(Target, new object[] { Target, value });
}
}
}
}
/// <summary>
/// AddRefOnChannel
/// </summary>
DUCE.ResourceHandle DUCE.IResource.AddRefOnChannel(DUCE.Channel channel)
{
// reconsider the need for this lock
using (CompositionEngineLock.Acquire())
{
#if DEBUG
// We assume that a multi-channel resource can only be multi-channel
// if it is Frozen and does not have animated properties. In this case we know
// the target resource has at least one animated property so we expect that this
// independently animated property resource will only be added to the channel
// associated with the MediaContext associated with the target object's Dispatcher.
DependencyObject d = (DependencyObject)_dependencyObject.Target;
// I'm not sure how our target animated DependencyObject would get garbage
// collected before we call AddRefOnChannel on one of its animated property
// resources, but if it happens it will be a bad thing.
Debug.Assert(d != null);
// Any animated DependencyObject must be associated with a Dispatcher because the
// AnimationClocks doing the animating must be associated with a Dispatcher.
Debug.Assert(d.Dispatcher != null);
// Make sure the target belongs to this thread
Debug.Assert(d.CheckAccess());
#endif
if (_duceResource.CreateOrAddRefOnChannel(this, channel, ResourceType))
{
_updateResourceHandler = new MediaContext.ResourcesUpdatedHandler(UpdateResource);
UpdateResourceCore(channel);
}
return(_duceResource.GetHandle(channel));
}
}
private void TryRegisterRegion()
{
if (visualizingRegion.InnerRegion == null)
{
visualizingRegion.InnerRegion = this.Region;
// Add the AutoPopulateRegionBehavior. This region should be autopopulated, not the inner region, because
// if you register a viewmodel to a region, it should still be visualized.
this.autoPopulateRegionBehavior.Region = this.visualizingRegion;
this.autoPopulateRegionBehavior.Attach();
}
DependencyObject targetElement = this.HostControl;
if (targetElement.CheckAccess())
{
IRegionManager regionManager = this.FindRegionManager(targetElement);
IRegionManager attachedRegionManager = this.GetAttachedRegionManager();
if (regionManager != attachedRegionManager)
{
if (attachedRegionManager != null)
{
this.attachedRegionManagerWeakReference = null;
attachedRegionManager.Regions.Remove(this.Region.Name);
}
if (regionManager != null)
{
this.attachedRegionManagerWeakReference = new WeakReference(regionManager);
regionManager.Regions.Add(this.visualizingRegion);
}
}
}
}
/// <summary>
/// Gets the parent in the visual or logical tree.
/// </summary>
/// <param name="depObj">The dependency object.</param>
/// <param name="isVisualTree">True for visual tree, false for logical tree.</param>
/// <returns>The parent, if available.</returns>
public static DependencyObject GetParent(this DependencyObject depObj, bool isVisualTree)
{
return(depObj.CheckAccess()
? GetParentInternal(depObj, isVisualTree)
: depObj.Dispatcher.Invoke(() => GetParentInternal(depObj, isVisualTree)));
}
