public BaseFrameworkElement GetRelativeTargetElement(DocumentNodePath relativeEditingContainerPath) { if (relativeEditingContainerPath.ContainerNode != this.DocumentNode) { return((BaseFrameworkElement)null); } DocumentNodePath containerOwnerPath = relativeEditingContainerPath.GetContainerOwnerPath(); if (containerOwnerPath == null) { return((BaseFrameworkElement)null); } SetterSceneNode setterSceneNode = this.ViewModel.GetSceneNode(containerOwnerPath.Node) as SetterSceneNode; if (setterSceneNode == null) { return(this.ViewModel.GetSceneNode(containerOwnerPath.Node) as BaseFrameworkElement); } IStoryboardContainer storyboardContainer = (IStoryboardContainer)this.ViewModel.GetSceneNode(containerOwnerPath.ContainerNode); SceneNode sceneNode = storyboardContainer.ResolveTargetName(setterSceneNode.Target); if (sceneNode == storyboardContainer) { return(storyboardContainer.TargetElement); } return(sceneNode as BaseFrameworkElement); }
public void RenameTemplateIDs() { if (this.VisualTreeRoot == null) { return; } SceneNodeIDHelper sceneNodeIdHelper = new SceneNodeIDHelper(this.ViewModel, (SceneNode)this.VisualTreeRoot); Dictionary <string, string> renameTable = new Dictionary <string, string>(); foreach (SceneElement sceneElement in SceneElementHelper.GetElementTree((SceneElement)this.VisualTreeRoot)) { string name = sceneElement.Name; if (name == null || name.StartsWith("~ChildID")) { sceneNodeIdHelper.SetValidName((SceneNode)sceneElement, sceneElement.TargetType.Name); if (name != null && sceneElement.Name != name) { renameTable.Add(name, sceneElement.Name); } } } IStoryboardContainer storyboardContainer = (IStoryboardContainer)this; if (storyboardContainer == null) { return; } this.ViewModel.AnimationEditor.UpdateStoryboardOnElementRename(storyboardContainer, renameTable); }
private void RecacheTargetElement() { this.Invalidate(); IStoryboardContainer storyboardContainer = this.StoryboardContainer; if (storyboardContainer == null) { return; } this.cachedTargetAvalonElement = storyboardContainer.ResolveTargetName(this.TargetName); this.cachedChangeStamp = this.ViewModel.ChangeStamp; }
protected SceneElement GetUnlockedAncestorInEditingContainer(DocumentNodePath nodePath) { IStoryboardContainer storyboardContainer = this.ActiveSceneViewModel.ActiveStoryboardContainer; DocumentNodePath targetElementPath = storyboardContainer.TargetElement != null ? storyboardContainer.TargetElement.DocumentNodePath : ((SceneNode)storyboardContainer).DocumentNodePath; DocumentNodePath editingContainer = this.ActiveSceneViewModel.GetAncestorInEditingContainer(nodePath, this.ActiveSceneViewModel.ActiveEditingContainerPath, targetElementPath); nodePath = editingContainer == null?this.ActiveSceneViewModel.GetAncestorInEditingContainer(nodePath, this.ActiveSceneViewModel.ViewRoot.DocumentNodePath, this.ActiveSceneViewModel.ViewRoot.DocumentNodePath) : editingContainer; SceneElement sceneElement = (SceneElement)null; if (nodePath != null) { sceneElement = this.ActiveSceneViewModel.GetUnlockedAncestor(nodePath); } return(sceneElement); }
private SceneElement GetSelectableElement(DocumentNodePath nodePath) { IStoryboardContainer storyboardContainer = this.view.ViewModel.ActiveStoryboardContainer; DocumentNodePath targetElementPath = storyboardContainer.TargetElement != null ? storyboardContainer.TargetElement.DocumentNodePath : ((SceneNode)storyboardContainer).DocumentNodePath; DocumentNodePath editingContainer = this.view.ViewModel.GetAncestorInEditingContainer(nodePath, this.view.ViewModel.ActiveEditingContainerPath, targetElementPath); SceneElement sceneElement = (SceneElement)null; if (editingContainer != null) { sceneElement = this.view.ViewModel.GetUnlockedAncestor(editingContainer); if (!sceneElement.IsSelectable) { sceneElement = (SceneElement)null; } } return(sceneElement); }
public FromToAnimationSceneNode InstantiateWithTarget(SceneViewModel viewModel, SceneNode targetElement, PropertyReference targetProperty, IStoryboardContainer referenceStoryboardContainer, ITypeId type) { return((FromToAnimationSceneNode)base.InstantiateWithTarget(viewModel, targetElement, targetProperty, referenceStoryboardContainer, type)); }
public override void Execute(object arg) { ITypeId type = this.Type; if (type is ProjectNeutralTypeId && !this.SceneViewModel.ProjectContext.PlatformMetadata.IsSupported((ITypeResolver)this.SceneViewModel.ProjectContext, type)) { return; } using (SceneEditTransaction editTransaction = this.DesignerContext.ActiveDocument.CreateEditTransaction(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.UndoUnitLayoutPaneChangeLayoutType, new object[1] { (object)this.Type.Name }))) { bool flag1 = false; SceneViewModel activeSceneViewModel = this.DesignerContext.ActiveSceneViewModel; ReadOnlyCollection <SceneElement> selection = this.DesignerContext.SelectionManager.ElementSelectionSet.Selection; SceneElement primarySelection1 = this.DesignerContext.SelectionManager.ElementSelectionSet.PrimarySelection; List <SceneElement> list = new List <SceneElement>(); bool flag2 = false; bool flag3 = false; bool flag4 = false; SceneElement sceneElement1 = (SceneElement)null; IStoryboardContainer storyboardContainer = (IStoryboardContainer)null; SceneElement primarySelection2 = (SceneElement)null; this.DesignerContext.SelectionManager.ElementSelectionSet.Clear(); List <SceneElement> elements = new List <SceneElement>(); elements.AddRange((IEnumerable <SceneElement>)selection); ElementUtilities.SortElementsByDepth(elements); foreach (SceneElement sceneElement2 in elements) { ITypeId typeId1 = (ITypeId)null; foreach (ITypeId typeId2 in ChangeLayoutTypeFlyoutCommand.LayoutTypes) { if (typeId2.IsAssignableFrom((ITypeId)sceneElement2.Type)) { typeId1 = typeId2; break; } } if (typeId1 == null) { list.Add(sceneElement2); } else { if (activeSceneViewModel.LockedInsertionPoint != null) { if (activeSceneViewModel.LockedInsertionPoint.SceneElement == sceneElement2) { flag2 = true; } else if (sceneElement2.IsAncestorOf((SceneNode)activeSceneViewModel.ActiveSceneInsertionPoint.SceneElement)) { sceneElement1 = activeSceneViewModel.ActiveSceneInsertionPoint.SceneElement; flag2 = true; } } if (primarySelection1 == sceneElement2) { flag4 = true; } if (!flag3 && activeSceneViewModel.ActiveStoryboardContainer == sceneElement2) { activeSceneViewModel.SetActiveStoryboardTimeline((IStoryboardContainer)null, (StoryboardTimelineSceneNode)null, (TriggerBaseNode)null); flag3 = true; } using (sceneElement2.ViewModel.ForceBaseValue()) { BaseFrameworkElement parent1 = sceneElement2 as BaseFrameworkElement; List <LayoutCacheRecord> layoutCache = (List <LayoutCacheRecord>)null; ILayoutDesigner designerForParent = activeSceneViewModel.GetLayoutDesignerForParent(sceneElement2, true); if (parent1 != null) { layoutCache = designerForParent.GetCurrentRects(parent1); } SceneElement elementContainingChildren = (SceneElement)null; SceneElement sceneElement3 = ChangeLayoutTypeCommand.ChangeLayoutType(sceneElement2, type, ref elementContainingChildren); editTransaction.Update(); if (sceneElement3.IsViewObjectValid) { this.SceneViewModel.DefaultView.UpdateLayout(); BaseFrameworkElement parent2 = elementContainingChildren as BaseFrameworkElement; if (parent2 != null && parent2.IsViewObjectValid && layoutCache != null) { activeSceneViewModel.GetLayoutDesignerForParent(elementContainingChildren, true).SetCurrentRects(parent2, layoutCache); } if (flag2 && sceneElement1 == null) { sceneElement1 = elementContainingChildren; } if (flag3 && storyboardContainer == null) { storyboardContainer = (IStoryboardContainer)sceneElement3; } if (flag4 && primarySelection2 == null) { primarySelection2 = sceneElement3; } list.Add(sceneElement3); } flag1 = true; } } } if (flag2 && sceneElement1 != null) { activeSceneViewModel.SetLockedInsertionPoint(sceneElement1); } if (flag3 && storyboardContainer != null) { activeSceneViewModel.SetActiveStoryboardTimeline(storyboardContainer, (StoryboardTimelineSceneNode)null, (TriggerBaseNode)null); } this.DesignerContext.SelectionManager.ElementSelectionSet.SetSelection((ICollection <SceneElement>)list, primarySelection2); if (flag1) { editTransaction.Commit(); } else { editTransaction.Cancel(); } } }
protected static IEnumerable <SceneNode> Enumerate(SceneNode pivot, SearchAxis axis, ISearchPredicate continueTester) { SceneViewModel viewModel = pivot.ViewModel; switch (axis.axisType) { case SearchAxis.AxisType.DocumentAncestor: foreach (DocumentNode node in pivot.DocumentNode.AncestorNodes) { SceneNode sceneNode = viewModel.GetSceneNode(node); yield return(sceneNode); if (continueTester != null && !continueTester.Test(sceneNode)) { break; } } break; case SearchAxis.AxisType.DocumentParent: DocumentNode parentNode = (DocumentNode)pivot.DocumentNode.Parent; if (parentNode == null) { break; } yield return(viewModel.GetSceneNode(parentNode)); break; case SearchAxis.AxisType.DocumentChild: foreach (DocumentNode node in pivot.DocumentNode.ChildNodes) { SceneNode sceneNode = viewModel.GetSceneNode(node); yield return(sceneNode); } break; case SearchAxis.AxisType.DocumentDescendant: foreach (DocumentNode node in SearchAxis.TraverseDocumentDescendants(pivot.DocumentNode, continueTester, viewModel)) { yield return(viewModel.GetSceneNode(node)); } break; case SearchAxis.AxisType.DocumentSelfAndDescendant: yield return(pivot); foreach (DocumentNode node in SearchAxis.TraverseDocumentDescendants(pivot.DocumentNode, continueTester, viewModel)) { yield return(viewModel.GetSceneNode(node)); } break; case SearchAxis.AxisType.Self: yield return(pivot); break; case SearchAxis.AxisType.Root: yield return(viewModel.GetSceneNode(pivot.DocumentNode.DocumentRoot.RootNode)); break; case SearchAxis.AxisType.StoryboardContainer: SceneNode thisStoryboardContainer = (SceneNode)pivot.StoryboardContainer; if (thisStoryboardContainer == null) { break; } yield return(thisStoryboardContainer); break; case SearchAxis.AxisType.StoryboardAncestor: for (IStoryboardContainer cur = pivot.StoryboardContainer; cur != null; cur = cur.TargetElement.StoryboardContainer) { yield return((SceneNode)cur); if (continueTester != null && !continueTester.Test((SceneNode)cur)) { break; } } break; case SearchAxis.AxisType.ActiveStoryboard: if (pivot.ViewModel.ActiveStoryboardTimeline == null) { break; } yield return((SceneNode)pivot.ViewModel.ActiveStoryboardTimeline); break; case SearchAxis.AxisType.Animations: StoryboardTimelineSceneNode storyboard = pivot as StoryboardTimelineSceneNode; if (storyboard == null) { break; } foreach (TimelineSceneNode timelineSceneNode in (IEnumerable <TimelineSceneNode>)storyboard.Children) { yield return((SceneNode)timelineSceneNode); } break; case SearchAxis.AxisType.KeyFrames: KeyFrameAnimationSceneNode keyFrameAnimation = pivot as KeyFrameAnimationSceneNode; if (keyFrameAnimation == null) { break; } foreach (KeyFrameSceneNode keyFrameSceneNode in keyFrameAnimation.KeyFrames) { yield return((SceneNode)keyFrameSceneNode); } break; case SearchAxis.AxisType.SceneAncestor: for (SceneNode parent = pivot.Parent; parent != null; parent = parent.Parent) { yield return(parent); if (continueTester != null && !continueTester.Test(parent)) { break; } } break; case SearchAxis.AxisType.SceneParent: SceneNode node1 = pivot.Parent; if (node1 == null) { break; } yield return(node1); break; case SearchAxis.AxisType.SceneChild: DocumentCompositeNode docNode = pivot.DocumentNode as DocumentCompositeNode; if (docNode == null) { break; } if (docNode.SupportsChildren) { ISceneNodeCollection <SceneNode> children = pivot.GetChildren(); for (int i = 0; i < children.Count; ++i) { yield return(children[i]); } break; } foreach (IPropertyId propertyKey in (IEnumerable <IProperty>)docNode.Properties.Keys) { SceneNode subNode = pivot.GetLocalValueAsSceneNode(propertyKey); yield return(subNode); } break; case SearchAxis.AxisType.SceneDescendant: IEnumerator <SceneNode> descendantEnumerator = (IEnumerator <SceneNode>) new SearchAxis.SceneDescendantTraversalEnumerator(pivot, continueTester); while (descendantEnumerator.MoveNext()) { yield return(descendantEnumerator.Current); } break; case SearchAxis.AxisType.Property: IProperty resolvedProperty = pivot.ProjectContext.ResolveProperty(axis.Property); if (resolvedProperty == null) { break; } SceneNode node2 = pivot.GetLocalValueAsSceneNode((IPropertyId)resolvedProperty); if (node2 == null) { break; } yield return(node2); break; case SearchAxis.AxisType.CollectionChild: SceneNode node3 = pivot.GetChildren()[axis.ChildIndex]; if (node3 == null) { break; } yield return(node3); break; } }
protected override IList <SceneElement> AddToDocumentInternal(string importedFilePath, SceneElement element, ISceneInsertionPoint insertionPoint, SceneViewModel sceneViewModel, SceneEditTransaction editTransaction) { MediaSceneElement mediaSceneElement = element as MediaSceneElement; IList <SceneElement> list = (IList <SceneElement>) new List <SceneElement>(); if (mediaSceneElement != null) { double num = (double)mediaSceneElement.GetLocalOrDefaultValueAsWpf(DesignTimeProperties.DesignTimeNaturalDurationProperty); mediaSceneElement.ClearLocalValue(DesignTimeProperties.DesignTimeNaturalDurationProperty); if (insertionPoint.CanInsert((ITypeId)mediaSceneElement.Type)) { if (!JoltHelper.TypeSupported((ITypeResolver)element.ProjectContext, PlatformTypes.MediaTimeline)) { Uri uri = new Uri(importedFilePath, UriKind.RelativeOrAbsolute); mediaSceneElement.SetLocalValueAsWpf(MediaSceneElement.SourceProperty, (object)uri); } else { IStoryboardContainer mediaStoryboardContainer = insertionPoint.SceneNode.StoryboardContainer; StoryboardTimelineSceneNode targetStoryboard = (StoryboardTimelineSceneNode)null; sceneViewModel.EditContextManager.SingleViewModelEditContextWalker.Walk(false, (SingleHistoryCallback)((context, isGhosted) => { if (context.StoryboardContainer != mediaStoryboardContainer) { return(false); } targetStoryboard = context.Timeline; return(true); })); if (targetStoryboard == null) { foreach (TriggerBaseNode triggerBaseNode in (IEnumerable <TriggerBaseNode>)mediaStoryboardContainer.VisualTriggers) { EventTriggerNode eventTriggerNode = triggerBaseNode as EventTriggerNode; if (eventTriggerNode != null && eventTriggerNode.RoutedEvent == FrameworkElement.LoadedEvent) { foreach (SceneNode sceneNode in (IEnumerable <SceneNode>)eventTriggerNode.Actions) { TimelineActionNode timelineActionNode = sceneNode as TimelineActionNode; if (timelineActionNode != null && timelineActionNode.TimelineOperation == TimelineOperation.Begin) { targetStoryboard = timelineActionNode.TargetTimeline; if (!TimelinePane.ShouldExposeStoryboardToUser((SceneNode)targetStoryboard)) { targetStoryboard = (StoryboardTimelineSceneNode)null; } else { break; } } } } if (targetStoryboard != null) { break; } } if (targetStoryboard != null) { sceneViewModel.SetActiveStoryboardTimeline(mediaStoryboardContainer, targetStoryboard, (TriggerBaseNode)null); } } if (targetStoryboard == null) { targetStoryboard = sceneViewModel.AnimationEditor.CreateNewTimeline(sceneViewModel.ActiveStoryboardContainer, element.Name, TriggerCreateBehavior.Default, true); sceneViewModel.AnimationEditor.IsRecording = false; } IType type = this.DesignerContext.ActiveDocument.ProjectContext.ResolveType(PlatformTypes.MediaTimeline); MediaTimelineSceneNode timelineSceneNode = (MediaTimelineSceneNode)sceneViewModel.CreateSceneNode(type.RuntimeType); timelineSceneNode.SetLocalValue(DesignTimeProperties.DesignTimeNaturalDurationProperty, (object)num); Uri uri = new Uri(importedFilePath, UriKind.RelativeOrAbsolute); timelineSceneNode.Source = uri; timelineSceneNode.TargetName = element.Name; double animationTime = sceneViewModel.AnimationEditor.AnimationTime; timelineSceneNode.Begin = animationTime; targetStoryboard.Children.Add((TimelineSceneNode)timelineSceneNode); editTransaction.Update(); } list.Add(element); insertionPoint.Insert((SceneNode)mediaSceneElement); } } return(list); }
public virtual TimelineSceneNode InstantiateWithTarget(SceneViewModel viewModel, SceneNode targetElement, PropertyReference targetProperty, IStoryboardContainer referenceStoryboardContainer, ITypeId type) { TimelineSceneNode timelineSceneNode = (TimelineSceneNode)this.Instantiate(viewModel, type); timelineSceneNode.Initialize(targetElement, targetProperty, referenceStoryboardContainer); return(timelineSceneNode); }
private void Initialize(SceneNode targetElement, PropertyReference targetProperty, IStoryboardContainer referenceStoryboardContainer) { this.referenceStoryboardContainer = referenceStoryboardContainer; this.TargetAvalonElement = targetElement; this.TargetAvalonProperty = targetProperty; }