public PathDiff(Base2DElement targetElement, IPropertyId pathProperty, PathDiffChangeList changeList)
{
this.targetElement = targetElement;
this.platformMetadata = targetElement.Platform.Metadata;
this.pathProperty = this.platformMetadata.ResolveProperty(pathProperty) as ReferenceStep;
this.changeList = changeList;
}
private static object InstantiateConstructorArgument(IInstanceBuilderContext context, ViewNode viewNode, IParameter constructorArgument, IProperty constructorArgumentProperty, DocumentNode constructorArgumentNode)
{
object defaultValue;
if (constructorArgumentProperty != null)
{
return(InstanceBuilderOperations.UpdatePropertyWithoutApply(context, viewNode, constructorArgumentProperty, constructorArgumentNode).Instance);
}
if (constructorArgumentNode != null)
{
ViewNode viewNode1 = InstanceBuilderOperations.UpdateChildWithoutApply(context, viewNode, viewNode.Children.Count, DocumentNodeChangeAction.Add, constructorArgumentNode);
return(viewNode1.Instance);
}
IDocumentContext documentContext = viewNode.DocumentNode.Context;
Type targetType = viewNode.TargetType;
Type runtimeType = constructorArgument.ParameterType.RuntimeType;
ReferenceStep referenceStep = constructorArgumentProperty as ReferenceStep;
if (referenceStep == null || !referenceStep.HasDefaultValue(targetType))
{
bool flag = documentContext.TypeResolver.InTargetAssembly(constructorArgument.ParameterType);
defaultValue = InstanceBuilderOperations.InstantiateType(runtimeType, flag);
}
else
{
defaultValue = referenceStep.GetDefaultValue(targetType);
}
if (context.IsSerializationScope)
{
defaultValue = documentContext.CreateNode(runtimeType, defaultValue);
}
return(defaultValue);
}
private void UpdateFromDataContext()
{
this.editingValue = this.DataContext as Microsoft.Windows.Design.PropertyEditing.PropertyValue;
this.UnhookEditingProperty();
if (this.editingValue != null)
{
this.editingProperty = (SceneNodeProperty)this.editingValue.ParentProperty;
}
if (this.editingProperty == null)
{
return;
}
SceneNodeObjectSet sceneNodeObjectSet = this.editingProperty.SceneNodeObjectSet;
ReferenceStep singleStep1 = (ReferenceStep)sceneNodeObjectSet.ProjectContext.ResolveProperty(BehaviorEventTriggerBaseNode.BehaviorSourceNameProperty);
if (singleStep1 != null)
{
this.sourceNameProperty = sceneNodeObjectSet.CreateSceneNodeProperty(new PropertyReference(singleStep1), (AttributeCollection)null);
this.sourceNameProperty.PropertyReferenceChanged += new Microsoft.Expression.DesignSurface.Documents.PropertyReferenceChangedEventHandler(this.OnSourceNameOrSourceObjectPropertyPropertyReferenceChanged);
}
ReferenceStep singleStep2 = (ReferenceStep)sceneNodeObjectSet.ProjectContext.ResolveProperty(BehaviorEventTriggerBaseNode.BehaviorSourceObjectProperty);
if (singleStep2 != null)
{
this.sourceObjectProperty = sceneNodeObjectSet.CreateSceneNodeProperty(new PropertyReference(singleStep2), (AttributeCollection)null);
this.sourceObjectProperty.PropertyReferenceChanged += new Microsoft.Expression.DesignSurface.Documents.PropertyReferenceChangedEventHandler(this.OnSourceNameOrSourceObjectPropertyPropertyReferenceChanged);
}
this.editingProperty.PropertyReferenceChanged += new Microsoft.Expression.DesignSurface.Documents.PropertyReferenceChangedEventHandler(this.OnEditingPropertyChanged);
this.Rebuild();
}
public WrapperObjectSet(SceneNodeObjectSet baseSet, ReferenceStep targetStep, IPropertyInformation redirectedProperty)
: base(baseSet.DesignerContext, baseSet.TransactionContext)
{
this.baseSet = baseSet;
this.targetStep = targetStep;
this.redirectedProperty = redirectedProperty;
}
private static void RunDesignModeValueProvider(object target, IPlatform platform, ValueTranslationService valueTranslationService, IType type, Type runtimeType, PropertyIdentifier property, ReferenceStep referenceStep, bool isFirstTime)
{
if (!runtimeType.IsAssignableFrom(target.GetType()))
{
return;
}
ModelItem modelItemForObject = DesignModeValueProviderService.GetModelItemForObject(platform, target);
if (modelItemForObject == null)
{
return;
}
ReferenceStep referenceStep1 = (ReferenceStep)DesignTimeProperties.GetShadowProperty((IProperty)referenceStep, (ITypeId)type);
try
{
object valueToSet;
if (isFirstTime && !referenceStep1.IsSet(target))
{
valueToSet = referenceStep.GetValue(target);
referenceStep1.SetValue(target, valueToSet);
}
else
{
valueToSet = referenceStep1.GetValue(target);
}
referenceStep.SetValue(target, valueTranslationService.TranslatePropertyValue(runtimeType, modelItemForObject, property, valueToSet));
}
catch (Exception ex)
{
}
}
public IEnumerable <IProperty> GetProperties(MemberAccessTypes access)
{
ReadOnlyCollection <IProperty> readOnlyCollection1;
if (this.designPropertySets.TryGetValue(access, out readOnlyCollection1))
{
return((IEnumerable <IProperty>)readOnlyCollection1);
}
IEnumerable <IProperty> properties = this.designType.GetProperties(access);
List <IProperty> list = new List <IProperty>();
foreach (IProperty property in properties)
{
ReferenceStep actualReferenceStep = property as ReferenceStep;
if (actualReferenceStep != null)
{
TypeReflectingProjectContext.DesignTypeProperty createDesignProperty = this.GetOrCreateDesignProperty(actualReferenceStep);
list.Add((IProperty)createDesignProperty);
}
}
ReadOnlyCollection <IProperty> readOnlyCollection2 = new ReadOnlyCollection <IProperty>((IList <IProperty>)list);
this.designPropertySets[access] = readOnlyCollection2;
return((IEnumerable <IProperty>)readOnlyCollection2);
}
private void UpdateFromDataContext()
{
this.UnhookEditingProperty();
Microsoft.Windows.Design.PropertyEditing.PropertyValue propertyValue = this.hostControl.DataContext as Microsoft.Windows.Design.PropertyEditing.PropertyValue;
if (propertyValue != null)
{
this.editingProperty = (PropertyReferenceProperty)propertyValue.ParentProperty;
}
if (this.editingProperty == null)
{
return;
}
this.editingProperty.PropertyReferenceChanged += new Microsoft.Expression.DesignSurface.Documents.PropertyReferenceChangedEventHandler(this.OnEditingPropertyChanged);
SceneNodeObjectSetBase nodeObjectSetBase = (SceneNodeObjectSetBase)this.editingProperty.ObjectSet;
ReferenceStep singleStep1 = (ReferenceStep)nodeObjectSetBase.ProjectContext.ResolveProperty(BehaviorTargetedTriggerActionNode.BehaviorTargetNameProperty);
if (singleStep1 != null)
{
this.targetNameProperty = (SceneNodeProperty)nodeObjectSetBase.CreateProperty(new PropertyReference(singleStep1), (AttributeCollection)null);
this.targetNameProperty.PropertyReferenceChanged += new Microsoft.Expression.DesignSurface.Documents.PropertyReferenceChangedEventHandler(this.OnEditingPropertyChanged);
}
ReferenceStep singleStep2 = (ReferenceStep)nodeObjectSetBase.ProjectContext.ResolveProperty(BehaviorTargetedTriggerActionNode.BehaviorTargetObjectProperty);
if (singleStep2 != null)
{
this.targetObjectProperty = (SceneNodeProperty)nodeObjectSetBase.CreateProperty(new PropertyReference(singleStep2), (AttributeCollection)null);
this.targetObjectProperty.PropertyReferenceChanged += new Microsoft.Expression.DesignSurface.Documents.PropertyReferenceChangedEventHandler(this.OnEditingPropertyChanged);
}
this.Rebuild();
}
private void ApplyEyedropperTextElement(BaseTextElement textElement)
{
PropertyManager propertyManager = (PropertyManager)this.ToolBehaviorContext.PropertyManager;
IPlatform platform = this.ActiveDocument.ProjectContext.Platform;
IPlatformMetadata platformMetadata = (IPlatformMetadata)platform.Metadata;
Artboard artboard = this.ActiveView.Artboard;
Matrix matrix = artboard.CalculateTransformFromArtboardToContent().Value;
Matrix transformFromRoot = this.ActiveView.GetComputedTransformFromRoot((SceneElement)textElement);
Point position = this.MouseDevice.GetPosition((IInputElement)artboard);
Point point1 = matrix.Transform(position);
Point point2 = transformFromRoot.Transform(point1);
this.EnsureEditTransaction();
foreach (IPropertyId propertyId in PropertyToolBehavior.PropertyList)
{
ReferenceStep singleStep = platformMetadata.ResolveProperty(propertyId) as ReferenceStep;
if (singleStep != null && singleStep.PropertyType.PlatformMetadata == platform.Metadata)
{
PropertyReference propertyReference1 = new PropertyReference(singleStep);
PropertyReference propertyReference2 = propertyManager.FilterProperty((SceneNode)textElement, propertyReference1);
if (propertyReference2 != null)
{
object textValueAtPoint = textElement.GetTextValueAtPoint(point2, true, propertyReference2);
propertyManager.SetValue(propertyReference2, textValueAtPoint);
}
}
}
this.UpdateEditTransaction();
}
private void ApplyEyedropperSceneElement(SceneElement hitElement)
{
PropertyManager propertyManager = (PropertyManager)this.ToolBehaviorContext.PropertyManager;
IPlatform platform = this.ActiveDocument.ProjectContext.Platform;
IPlatformMetadata platformMetadata = (IPlatformMetadata)platform.Metadata;
this.EnsureEditTransaction();
foreach (IPropertyId propertyId in PropertyToolBehavior.PropertyList)
{
ReferenceStep singleStep = platformMetadata.ResolveProperty(propertyId) as ReferenceStep;
if (singleStep != null && singleStep.PropertyType.PlatformMetadata == platform.Metadata)
{
PropertyReference propertyReference1 = new PropertyReference(singleStep);
PropertyReference propertyReference2 = propertyManager.FilterProperty((SceneNode)hitElement, propertyReference1);
if (propertyReference2 != null)
{
object second = propertyManager.GetValue(propertyReference2);
object computedValue = hitElement.GetComputedValue(propertyReference2);
if (computedValue != MixedProperty.Mixed && !PropertyUtilities.Compare(computedValue, second, hitElement.ViewModel.DefaultView))
{
propertyManager.SetValue(propertyReference2, computedValue);
}
}
}
}
this.UpdateEditTransaction();
}
private static bool IsPropertyBindableAsTarget(SceneNode sceneNode, ReferenceStep referenceStep, bool isDeclaringTypeBindable)
{
if (referenceStep.Equals((object)referenceStep.DeclaringType.Metadata.NameProperty) || (referenceStep.WriteAccess & (MemberAccessType)14) == MemberAccessType.None)
{
return(false);
}
SceneNode[] selection = new SceneNode[1]
{
sceneNode
};
TargetedReferenceStep targetedReferenceStep = new TargetedReferenceStep(referenceStep, sceneNode.Type);
if ((!PropertyInspectorModel.IsPropertyBrowsable(selection, targetedReferenceStep) || !PropertyInspectorModel.IsAttachedPropertyBrowsable(selection, sceneNode.Type, targetedReferenceStep, (ITypeResolver)sceneNode.ProjectContext)) && !referenceStep.Equals((object)ContentControlElement.ContentProperty))
{
return(false);
}
if (referenceStep.PropertyType.IsBinding)
{
return(true);
}
object[] customAttributes = referenceStep.GetCustomAttributes(typeof(BindableAttribute), false);
if (customAttributes != null && customAttributes.Length > 0)
{
return(((BindableAttribute)customAttributes[0]).Bindable);
}
return(isDeclaringTypeBindable && referenceStep is DependencyPropertyReferenceStep);
}
protected object ResolveCurrentStyle(SceneElement targetElement, PropertyReference propertyReference, bool allowDefaultStyle)
{
ReferenceStep referenceStep = propertyReference[0];
object computedValue = targetElement.GetComputedValue(propertyReference);
StyleNode styleNode = targetElement.GetLocalOrDefaultValue(propertyReference) as StyleNode;
bool flag = computedValue == null || styleNode != null && styleNode.IsDefaultStyle;
if (!allowDefaultStyle && flag && referenceStep.Equals((object)BaseFrameworkElement.StyleProperty))
{
return((object)null);
}
if (computedValue != null)
{
Style style = computedValue as Style;
if (style != null)
{
foreach (SetterBase setterBase in (Collection <SetterBase>)style.Setters)
{
Setter setter = setterBase as Setter;
FrameworkTemplate frameworkTemplate;
if (setter != null && (frameworkTemplate = setter.Value as FrameworkTemplate) != null && frameworkTemplate.VisualTree != null)
{
return((object)null);
}
}
}
}
return(computedValue);
}
private void UpdateTranslation(bool scrollNow)
{
SceneView activeView = this.ActiveView;
SceneViewModel viewModel = activeView.ViewModel;
Vector delta = this.dragCurrentPosition - this.dragStartPosition;
if (this.isConstraining)
{
delta = this.ConstrainDeltaToAxis(delta);
}
if (delta == this.lastMove || this.IsAltDown)
{
return;
}
this.EnsureEditTransaction();
Vector vector1 = delta - this.lastMove;
SceneElement primarySelection = viewModel.ElementSelectionSet.PrimarySelection;
if (primarySelection == null)
{
return;
}
PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)primarySelection);
if (propertyReference == null)
{
return;
}
object computedValue = primarySelection.GetComputedValue(propertyReference);
if (computedValue != null && !PlatformTypes.IsInstance(computedValue, PlatformTypes.SolidColorBrush, (ITypeResolver)primarySelection.ProjectContext))
{
Vector vector2 = vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, true);
if (PlatformTypes.IsInstance(computedValue, PlatformTypes.LinearGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool)
{
ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.StartPointProperty);
ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.EndPointProperty);
Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2);
Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2);
this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point1);
this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point2);
}
else if (PlatformTypes.IsInstance(computedValue, PlatformTypes.RadialGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool)
{
ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.CenterProperty);
ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.GradientOriginProperty);
Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2);
Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2);
this.SetBrushValue(RadialGradientBrushNode.CenterProperty, (object)point1);
this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point2);
}
else
{
this.TranslateBrushPosition(vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, false), primarySelection);
}
}
activeView.EnsureVisible(this.dragStartPosition + delta, scrollNow);
this.lastMove = delta;
this.UpdateEditTransaction();
}
public void TranslateBrushPosition(Vector elementDelta, SceneElement element)
{
PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)element);
if (propertyReference == null)
{
return;
}
object computedValue = element.GetComputedValue(propertyReference);
if (computedValue == null || PlatformTypes.IsInstance(computedValue, PlatformTypes.SolidColorBrush, (ITypeResolver)element.ProjectContext))
{
return;
}
ReferenceStep referenceStep = (ReferenceStep)element.Platform.Metadata.ResolveProperty(BrushNode.RelativeTransformProperty);
object obj = element.ViewModel.DefaultView.ConvertToWpfValue(referenceStep.GetCurrentValue(computedValue));
CanonicalTransform canonicalTransform = !(obj is Transform) ? new CanonicalTransform(Matrix.Identity) : new CanonicalTransform((Transform)obj);
elementDelta *= canonicalTransform.TransformGroup.Value;
double valueToSet1 = RoundingHelper.RoundLength(canonicalTransform.TranslationX + elementDelta.X);
double valueToSet2 = RoundingHelper.RoundLength(canonicalTransform.TranslationY + elementDelta.Y);
this.SetBrushTransformValue(element.Platform.Metadata.CommonProperties.BrushTranslationXReference, valueToSet1);
this.SetBrushTransformValue(element.Platform.Metadata.CommonProperties.BrushTranslationYReference, valueToSet2);
}
public ReferenceStepQuery.Step.MatchType Matches(ReferenceStep otherStep)
{
if (this.wildcard != ReferenceStepQuery.WildcardType.None)
{
if (this.wildcard == ReferenceStepQuery.WildcardType.Descendant)
{
return(ReferenceStepQuery.Step.MatchType.ContinueMatch);
}
if (this.wildcard != ReferenceStepQuery.WildcardType.Indexer)
{
return(ReferenceStepQuery.Step.MatchType.NoMatch);
}
if (otherStep.GetType() != typeof(IndexedClrPropertyReferenceStep))
{
return(ReferenceStepQuery.Step.MatchType.NoMatch);
}
return(ReferenceStepQuery.Step.MatchType.YesMatch);
}
if (this.referenceStep == null)
{
if (!otherStep.Name.Contains(this.nameContains))
{
return(ReferenceStepQuery.Step.MatchType.NoMatch);
}
return(ReferenceStepQuery.Step.MatchType.YesMatch);
}
if (this.referenceStep.SortValue == otherStep.SortValue && this.referenceStep.GetType() == otherStep.GetType())
{
return(ReferenceStepQuery.Step.MatchType.YesMatch);
}
return(ReferenceStepQuery.Step.MatchType.NoMatch);
}
private static bool ShouldUseRelativeSourceTemplateBinding(DocumentNode targetNode, PropertyReference targetProperty)
{
bool flag;
if (!targetNode.PlatformMetadata.IsCapabilitySet(PlatformCapability.UseRelativeSourceTemplateBinding))
{
return(false);
}
if (!PlatformTypes.FrameworkElement.IsAssignableFrom(targetNode.Type) && !PlatformTypes.FrameworkContentElement.IsAssignableFrom(targetNode.Type))
{
return(true);
}
if (targetProperty != null)
{
using (IEnumerator <ReferenceStep> enumerator = targetProperty.ReferenceSteps.GetEnumerator())
{
while (enumerator.MoveNext())
{
ReferenceStep current = enumerator.Current;
if (!PlatformTypes.Freezable.IsAssignableFrom(current.DeclaringType) || PlatformTypes.FrameworkElement.IsAssignableFrom(current.DeclaringType) || PlatformTypes.FrameworkContentElement.IsAssignableFrom(current.DeclaringType))
{
continue;
}
flag = true;
return(flag);
}
return(false);
}
return(flag);
}
return(false);
}
private static IEnumerable <ReferenceStep> GetPropertiesForSceneNode(SceneNode node)
{
TextRangeElement textRange = node as TextRangeElement;
if (textRange != null)
{
foreach (IPropertyId propertyId in textRange.RangeProperties)
{
DependencyPropertyReferenceStep dp = node.ProjectContext.ResolveProperty(propertyId) as DependencyPropertyReferenceStep;
if (dp != null)
{
yield return((ReferenceStep)dp);
}
}
}
else
{
foreach (IProperty property in ITypeExtensions.GetProperties(PropertyMerger.GetTypeFromSceneNode(node), MemberAccessTypes.Public, true))
{
ReferenceStep referenceStep = property as ReferenceStep;
if (referenceStep != null)
{
DependencyPropertyReferenceStep dependencyPropertyReferenceStep = referenceStep as DependencyPropertyReferenceStep;
if (dependencyPropertyReferenceStep == null || !dependencyPropertyReferenceStep.IsAttachable)
{
yield return(referenceStep);
}
}
}
}
}
public static bool DoesPropertyApply(SceneNode sceneNode, ReferenceStep referenceStep, SceneNode valueNode, out ReferenceStep appliedReferenceStep)
{
appliedReferenceStep = sceneNode.DesignerContext.PropertyManager.FilterProperty(sceneNode, referenceStep);
if (appliedReferenceStep == null)
{
return(false);
}
if (DocumentNodeUtilities.IsStyleOrTemplate(appliedReferenceStep.PropertyType))
{
DocumentNode node = valueNode.DocumentNode;
if (node.Type.IsExpression)
{
node = new ExpressionEvaluator(sceneNode.ViewModel.DocumentRootResolver).EvaluateExpression(sceneNode.DocumentNodePath, valueNode.DocumentNode);
}
if (node == null || !DocumentNodeUtilities.IsStyleOrTemplate(node.Type) || !appliedReferenceStep.PropertyType.IsAssignableFrom((ITypeId)node.Type))
{
return(false);
}
IType templateTargetType = DocumentNodeUtilities.GetStyleOrTemplateTargetType(node);
Type propertyTargetType = sceneNode.Metadata.GetStylePropertyTargetType((IPropertyId)appliedReferenceStep);
if (templateTargetType != null && propertyTargetType != (Type)null && !templateTargetType.RuntimeType.IsAssignableFrom(propertyTargetType))
{
return(false);
}
}
return(true);
}
public ApplyResourceCommand(ResourceToolBehavior behavior, SceneElement targetElement, ReferenceStep targetProperty, ResourceEntryItem resource)
{
this.behavior = behavior;
this.targetElement = targetElement;
this.resource = resource;
this.targetProperty = targetProperty;
}
private static object CreateXmlDataContext(DataSourceInfo dataSource, SceneViewModel viewModel)
{
DocumentNode sourceNode = dataSource.SourceNode;
object obj = (object)null;
using (StandaloneInstanceBuilderContext instanceBuilderContext = new StandaloneInstanceBuilderContext(viewModel.Document.DocumentContext, viewModel.DesignerContext))
{
try
{
IInstanceBuilder builder = instanceBuilderContext.InstanceBuilderFactory.GetBuilder(sourceNode.TargetType);
ViewNode viewNode = builder.GetViewNode((IInstanceBuilderContext)instanceBuilderContext, sourceNode);
obj = (object)(bool)(builder.Instantiate((IInstanceBuilderContext)instanceBuilderContext, viewNode) ? true : false);
}
catch
{
}
}
ReferenceStep referenceStep = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(XmlDataProviderSceneNode.XPathProperty);
string inheritedXPath = referenceStep.GetValue(obj) as string;
if (string.IsNullOrEmpty(inheritedXPath))
{
inheritedXPath = dataSource.Path;
}
else if (!string.IsNullOrEmpty(dataSource.Path))
{
inheritedXPath = XmlSchema.CombineXPaths(inheritedXPath, dataSource.Path);
}
if (!string.IsNullOrEmpty(inheritedXPath))
{
referenceStep.SetValue(obj, (object)inheritedXPath);
}
return(obj);
}
protected override DocumentNode CreateValue(BaseFrameworkElement source)
{
object tileBrush = this.CreateTileBrush(source);
if (tileBrush == null)
{
return((DocumentNode)null);
}
ITypeResolver typeResolver = (ITypeResolver)source.ProjectContext;
IViewObject visual = source.Visual;
if (visual != null)
{
object platformSpecificObject = visual.PlatformSpecificObject;
if (platformSpecificObject != null && PlatformTypes.Image.IsAssignableFrom((ITypeId)visual.GetIType((ITypeResolver)this.SceneViewModel.ProjectContext)))
{
ReferenceStep referenceStep = typeResolver.ResolveProperty(TileBrushNode.StretchProperty) as ReferenceStep;
object obj = referenceStep.GetValue(tileBrush);
object valueToSet = (typeResolver.ResolveProperty(ImageElement.StretchProperty) as ReferenceStep).GetValue(platformSpecificObject);
if (!obj.Equals(valueToSet))
{
referenceStep.SetValue(tileBrush, valueToSet);
}
}
}
return(this.SceneViewModel.Document.DocumentContext.CreateNode(typeResolver.ResolveType(PlatformTypes.TileBrush).RuntimeType, tileBrush));
}
public ControlStylingCommandBase(ISceneViewHost viewHost, SceneViewModel viewModel, IPropertyId targetProperty, bool useRootTemplateProperty)
: base(viewModel)
{
this.viewHost = viewHost;
this.targetProperty = viewModel.ProjectContext.ResolveProperty(targetProperty) as ReferenceStep;
this.useRootTemplateProperty = useRootTemplateProperty;
}
public void Setup()
{
flowIdentifier1 = new FlowIdentifier(FlowType.Basic, 0);
flowIdentifier2 = new FlowIdentifier(FlowType.BoundedAlternative, 1);
referenceStep1 = new ReferenceStep(flowIdentifier1, 0);
referenceStep2 = new ReferenceStep(flowIdentifier2, 1);
List <Node> nodes = new List <Node>();
nodes.Add(new Node("A node", flowIdentifier1));
nodeList1 = nodes.AsReadOnly();
nodes = new List <Node>();
nodes.Add(new Node("Another node", flowIdentifier2));
nodeList2 = nodes.AsReadOnly();
List <ReferenceStep> referenceSteps = new List <ReferenceStep>();
referenceSteps.Add(referenceStep1);
referenceStepList1 = referenceSteps.AsReadOnly();
referenceSteps = new List <ReferenceStep>();
referenceSteps.Add(referenceStep2);
referenceStepList2 = referenceSteps.AsReadOnly();
}
private void Rebuild(object sender, EventArgs args)
{
if (this.targetPropertyEntry != null)
{
this.targetPropertyEntry.OnRemoveFromCategory();
this.targetPropertyEntry = (SceneNodeProperty)null;
}
if (this.contextHelper.EditingProperty != null && this.contextHelper.CurrentProperty != null)
{
SceneNodeObjectSetBase nodeObjectSetBase = (SceneNodeObjectSetBase)this.contextHelper.EditingProperty.ObjectSet;
ReferenceStep referenceStep = (ReferenceStep)nodeObjectSetBase.ProjectContext.ResolveProperty(ChangePropertyActionNode.ValueProperty);
PropertyPickerExtendedEditor.WrapperObjectSet wrapperObjectSet = new PropertyPickerExtendedEditor.WrapperObjectSet((SceneNodeObjectSet)nodeObjectSetBase, referenceStep, this.contextHelper.CurrentProperty);
this.targetPropertyEntry = (SceneNodeProperty) new PropertyPickerExtendedEditor.WrapperTypedSceneNodeProperty((SceneNodeObjectSet)wrapperObjectSet, new PropertyReference(referenceStep), this.contextHelper.CurrentProperty.Name, this.contextHelper.CurrentProperty.Attributes, this.contextHelper.CurrentProperty.PropertyType.RuntimeType, (ITypeResolver)nodeObjectSetBase.ProjectContext);
this.targetPropertyEntry.Recache();
wrapperObjectSet.TargetProperty = this.targetPropertyEntry;
this.propertyContainer.PropertyEntry = (PropertyEntry)this.targetPropertyEntry;
if (this.propertyContainer.ExtendedEditorTemplate == null)
{
return;
}
this.propertyContainer.ActiveEditMode = PropertyContainerEditMode.ExtendedPinned;
}
else
{
this.propertyContainer.PropertyEntry = (PropertyEntry)null;
}
}
private bool SetBinding(SceneNode targetNode, ref IProperty targetProperty)
{
ReferenceStep targetProperty1 = (ReferenceStep)null;
if (targetProperty != null)
{
targetProperty1 = this.DragModel.DocumentContext.TypeResolver.ResolveProperty((IPropertyId)targetProperty) as ReferenceStep;
}
DataSchemaNodePath bindingPath = new DataSchemaNodePath(this.DragModel.DataSource.PrimaryAbsoluteSchema, this.DragModel.RelativeDropSchemaPath.Node);
SceneNode setBindingOrData;
if (targetProperty1 == null)
{
bool useDesignDataContext = DataBindingModeModel.Instance.NormalizedMode == DataBindingMode.Details;
setBindingOrData = MiniBindingDialog.CreateAndSetBindingOrData(bindingPath, targetNode, useDesignDataContext, ref targetProperty1);
}
else
{
setBindingOrData = this.DragModel.ViewModel.BindingEditor.CreateAndSetBindingOrData(targetNode, (IPropertyId)targetProperty1, bindingPath);
}
if (setBindingOrData == null)
{
return(false);
}
if (targetProperty != null)
{
this.GenerateDetailsIfNeeded(targetNode, (IProperty)targetProperty1);
}
targetProperty = (IProperty)targetProperty1;
return(true);
}
private DataContextMetadata.AncestorPropertyPath ParseInternal()
{
List <string> list = new List <string>();
while (this.parsePosition < this.ancestorPath.Length)
{
string str = this.ParseNextStep();
if (str == null)
{
return((DataContextMetadata.AncestorPropertyPath)null);
}
list.Add(str);
}
List <ReferenceStep> steps = new List <ReferenceStep>(list.Count);
for (int index = list.Count - 1; index >= 0; --index)
{
this.ancestorNode = this.ancestorNode.Parent;
if (this.ancestorNode == null)
{
return((DataContextMetadata.AncestorPropertyPath)null);
}
ReferenceStep property = this.GetProperty(list[index]);
if (property == null)
{
return((DataContextMetadata.AncestorPropertyPath)null);
}
steps.Add(property);
}
steps.Reverse();
return(new DataContextMetadata.AncestorPropertyPath(this.ancestorNode, new PropertyReference(steps)));
}
private MenuItem BuildMenuItem(SceneElement element, ReferenceStep referenceStep)
{
MenuItem menuItem = (MenuItem)null;
IList <Control> list = this.GeneratePropertyItems(element, referenceStep);
if (list.Count > 0)
{
menuItem = new MenuItem();
menuItem.SetValue(AutomationElement.IdProperty, (object)referenceStep.Name);
foreach (Control control in (IEnumerable <Control>)list)
{
menuItem.Items.Add((object)control);
}
string displayName = this.GetDisplayName((IPropertyId)referenceStep);
if (displayName != null)
{
menuItem.Header = (object)string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.EditPropertyItemWithDisplayNameFormat, new object[2]
{
(object)displayName,
(object)referenceStep.Name
});
}
else
{
menuItem.Header = (object)string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.EditPropertyItemFormat, new object[1]
{
(object)referenceStep.Name
});
}
}
return(menuItem);
}
private void Rebuild()
{
this.X1Property = this.CreateProperty("KeySpline.ControlPoint1/X");
this.Y1Property = this.CreateProperty("KeySpline.ControlPoint1/Y");
this.X2Property = this.CreateProperty("KeySpline.ControlPoint2/X");
this.Y2Property = this.CreateProperty("KeySpline.ControlPoint2/Y");
if (this.keySplineProperty == null || this.keySplineProperty.IsEmpty)
{
return;
}
KeyFrameSceneNode keyFrameSceneNode = this.keySplineProperty.SceneNodeObjectSet.RepresentativeSceneNode as KeyFrameSceneNode;
if (keyFrameSceneNode == null)
{
return;
}
ReferenceStep singleStep = (IProperty)keyFrameSceneNode.Type.GetMember(MemberType.LocalProperty, "KeyTime", MemberAccessTypes.Public) as ReferenceStep;
if (singleStep != null)
{
this.keyTimeProperty = new PropertyReference(singleStep);
this.keySplineProperty.SceneNodeObjectSet.RegisterPropertyChangedHandler(this.keyTimeProperty, new Microsoft.Expression.DesignSurface.Documents.PropertyReferenceChangedEventHandler(this.KeyTimePropertyChanged));
}
this.UpdateTime0KeyFrameStatus();
}
public DataBindingDialogModel(DataPanelModel model, SceneNode targetElement, ReferenceStep targetProperty)
: base(targetElement, targetProperty)
{
this.isBinding = true;
this.addXmlDataSourceCommand = model.AddXmlDataSourceCommand;
this.createSampleDataCommand = model.CreateSampleDataCommand;
this.createSampleDataFromXmlCommand = model.CreateSampleDataFromXmlCommand;
this.addClrObjectDataSourceCommand = model.AddClrObjectDataSourceCommand;
DataContextInfo dataContextInfo = new DataContextEvaluator().Evaluate(targetElement, (IPropertyId)targetProperty, true);
if (dataContextInfo.DataSource.IsValidWithSource)
{
ISchema schemaForDataSource = SchemaManager.GetSchemaForDataSource(dataContextInfo.DataSource.SourceNode);
if (schemaForDataSource != null && !(schemaForDataSource is EmptySchema))
{
this.dataContext = schemaForDataSource.GetNodePathFromPath(dataContextInfo.DataSource.Path);
}
}
this.bindsTwoWayByDefault = this.BindsTwoWayByDefault(targetElement, targetProperty);
this.bindingFilterModes = new ObservableCollection <BindingFilterMode>();
this.bindingFilterModes.Add(BindingFilterMode.None);
this.bindingFilterModes.Add(BindingFilterMode.FilterByType);
ICollectionView defaultView = CollectionViewSource.GetDefaultView((object)this.bindingFilterModes);
defaultView.MoveCurrentTo((object)BindingFilterMode.FilterByType);
this.bindingSources = new ObservableCollection <IBindingSourceModel>();
this.dataSourceModel = new DataSourceBindingSourceModel(model, new DataSchemaItemFilter(this.BindingFilter));
this.AddBindingSource((IBindingSourceModel)this.dataSourceModel);
if (targetElement.ViewModel.ActiveEditingContainer is SceneElement)
{
this.elementPropertyModel = new ElementPropertyBindingSourceModel(targetElement, new DataSchemaItemFilter(this.BindingFilter));
this.AddBindingSource((IBindingSourceModel)this.elementPropertyModel);
}
this.explicitDataContextModel = new ExplicitDataContextBindingSourceModel(targetElement, targetProperty, new DataSchemaItemFilter(this.BindingFilter));
this.AddBindingSource((IBindingSourceModel)this.explicitDataContextModel);
this.bindingSourcesProxy = new BindingProxy <IBindingSourceModel>();
this.bindingSourcesProxy.PropertyChanged += new PropertyChangedEventHandler(this.BindingSourcesProxy_PropertyChanged);
this.bindingSourcesView = (CollectionView) new DataBindingProxyCollectionView <IBindingSourceModel>(this.bindingSources, (IDataBindingProxy <IBindingSourceModel>) this.bindingSourcesProxy);
BindingSceneNode binding = targetElement.GetBinding((IPropertyId)targetProperty);
if (binding != null)
{
this.SetExistingBindingValues(binding);
}
else if (!(this.explicitDataContextModel.Schema is EmptySchema))
{
this.bindingSourcesView.MoveCurrentTo((object)this.explicitDataContextModel);
}
else
{
this.bindingSourcesView.MoveCurrentTo((object)this.dataSourceModel);
}
if (binding == null || !binding.IsModeSet)
{
this.CurrentBindingMode = BindingPropertyHelper.GetDefaultBindingMode(this.TargetElement.DocumentNode, (IPropertyId)this.TargetProperty, this.CurrentDataPath).Mode;
}
this.bindingSourcesView.CurrentChanging += new CurrentChangingEventHandler(this.BindingSourcesView_CurrentChanging);
defaultView.CurrentChanged += new EventHandler(this.BindingFilterModesView_CurrentChanged);
this.PropertyChanged += new PropertyChangedEventHandler(this.DataBindingDialogModel_PropertyChanged);
}
public static PropertyReference ConvertTransformPropertyToComposite(PropertyReference propertyReference)
{
if (propertyReference == null)
{
return((PropertyReference)null);
}
int num = -1;
for (int index = 0; index < propertyReference.Count; ++index)
{
if (PlatformTypes.Transform.IsAssignableFrom((ITypeId)propertyReference[index].PropertyType))
{
num = index;
break;
}
}
if (num == -1)
{
return((PropertyReference)null);
}
ReferenceStep compositeProperty = TransformPropertyLookup.GetCorrespondingCompositeProperty(propertyReference);
if (compositeProperty == null)
{
return((PropertyReference)null);
}
ReferenceStep[] steps = new ReferenceStep[num + 2];
for (int index = 0; index <= num; ++index)
{
steps[index] = propertyReference.ReferenceSteps[index];
}
steps[num + 1] = compositeProperty;
return(PropertyReference.CreateNewPropertyReferenceFromStepsWithoutCopy(steps));
}
internal static PropertyReference FilterProperty(ITypeResolver typeResolver, IType type, PropertyReference propertyReference)
{
ReferenceStep referenceStep = propertyReference[0];
ReferenceStep filteredStep = SceneNodeObjectSet.FilterProperty(typeResolver, type, referenceStep);
return(SceneNodeObjectSet.UpdatePropertyReference(propertyReference, referenceStep, filteredStep));
}
