/// <summary>
/// Finds a DependencyProperty for the specified C# property
/// </summary>
private DependencyProperty FindStandardProperty(Type originalObjectType, string dependencyProperty)
{
var propertyType = BindingPropertyHelper.GetPropertyType(originalObjectType, dependencyProperty);
if (propertyType != null)
{
// This line populates the cache for the getter in the BindingPropertyHelper, making the binder
// pick it up later on.
var setter = BindingPropertyHelper.GetValueSetter(originalObjectType, dependencyProperty, true);
var property = DependencyProperty.GetProperty(originalObjectType, dependencyProperty);
if (property == null)
{
// Create a stub property so the BindingPropertyHelper is able to pick up
// the plain C# properties.
property = DependencyProperty.Register(
dependencyProperty,
propertyType,
originalObjectType,
new PropertyMetadata(null)
);
}
return(property);
}
else
{
this.Log().Error($"The property {dependencyProperty} does not exist on {originalObjectType}");
return(null);
}
}
private void ApplyRulesInternal(DataBindingDragDropModel model, DataBindingDragDropFlags filteredDragFlags)
{
if ((filteredDragFlags & DataBindingDragDropFlags.SetBinding) == DataBindingDragDropFlags.SetBinding)
{
if (model.InsertionPoint.Property != null)
{
model.DropFlags &= ~DataBindingDragDropFlags.SetBinding;
IType type = model.RelativeDropSchemaPath.Type;
if (type != null && BindingPropertyHelper.GetPropertyCompatibility(model.InsertionPoint.Property, type, (ITypeResolver)model.TargetNode.ProjectContext) != BindingPropertyCompatibility.None)
{
model.TargetProperty = model.InsertionPoint.Property;
model.DropFlags |= DataBindingDragDropFlags.SetBinding;
}
}
else if ((filteredDragFlags & DataBindingDragDropFlags.AutoPickProperty) == DataBindingDragDropFlags.AutoPickProperty)
{
model.TargetProperty = this.GetSpecialDefaultBindingProperty(filteredDragFlags);
if (model.TargetProperty == null)
{
model.TargetProperty = this.GetDefaultBindingProperty(filteredDragFlags, model.RelativeDropSchemaPath);
}
if (model.TargetProperty != null)
{
model.DropFlags |= DataBindingDragDropFlags.SetBinding;
}
}
}
if ((filteredDragFlags & DataBindingDragDropFlags.CreateElement) != DataBindingDragDropFlags.CreateElement || !PlatformTypes.Panel.IsAssignableFrom((ITypeId)model.TargetNode.Type))
{
return;
}
if (DataBindingModeModel.Instance.NormalizedMode == DataBindingMode.Default && model.RelativeDropSchemaPath.IsCollection)
{
model.NewElementType = !model.RelativeDropSchemaPath.IsHierarchicalCollection ? DataBindingDragDropDefaultHandler.ItemsControlType : DataBindingDragDropDefaultHandler.TreeControlType;
model.NewElementProperty = (IPropertyId)model.NewElementType.GetMember(MemberType.LocalProperty, "ItemsSource", MemberAccessTypes.Public);
model.DropFlags |= DataBindingDragDropFlags.CreateElement;
}
List <DataSchemaNode> toCreateElements = this.GetNodesToCreateElements();
if (toCreateElements.Count < model.DataSource.Count)
{
return;
}
model.DropFlags |= DataBindingDragDropFlags.CreateElement;
model.NodesToCreateElements = (IList <DataSchemaNode>)toCreateElements;
if (model.NewElementType != null)
{
return;
}
IType dataType = toCreateElements[0].ResolveType(model.TargetNode.DocumentNode.TypeResolver);
DataViewTemplateEntry viewTemplateEntry = DataViewFactory.GetDataViewTemplateEntry(model.Platform, dataType, DataViewCategory.Master);
model.NewElementType = (ITypeId)viewTemplateEntry.FieldNode.Type;
model.NewElementProperty = (IPropertyId)viewTemplateEntry.FieldValueProperty;
}
private static void ValidateEnumType(Type enumType)
{
var names = Enum.GetNames(enumType);
var values = Enum.GetValues(enumType);
for (int i = 0; i < names.Length; i++)
{
object expected = values.GetValue(i);
object actual = BindingPropertyHelper.Convert(() => enumType, names[i]);
Assert.AreEqual(expected, actual);
object actualLower = BindingPropertyHelper.Convert(() => enumType, names[i].ToLowerInvariant());
Assert.AreEqual(expected, actual);
}
}
public void When_String_To_FontWeight()
{
var allWeights = typeof(FontWeights).GetFields(BindingFlags.Static | BindingFlags.Public);
foreach (var weight in allWeights)
{
object expected = weight.GetValue(null);
object actual = BindingPropertyHelper.Convert(() => typeof(FontWeight), weight.Name);
Assert.AreEqual(expected, actual);
object actualLower = BindingPropertyHelper.Convert(() => typeof(FontWeight), weight.Name.ToLowerInvariant());
Assert.AreEqual(expected, actualLower);
}
}
public static bool CanBindToSchemaNode(SceneNode targetElement, IPropertyId targetPropertyId, DataSchemaNode schemaNode)
{
ReferenceStep referenceStep = targetElement.ProjectContext.ResolveProperty(targetPropertyId) as ReferenceStep;
if (!BindingPropertyHelper.IsPropertyBindable(targetElement, referenceStep))
{
return(false);
}
IType dataType = schemaNode.ResolveType((ITypeResolver)targetElement.ProjectContext);
if (dataType == null)
{
return(true);
}
return(BindingPropertyHelper.GetPropertyCompatibility((IProperty)referenceStep, dataType, (ITypeResolver)targetElement.ProjectContext) != BindingPropertyCompatibility.None);
}
public static void ApplyResource(DependencyObject owner, DependencyProperty property, object resourceKey, bool isThemeResourceExtension, object context = null)
{
// Set initial value based on statically-available top-level resources.
if (TryStaticRetrieval(resourceKey, context, out var value))
{
owner.SetValue(property, BindingPropertyHelper.Convert(() => property.Type, value));
if (!isThemeResourceExtension)
{
// If it's {StaticResource Foo} and we managed to resolve it at parse-time, then we don't want to update it again (per UWP).
return;
}
}
(owner as IDependencyObjectStoreProvider).Store.SetBinding(property, new ResourceBinding(resourceKey, isThemeResourceExtension, context));
}
private IProperty GetDefaultBindingProperty(DataBindingDragDropFlags filteredDragFlags, IType dataType)
{
if (dataType == null)
{
return((IProperty)null);
}
BindingPropertyMatchInfo bindingPropertyInfo = BindingPropertyHelper.GetDefaultBindingPropertyInfo(this.DragModel.TargetNode, dataType);
if (bindingPropertyInfo.Property == null)
{
return((IProperty)null);
}
if (bindingPropertyInfo.Compatibility == BindingPropertyCompatibility.StringSpecial && !PlatformTypes.IConvertible.IsAssignableFrom((ITypeId)dataType))
{
return((IProperty)null);
}
if (bindingPropertyInfo.Compatibility == BindingPropertyCompatibility.DataContext)
{
if ((filteredDragFlags & DataBindingDragDropFlags.DiscourageDataContext) == DataBindingDragDropFlags.DiscourageDataContext)
{
return((IProperty)null);
}
SceneElement sceneElement = this.DragModel.TargetNode as SceneElement;
if (sceneElement == null)
{
return((IProperty)null);
}
if (!sceneElement.IsContainer && !PlatformTypes.UserControl.IsAssignableFrom((ITypeId)sceneElement.Type) && (sceneElement.Parent != null && !PlatformTypes.FrameworkTemplate.IsAssignableFrom((ITypeId)sceneElement.Parent.Type)))
{
return((IProperty)null);
}
if (PlatformTypes.IConvertible.IsAssignableFrom((ITypeId)dataType))
{
return((IProperty)null);
}
}
if (bindingPropertyInfo.Compatibility == BindingPropertyCompatibility.Assignable && bindingPropertyInfo.Property.PropertyType.RuntimeType == typeof(object) && !PlatformTypes.IConvertible.IsAssignableFrom((ITypeId)dataType))
{
return((IProperty)null);
}
if (PlatformTypes.IEnumerable.IsAssignableFrom((ITypeId)bindingPropertyInfo.Property.PropertyType) && !PlatformTypes.String.IsAssignableFrom((ITypeId)bindingPropertyInfo.Property.PropertyType) && PlatformTypes.String.IsAssignableFrom((ITypeId)dataType))
{
return((IProperty)null);
}
return(bindingPropertyInfo.Property);
}
private SceneNode CreateDataGridBoundColumn(DataSchemaNodePath schemaPath, ITypeId columnType)
{
DataGridColumnNode dataGridColumnNode = (DataGridColumnNode)this.DragModel.ViewModel.CreateSceneNode(columnType);
string columnName = DataBindingDragDropDefaultHandler.GetColumnName(schemaPath);
dataGridColumnNode.SetLocalValue(DataGridColumnNode.ColumnHeaderProperty, (object)columnName);
BindingSceneNode bindingSceneNode = (BindingSceneNode)this.DragModel.ViewModel.CreateSceneNode(PlatformTypes.Binding);
bindingSceneNode.SetPath(schemaPath.Path);
BindingModeInfo defaultBindingMode = BindingPropertyHelper.GetDefaultBindingMode(dataGridColumnNode.DocumentNode, DataGridColumnNode.BoundColumnBindingProperty, schemaPath);
if (!defaultBindingMode.IsOptional)
{
bindingSceneNode.Mode = defaultBindingMode.Mode;
}
dataGridColumnNode.SetValueAsSceneNode(DataGridColumnNode.BoundColumnBindingProperty, (SceneNode)bindingSceneNode);
return((SceneNode)dataGridColumnNode);
}
public static DataBindingDragDropModel GetDragFeedback(DataSchemaNodePathCollection information, BindingSceneInsertionPoint insertionPoint, DataBindingDragDropFlags dragFlags, ModifierKeys modifiers)
{
bool flag = (modifiers & ModifierKeys.Alt) == ModifierKeys.Alt;
if (!DataBindingDragDropManager.isAltModifier.HasValue)
{
if (flag)
{
DataBindingModeModel.Instance.SetMode(DataBindingMode.Details, false);
}
}
else if (DataBindingDragDropManager.isAltModifier.Value != flag)
{
DataBindingModeModel.Instance.SetMode(flag ? DataBindingMode.Details : DataBindingMode.Default, false);
}
DataBindingDragDropManager.isAltModifier = new bool?(flag);
if ((modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
{
dragFlags &= ~DataBindingDragDropFlags.AutoPickProperty;
dragFlags &= ~DataBindingDragDropFlags.AllowRetargetElement;
}
if (insertionPoint.Property != null)
{
dragFlags &= ~DataBindingDragDropFlags.CreateElement;
}
if (!BindingPropertyHelper.HasBindableProperties(insertionPoint.SceneNode))
{
dragFlags &= ~(DataBindingDragDropFlags.SetBinding | DataBindingDragDropFlags.AutoPickProperty);
}
DataBindingDragDropModel bindingDragDropModel = new DataBindingDragDropModel(information, insertionPoint, dragFlags, modifiers);
if (!DataBindingDragDropModel.Equals(bindingDragDropModel, DataBindingDragDropManager.effectiveDragModel))
{
PerformanceUtility.StartPerformanceSequence(PerformanceEvent.DataBindingDragModelUpdate);
DataBindingDragDropManager.effectiveDragModel = DataBindingDragDropManager.UpdateDragModel(bindingDragDropModel);
PerformanceUtility.EndPerformanceSequence(PerformanceEvent.DataBindingDragModelUpdate);
}
return(DataBindingDragDropManager.effectiveDragModel);
}
public bool CanCreateAndSetBindingOrData(SceneNode target, DataSchemaNodePath bindingPath, bool useSourceInherited)
{
IPropertyId targetProperty;
if (PlatformTypes.FrameworkElement.IsAssignableFrom((ITypeId)target.Type))
{
targetProperty = BaseFrameworkElement.WidthProperty;
}
else
{
targetProperty = (IPropertyId)Enumerable.FirstOrDefault <ReferenceStep>((IEnumerable <ReferenceStep>)BindingPropertyHelper.GetBindableTargetProperties(target), (Func <ReferenceStep, bool>)(prop => !DataContextHelper.IsDataContextProperty(target.DocumentNode, (IPropertyId)prop)));
if (targetProperty == null)
{
return(false);
}
}
return(this.CanCreateAndSetBindingOrDataInternal(target, targetProperty, bindingPath, useSourceInherited));
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
return((object)BindingPropertyHelper.GetElementNameFromBoundProperty(value as SceneNodeProperty));
}
