internal void AddTriggerNode()
{
Type newClrObject = ClrNewObjectDialog.CreateNewClrObject(this.sceneViewModel, this.sceneViewModel.ProjectContext.ResolveType(ProjectNeutralTypes.BehaviorTriggerBase).RuntimeType, true);
if (!(newClrObject != (Type)null))
{
return;
}
using (SceneEditTransaction editTransaction = this.sceneViewModel.CreateEditTransaction(StringTable.AddBehaviorCommandTriggerUndo))
{
BehaviorTriggerBaseNode behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)this.sceneViewModel.CreateSceneNode(newClrObject);
InvokeCommandActionNode commandActionNode = (InvokeCommandActionNode)this.sceneViewModel.CreateSceneNode(ProjectNeutralTypes.InvokeCommandAction);
commandActionNode.CommandName = this.CategoryName;
behaviorTriggerBaseNode.Actions.Add((SceneNode)commandActionNode);
if (ProjectNeutralTypes.BehaviorEventTriggerBase.IsAssignableFrom((ITypeId)behaviorTriggerBaseNode.Type))
{
SceneNode sceneNode = (SceneNode)this.behaviorNode;
while (sceneNode != null && !(sceneNode is SceneElement))
{
sceneNode = sceneNode.Parent;
}
if (sceneNode != null)
{
sceneNode.EnsureNamed();
((BehaviorEventTriggerBaseNode)behaviorTriggerBaseNode).SourceName = sceneNode.Name;
}
}
this.behaviorNode.GetCollectionForProperty(BehaviorHelper.BehaviorTriggersProperty).Add((SceneNode)behaviorTriggerBaseNode);
editTransaction.Commit();
}
this.Rebuild();
this.TriggerNodeView.MoveCurrentToLast();
}
public static void CopyBehaviorNodes(SceneViewModel viewModel, IList <BehaviorBaseNode> behaviorNodes)
{
PastePackage pastePackage = new PastePackage(viewModel);
using (viewModel.ForceBaseValue())
{
foreach (SceneNode childPropertyNode in (IEnumerable <BehaviorBaseNode>)behaviorNodes)
{
if (ProjectNeutralTypes.Behavior.IsAssignableFrom((ITypeId)childPropertyNode.Type))
{
pastePackage.AddChildPropertyNode(childPropertyNode);
}
else
{
BehaviorTriggerActionNode triggerActionNode1 = (BehaviorTriggerActionNode)childPropertyNode;
BehaviorTriggerBaseNode behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)triggerActionNode1.Parent;
if (behaviorTriggerBaseNode.Actions.Count > 1)
{
DocumentNode node1 = triggerActionNode1.DocumentNode.Clone(viewModel.Document.DocumentContext);
BehaviorTriggerActionNode triggerActionNode2 = (BehaviorTriggerActionNode)viewModel.GetSceneNode(node1);
DocumentNode node2 = behaviorTriggerBaseNode.DocumentNode.Clone(viewModel.Document.DocumentContext);
behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)viewModel.GetSceneNode(node2);
behaviorTriggerBaseNode.Actions.Clear();
behaviorTriggerBaseNode.Actions.Add((SceneNode)triggerActionNode2);
}
pastePackage.AddChildPropertyNode((SceneNode)behaviorTriggerBaseNode);
}
}
}
pastePackage.SendToClipboard();
}
private void Canonicalize()
{
bool flag = false;
if (this.conditions.Count == 0)
{
this.conditionBehaviorNode.Remove();
flag = true;
}
if (this.behaviorTriggerBaseNode.GetCollectionForProperty(BehaviorHelper.BehaviorsProperty).Count == 0)
{
this.behaviorTriggerBaseNode.ClearLocalValue(BehaviorHelper.BehaviorsProperty);
BehaviorTriggerBaseNode matchingDocumentNode = this.objectSet.FindExistingTriggerMatchingDocumentNode(this.behaviorTriggerBaseNode.DocumentNode);
if (matchingDocumentNode != null)
{
this.objectSet.ReparentActionAndCopyBehaviors(matchingDocumentNode);
this.behaviorTriggerBaseNode = matchingDocumentNode;
this.keepPanelOpened = true;
}
}
if (!flag)
{
return;
}
this.CleanConditionBehaviorReferences();
}
public static SceneNode CreateTrigger(SceneNode targetNode, IType triggerType)
{
ProjectContext projectContext = ProjectContext.GetProjectContext(targetNode.ProjectContext);
BehaviorHelper.EnsureSystemWindowsInteractivityReferenced((ITypeResolver)projectContext);
targetNode.DesignerContext.ViewUpdateManager.RebuildPostponedViews();
using (SceneEditTransaction editTransaction = targetNode.ViewModel.CreateEditTransaction(StringTable.CreateTriggerActionUndoString))
{
SceneNode sceneNode1 = targetNode;
ISceneNodeCollection <SceneNode> collectionForProperty = sceneNode1.GetCollectionForProperty(BehaviorHelper.BehaviorTriggersProperty);
BehaviorTriggerBaseNode behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)null;
SceneViewModel viewModel = targetNode.ViewModel;
object triggerAttribute = BehaviorHelper.CreateTriggerFromDefaultTriggerAttribute((IEnumerable)TypeUtilities.GetAttributes(triggerType.RuntimeType), targetNode.TargetType);
if (triggerAttribute != null)
{
behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)viewModel.CreateSceneNode(triggerAttribute);
}
if (behaviorTriggerBaseNode == null)
{
BehaviorEventTriggerNode eventTriggerNode = (BehaviorEventTriggerNode)sceneNode1.ViewModel.CreateSceneNode(ProjectNeutralTypes.BehaviorEventTrigger);
string result;
if (!PlatformNeutralAttributeHelper.TryGetAttributeValue <string>(targetNode.TargetType, PlatformTypes.DefaultEventAttribute, "Name", out result))
{
result = "Loaded";
}
eventTriggerNode.EventName = result;
behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)eventTriggerNode;
}
bool flag = false;
viewModel.BehaviorSelectionSet.Clear();
foreach (SceneNode sceneNode2 in (IEnumerable <SceneNode>)collectionForProperty)
{
if (BehaviorHelper.CompareTriggerNodes(behaviorTriggerBaseNode.DocumentNode as DocumentCompositeNode, sceneNode2.DocumentNode as DocumentCompositeNode))
{
behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)sceneNode2;
flag = true;
break;
}
}
if (!flag)
{
collectionForProperty.Add((SceneNode)behaviorTriggerBaseNode);
}
BehaviorTriggerActionNode triggerActionNode = (BehaviorTriggerActionNode)sceneNode1.ViewModel.CreateSceneNode((ITypeId)triggerType);
if (projectContext.IsCapabilitySet(PlatformCapability.SupportsAttachingToRootElements) && ProjectNeutralTypes.BehaviorTargetedTriggerAction.IsAssignableFrom((ITypeId)triggerActionNode.Type) && targetNode.ViewModel.ActiveEditingContainer.Equals((object)targetNode))
{
IProperty property = projectContext.ResolveProperty(BehaviorTargetedTriggerActionNode.BehaviorTargetObjectProperty);
if (property != null)
{
BehaviorHelper.CreateAndSetElementNameBinding((IPropertyId)property, (SceneNode)triggerActionNode, targetNode);
}
}
behaviorTriggerBaseNode.Actions.Add((SceneNode)triggerActionNode);
viewModel.BehaviorSelectionSet.SetSelection((BehaviorBaseNode)triggerActionNode);
editTransaction.Commit();
return((SceneNode)triggerActionNode);
}
}
private void CleanBehaviorTriggerReferences()
{
this.CleanConditionBehaviorReferences();
if (this.objectSet != null)
{
this.objectSet.Dispose();
this.objectSet = (TriggerObjectSet)null;
}
this.behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)null;
}
internal void AddConditionNode()
{
if (!this.EnsureInteractionsAssemblyReferenced() || this.behaviorTriggerBaseNode == null)
{
return;
}
BehaviorTriggerBaseNode newTriggerParent = this.CloneCurrentTrigger();
using (SceneEditTransaction editTransaction = this.sceneViewModel.CreateEditTransaction(StringTable.AddConditionUndo))
{
ISceneNodeCollection <SceneNode> collectionForProperty = newTriggerParent.GetCollectionForProperty(BehaviorHelper.BehaviorsProperty);
this.conditionalExpressionNode = (ConditionalExpressionNode)null;
this.conditionBehaviorNode = (ConditionBehaviorNode)null;
foreach (SceneNode sceneNode in (IEnumerable <SceneNode>)collectionForProperty)
{
if (ProjectNeutralTypes.ConditionBehavior.IsAssignableFrom((ITypeId)sceneNode.TrueTargetTypeId))
{
ConditionBehaviorNode conditionBehaviorNode = (ConditionBehaviorNode)sceneNode;
ConditionalExpressionNode conditionalExpressionNode = conditionBehaviorNode.ConditionAsConditionalExpressionNode;
if (conditionalExpressionNode != null)
{
this.conditionBehaviorNode = conditionBehaviorNode;
this.conditionalExpressionNode = conditionalExpressionNode;
break;
}
}
}
if (this.conditionBehaviorNode == null)
{
this.conditionBehaviorNode = (ConditionBehaviorNode)this.sceneViewModel.CreateSceneNode(ProjectNeutralTypes.ConditionBehavior);
collectionForProperty.Add((SceneNode)this.conditionBehaviorNode);
this.conditionalExpressionNode = (ConditionalExpressionNode)this.sceneViewModel.CreateSceneNode(ProjectNeutralTypes.ConditionalExpression);
this.conditionBehaviorNode.ConditionAsConditionalExpressionNode = this.conditionalExpressionNode;
}
this.conditions = this.conditionalExpressionNode.Conditions;
if (this.conditions != null)
{
this.conditions.Add(this.sceneViewModel.CreateSceneNode(ProjectNeutralTypes.ComparisonCondition));
}
if (this.behaviorTriggerBaseNode.Actions.Count > 1)
{
this.objectSet.ReparentActionAndCopyBehaviors(newTriggerParent);
this.behaviorTriggerBaseNode = newTriggerParent;
}
else
{
SceneNode valueAsSceneNode = newTriggerParent.GetLocalValueAsSceneNode(BehaviorHelper.BehaviorsProperty);
valueAsSceneNode.Remove();
this.behaviorTriggerBaseNode.SetValueAsSceneNode(BehaviorHelper.BehaviorsProperty, valueAsSceneNode);
}
editTransaction.Commit();
}
this.Rebuild();
this.Expanded = true;
}
internal void ReparentActionAndCopyBehaviors(BehaviorTriggerBaseNode newTriggerParent)
{
SceneNode valueAsSceneNode = this.ParentTrigger.GetLocalValueAsSceneNode(BehaviorHelper.BehaviorsProperty);
if (valueAsSceneNode != null)
{
DocumentNode node = valueAsSceneNode.DocumentNode.Clone(valueAsSceneNode.DocumentContext);
SceneNode sceneNode = newTriggerParent.ViewModel.GetSceneNode(node);
newTriggerParent.SetValueAsSceneNode(BehaviorHelper.BehaviorsProperty, sceneNode);
}
BehaviorHelper.ReparentAction(this.TriggersCollection, this.ParentTrigger, newTriggerParent, this.actionNode);
}
private BehaviorTriggerBaseNode CopyTriggerAndActionNode(BehaviorTriggerActionNode actionNode)
{
SceneViewModel viewModel = this.InsertionPoint.SceneNode.ViewModel;
DocumentNode node1 = actionNode.DocumentNode.Clone(viewModel.Document.DocumentContext);
DocumentNode node2 = actionNode.Parent.DocumentNode.Clone(viewModel.Document.DocumentContext);
BehaviorTriggerBaseNode behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)viewModel.GetSceneNode(node2);
BehaviorTriggerActionNode triggerActionNode = (BehaviorTriggerActionNode)viewModel.GetSceneNode(node1);
behaviorTriggerBaseNode.Actions.Clear();
behaviorTriggerBaseNode.Actions.Add((SceneNode)triggerActionNode);
return(behaviorTriggerBaseNode);
}
public override void OnSelectionChanged(SceneNode[] selectedObjects)
{
base.OnSelectionChanged(selectedObjects);
if (this.objectSet != null)
{
this.objectSet.Dispose();
this.objectSet = (TriggerObjectSet)null;
}
this.selectedObjects = selectedObjects;
if (selectedObjects.Length > 0)
{
SceneNode sceneNode = selectedObjects[0];
if (sceneNode != null && ProjectNeutralTypes.BehaviorTriggerAction.IsAssignableFrom((ITypeId)sceneNode.Type))
{
BehaviorTriggerBaseNode behaviorTriggerBaseNode = sceneNode.Parent as BehaviorTriggerBaseNode;
if (behaviorTriggerBaseNode != null)
{
this.objectSet = new TriggerObjectSet((BehaviorTriggerActionNode)sceneNode);
this.TriggerType = behaviorTriggerBaseNode.Type;
List <TargetedReferenceStep> list = new List <TargetedReferenceStep>();
foreach (IProperty property in ITypeExtensions.GetProperties(behaviorTriggerBaseNode.Type, MemberAccessTypes.Public, true))
{
ReferenceStep referenceStep = property as ReferenceStep;
if (referenceStep != null)
{
list.Add(new TargetedReferenceStep(referenceStep, behaviorTriggerBaseNode.Type));
}
}
foreach (TargetedReferenceStep targetedReferenceStep in list)
{
if (PropertyInspectorModel.IsPropertyBrowsable(this.selectedObjects, targetedReferenceStep))
{
AttributeCollection attributes = targetedReferenceStep.Attributes;
Attribute[] attributeArray = new Attribute[attributes.Count + 1];
int index;
for (index = 0; index < attributes.Count; ++index)
{
attributeArray[index] = attributes[index];
}
attributeArray[index] = (Attribute) new CategoryAttribute(CategoryLocalizationHelper.GetLocalizedCategoryName(CategoryLocalizationHelper.CategoryName.Triggers));
SceneNodeProperty property = (SceneNodeProperty)this.objectSet.CreateProperty(new PropertyReference(targetedReferenceStep.ReferenceStep), new AttributeCollection(attributeArray));
if (!PlatformTypes.IList.IsAssignableFrom((ITypeId)property.PropertyTypeId))
{
this.AddProperty(property);
}
}
}
}
}
}
this.OnPropertyChanged("IsEmpty");
}
private BehaviorTriggerBaseNode GetUpdatedParentNode(PropertyReference propertyReference, object valueToSet, Modification modification)
{
BehaviorTriggerBaseNode behaviorTriggerBaseNode = this.FindExistingTriggerMatchingPropertyChange(propertyReference, valueToSet, modification);
if (behaviorTriggerBaseNode == null)
{
if (this.ParentTrigger.Actions.Count <= 1)
{
return((BehaviorTriggerBaseNode)null);
}
behaviorTriggerBaseNode = BehaviorHelper.CloneTrigger(this.ParentTrigger, this.ViewModel);
}
return(behaviorTriggerBaseNode);
}
internal override SceneEditTransaction PrepareTreeForModifyValue(PropertyReference propertyReference, object valueToSet, Modification modification, out bool treeModified)
{
BehaviorTriggerBaseNode updatedParentNode = this.GetUpdatedParentNode(propertyReference, valueToSet, modification);
if (updatedParentNode == null)
{
treeModified = false;
return((SceneEditTransaction)null);
}
SceneEditTransaction transaction = this.CreateTransaction(propertyReference.LastStep.Name);
this.ReparentActionAndCopyBehaviors(updatedParentNode);
treeModified = true;
return(transaction);
}
public override void OnSelectionChanged(SceneNode[] selectedObjects)
{
this.CleanBehaviorTriggerReferences();
this.UnhookSelectionManagerEarlySceneUpdate();
BehaviorTriggerActionNode actionNode = Enumerable.FirstOrDefault <BehaviorTriggerActionNode>(Enumerable.OfType <BehaviorTriggerActionNode>((IEnumerable)selectedObjects));
if (actionNode == null || actionNode.Parent == null || !(actionNode.Parent is BehaviorTriggerBaseNode))
{
return;
}
this.behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)actionNode.Parent;
this.objectSet = new TriggerObjectSet(actionNode);
this.sceneViewModel = this.behaviorTriggerBaseNode.ViewModel;
this.HookSelectionManagerEarlySceneUpdate();
this.Rebuild();
}
private BehaviorCommandCategory.PropertyEntryCollectionWrapper GetTriggerProperties(PropertyEntry triggerProperty)
{
BehaviorCommandCategory.PropertyEntryCollectionWrapper collectionWrapper = new BehaviorCommandCategory.PropertyEntryCollectionWrapper(triggerProperty.PropertyValue.SubProperties);
SceneNodeProperty sceneNodeProperty = (SceneNodeProperty)triggerProperty;
BehaviorTriggerBaseNode behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)this.behaviorNode.GetLocalValueAsSceneNode(sceneNodeProperty.Reference);
foreach (BehaviorTriggerActionNode triggerActionNode in (IEnumerable <SceneNode>)behaviorTriggerBaseNode.Actions)
{
if (ProjectNeutralTypes.InvokeCommandAction.IsAssignableFrom((ITypeId)triggerActionNode.Type) && ((InvokeCommandActionNode)triggerActionNode).CommandName.Equals(this.CategoryName, StringComparison.Ordinal))
{
PropertyReference propertyReference = sceneNodeProperty.Reference.Append(BehaviorTriggerBaseNode.BehaviorActionsProperty).Append((ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((ITypeResolver)triggerActionNode.ProjectContext, ProjectNeutralTypes.BehaviorTriggerActionCollection, behaviorTriggerBaseNode.Actions.IndexOf((SceneNode)triggerActionNode))).Append(InvokeCommandActionNode.CommandParameterProperty);
collectionWrapper.AddCustomProperty(sceneNodeProperty.SceneNodeObjectSet.CreateProperty(propertyReference, propertyReference.LastStep.Attributes));
break;
}
}
return(collectionWrapper);
}
protected override void ModifyValue(PropertyReferenceProperty property, object valueToSet, Modification modification, int index)
{
BehaviorTriggerBaseNode updatedParentNode = this.GetUpdatedParentNode(property.Reference, valueToSet, modification);
if (updatedParentNode == null)
{
base.ModifyValue(property, valueToSet, modification, index);
}
else
{
using (SceneEditTransaction transaction = this.CreateTransaction(property.PropertyName))
{
this.ReparentActionAndCopyBehaviors(updatedParentNode);
base.ModifyValue(property, valueToSet, modification, index);
transaction.Commit();
}
}
}
private SceneNode Move(SceneNode node)
{
BehaviorTriggerActionNode actionNode = node as BehaviorTriggerActionNode;
BehaviorNode behaviorNode = node as BehaviorNode;
if (actionNode != null)
{
BehaviorTriggerBaseNode triggerNode = this.CopyTriggerAndActionNode(actionNode);
this.DeleteBehaviorNode((BehaviorBaseNode)actionNode);
return(this.InsertTrigger(triggerNode));
}
if (behaviorNode == null)
{
return((SceneNode)null);
}
this.DeleteBehaviorNode((BehaviorBaseNode)behaviorNode);
return(this.InsertBehavior(behaviorNode));
}
protected override SceneNode InternalCreateInstance(ISceneInsertionPoint insertionPoint, Rect rect, OnCreateInstanceAction action)
{
ProjectContext projectContext = ProjectContext.GetProjectContext(insertionPoint.SceneNode.ProjectContext);
if (!this.EnsureTypeReferenced(projectContext))
{
return((SceneNode)null);
}
BehaviorHelper.EnsureSystemWindowsInteractivityReferenced((ITypeResolver)projectContext);
insertionPoint.SceneNode.DesignerContext.ViewUpdateManager.RebuildPostponedViews();
SceneViewModel viewModel = insertionPoint.SceneNode.ViewModel;
using (SceneEditTransaction editTransaction = viewModel.CreateEditTransaction(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.UndoUnitCreateControlFormat, new object[1]
{
(object)this.Name
})))
{
viewModel.BehaviorSelectionSet.Clear();
BehaviorBaseNode selectionToSet = (BehaviorBaseNode)base.InternalCreateInstance(insertionPoint, rect, action);
ISceneNodeCollection <SceneNode> collectionForProperty = selectionToSet.GetCollectionForProperty(BehaviorHelper.BehaviorTriggersProperty);
foreach (IProperty property in selectionToSet.GetProperties())
{
if (PlatformTypes.ICommand.IsAssignableFrom((ITypeId)property.PropertyType))
{
object triggerAttribute = BehaviorHelper.CreateTriggerFromDefaultTriggerAttribute((IEnumerable)property.Attributes, insertionPoint.SceneNode.TargetType);
if (triggerAttribute != null)
{
BehaviorTriggerBaseNode behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)viewModel.CreateSceneNode(triggerAttribute);
InvokeCommandActionNode commandActionNode = (InvokeCommandActionNode)viewModel.CreateSceneNode(ProjectNeutralTypes.InvokeCommandAction);
commandActionNode.CommandName = property.Name;
behaviorTriggerBaseNode.Actions.Add((SceneNode)commandActionNode);
if (ProjectNeutralTypes.BehaviorEventTriggerBase.IsAssignableFrom((ITypeId)behaviorTriggerBaseNode.Type))
{
BehaviorHelper.CreateAndSetElementNameBinding(BehaviorEventTriggerBaseNode.BehaviorSourceObjectProperty, (SceneNode)behaviorTriggerBaseNode, insertionPoint.SceneNode);
}
collectionForProperty.Add((SceneNode)behaviorTriggerBaseNode);
}
}
}
viewModel.BehaviorSelectionSet.SetSelection(selectionToSet);
editTransaction.Commit();
return((SceneNode)selectionToSet);
}
}
private SceneNode InsertTrigger(BehaviorTriggerBaseNode triggerNode)
{
BehaviorTriggerActionNode triggerActionNode1 = (BehaviorTriggerActionNode)triggerNode.Actions[0];
DocumentCompositeNode documentCompositeNode = (DocumentCompositeNode)triggerNode.DocumentNode;
IProjectContext projectContext = triggerNode.ProjectContext;
SceneNode sceneNode = this.InsertionPoint.SceneNode;
ISceneNodeCollection <SceneNode> collectionForProperty = sceneNode.GetCollectionForProperty(BehaviorHelper.BehaviorTriggersProperty);
BehaviorTriggerBaseNode behaviorTriggerBaseNode = BehaviorHelper.FindMatchingTriggerNode((DocumentNode)documentCompositeNode, collectionForProperty);
if (behaviorTriggerBaseNode != null)
{
BehaviorTriggerActionNode triggerActionNode2 = (BehaviorTriggerActionNode)this.ViewModel.GetSceneNode(triggerActionNode1.DocumentNode.Clone(this.ViewModel.Document.DocumentContext));
behaviorTriggerBaseNode.Actions.Add((SceneNode)triggerActionNode2);
triggerActionNode1 = triggerActionNode2;
}
else
{
behaviorTriggerBaseNode = triggerNode;
collectionForProperty.Add((SceneNode)behaviorTriggerBaseNode);
}
if (projectContext.IsCapabilitySet(PlatformCapability.SupportsAttachingToRootElements) && sceneNode.ViewModel.ActiveEditingContainer.Equals((object)sceneNode))
{
IProperty property = projectContext.ResolveProperty(BehaviorTargetedTriggerActionNode.BehaviorTargetObjectProperty);
if (property != null)
{
foreach (BehaviorTriggerActionNode triggerActionNode2 in (IEnumerable <SceneNode>)behaviorTriggerBaseNode.Actions)
{
if (ProjectNeutralTypes.BehaviorTargetedTriggerAction.IsAssignableFrom((ITypeId)triggerActionNode2.Type))
{
BehaviorHelper.CreateAndSetElementNameBinding((IPropertyId)property, (SceneNode)triggerActionNode2, sceneNode);
}
}
}
}
BehaviorEventTriggerNode eventTriggerNode = behaviorTriggerBaseNode as BehaviorEventTriggerNode;
if (eventTriggerNode != null)
{
BehaviorEventTriggerNode.FixUpEventName(eventTriggerNode);
}
return((SceneNode)triggerActionNode1);
}
private void Rebuild()
{
if (this.TriggerNodeView == null)
{
return;
}
int currentPosition = this.TriggerNodeView.CurrentPosition;
this.ClearTriggerPropertiesList();
ISceneNodeCollection <SceneNode> collectionForProperty = this.behaviorNode.GetCollectionForProperty(BehaviorHelper.BehaviorTriggersProperty);
foreach (SceneNode sceneNode in (IEnumerable <SceneNode>)collectionForProperty)
{
BehaviorTriggerBaseNode behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)sceneNode;
foreach (BehaviorTriggerActionNode triggerActionNode in (IEnumerable <SceneNode>)behaviorTriggerBaseNode.Actions)
{
InvokeCommandActionNode commandActionNode = triggerActionNode as InvokeCommandActionNode;
if (commandActionNode != null && commandActionNode.IsAttached && string.Compare(commandActionNode.CommandName, this.CategoryName, StringComparison.OrdinalIgnoreCase) == 0)
{
PropertyReference propertyReference = new PropertyReference(new List <ReferenceStep>()
{
this.behaviorNode.GetPropertyForChild((SceneNode)behaviorTriggerBaseNode) as ReferenceStep,
(ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((ITypeResolver)sceneNode.ProjectContext, ProjectNeutralTypes.BehaviorTriggerCollection, collectionForProperty.IndexOf((SceneNode)behaviorTriggerBaseNode))
});
if (!Enumerable.Any <PropertyEntry>((IEnumerable <PropertyEntry>) this.TriggerNodes, (Func <PropertyEntry, bool>)(existingProperty => ((PropertyReferenceProperty)existingProperty).Reference.Equals((object)propertyReference))))
{
this.TriggerNodes.Add((PropertyEntry)this.CreateProperty(propertyReference));
}
}
}
}
if (currentPosition >= this.TriggerNodes.Count)
{
return;
}
this.TriggerNodeView.MoveCurrentToPosition(currentPosition);
}
private static void PasteChildProperty(SceneViewModel viewModel, SceneNode childProperty, IList <SceneNode> pastedNodes)
{
IList <SceneElement> list = (IList <SceneElement>)null;
DocumentNodeHelper.StripExtraNamespaces(childProperty.DocumentNode);
if (viewModel.ElementSelectionSet.Selection.Count != 0)
{
list = (IList <SceneElement>)viewModel.ElementSelectionSet.Selection;
}
else if (viewModel.ChildPropertySelectionSet.Selection.Count != 0 && !(childProperty is BehaviorBaseNode) && !(childProperty is BehaviorTriggerBaseNode))
{
list = (IList <SceneElement>) new List <SceneElement>();
foreach (SceneNode sceneNode in viewModel.ChildPropertySelectionSet.Selection)
{
SceneElement sceneElement = sceneNode.Parent as SceneElement;
list.Add(sceneElement);
}
}
if (list == null)
{
return;
}
IProperty targetProperty = viewModel.ProjectContext.ResolveProperty(PasteCommand.ChildSceneNodeToPropertyId(childProperty));
foreach (SceneElement sceneElement in (IEnumerable <SceneElement>)list)
{
PropertySceneInsertionPoint sceneInsertionPoint = new PropertySceneInsertionPoint(sceneElement, targetProperty);
if (sceneInsertionPoint.CanInsert((ITypeId)childProperty.Type))
{
if (ProjectNeutralTypes.BehaviorTriggerBase.IsAssignableFrom((ITypeId)childProperty.Type))
{
BehaviorTriggerBaseNode behaviorTriggerBaseNode1 = (BehaviorTriggerBaseNode)childProperty;
bool flag = true;
foreach (SceneNode sceneNode in (IEnumerable <SceneNode>)behaviorTriggerBaseNode1.Actions)
{
if (!sceneInsertionPoint.CanInsert((ITypeId)sceneNode.Type))
{
flag = false;
break;
}
}
if (flag)
{
ISceneNodeCollection <SceneNode> collectionForProperty = sceneElement.GetCollectionForProperty((IPropertyId)targetProperty);
BehaviorTriggerBaseNode behaviorTriggerBaseNode2 = BehaviorHelper.FindMatchingTriggerNode(behaviorTriggerBaseNode1.DocumentNode, collectionForProperty);
if (behaviorTriggerBaseNode2 == null)
{
DocumentNode node = behaviorTriggerBaseNode1.DocumentNode.Clone(behaviorTriggerBaseNode1.DocumentContext);
behaviorTriggerBaseNode2 = (BehaviorTriggerBaseNode)viewModel.GetSceneNode(node);
collectionForProperty.Add((SceneNode)behaviorTriggerBaseNode2);
}
else
{
DocumentNode node = behaviorTriggerBaseNode1.Actions[0].DocumentNode.Clone(behaviorTriggerBaseNode1.Actions[0].DocumentNode.Context);
BehaviorTriggerActionNode triggerActionNode = (BehaviorTriggerActionNode)viewModel.GetSceneNode(node);
behaviorTriggerBaseNode2.Actions.Add((SceneNode)triggerActionNode);
}
BehaviorEventTriggerNode eventTriggerNode = behaviorTriggerBaseNode2 as BehaviorEventTriggerNode;
if (eventTriggerNode != null)
{
BehaviorEventTriggerNode.FixUpEventName(eventTriggerNode);
}
}
else
{
continue;
}
}
else
{
DocumentNode node = childProperty.DocumentNode.Clone(childProperty.DocumentNode.Context);
SceneNode sceneNode = viewModel.GetSceneNode(node);
sceneInsertionPoint.Insert(sceneNode);
if (sceneNode is EffectNode)
{
pastedNodes.Add(sceneNode);
}
}
TimelineItem timelineItem = viewModel.TimelineItemManager.FindTimelineItem((SceneNode)sceneElement);
if (timelineItem != null)
{
timelineItem.IsExpanded = true;
}
}
}
}
