/// <summary>
/// Sets the templated parent, with the ability to control the propagation of the templated parent.
/// </summary>
/// <param name="templatedParent">The parent to apply.</param>
/// <param name="applyToChildren">
/// Applies the templated parent to children if true. False is generally used when a control is template-able
/// to avoid propagating its own templated parent to its children.
/// </param>
public void SetTemplatedParent(FrameworkElement templatedParent)
{
try
{
if (_isApplyingTemplateBindings || _bindingsSuspended)
{
// If we reach this point, this means that a propagation loop has been detected, and
// we can skip the current binder.
// This can happen if a DependencyObject-typed DependencyProperty contains a reference
// to one of its ancestors.
return;
}
_isApplyingTemplateBindings = true;
if (this.Log().IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
{
this.Log().DebugFormat(
"{0}.ApplyTemplateBindings({1}/{2}) (h:{3:X8})",
_originalObjectType.ToString(),
templatedParent?.GetType().ToString() ?? "[null]",
templatedParent?.GetHashCode().ToString("X8", CultureInfo.InvariantCulture) ?? "[null]",
ActualInstance?.GetHashCode()
);
}
_properties.ApplyTemplatedParent(templatedParent);
ApplyChildrenBindable(templatedParent, isTemplatedParent: true);
}
finally
{
_isApplyingTemplateBindings = false;
}
}
private void GetExtraPropertyInfo(FrameworkElement frameworkElement, out object extraPropertyValue, out TypeInfo extraPropertyType)
{
extraPropertyValue = null;
extraPropertyType = null;
if (ExtraArgumentPropertyName != null)
{
var extraPropertyInfo = frameworkElement.GetType().GetRuntimeProperty(ExtraArgumentPropertyName);
if (extraPropertyInfo == null)
Debug.WriteLine(string.Format("Cannot find property {0} on UI element {1} when handling event {2}", ExtraArgumentPropertyName, frameworkElement.GetType().FullName, EventName));
else
{
extraPropertyValue = extraPropertyInfo.GetValue(frameworkElement);
if (extraPropertyValue != null)
extraPropertyType = extraPropertyValue.GetType().GetTypeInfo();
}
}
}
protected override void ApplyBindings(FrameworkElement attachedObject,
IEnumerable<MvxBindingDescription> bindingDescriptions)
{
var actualType = attachedObject.GetType();
foreach (var bindingDescription in bindingDescriptions)
{
ApplyBinding(bindingDescription, actualType, attachedObject);
}
}
public static void Appear(FrameworkElement el, int millisecondPostpone = 0)
{
if (el.GetType().Name == "SplashScreenView")
{
el.Opacity =1.0;
return;
}
DispatchedHandler invokedHandler = new DispatchedHandler(() =>
{
TranslateTransform translateTransform = new TranslateTransform();
el.RenderTransform = translateTransform;
translateTransform.X = (double)Animation.pixelsMove;
if (translateTransform != null)
{
SplineDoubleKeyFrame splineDoubleKeyFrame = new SplineDoubleKeyFrame();
splineDoubleKeyFrame.KeyTime = TimeSpan.FromMilliseconds((double)(10 + millisecondPostpone));
splineDoubleKeyFrame.Value = (double)Animation.pixelsMove;
SplineDoubleKeyFrame splineDoubleKeyFrame2 = new SplineDoubleKeyFrame();
splineDoubleKeyFrame2.KeyTime = TimeSpan.FromMilliseconds((double)(350 + millisecondPostpone));
splineDoubleKeyFrame2.Value = 0.0;
splineDoubleKeyFrame2.KeySpline = new KeySpline();
splineDoubleKeyFrame2.KeySpline.ControlPoint1 = new Point(0.0, 0.0);
splineDoubleKeyFrame2.KeySpline.ControlPoint2 = new Point(0.0, 1.0);
DoubleAnimationUsingKeyFrames doubleAnimationUsingKeyFrames = new DoubleAnimationUsingKeyFrames();
Storyboard.SetTarget(doubleAnimationUsingKeyFrames, translateTransform);
Storyboard.SetTargetProperty(doubleAnimationUsingKeyFrames, "(TranslateTransform.X)");
doubleAnimationUsingKeyFrames.KeyFrames.Add(splineDoubleKeyFrame);
doubleAnimationUsingKeyFrames.KeyFrames.Add(splineDoubleKeyFrame2);
SplineDoubleKeyFrame splineDoubleKeyFrame3 = new SplineDoubleKeyFrame();
splineDoubleKeyFrame3.KeyTime = TimeSpan.FromMilliseconds((double)millisecondPostpone);
splineDoubleKeyFrame3.Value = 0.0;
SplineDoubleKeyFrame splineDoubleKeyFrame4 = new SplineDoubleKeyFrame();
splineDoubleKeyFrame4.KeyTime = TimeSpan.FromMilliseconds((double)(300 + millisecondPostpone));
splineDoubleKeyFrame4.Value = 1.0;
DoubleAnimationUsingKeyFrames doubleAnimationUsingKeyFrames2 = new DoubleAnimationUsingKeyFrames();
Storyboard.SetTarget(doubleAnimationUsingKeyFrames2, el);
Storyboard.SetTargetProperty(doubleAnimationUsingKeyFrames2, "(UIElement.Opacity)");
doubleAnimationUsingKeyFrames2.KeyFrames.Add(splineDoubleKeyFrame3);
doubleAnimationUsingKeyFrames2.KeyFrames.Add(splineDoubleKeyFrame4);
Storyboard storyboard = new Storyboard();
storyboard.Children.Add(doubleAnimationUsingKeyFrames);
storyboard.Children.Add(doubleAnimationUsingKeyFrames2);
storyboard.Begin();
}
});
el.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, invokedHandler).GetResults();
}
public void SetTemplatedParent(FrameworkElement?templatedParent)
{
#if !HAS_EXPENSIVE_TRYFINALLY
// The try/finally incurs a very large performance hit in mono-wasm, and SetValue is in a very hot execution path.
// See https://github.com/mono/mono/issues/13653 for more details.
try
#endif
{
if (_isApplyingTemplateBindings || _bindingsSuspended)
{
// If we reach this point, this means that a propagation loop has been detected, and
// we can skip the current binder.
// This can happen if a DependencyObject-typed DependencyProperty contains a reference
// to one of its ancestors.
return;
}
_isApplyingTemplateBindings = true;
if (this.Log().IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
{
this.Log().DebugFormat(
"{0}.ApplyTemplateBindings({1}/{2}) (h:{3:X8})",
_originalObjectType.ToString(),
templatedParent?.GetType().ToString() ?? "[null]",
templatedParent?.GetHashCode().ToString("X8", CultureInfo.InvariantCulture) ?? "[null]",
ActualInstance?.GetHashCode()
);
}
_properties.ApplyTemplatedParent(templatedParent);
ApplyChildrenBindable(templatedParent, isTemplatedParent: true);
}
#if !HAS_EXPENSIVE_TRYFINALLY
finally
#endif
{
_isApplyingTemplateBindings = false;
}
}
/// <summary>
/// Attaches to the specified object.
///
/// </summary>
/// <param name="dependencyObject">The object to attach to.</param><exception cref="T:System.InvalidOperationException">The Behavior is already hosted on a different element.</exception><exception cref="T:System.InvalidOperationException">dependencyObject does not satisfy the Behavior type constraint.</exception>
public override void Attach(FrameworkElement dependencyObject)
{
if (dependencyObject == this.AssociatedObject)
{
return;
}
if (this.AssociatedObject != null)
{
throw new InvalidOperationException("Cannot host behavior multiple times.");
}
if (dependencyObject != null && !this.AssociatedObjectTypeConstraint.GetTypeInfo().IsAssignableFrom(dependencyObject.GetType().GetTypeInfo()))
{
throw new InvalidOperationException("Type constraint violated.");
}
else
{
this.AssociatedObject = dependencyObject;
this.OnAssociatedObjectChanged();
//we need to fix the datacontext for databinding to work
this.ConfigureDataContext();
this.OnAttached();
}
}
/// <summary>
/// Attaches to the specified object.
///
/// </summary>
/// <param name="frameworkElement">The object to attach to.</param><exception cref="T:System.InvalidOperationException">The Behavior is already hosted on a different element.</exception><exception cref="T:System.InvalidOperationException">dependencyObject does not satisfy the Behavior type constraint.</exception>
public override void Attach(FrameworkElement frameworkElement)
{
if (frameworkElement == this.AssociatedObject)
{
return;
}
if (this.AssociatedObject != null)
{
throw new InvalidOperationException("Cannot host behavior multiple times.");
}
if (frameworkElement != null && !this.AssociatedObjectTypeConstraint.GetTypeInfo().IsAssignableFrom(frameworkElement.GetType().GetTypeInfo()))
{
throw new InvalidOperationException("Type constraint violated.");
}
else
{
this.AssociatedObject = frameworkElement;
this.OnAssociatedObjectChanged();
//Attach handles the DataContext
base.Attach(frameworkElement);
this.OnAttached();
}
}
/// <summary>
/// Attaches to the specified object.
///
/// </summary>
/// <param name="frameworkElement">The object to attach to.</param><exception cref="T:System.InvalidOperationException">Cannot host the same trigger on more than one object at a time.</exception><exception cref="T:System.InvalidOperationException">dependencyObject does not satisfy the trigger type constraint.</exception>
public override async void Attach(FrameworkElement frameworkElement)
{
if (frameworkElement == this.AssociatedObject)
{
return;
}
if (this.AssociatedObject != null)
{
throw new InvalidOperationException("Cannot Host Trigger Multiple Times");
}
if (frameworkElement != null && !this.AssociatedObjectTypeConstraint.GetTypeInfo().IsAssignableFrom(frameworkElement.GetType().GetTypeInfo()))
{
throw new InvalidOperationException("Type Constraint Violated");
}
else
{
this.AssociatedObject = frameworkElement;
this.OnAssociatedObjectChanged();
//we need to fix the datacontext for databinding to work
await this.ConfigureDataContext();
this.Actions.Attach(frameworkElement);
this.OnAttached();
}
}
public ContentDialogWrapper(FrameworkElement window)
{
_window = window;
if (_closingEvent == null)
_closingEvent = window.GetType().GetRuntimeEvent("Closing");
Delegate handler = ServiceProvider
.ReflectionManager
.TryCreateDelegate(_closingEvent.EventHandlerType, this, OnClosingMethod);
if (handler == null)
{
Tracer.Error("The provider cannot create delegate for event '{0}'", _closingEvent.EventHandlerType);
return;
}
_token = (EventRegistrationToken)_closingEvent.AddMethod.InvokeEx(window, handler);
}
/// <summary>
/// Applies the Binding represented by the SetterValueBindingHelper.
/// </summary>
/// <param name="element">Element to apply the Binding to.</param>
/// <param name="item">SetterValueBindingHelper representing the Binding.</param>
private static void ApplyBinding(FrameworkElement element, SetterValueBindingHelper item)
{
if ((null == item.Property) || (null == item.Binding))
{
throw new ArgumentException(
"SetterValueBindingHelper's Property and Binding must both be set to non-null values.");
}
// Get the type on which to set the Binding
Type type = null;
TypeInfo typeInfo = null;
if (null == item.Type)
{
// No type specified; setting for the specified element
type = element.GetType();
typeInfo = type.GetTypeInfo();
}
else
{
// Try to get the type from the type system
type = System.Type.GetType(item.Type);
if (null == type)
{
// Search for the type in the list of assemblies
foreach (var assembly in AssembliesToSearch)
{
// Match on short or full name
typeInfo = assembly.DefinedTypes
.Where(t => (t.FullName == item.Type) || (t.Name == item.Type))
.FirstOrDefault();
if (null != typeInfo)
{
// Found; done searching
break;
}
}
if (null == typeInfo)
{
// Unable to find the requested type anywhere
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"Unable to access type \"{0}\". Try using an assembly qualified type name.",
item.Type));
}
}
else
{
typeInfo = type.GetTypeInfo();
}
}
// Get the DependencyProperty for which to set the Binding
DependencyProperty property = null;
var field = typeInfo.GetDeclaredProperty(item.Property + "Property"); // type.GetRuntimeField(item.Property + "Property");
if (null != field)
{
property = field.GetValue(null) as DependencyProperty;
}
if (null == property)
{
// Unable to find the requsted property
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"Unable to access DependencyProperty \"{0}\" on type \"{1}\".",
item.Property, type.Name));
}
// Set the specified Binding on the specified property
element.SetBinding(property, item.Binding);
}
// </snippet3303>
// </snippet300>
private static object GetViewModelForView(FrameworkElement view)
{
// Mapping of view models base on view type (or instance) goes here
if (factories.ContainsKey(view.GetType().ToString()))
return factories[view.GetType().ToString()]();
return null;
}
/// <summary>
/// This method will change the visibility of the framework element that is passed as an argument, to collapsed.
/// It will then use the siblingType parameter to find the other element that should be toggled to visible
/// </summary>
/// <param name="caller">FrameworkElement that should be collapsed</param>
/// <param name="siblingType">The type of the sibling that should be visible</param>
// This was originally ment for an inferiour solution, with no usercontrol.
// However, i like the solution i made, so im going to keep this.
private void ToggleVisibility(FrameworkElement caller, Type siblingType)
{
var sibling = caller?
.FindName(
caller
.Name?
.Replace(
caller
.GetType()
.Name
.ToLower(),
siblingType
.Name
.ToLower()
)
) as FrameworkElement;
if (sibling == null) return; // TODO implement some kind of error handeling/notification.
caller.Visibility = Visibility.Collapsed;
sibling.Visibility = Visibility.Visible;
}
