public void PropertyReferenceConstructor_WithNoSlashes_ShouldOnlySetPropertyName()
{
const string fullPath = "X";
var target = new PropertyReference(fullPath);
Assert.AreEqual(string.Empty, target.Path);
Assert.AreEqual("X", target.PropertyName);
}
public void PropertyReferenceConstructor_WithTwoSlashes_ShouldSetPathAndPropertyName()
{
const string fullPath = "X/Y/Z";
var target = new PropertyReference(fullPath);
Assert.AreEqual("X/Y", target.Path);
Assert.AreEqual("Z", target.PropertyName);
}
void InjectPropertyGetterGuard(MethodBody getBody, SequencePoint seqPoint, PropertyReference property)
{
var guardInstructions = new List<Instruction>();
var returnPoints = getBody.Instructions
.Select((o, i) => new { o, i })
.Where(a => a.o.OpCode == OpCodes.Ret)
.Select(a => a.i)
.OrderByDescending(i => i);
foreach (var ret in returnPoints)
{
var returnInstruction = getBody.Instructions[ret];
var errorMessage = string.Format(CultureInfo.InvariantCulture, ReturnValueOfPropertyIsNull, property.FullName);
guardInstructions.Clear();
if (isDebug)
{
InstructionPatterns.DuplicateReturnValue(guardInstructions, property.PropertyType);
InstructionPatterns.CallDebugAssertInstructions(guardInstructions, errorMessage);
}
InstructionPatterns.DuplicateReturnValue(guardInstructions, property.PropertyType);
InstructionPatterns.IfNull(guardInstructions, returnInstruction, i =>
{
// Clean up the stack since we're about to throw up.
i.Add(Instruction.Create(OpCodes.Pop));
InstructionPatterns.LoadInvalidOperationException(i, errorMessage);
// Throw the top item off the stack
i.Add(Instruction.Create(OpCodes.Throw));
});
guardInstructions[0].HideLineFromDebugger(seqPoint);
getBody.Instructions.Insert(ret, guardInstructions);
}
}
public static DocumentNodePath ResolveNodePathForTemplateWithinExistingStyle(SceneElement targetElement, PropertyReference targetPropertyReference)
{
DocumentNodePath documentNodePath = ControlStylingOperations.ProvideStyleOrTemplateNodePath(targetElement, targetPropertyReference);
if (documentNodePath != null)
{
SceneView defaultView = targetElement.ViewModel.DefaultView;
ICollection <IViewObject> instantiatedElements = defaultView.GetInstantiatedElements(documentNodePath);
if (instantiatedElements.Count <= 0)
{
return(ControlStylingOperations.FindTemplateWithinStyle(documentNodePath, targetElement, ControlElement.TemplateProperty, (IPropertyId)targetPropertyReference[0]));
}
foreach (IViewObject viewObject in (IEnumerable <IViewObject>)instantiatedElements)
{
if (PlatformTypes.Control.IsAssignableFrom((ITypeId)viewObject.GetIType((ITypeResolver)targetElement.ProjectContext)))
{
object platformObject = viewObject.GetValue(targetElement.ProjectContext.ResolveProperty(ControlElement.TemplateProperty));
if (platformObject != null)
{
IViewObject instance = targetElement.ViewModel.ProjectContext.Platform.ViewObjectFactory.Instantiate(platformObject);
DocumentNodePath correspondingNodePath = defaultView.GetCorrespondingNodePath(instance, true);
if (correspondingNodePath != null && ControlStylingOperations.ShouldSetEditingContextToNodePath(correspondingNodePath, targetElement, targetPropertyReference[0]))
{
return(correspondingNodePath);
}
}
}
}
}
return((DocumentNodePath)null);
}
public static IEnumerable <Instruction> PushServiceProvider(this INode node, ILContext context, FieldReference bpRef = null, PropertyReference propertyRef = null, TypeReference declaringTypeReference = null)
{
var module = context.Body.Method.Module;
#if NOSERVICEPROVIDER
yield return(Instruction.Create(OpCodes.Ldnull));
yield break;
#endif
var ctorinfo = typeof(XamlServiceProvider).GetConstructor(new Type[] { });
var ctor = module.Import(ctorinfo);
var addServiceInfo = typeof(XamlServiceProvider).GetMethod("Add", new[] { typeof(Type), typeof(object) });
var addService = module.Import(addServiceInfo);
var getTypeFromHandle =
module.Import(typeof(Type).GetMethod("GetTypeFromHandle", new[] { typeof(RuntimeTypeHandle) }));
var getAssembly = module.Import(typeof(Type).GetProperty("Assembly").GetMethod);
yield return(Instruction.Create(OpCodes.Newobj, ctor));
//Add a SimpleValueTargetProvider
var pushParentIl = node.PushParentObjectsArray(context).ToList();
if (pushParentIl[pushParentIl.Count - 1].OpCode != OpCodes.Ldnull)
{
yield return(Instruction.Create(OpCodes.Dup)); //Keep the serviceProvider on the stack
yield return(Instruction.Create(OpCodes.Ldtoken, module.Import(typeof(IProvideValueTarget))));
yield return(Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle)));
foreach (var instruction in pushParentIl)
{
yield return(instruction);
}
foreach (var instruction in PushTargetProperty(bpRef, propertyRef, declaringTypeReference, module))
{
yield return(instruction);
}
var targetProviderCtor =
module.Import(typeof(SimpleValueTargetProvider).GetConstructor(new[] { typeof(object[]), typeof(object) }));
yield return(Instruction.Create(OpCodes.Newobj, targetProviderCtor));
yield return(Instruction.Create(OpCodes.Callvirt, addService));
}
//Add a NamescopeProvider
if (context.Scopes.ContainsKey(node))
{
yield return(Instruction.Create(OpCodes.Dup)); //Dupicate the serviceProvider
yield return(Instruction.Create(OpCodes.Ldtoken, module.Import(typeof(INameScopeProvider))));
yield return(Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle)));
var namescopeProviderCtor = module.Import(typeof(NameScopeProvider).GetConstructor(new Type[] { }));
yield return(Instruction.Create(OpCodes.Newobj, namescopeProviderCtor));
yield return(Instruction.Create(OpCodes.Dup)); //Duplicate the namescopeProvider
var setNamescope = module.Import(typeof(NameScopeProvider).GetProperty("NameScope").GetSetMethod());
yield return(Instruction.Create(OpCodes.Ldloc, context.Scopes[node]));
yield return(Instruction.Create(OpCodes.Callvirt, setNamescope));
yield return(Instruction.Create(OpCodes.Callvirt, addService));
}
//Add a XamlTypeResolver
if (node.NamespaceResolver != null)
{
yield return(Instruction.Create(OpCodes.Dup)); //Dupicate the serviceProvider
yield return(Instruction.Create(OpCodes.Ldtoken, module.Import(typeof(IXamlTypeResolver))));
yield return(Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle)));
var xmlNamespaceResolverCtor = module.Import(typeof(XmlNamespaceResolver).GetConstructor(new Type[] { }));
var addNamespace = module.Import(typeof(XmlNamespaceResolver).GetMethod("Add"));
yield return(Instruction.Create(OpCodes.Newobj, xmlNamespaceResolverCtor));
foreach (var kvp in node.NamespaceResolver.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml))
{
yield return(Instruction.Create(OpCodes.Dup)); //dup the resolver
yield return(Instruction.Create(OpCodes.Ldstr, kvp.Key));
yield return(Instruction.Create(OpCodes.Ldstr, kvp.Value));
yield return(Instruction.Create(OpCodes.Callvirt, addNamespace));
}
yield return(Instruction.Create(OpCodes.Ldtoken, context.Body.Method.DeclaringType));
yield return(Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle)));
yield return(Instruction.Create(OpCodes.Callvirt, getAssembly));
var xtr = module.Import(typeof(XamlTypeResolver)).Resolve();
var xamlTypeResolverCtor = module.Import(xtr.Methods.First(md => md.IsConstructor && md.Parameters.Count == 2));
yield return(Instruction.Create(OpCodes.Newobj, xamlTypeResolverCtor));
yield return(Instruction.Create(OpCodes.Callvirt, addService));
}
if (node is IXmlLineInfo)
{
yield return(Instruction.Create(OpCodes.Dup)); //Dupicate the serviceProvider
yield return(Instruction.Create(OpCodes.Ldtoken, module.Import(typeof(IXmlLineInfoProvider))));
yield return(Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle)));
foreach (var instruction in node.PushXmlLineInfo(context))
{
yield return(instruction);
}
var lip = module.Import(typeof(XmlLineInfoProvider)).Resolve();
var lineInfoProviderCtor = module.Import(lip.Methods.First(md => md.IsConstructor && md.Parameters.Count == 1));
yield return(Instruction.Create(OpCodes.Newobj, lineInfoProviderCtor));
yield return(Instruction.Create(OpCodes.Callvirt, addService));
}
}
protected override DocumentNodePath ProvideEditingContainer(SceneElement targetElement, PropertyReference targetProperty, DocumentNode resourceNode)
{
SceneViewModel viewModel = targetElement.ViewModel.GetViewModel(resourceNode.DocumentRoot, false);
DocumentNodePath documentNodePath = targetElement.GetLocalValueAsDocumentNode(targetProperty) ?? new DocumentNodePath(resourceNode.DocumentRoot.RootNode, resourceNode);
DocumentNode documentNode = (viewModel.GetSceneNode(resourceNode) as StyleNode).GetLocalValueAsSceneNode(ControlElement.TemplateProperty).DocumentNode;
return(documentNodePath.GetPathInContainer((DocumentNode)documentNode.Parent).GetPathInSubContainer(documentNode.SitePropertyKey, documentNode));
}
public KeyframeSceneNodeProperty(SceneNodeObjectSet objectSet, PropertyReference propertyReference, AttributeCollection attributes, Type proxyType)
: base(objectSet, propertyReference, attributes, (PropertyValue)null, proxyType)
{
}
static PropertyDefinition Find(this TypeReference declaringType, PropertyReference reference)
{
return(declaringType.Resolve().Properties
.FirstOrDefault(property => HasSameSignature(declaringType, property, reference.DeclaringType, reference.Resolve())));
}
public void AddPropertyReference(string referencedClass, string propertyName)
{
var upr = new PropertyReference {referencedClass = referencedClass, propertyName = propertyName};
propertyReferences.Add(upr);
}
public bool IsSet(PropertyReference propertyReference)
{
return(propertyReference.IsSet(this.viewObject));
}
internal void AddPropertyReference(string referencedClass, string propertyName)
{
PropertyReference upr = new PropertyReference();
upr.referencedClass = referencedClass;
upr.propertyName = propertyName;
propertyReferences.Add(upr);
}
protected MarkupPropertyBase( PropertyReference reference )
{
Reference = reference;
}
/// <summary>
/// Opens the array size field menu.
/// </summary>
void OpenArraySizeFieldMenu( Object targetObject, string targetPropertyPath, Vector3 mousePos )
{
PropertyReference propRef = new PropertyReference();
propRef.target = targetObject;
propRef.path = targetPropertyPath;
Rect menuRect = new Rect( mousePos.x, mousePos.y, 0, 0 );
EditorUtility.DisplayCustomMenu( menuRect, CreateArraySizeMenuContents(), -1, SelectArraySizeMenuCallback, propRef );
}
/// <summary>
/// Resolves a property reference declared in this assembly.
/// </summary>
/// <param name="propertyRef">The property reference to resolve.</param>
/// <returns>A property referred to by the reference.</returns>
public IProperty Resolve(PropertyReference propertyRef)
{
return(Resolver.Resolve(propertyRef, this));
}
public void ClearValue(PropertyReference propertyReference)
{
propertyReference.ClearValue(this.viewObject);
}
public override string ToString()
{
return(PropertyReference.ToString(this.mTarget, this.name));
}
public object GetBaseValue(PropertyReference propertyReference)
{
return(propertyReference.GetBaseValue(this.viewObject));
}
public static Transform ReplacePathGeometry(PathElement pathElement, PathGeometry pathGeometry, SceneEditTransaction editTransaction)
{
Transform transform1 = Transform.Identity;
using (pathElement.ViewModel.ForceBaseValue())
{
if (pathGeometry == null)
{
pathElement.ClearLocalValue(PathElement.DataProperty);
}
else
{
editTransaction.Update();
ILayoutDesigner designerForChild = pathElement.ViewModel.GetLayoutDesignerForChild((SceneElement)pathElement, true);
Rect childRect = designerForChild.GetChildRect((BaseFrameworkElement)pathElement);
Path path = pathElement.Path;
Transform transform2 = path == null ? (Transform)null : path.RenderTransform;
Point point1 = path == null ? new Point(0.0, 0.0) : path.RenderTransformOrigin;
double num = path == null || path.Stroke == null ? 0.0 : path.StrokeThickness;
Rect bounds = pathGeometry.Bounds;
PathGeometry pathGeometry1 = new PathGeometry();
pathGeometry1.AddGeometry((System.Windows.Media.Geometry)pathGeometry);
Rect rect1 = PathCommandHelper.InflateRectByStrokeWidth(pathGeometry1.Bounds, pathElement, false);
Vector vector1 = new Vector(-rect1.Left, -rect1.Top);
transform1 = (Transform) new TranslateTransform(vector1.X, vector1.Y);
PathGeometry pathGeometry2 = PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry)pathGeometry1, transform1);
pathElement.PathGeometry = pathGeometry2;
PropertyReference propertyReference = PathCommandHelper.GetPathDataPropertyReference(pathElement.Platform);
PathCommandHelper.TransformPointKeyframes((SceneElement)pathElement, propertyReference, transform1);
if (!bounds.IsEmpty)
{
bounds.Inflate(num / 2.0, num / 2.0);
Rect rect2 = new Rect(childRect.Left + bounds.Left, childRect.Top + bounds.Top, bounds.Width, bounds.Height);
editTransaction.Update();
designerForChild.SetChildRect((BaseFrameworkElement)pathElement, rect2);
if (pathElement.IsSet(Base2DElement.RenderTransformOriginProperty) != PropertyState.Set)
{
if (transform2 != null)
{
if (transform2.Value.IsIdentity)
{
goto label_15;
}
}
else
{
goto label_15;
}
}
Vector vector2 = childRect.TopLeft + new Vector(point1.X * childRect.Width, point1.Y * childRect.Height) - rect2.TopLeft;
Point point2 = new Point(0.0, 0.0);
if (rect2.Width != 0.0)
{
point2.X = vector2.X / rect2.Width;
}
if (rect2.Height != 0.0)
{
point2.Y = vector2.Y / rect2.Height;
}
pathElement.RenderTransformOrigin = point2;
}
}
}
label_15:
return(transform1);
}
/************************************************************************************************************************/
/// <summary>Returns true if the `reference` and <see cref="PropertyReference.Property"/> are not null.</summary>
public static bool IsValid(this PropertyReference reference) => reference?.Property != null;
private static void FixPropertyNaming(PropertyReference property)
{
FixNaming(property, t => t.Name, (t, name) => t.Name = name,
TypeNameToMemberPrefix(property.PropertyType.GetElementType().Name));
}
protected virtual void NotifyPropertyReferenceChanged(PropertyReference propertyReference)
{
}
public bool HasProperty(PropertyReference propRef)
{
return(assembly.FullName == propRef.Resolve().Module.Assembly.FullName);
}
private void UpdateBrushForMappingModeChange(PropertyReference brushPropertyReference, BrushMappingMode mappingMode)
{
GradientBrush gradientBrush = this.GetComputedValueAsWpf(brushPropertyReference) as GradientBrush;
if (gradientBrush == null || gradientBrush.MappingMode == mappingMode)
{
return;
}
Rect computedTightBounds = this.GetComputedTightBounds();
if (computedTightBounds.IsEmpty)
{
return;
}
Matrix identity = Matrix.Identity;
Matrix matrix = Matrix.Identity;
if (BrushAdorner.IsAdorningFillProperty((SceneElement)this))
{
matrix = BrushAdorner.GetStrokeTransform((SceneElement)this);
}
if (mappingMode == BrushMappingMode.Absolute)
{
identity *= matrix;
identity.Scale(computedTightBounds.Width, computedTightBounds.Height);
identity.Translate(computedTightBounds.X, computedTightBounds.Y);
}
else if (mappingMode == BrushMappingMode.RelativeToBoundingBox)
{
identity.Translate(-computedTightBounds.X, -computedTightBounds.Y);
identity.Scale(computedTightBounds.Width == 0.0 ? 1.0 : 1.0 / computedTightBounds.Width, computedTightBounds.Height == 0.0 ? 1.0 : 1.0 / computedTightBounds.Height);
matrix.Invert();
identity *= matrix;
}
if (identity.IsIdentity)
{
return;
}
LinearGradientBrush linearGradientBrush;
if ((linearGradientBrush = gradientBrush as LinearGradientBrush) != null)
{
Point point1 = RoundingHelper.RoundPosition(linearGradientBrush.StartPoint * identity);
Point point2 = RoundingHelper.RoundPosition(linearGradientBrush.EndPoint * identity);
this.SetValueAsWpf(brushPropertyReference.Append(LinearGradientBrushNode.StartPointProperty), (object)point1);
this.SetValueAsWpf(brushPropertyReference.Append(LinearGradientBrushNode.EndPointProperty), (object)point2);
}
else
{
RadialGradientBrush radialGradientBrush;
if ((radialGradientBrush = gradientBrush as RadialGradientBrush) == null)
{
return;
}
Point point1 = RoundingHelper.RoundPosition(radialGradientBrush.Center * identity);
Point point2 = RoundingHelper.RoundPosition(radialGradientBrush.GradientOrigin * identity);
double num1 = RoundingHelper.RoundLength(radialGradientBrush.RadiusX * identity.M11);
double num2 = RoundingHelper.RoundLength(radialGradientBrush.RadiusY * identity.M22);
this.SetValueAsWpf(brushPropertyReference.Append(RadialGradientBrushNode.CenterProperty), (object)point1);
this.SetValueAsWpf(brushPropertyReference.Append(RadialGradientBrushNode.GradientOriginProperty), (object)point2);
this.SetValue(brushPropertyReference.Append(RadialGradientBrushNode.RadiusXProperty), (object)num1);
this.SetValue(brushPropertyReference.Append(RadialGradientBrushNode.RadiusYProperty), (object)num2);
}
}
protected override DocumentNodePath ProvideEditingContainer(SceneElement targetElement, PropertyReference targetProperty, DocumentNode resourceNode)
{
return(ControlStylingOperations.ResolveNodePathForTemplateWithinExistingStyle(targetElement, targetProperty) ?? base.ProvideEditingContainer(targetElement, targetProperty, resourceNode));
}
public KeyFrameAnimationSceneNode InstantiateWithTarget(SceneViewModel viewModel, SceneNode targetElement, PropertyReference targetProperty, IStoryboardContainer referenceStoryboardContainer, ITypeId type)
{
return((KeyFrameAnimationSceneNode)base.InstantiateWithTarget(viewModel, targetElement, targetProperty, referenceStoryboardContainer, type));
}
public static PropertyReference PropertyReferenceFromVisual3D(Base3DElement item, PropertyReference propertyReference)
{
for (Base3DElement base3Delement = item.ParentElement as Base3DElement; base3Delement != null; base3Delement = item.ParentElement as Base3DElement)
{
if (base3Delement is ModelVisual3DElement)
{
if (item is Model3DElement)
{
propertyReference = new PropertyReference((ReferenceStep)item.ProjectContext.ResolveProperty(ModelVisual3DElement.ContentProperty)).Append(propertyReference);
break;
}
break;
}
if (base3Delement is ModelUIElement3DElement)
{
if (item is Model3DElement)
{
propertyReference = new PropertyReference((ReferenceStep)item.ProjectContext.ResolveProperty(ModelUIElement3DElement.ModelProperty)).Append(propertyReference);
break;
}
break;
}
int siteChildIndex = item.DocumentNode.SiteChildIndex;
PropertyReference propertyReference1 = new PropertyReference((ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((ITypeResolver)item.ProjectContext, typeof(Model3DCollection), siteChildIndex));
propertyReference = new PropertyReference((ReferenceStep)item.ProjectContext.ResolveProperty(Model3DGroupElement.ChildrenProperty)).Append(propertyReference1).Append(propertyReference);
item = base3Delement;
}
return(propertyReference);
}
public void ReverseKeyFrames(double startTime, double endTime)
{
if (this.KeyFrameCount == 0)
{
return;
}
this.ConvertKeySplineResourcesToLocalValues();
int capacity = 0;
IList <KeyFrameSceneNode> keyFrameCollection = this.KeyFrameCollection;
int index1 = 0;
while (index1 < keyFrameCollection.Count && keyFrameCollection[index1].Time < startTime)
{
++index1;
}
int index2 = index1;
for (; index1 < keyFrameCollection.Count && keyFrameCollection[index1].Time <= endTime; ++index1)
{
++capacity;
}
if (capacity == 0)
{
return;
}
bool flag = startTime == 0.0 && keyFrameCollection[0].Time != 0.0;
if (flag)
{
++capacity;
}
List <KeyFrameSceneNode> list1 = new List <KeyFrameSceneNode>(capacity);
List <Point?> list2 = new List <Point?>(capacity);
if (flag)
{
KeyFrameSceneNode keyFrameSceneNode = this.IsDiscreteOnly ? (KeyFrameSceneNode)KeyFrameSceneNode.Factory.Instantiate(this.ViewModel, this.GetKeyFrameType(KeyFrameInterpolationType.Discrete)) : (KeyFrameSceneNode)KeyFrameSceneNode.Factory.Instantiate(this.ViewModel, this.GetKeyFrameType(KeyFrameInterpolationType.Spline));
keyFrameSceneNode.Time = 0.0;
SceneElement sceneElement = this.TargetElement as SceneElement;
IViewObject viewObject = sceneElement.ViewTargetElement;
if (PlatformTypes.Viewport3D.Equals((object)viewObject.GetIType((ITypeResolver)this.ProjectContext)))
{
viewObject = sceneElement.ViewObject;
}
PropertyReference propertyReference = DesignTimeProperties.GetAppliedShadowPropertyReference(this.TargetProperty, (ITypeId)this.Type);
keyFrameSceneNode.Value = viewObject.GetBaseValue(propertyReference);
list1.Add(keyFrameSceneNode);
if (keyFrameCollection[0].InterpolationType == KeyFrameInterpolationType.Spline && keyFrameCollection[0].KeySpline != null)
{
list2.Add(new Point?(keyFrameCollection[0].KeySpline.ControlPoint1));
}
else if (!this.IsDiscreteOnly)
{
list2.Add(new Point?(new Point()));
}
else
{
list2.Add(new Point?());
}
}
int num1 = 0;
while (list1.Count < capacity)
{
if (keyFrameCollection[index2].InterpolationType != KeyFrameInterpolationType.Discrete)
{
list2.Add(new Point?(keyFrameCollection[index2].EaseOutControlPoint));
}
else
{
list2.Add(new Point?());
}
list1.Add(keyFrameCollection[index2]);
keyFrameCollection.RemoveAt(index2);
++num1;
}
for (int index3 = 0; index3 < list1.Count; ++index3)
{
KeyFrameSceneNode keyFrameSceneNode1 = list1[index3];
Point? nullable1 = list2[index3];
Point? nullable2 = new Point?();
if (keyFrameSceneNode1.InterpolationType != KeyFrameInterpolationType.Discrete)
{
nullable2 = new Point?(keyFrameSceneNode1.EaseInControlPoint);
}
double num2 = endTime - (keyFrameSceneNode1.Time - startTime);
KeyFrameSceneNode node;
if (nullable1.HasValue)
{
KeyFrameSceneNode keyFrameSceneNode2 = (KeyFrameSceneNode)KeyFrameSceneNode.Factory.Instantiate(this.ViewModel, this.GetKeyFrameType(KeyFrameInterpolationType.Spline));
keyFrameSceneNode2.ValueNode = keyFrameSceneNode1.ValueNode.Clone(keyFrameSceneNode2.DocumentContext);
node = keyFrameSceneNode2;
node.EaseInControlPoint = new Point(1.0 - nullable1.Value.X, 1.0 - nullable1.Value.Y);
}
else
{
KeyFrameSceneNode keyFrameSceneNode2 = (KeyFrameSceneNode)KeyFrameSceneNode.Factory.Instantiate(this.ViewModel, this.GetKeyFrameType(KeyFrameInterpolationType.Discrete));
keyFrameSceneNode2.ValueNode = keyFrameSceneNode1.ValueNode.Clone(keyFrameSceneNode2.DocumentContext);
node = keyFrameSceneNode2;
}
node.Time = num2;
keyFrameCollection.Insert(index2, node);
if (nullable2.HasValue)
{
Point newEaseOut = new Point(1.0 - nullable2.Value.X, 1.0 - nullable2.Value.Y);
KeyFrameSceneNode.SetEaseOutControlPoint(node, newEaseOut);
}
}
if (!flag)
{
return;
}
Point?nullable = new Point?(keyFrameCollection[0].EaseOutControlPoint);
if (nullable.HasValue)
{
this.SetHandoffKeyFrameEaseOutPoint(nullable.Value);
}
this.RemoveKeyFrame(0.0);
}
public static DocumentNodePath ProvideStyleOrTemplateNodePath(SceneElement targetElement, PropertyReference targetPropertyReference)
{
DocumentNodePath documentNodePath = (DocumentNodePath)null;
ReferenceStep targetProperty = targetPropertyReference[0];
StyleNode styleNode = targetElement as StyleNode;
if (targetPropertyReference.TargetType.IsAssignableFrom(targetElement.TargetType) || styleNode != null && targetPropertyReference.TargetType.IsAssignableFrom(styleNode.StyleTargetType))
{
IViewObjectFactory viewObjectFactory = targetElement.Platform.ViewObjectFactory;
object computedValue = targetElement.GetComputedValue(targetPropertyReference);
DocumentNodePath valuePath = (DocumentNodePath)null;
if (computedValue != null)
{
IViewObject instance = viewObjectFactory.Instantiate(computedValue);
valuePath = targetElement.ViewModel.DefaultView.GetCorrespondingNodePath(instance, true);
}
if (valuePath == null && !BaseFrameworkElement.StyleProperty.Equals((object)targetProperty))
{
BaseFrameworkElement frameworkElement = targetElement as BaseFrameworkElement;
if (frameworkElement != null)
{
frameworkElement.FindMissingImplicitStyle();
}
if (computedValue != null)
{
IViewObject instance = viewObjectFactory.Instantiate(computedValue);
DocumentNodePath correspondingNodePath = targetElement.ViewModel.DefaultView.GetCorrespondingNodePath(instance, true);
if (correspondingNodePath != null)
{
valuePath = ControlStylingOperations.FindTemplateWithinStyle(correspondingNodePath, targetElement, (IPropertyId)targetProperty, (IPropertyId)targetProperty);
}
}
}
if (ControlStylingOperations.ShouldSetEditingContextToNodePath(valuePath, targetElement, targetProperty))
{
documentNodePath = valuePath;
}
}
if (documentNodePath == null && styleNode != null && targetElement.IsSet(targetPropertyReference) == PropertyState.Set)
{
DocumentNodePath valueAsDocumentNode = targetElement.GetLocalValueAsDocumentNode(targetPropertyReference);
if (ControlStylingOperations.ShouldSetEditingContextToNodePath(valueAsDocumentNode, targetElement, targetProperty))
{
documentNodePath = valueAsDocumentNode;
}
}
return(documentNodePath);
}
protected override string GetPropertyName(PropertyReference property)
{
return((writerContext == null || writerContext.ModuleContext.Module == null) ? property.Name : base.GetPropertyName(property));
}
public override void OnInspectorGUI()
{
PropertyBinding pb = target as PropertyBinding;
NGUIEditorTools.SetLabelWidth(80f);
serializedObject.Update();
if (pb.direction == PropertyBinding.Direction.TargetUpdatesSource && pb.target != null)
{
PropertyReferenceDrawer.filter = pb.target.GetPropertyType();
}
GUILayout.Space(3f);
PropertyBinding.Direction dir = (target as PropertyBinding).direction;
PropertyReferenceDrawer.mustRead = (dir == PropertyBinding.Direction.SourceUpdatesTarget ||
dir == PropertyBinding.Direction.BiDirectional);
PropertyReferenceDrawer.mustWrite = (dir == PropertyBinding.Direction.TargetUpdatesSource ||
dir == PropertyBinding.Direction.BiDirectional);
NGUIEditorTools.DrawProperty(serializedObject, "source");
if (pb.direction == PropertyBinding.Direction.SourceUpdatesTarget && pb.source != null)
{
PropertyReferenceDrawer.filter = pb.source.GetPropertyType();
}
if (pb.source.target != null)
{
GUILayout.Space(-18f);
if (pb.direction == PropertyBinding.Direction.TargetUpdatesSource)
{
GUILayout.Label(" \u25B2"); // Up
}
else if (pb.direction == PropertyBinding.Direction.SourceUpdatesTarget)
{
GUILayout.Label(" \u25BC"); // Down
}
else
{
GUILayout.Label(" \u25B2\u25BC");
}
}
GUILayout.Space(1f);
PropertyReferenceDrawer.mustRead = (dir == PropertyBinding.Direction.TargetUpdatesSource ||
dir == PropertyBinding.Direction.BiDirectional);
PropertyReferenceDrawer.mustWrite = (dir == PropertyBinding.Direction.SourceUpdatesTarget ||
dir == PropertyBinding.Direction.BiDirectional);
NGUIEditorTools.DrawProperty(serializedObject, "target");
PropertyReferenceDrawer.mustRead = false;
PropertyReferenceDrawer.mustWrite = false;
PropertyReferenceDrawer.filter = typeof(void);
GUILayout.Space(1f);
NGUIEditorTools.DrawPaddedProperty(serializedObject, "direction");
NGUIEditorTools.DrawPaddedProperty(serializedObject, "update");
GUILayout.BeginHorizontal();
NGUIEditorTools.DrawProperty(" ", serializedObject, "editMode", GUILayout.Width(100f));
GUILayout.Label("Update in Edit Mode");
GUILayout.EndHorizontal();
if (!serializedObject.isEditingMultipleObjects)
{
if (pb.source != null && pb.target != null && pb.source.GetPropertyType() != pb.target.GetPropertyType())
{
if (pb.direction == PropertyBinding.Direction.BiDirectional)
{
EditorGUILayout.HelpBox("Bi-Directional updates require both Source and Target to reference values of the same type.", MessageType.Error);
}
else if (pb.direction == PropertyBinding.Direction.SourceUpdatesTarget)
{
if (!PropertyReference.Convert(pb.source.Get(), pb.target.GetPropertyType()))
{
EditorGUILayout.HelpBox("Unable to convert " + pb.source.GetPropertyType() + " to " + pb.target.GetPropertyType(), MessageType.Error);
}
}
else if (!PropertyReference.Convert(pb.target.Get(), pb.source.GetPropertyType()))
{
EditorGUILayout.HelpBox("Unable to convert " + pb.target.GetPropertyType() + " to " + pb.source.GetPropertyType(), MessageType.Error);
}
}
}
serializedObject.ApplyModifiedProperties();
}
public static PropertyInfo ResolveReflection(this PropertyReference mref) => _ResolveReflection(mref, null) as PropertyInfo;
public PropertyReferenceProperty CreateProperty(string propertyPath, AttributeCollection attributes)
{
if (this.activeObjectSet == null || this.activePropertyCache == null)
{
return((PropertyReferenceProperty)null);
}
if (this.platformSupportsCompositeTransform && this.TransformType.Equals((object)TransformType.Transform2D))
{
string str = string.Empty;
propertyPath = !TransformPropertyLookup.TranformGroupPathToCompositePathMap.TryGetValue(propertyPath, out str) ? "CompositeTransform." + propertyPath : str;
}
else if (this.Relative)
{
switch (this.TransformType)
{
case TransformType.Transform2D:
propertyPath = "CanonicalTransform." + propertyPath;
break;
case TransformType.Transform3D:
propertyPath = "CanonicalTransform3D." + propertyPath;
break;
}
}
else
{
switch (this.TransformType)
{
case TransformType.Transform2D:
if (propertyPath.Equals("CenterX") || propertyPath.Equals("CenterY"))
{
return((PropertyReferenceProperty)this.BuildCenterTransformPropertyReference(propertyPath, attributes));
}
propertyPath = this.BuildExpandedPropertyPath2D(propertyPath);
break;
case TransformType.Transform3D:
propertyPath = this.BuildExpandedPropertyPath3D(propertyPath);
break;
}
}
PropertyReferenceProperty referenceProperty = (PropertyReferenceProperty)null;
if (this.activePropertyCache.TryGetValue(propertyPath, out referenceProperty))
{
return(referenceProperty);
}
PropertyReference propertyReference = (PropertyReference)null;
try
{
propertyReference = new PropertyReference((ITypeResolver)this.sceneNodeObjectSet.ProjectContext, propertyPath);
}
catch (Exception ex)
{
}
if (propertyReference != null)
{
if (!this.relative)
{
referenceProperty = (PropertyReferenceProperty) new TransformSceneNodeProperty((SceneNodeObjectSet)this.activeObjectSet, this.transformProperty.Reference.Append(propertyReference), attributes);
referenceProperty.Recache();
}
else
{
referenceProperty = this.activeObjectSet.CreateProperty(propertyReference, attributes);
}
}
if (referenceProperty != null)
{
this.activePropertyCache[propertyPath] = referenceProperty;
}
return(referenceProperty);
}
///--------------------------------------------------------------------------------
/// <summary>Interpret this node to produce code, output, or model data..</summary>
///
/// <param name="interpreterType">The type of interpretation to perform.</param>
/// <param name="solutionContext">The associated solution.</param>
/// <param name="templateContext">The associated template.</param>
/// <param name="modelContext">The associated model context.</param>
///--------------------------------------------------------------------------------
public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext)
{
try
{
if (CurrentItem != null)
{
if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentAuditProperty))
{
if (solutionContext.CurrentAuditProperty != null)
{
AuditProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- AuditProperty: ").Append(solutionContext.CurrentAuditProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentCollection))
{
if (solutionContext.CurrentCollection != null)
{
Collection.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Collection: ").Append(solutionContext.CurrentCollection.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEntity))
{
if (solutionContext.CurrentEntity != null)
{
Entity.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Entity: ").Append(solutionContext.CurrentEntity.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEntityReference))
{
if (solutionContext.CurrentEntityReference != null)
{
EntityReference.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- EntityReference: ").Append(solutionContext.CurrentEntityReference.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEnumeration))
{
if (solutionContext.CurrentEnumeration != null)
{
Enumeration.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Enumeration: ").Append(solutionContext.CurrentEnumeration.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentFeature))
{
if (solutionContext.CurrentFeature != null)
{
Feature.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Feature: ").Append(solutionContext.CurrentFeature.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentIndex))
{
if (solutionContext.CurrentIndex != null)
{
Index.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Index: ").Append(solutionContext.CurrentIndex.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentIndexProperty))
{
if (solutionContext.CurrentIndexProperty != null)
{
IndexProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- IndexProperty: ").Append(solutionContext.CurrentIndexProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentMethod))
{
if (solutionContext.CurrentMethod != null)
{
Method.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Method: ").Append(solutionContext.CurrentMethod.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentMethodRelationship))
{
if (solutionContext.CurrentMethodRelationship != null)
{
MethodRelationship.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- MethodRelationship: ").Append(solutionContext.CurrentMethodRelationship.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModel))
{
if (solutionContext.CurrentModel != null)
{
Model.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Model: ").Append(solutionContext.CurrentModel.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModelObject))
{
if (solutionContext.CurrentModelObject != null)
{
ModelObject.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- ModelObject: ").Append(solutionContext.CurrentModelObject.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModelProperty))
{
if (solutionContext.CurrentModelProperty != null)
{
ModelProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- ModelProperty: ").Append(solutionContext.CurrentModelProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentObjectInstance))
{
if (solutionContext.CurrentObjectInstance != null)
{
ObjectInstance.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- ObjectInstance: ").Append(solutionContext.CurrentObjectInstance.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentParameter))
{
if (solutionContext.CurrentParameter != null)
{
Parameter.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Parameter: ").Append(solutionContext.CurrentParameter.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentProject))
{
if (solutionContext.CurrentProject != null)
{
Project.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Project: ").Append(solutionContext.CurrentProject.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentProperty))
{
if (solutionContext.CurrentProperty != null)
{
Property.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Property: ").Append(solutionContext.CurrentProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyInstance))
{
if (solutionContext.CurrentPropertyInstance != null)
{
PropertyInstance.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- PropertyInstance: ").Append(solutionContext.CurrentPropertyInstance.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyReference))
{
if (solutionContext.CurrentPropertyReference != null)
{
PropertyReference.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- PropertyReference: ").Append(solutionContext.CurrentPropertyReference.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyRelationship))
{
if (solutionContext.CurrentPropertyRelationship != null)
{
PropertyRelationship.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- PropertyRelationship: ").Append(solutionContext.CurrentPropertyRelationship.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentRelationship))
{
if (solutionContext.CurrentRelationship != null)
{
Relationship.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Relationship: ").Append(solutionContext.CurrentRelationship.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentRelationshipProperty))
{
if (solutionContext.CurrentRelationshipProperty != null)
{
RelationshipProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- RelationshipProperty: ").Append(solutionContext.CurrentRelationshipProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStage))
{
if (solutionContext.CurrentStage != null)
{
Stage.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Stage: ").Append(solutionContext.CurrentStage.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStageTransition))
{
if (solutionContext.CurrentStageTransition != null)
{
StageTransition.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- StageTransition: ").Append(solutionContext.CurrentStageTransition.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentState))
{
if (solutionContext.CurrentState != null)
{
State.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- State: ").Append(solutionContext.CurrentState.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStateModel))
{
if (solutionContext.CurrentStateModel != null)
{
StateModel.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- StateModel: ").Append(solutionContext.CurrentStateModel.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStateTransition))
{
if (solutionContext.CurrentStateTransition != null)
{
StateTransition.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- StateTransition: ").Append(solutionContext.CurrentStateTransition.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStep))
{
if (solutionContext.CurrentStep != null)
{
Step.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Step: ").Append(solutionContext.CurrentStep.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStepTransition))
{
if (solutionContext.CurrentStepTransition != null)
{
StepTransition.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- StepTransition: ").Append(solutionContext.CurrentStepTransition.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentValue))
{
if (solutionContext.CurrentValue != null)
{
Value.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Value: ").Append(solutionContext.CurrentValue.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentView))
{
if (solutionContext.CurrentView != null)
{
View.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- View: ").Append(solutionContext.CurrentView.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentViewProperty))
{
if (solutionContext.CurrentViewProperty != null)
{
ViewProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- ViewProperty: ").Append(solutionContext.CurrentViewProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentWorkflow))
{
if (solutionContext.CurrentWorkflow != null)
{
Workflow.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Workflow: ").Append(solutionContext.CurrentWorkflow.InnerXmlData);
}
}
}
#region protected
#endregion protected
else
{
LogException(solutionContext, templateContext, modelContext, String.Format(DisplayValues.Exception_CouldNotDeleteItem, CurrentItem.CurrentItemName), interpreterType);
}
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (System.Exception ex)
{
LogException(solutionContext, templateContext, modelContext, ex, interpreterType);
}
}
public static bool Convert(Type from, Type to)
{
object obj = null;
return(PropertyReference.Convert(ref obj, from, to));
}
public HavingClause(PropertyReference prop, Comparison comp, object literal)
: base(prop, comp, literal)
{
}
/// <summary>
/// Collect a list of usable properties and fields.
/// </summary>
static public List <Entry> GetProperties(GameObject target, bool read, bool write)
{
Component[] comps = target.GetComponents <Component>();
List <Entry> list = new List <Entry>();
for (int i = 0, imax = comps.Length; i < imax; ++i)
{
Component comp = comps[i];
if (comp == null)
{
continue;
}
Type type = comp.GetType();
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public;
FieldInfo[] fields = type.GetFields(flags);
PropertyInfo[] props = type.GetProperties(flags);
// The component itself without any method
if (PropertyReference.Convert(comp, filter))
{
Entry ent = new Entry();
ent.target = comp;
list.Add(ent);
}
for (int b = 0; b < fields.Length; ++b)
{
FieldInfo field = fields[b];
if (filter != typeof(void))
{
if (canConvert)
{
if (!PropertyReference.Convert(field.FieldType, filter))
{
continue;
}
}
else if (!filter.IsAssignableFrom(field.FieldType))
{
continue;
}
}
Entry ent = new Entry();
ent.target = comp;
ent.name = field.Name;
list.Add(ent);
}
for (int b = 0; b < props.Length; ++b)
{
PropertyInfo prop = props[b];
if (read && !prop.CanRead)
{
continue;
}
if (write && !prop.CanWrite)
{
continue;
}
if (filter != typeof(void))
{
if (canConvert)
{
if (!PropertyReference.Convert(prop.PropertyType, filter))
{
continue;
}
}
else if (!filter.IsAssignableFrom(prop.PropertyType))
{
continue;
}
}
Entry ent = new Entry();
ent.target = comp;
ent.name = prop.Name;
list.Add(ent);
}
}
return(list);
}
public DataContextProperty(DocumentCompositeNode sourceNode, IProperty property, bool isCollectionItem, PropertyReference ancestorPath)
{
this.SourceNode = sourceNode;
this.Property = property;
this.IsCollectionItem = isCollectionItem;
this.AncestorPath = ancestorPath;
this.IsValid = true;
}
private static void TransferPathFigureAnimations(PathElement oldElement, PathElement newElement, PropertyReference pathProperty, int oldFigureIndex, int newFigureIndex, Transform transform)
{
PathAnimationMovePackage animationMove = new PathAnimationMovePackage();
PathCommandHelper.TransferPathFigureAnimations(oldElement, newElement, pathProperty, oldFigureIndex, newFigureIndex, transform, animationMove);
animationMove.AddAndRemove();
}
public WhereClause(BooleanOperand boolOp, PropertyReference prop, Comparison comp, object literal)
: base(prop, comp, literal)
{
BooleanOperand = boolOp;
}
