protected override void OnAttached()
{
_originalBackground = AssociatedObject.Background;
BehaviorHelper.InvokeWhenWillBeLoaded(AssociatedObject, UpdateBlur);
AssociatedObject.Activated += OnIsActiveChanged;
AssociatedObject.Deactivated += OnIsActiveChanged;
}
private void BehaviorDelete()
{
foreach (BehaviorBaseNode node in this.SceneViewModel.BehaviorSelectionSet.Selection)
{
BehaviorHelper.DeleteBehavior(node);
}
}
public void Test()
{
var paymentId = RandomHelper.GetRandomAlphanumericString(12);
BehaviorHelper.Set(paymentId, Constants.PaymentStatuses.ManualCheck);
var restClient = new RestClient("http://*****:*****@mail.com" },
{ "fullName", "John Doe" }
};
var json = JsonConvert.SerializeObject(data, Formatting.Indented);
restRequest.AddParameter("application/json", json, ParameterType.RequestBody);
var response = restClient.Execute(restRequest).Content;
}
// -- MOVEMENT ----------
void GetWater()
{
GameObject closestObj = memorySystem.FindNearestGameObjectInMemory("Drink", transform);
if (closestObj == null)
{
return;
}
// No need to look again.
if (behaviorState == BehaviorStates.LookingForWater)
{
if (BehaviorHelper.AtEndOfPath(agent))
{
int quench = closestObj.GetComponent <Drink>().value;
memorySystem.RemoveGameObjectFromMemory(closestObj);
agent.SetDestination(transform.position);
thirst += quench;
behaviorState = BehaviorStates.Wandering;
Destroy(closestObj);
}
return;
}
behaviorState = BehaviorStates.LookingForWater;
agent.SetDestination(closestObj.transform.position);
}
void GetFood()
{
GameObject closestObj = memorySystem.FindNearestGameObjectInMemory("Food", transform);
if (closestObj == null)
{
return;
}
// No need to look again.
if (behaviorState == BehaviorStates.LookingForFood)
{
if (BehaviorHelper.AtEndOfPath(agent))
{
int food = closestObj.GetComponent <Food>().value;
memorySystem.RemoveGameObjectFromMemory(closestObj);
agent.SetDestination(transform.position);
hunger += food;
behaviorState = BehaviorStates.Wandering;
Destroy(closestObj);
}
return;
}
behaviorState = BehaviorStates.LookingForFood;
agent.SetDestination(closestObj.transform.position);
}
void ManageNeeds()
{
if (hunger != 0 && hunger > 1)
{
hunger--;
}
if (thirst != 0 & thirst > 2)
{
thirst = thirst - 2;
}
else
{
thirst = 0;
}
// We only want the being to look for needs if it has no suspicion
// and isn't doing anything already.
if (suspicion == 0)
{
if (thirst < needsThreshold & BehaviorHelper.CanPerformBehavior(BehaviorStates.LookingForWater, behaviorState))
{
GetWater();
}
else if (hunger < needsThreshold & BehaviorHelper.CanPerformBehavior(BehaviorStates.LookingForFood, behaviorState))
{
GetFood();
}
}
if (debug)
{
debugTextMesh.text = "Hunger: " + hunger.ToString() + " - " + "Thirst: " + thirst.ToString();
}
}
private void DeleteBehaviorNode(BehaviorBaseNode behaviorNode)
{
if (behaviorNode == null || !behaviorNode.IsAttached)
{
return;
}
BehaviorHelper.DeleteBehavior(behaviorNode);
}
public override void SelectElement(SceneElement element, SceneNodeProperty editingProperty)
{
if (element == null || editingProperty == null)
{
return;
}
BehaviorHelper.CreateAndSetElementNameBinding(editingProperty, (SceneNode)element);
}
private static void CutBehaviorNodes(SceneViewModel viewModel, IList <BehaviorBaseNode> behaviorNodes)
{
CopyCommand.CopyBehaviorNodes(viewModel, behaviorNodes);
foreach (BehaviorBaseNode node in (IEnumerable <BehaviorBaseNode>)behaviorNodes)
{
BehaviorHelper.DeleteBehavior(node);
}
}
public override void Execute()
{
BaseFrameworkElement selectedElement = this.SelectedElement;
SceneViewModel sceneViewModel1 = this.SceneViewModel;
bool flag1 = true;
BaseFrameworkElement frameworkElement = selectedElement;
int num1 = flag1 ? true : false;
ILayoutDesigner designerForChild = sceneViewModel1.GetLayoutDesignerForChild((SceneElement)frameworkElement, num1 != 0);
SceneNode parent = selectedElement.Parent;
IProperty propertyForChild = parent.GetPropertyForChild((SceneNode)selectedElement);
ISceneNodeCollection <SceneNode> collectionForProperty = parent.GetCollectionForProperty((IPropertyId)propertyForChild);
int index = collectionForProperty.IndexOf((SceneNode)selectedElement);
if (!BehaviorHelper.EnsureBlendSDKLibraryAssemblyReferenced(this.SceneViewModel, "Microsoft.Expression.Controls") || !ProjectContext.GetProjectContext(selectedElement.ProjectContext).IsTypeSupported(ProjectNeutralTypes.PathListBox))
{
return;
}
using (this.SceneViewModel.DisableUpdateChildrenOnAddAndRemove())
{
SceneViewModel sceneViewModel2 = this.SceneViewModel;
bool flag2 = false;
string unitMakeLayoutPath = StringTable.UndoUnitMakeLayoutPath;
int num2 = flag2 ? true : false;
using (SceneEditTransaction editTransaction = sceneViewModel2.CreateEditTransaction(unitMakeLayoutPath, num2 != 0))
{
using (this.SceneViewModel.ForceBaseValue())
{
using (this.SceneViewModel.DisableDrawIntoState())
{
this.SceneViewModel.ElementSelectionSet.Clear();
Rect childRect = designerForChild.GetChildRect(selectedElement);
selectedElement.EnsureNamed();
PathListBoxElement pathListBoxElement = (PathListBoxElement)this.SceneViewModel.CreateSceneNode(ProjectNeutralTypes.PathListBox);
LayoutPathNode layoutPathNode = (LayoutPathNode)this.SceneViewModel.CreateSceneNode(ProjectNeutralTypes.LayoutPath);
BindingSceneNode bindingSceneNode = (BindingSceneNode)this.SceneViewModel.CreateSceneNode(PlatformTypes.Binding);
bindingSceneNode.ElementName = selectedElement.Name;
layoutPathNode.SetValue(LayoutPathNode.SourceElementProperty, (object)bindingSceneNode.DocumentNode);
pathListBoxElement.LayoutPaths.Add((SceneNode)layoutPathNode);
if (!collectionForProperty.FixedCapacity.HasValue || collectionForProperty.Count < collectionForProperty.FixedCapacity.Value)
{
collectionForProperty.Insert(index, (SceneNode)pathListBoxElement);
}
else
{
GridElement gridElement = (GridElement)this.SceneViewModel.CreateSceneNode(PlatformTypes.Grid);
collectionForProperty[index] = (SceneNode)gridElement;
gridElement.Children.Add((SceneNode)pathListBoxElement);
gridElement.Children.Add((SceneNode)selectedElement);
}
editTransaction.Update();
designerForChild.SetChildRect((BaseFrameworkElement)pathListBoxElement, childRect);
this.SceneViewModel.ElementSelectionSet.SetSelection((SceneElement)pathListBoxElement);
editTransaction.Commit();
}
}
}
}
}
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 static DocumentNode GetParentNode(DocumentNode stateNode)
{
DocumentNode childNode = BehaviorHelper.ValidateNodeTypeAndGetParent(BehaviorHelper.ValidateNodeTypeAndGetParent(BehaviorHelper.ValidateNodeTypeAndGetParent(BehaviorHelper.ValidateNodeTypeAndGetParent((DocumentNode)stateNode.Parent, PlatformTypes.IList), ProjectNeutralTypes.VisualStateGroup), PlatformTypes.IList), PlatformTypes.FrameworkElement);
if (BehaviorHelper.ValidateNodeTypeAndGetParent(childNode, PlatformTypes.ICollection) != null && childNode.Parent != null)
{
childNode = (DocumentNode)childNode.Parent;
}
return(childNode);
}
public static int DetermineSpeed(int age)
{
List <int> values = new List <int>();
values.Add(30);
values.Add(25);
values.Add(20);
values.Add(15);
values.Add(10);
return(BehaviorHelper.QuickIntSwitch(age, BehaviorHelper.GetAgeBreakpoints(), values));
}
public static int DetermineViewDistance(int age)
{
List <int> values = new List <int>();
values.Add(100);
values.Add(120);
values.Add(100);
values.Add(80);
values.Add(60);
return(BehaviorHelper.QuickIntSwitch(age, BehaviorHelper.GetAgeBreakpoints(), values));
}
public static int DetermineViewAngle(int age)
{
List <int> values = new List <int>();
values.Add(Random.Range(60, 160));
values.Add(Random.Range(60, 120));
values.Add(Random.Range(60, 100));
values.Add(Random.Range(60, 90));
values.Add(Random.Range(40, 80));
return(BehaviorHelper.QuickIntSwitch(age, BehaviorHelper.GetAgeBreakpoints(), values));
}
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);
}
public void Execute(IMemberElement behavee)
{
var helper = new MemberBehaviorHelper <RequiredAttribute>();
var attribute = helper.GetAttribute(behavee);
if (attribute != null)
{
var data = new Dictionary <string, bool> {
{ "required", true }
};
BehaviorHelper.AddDataToClass(behavee, data);
}
}
public static CustomCategorySelector GetCustomCategorySelector(PropertyReferenceProperty property)
{
CustomCategorySelector selectorByCategoryName;
if ((selectorByCategoryName = CategoryFactory.GetCategorySelectorByCategoryName(CategoryLocalizationHelper.GetCanonicalCategoryName(property.CategoryName))) != null)
{
return(selectorByCategoryName);
}
if (BehaviorHelper.IsPropertyBehaviorCommand(property))
{
return((CustomCategorySelector) new CategoryFactory.BehaviorCommandCategorySelector());
}
return(new CustomCategorySelector());
}
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);
}
/// <summary>
/// This behavior affects elements bound to model properties having the Range attribute. It adds Json data
/// to the element's attribute incdicating the maximum and minimum values for the field.
/// </summary>
public void Execute(IMemberElement behavee)
{
var memberBehaviorHelper = new MemberBehaviorHelper <RangeAttribute>();
var attribute = memberBehaviorHelper.GetAttribute(behavee);
if (attribute != null)
{
var data = new Dictionary <string, object>
{
{ "maximum", attribute.Maximum },
{ "minimum", attribute.Minimum }
};
BehaviorHelper.AddDataToClass(behavee, data);
}
}
private bool EnsureInteractionsAssemblyReferenced()
{
if (!BehaviorHelper.EnsureBlendSDKLibraryAssemblyReferenced(this.sceneViewModel, "Microsoft.Expression.Interactions"))
{
int num = (int)this.sceneViewModel.DesignerContext.MessageDisplayService.ShowMessage(StringTable.CantAddConditionMessage, (string)null, MessageBoxButton.OK, MessageBoxImage.Exclamation);
return(false);
}
IType type = this.sceneViewModel.ProjectContext.ResolveType(ProjectNeutralTypes.ConditionBehavior);
if (type != null && !this.sceneViewModel.ProjectContext.PlatformMetadata.IsNullType((ITypeId)type))
{
return(true);
}
int num1 = (int)this.sceneViewModel.DesignerContext.MessageDisplayService.ShowMessage(StringTable.WrongInteractionReference, (string)null, MessageBoxButton.OK, MessageBoxImage.Exclamation);
return(false);
}
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 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;
}
}
}
}
internal BehaviorTriggerBaseNode CloneCurrentTrigger()
{
return(BehaviorHelper.CloneTrigger(this.behaviorTriggerBaseNode, this.sceneViewModel));
}
internal BehaviorTriggerBaseNode FindExistingTriggerMatchingDocumentNode(DocumentNode candidate)
{
return(BehaviorHelper.FindMatchingTriggerNode(candidate, this.TriggersCollection));
}
