public MainWindow()
{
InitializeComponent();
_sceneViewModel = new SceneViewModel();
this.DataContext = _sceneViewModel;
this.Loaded += MainWindow_Loaded;
this.Closed += MainWindow_Closed;
_sceneViewModel.PropertyChanged += SceneViewModelPropertyChanged;
_pointUIScaleTransform = new MatrixTransform()
{
Matrix = new Matrix
{
M11 = 37.5,
M22 = 37.5,
OffsetX = 150,
OffsetY = 150
}
};
}
public PasteCommand(SceneViewModel viewModel)
: base(viewModel)
{
}
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;
}
}
}
}
public static ICollection <SceneNode> PasteData(SceneViewModel viewModel, SafeDataObject dataObject, ISceneInsertionPoint insertionPoint, out bool canceledPasteOperation)
{
return(PasteCommand.PasteData(viewModel, dataObject, insertionPoint, false, out canceledPasteOperation));
}
public LockObjectsCommand(SceneViewModel viewModel, bool locked)
: base(viewModel)
{
this.locked = locked;
}
public SetupFontEmbeddingCommand(SceneViewModel viewModel)
: base(viewModel)
{
}
public RemoveActionNode Instantiate(SceneViewModel viewModel)
{
return((RemoveActionNode)this.Instantiate(viewModel, PlatformTypes.RemoveStoryboard));
}
public ModelExplorerViewModel(SceneViewModel scene)
{
Scenes = new BindableCollection <SceneViewModel>();
Scenes.Add(scene);
}
public MakeSameWidthCommand(SceneViewModel viewModel)
: base(viewModel)
{
}
public void Update(SceneViewModel targetViewModel, SceneViewModel.ViewStateBits viewStateBits)
{
bool flag1 = (viewStateBits & SceneViewModel.ViewStateBits.ElementSelection) != SceneViewModel.ViewStateBits.None;
if (targetViewModel != null && !targetViewModel.Document.IsEditable)
{
targetViewModel = (SceneViewModel)null;
}
if (targetViewModel != this.lastViewModel)
{
if (this.subscription == null || targetViewModel == null || this.subscription.ProjectContext != targetViewModel.ProjectContext)
{
if (this.subscription != null)
{
this.subscription.PathNodeInserted -= new XamlProjectSubscription.DocumentNodeInsertedHandler(this.Subscription_PathNodeInserted);
this.subscription.PathNodeRemoved -= new XamlProjectSubscription.DocumentNodeRemovedHandler(this.Subscription_PathNodeRemoved);
this.subscription.CatastrophicUpdate -= new EventHandler(this.Subscription_Refresh);
this.subscription.Dispose();
this.subscription = (XamlProjectSubscription)null;
}
if (targetViewModel != null)
{
this.subscription = new XamlProjectSubscription(this.ResourceManager.DesignerContext, targetViewModel.ProjectContext, new SearchPath(new SearchStep[2]
{
new SearchStep((SearchAxis) new DelegateAxis(new DelegateAxis.EnumerationHandler(this.FilterScopeEnumerator), SearchScope.NodeTreeSelf)),
new SearchStep((SearchAxis) new DelegateAxis(new DelegateAxis.EnumerationHandler(this.FilteredResourceEnumerator), SearchScope.NodeTreeDescendant))
}), new XamlProjectSubscription.DocumentNodeFilter(this.FilteredDocumentNodeEnumerator));
this.subscription.PathNodeInserted += new XamlProjectSubscription.DocumentNodeInsertedHandler(this.Subscription_PathNodeInserted);
this.subscription.PathNodeRemoved += new XamlProjectSubscription.DocumentNodeRemovedHandler(this.Subscription_PathNodeRemoved);
this.subscription.CatastrophicUpdate += new EventHandler(this.Subscription_Refresh);
}
}
else
{
this.subscription.Clear();
}
this.ClearItems();
this.lastViewModel = targetViewModel;
this.lastSelection.Clear();
flag1 = true;
}
if (this.lastViewModel == null || !flag1)
{
return;
}
DocumentNodeMarkerSortedListOf <DocumentNodePath> newBasisNodes = new DocumentNodeMarkerSortedListOf <DocumentNodePath>(this.Selection.Count);
foreach (SceneNode sceneNode in this.Selection.Selection)
{
DocumentNodeMarker marker = sceneNode.DocumentNode.Marker;
DocumentNodePath documentNodePath = this.lastSelection.Find(marker) ?? sceneNode.DocumentNodePath;
newBasisNodes.Add(marker, documentNodePath);
}
bool flag2 = true;
foreach (DocumentNodeMarker marker in this.lastSelection.Markers)
{
if (newBasisNodes.Find(marker) == null)
{
flag2 = false;
break;
}
}
if (!flag2)
{
this.subscription.Clear();
this.ClearItems();
}
this.subscription.SetBasisNodes(newBasisNodes);
this.lastSelection = newBasisNodes;
this.subscription.Update();
this.ResourceManager.SelectedItems.RemoveSelection((ResourceEntryBase)this);
this.OnPropertyChanged("Name");
this.OnPropertyChanged("Type");
this.OnPropertyChanged("UniqueId");
this.OnPropertyChanged("ToolTip");
}
public ClrAssemblyValueConverterModel(SelectionContext <TypeItem> selectionContext, SceneViewModel viewModel, Assembly runtimeAssembly, Assembly referenceAssembly)
: base(viewModel, runtimeAssembly, referenceAssembly)
{
this.selectionContext = selectionContext;
this.LoadAssembly();
}
public MakePartCommand(SceneViewModel viewModel, PartInPartsExplorer part)
: base(viewModel)
{
this.part = part;
}
public SendBackwardCommand(SceneViewModel viewModel)
: base(viewModel, true)
{
}
private void InitializeDrag(Point dragStartPosition)
{
SceneViewModel viewModel = this.ActiveView.ViewModel;
this.CreateSubTransaction();
this.dragStartPosition = dragStartPosition;
this.ComputeDraggedElements();
if (this.draggedElements == null || this.draggedElements.Count == 0)
{
this.moveStrategy = (MoveStrategy)null;
this.dragContainer = (BaseFrameworkElement)null;
this.CancelDrag();
}
else
{
this.moveStrategy = (MoveStrategy)null;
this.moveStrategyContext = MoveStrategyContext.FromSelection((ToolBehavior)this, this.primarySelection, this.selectedElements, this.draggedElements, this.DuplicationOffset, this.dragStartPosition);
this.dragContainer = (BaseFrameworkElement)null;
bool flag = false;
SceneElement sceneElement1 = (SceneElement)null;
foreach (SceneElement sceneElement2 in (IEnumerable <SceneElement>) this.selectedElements)
{
BaseFrameworkElement frameworkElement = (BaseFrameworkElement)null;
BaseFrameworkElement editingContainer = viewModel.FindPanelClosestToActiveEditingContainer();
if (editingContainer != null && editingContainer.IsAncestorOf((SceneNode)sceneElement2))
{
frameworkElement = editingContainer;
}
if (!flag)
{
flag = true;
this.dragContainer = frameworkElement;
sceneElement1 = sceneElement2.ParentElement;
}
else if (sceneElement2.ParentElement != sceneElement1)
{
this.dragContainer = (BaseFrameworkElement)null;
break;
}
if (frameworkElement != this.dragContainer)
{
this.dragContainer = (BaseFrameworkElement)null;
break;
}
}
if (this.dragContainer != null)
{
this.moveStrategy = MoveStrategyFactory.Create(this.moveStrategyContext, this.draggedElements[0].ParentElement, this.IsShiftDown);
if (this.moveStrategy != null)
{
this.moveStrategy.BeginDrag(dragStartPosition);
this.ToolBehaviorContext.SnappingEngine.Start(this.ToolBehaviorContext, this.primaryDraggedElement, this.draggedElements);
}
else
{
this.CancelDrag();
}
}
else
{
this.CancelDrag();
}
}
}
public SceneNodeModelService(SceneViewModel viewModel)
{
this.viewModel = viewModel;
}
protected BaseTaskViewModel(SceneViewModel sceneViewModel)
{
SceneViewModel = sceneViewModel;
}
protected override IEnumerable <ISceneInsertionPoint> InternalFindInsertionPoints(SceneViewModel viewModel)
{
IEnumerable <ISceneInsertionPoint> source = Enumerable.Select <SceneNode, ISceneInsertionPoint>(Enumerable.Where <SceneNode>((IEnumerable <SceneNode>)viewModel.ChildPropertySelectionSet.Selection, (Func <SceneNode, bool>)(childNode => childNode.Parent is SceneElement)), (Func <SceneNode, ISceneInsertionPoint>)(childNode => new EffectInsertionPointCreator((SceneElement)childNode.Parent).Create((object)childNode)));
if (Enumerable.FirstOrDefault <ISceneInsertionPoint>(source) != null)
{
return(source);
}
return(Enumerable.Select <SceneElement, ISceneInsertionPoint>((IEnumerable <SceneElement>)viewModel.ElementSelectionSet.Selection, (Func <SceneElement, ISceneInsertionPoint>)(element => new EffectInsertionPointCreator(element).Create((object)this))));
}
public DeleteElementCommand(SceneElement target, SceneViewModel viewModel)
: base(viewModel)
{
this.target = target;
}
internal static void InsertElement(SceneViewModel sceneViewModel, Base3DElement parent, SceneNode child, int?insertAt)
{
Model3DGroupElement model3DgroupElement = parent as Model3DGroupElement;
ModelVisual3DElement modelVisual3Delement = parent as ModelVisual3DElement;
Model3DElement model3Delement1 = child as Model3DElement;
Visual3DElement visual3Delement = child as Visual3DElement;
if (modelVisual3Delement != null)
{
if (visual3Delement != null)
{
if (insertAt.HasValue)
{
modelVisual3Delement.Children.Insert(insertAt.Value, visual3Delement);
}
else
{
modelVisual3Delement.Children.Add(visual3Delement);
}
}
else
{
if (model3Delement1 == null)
{
return;
}
modelVisual3Delement.Content = (SceneNode)model3Delement1;
}
}
else
{
if (model3DgroupElement == null)
{
return;
}
if (visual3Delement != null)
{
Model3DElement model3Delement2 = BaseElement3DCoercionHelper.CoerceToModel3D(sceneViewModel, (SceneElement)visual3Delement);
if (insertAt.HasValue)
{
model3DgroupElement.Children.Insert(insertAt.Value, model3Delement2);
}
else
{
model3DgroupElement.Children.Add(model3Delement2);
}
}
else
{
if (model3Delement1 == null)
{
return;
}
if (insertAt.HasValue)
{
model3DgroupElement.Children.Insert(insertAt.Value, model3Delement1);
}
else
{
model3DgroupElement.Children.Add(model3Delement1);
}
}
}
}
public BeginActionNode Instantiate(SceneViewModel viewModel)
{
return((BeginActionNode)this.Instantiate(viewModel, PlatformTypes.BeginStoryboard));
}
public static ISceneInsertionPoint GetInsertionPointToPreview(SceneViewModel viewModel, InsertionPointContext insertionPointContext)
{
return(viewModel.GetActiveSceneInsertionPointFromPosition(insertionPointContext) ?? (ISceneInsertionPoint)null);
}
public MoveToResourceCommand(SceneViewModel sceneView)
: base(sceneView)
{
}
public StartAction(PenCreateBehavior penCreateBehavior, PathEditorTarget pathEditorTarget, SceneViewModel viewModel)
: base(pathEditorTarget, viewModel)
{
this.penCreateBehavior = penCreateBehavior;
}
public static ICollection <SceneNode> PasteData(SceneViewModel viewModel, SafeDataObject dataObject)
{
bool canceledPasteOperation;
return(PasteCommand.PasteData(viewModel, dataObject, viewModel.ActiveSceneInsertionPoint, viewModel.LockedInsertionPoint == null, out canceledPasteOperation));
}
public AutoSizeFillCommand(SceneViewModel viewModel)
: base(viewModel)
{
}
private static ICollection <SceneNode> PasteData(SceneViewModel viewModel, SafeDataObject dataObject, ISceneInsertionPoint insertionPoint, bool allowInsertionPointChange, out bool canceledPasteOperation)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.PasteElements);
canceledPasteOperation = false;
List <SceneNode> list = new List <SceneNode>();
PastePackage pastePackage = PastePackage.FromData(viewModel, dataObject);
if (pastePackage != null)
{
if (allowInsertionPointChange)
{
insertionPoint = PasteCommand.ComputeNewInsertionPoint(viewModel, insertionPoint, pastePackage);
}
if (!PasteCommand.CanAddMultipleElements(insertionPoint.SceneElement, pastePackage.Elements.Count))
{
string name = insertionPoint.SceneElement.TargetType.Name;
viewModel.DesignerContext.MessageDisplayService.ShowError(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.PasteMultipleInSingleContainerError, new object[1]
{
(object)name
}));
}
else if (pastePackage.Elements.Count == 0 && pastePackage.Storyboards.Count == 0 && pastePackage.Resources.Count > 0)
{
viewModel.DesignerContext.MessageDisplayService.ShowError(StringTable.PasteElementsFailedNoElementsDialogMessage);
}
else
{
IDictionary <DocumentNode, string> imageMap = (IDictionary <DocumentNode, string>) new Dictionary <DocumentNode, string>();
foreach (SceneNode sceneNode in pastePackage.Elements)
{
foreach (KeyValuePair <DocumentNode, string> keyValuePair in (IEnumerable <KeyValuePair <DocumentNode, string> >)Microsoft.Expression.DesignSurface.Utility.ResourceHelper.CreateImageReferenceMap(sceneNode.DocumentNode, pastePackage, viewModel))
{
imageMap.Add(keyValuePair);
}
}
foreach (SceneNode sceneNode in pastePackage.Resources)
{
foreach (KeyValuePair <DocumentNode, string> keyValuePair in (IEnumerable <KeyValuePair <DocumentNode, string> >)Microsoft.Expression.DesignSurface.Utility.ResourceHelper.CreateImageReferenceMap(sceneNode.DocumentNode, pastePackage, viewModel))
{
imageMap.Add(keyValuePair);
}
}
int index = 0;
ISupportsResources resourcesCollection = ResourceNodeHelper.GetResourcesCollection(viewModel.RootNode.DocumentNode);
if (resourcesCollection != null && resourcesCollection.Resources != null && resourcesCollection.Resources.SupportsChildren)
{
index = resourcesCollection.Resources.Children.Count;
}
if (Microsoft.Expression.DesignSurface.Utility.ResourceHelper.PasteResources(pastePackage, imageMap, ResourceConflictResolution.UseExisting | ResourceConflictResolution.RenameNew | ResourceConflictResolution.OverwriteOld, viewModel.RootNode, index, false))
{
ILayoutDesigner designerForParent = viewModel.GetLayoutDesignerForParent(insertionPoint.SceneElement, true);
List <PasteCommand.DelayedElementTranslationInfo> elementsToTranslateLater = new List <PasteCommand.DelayedElementTranslationInfo>(pastePackage.Elements.Count);
string copyElementToken = pastePackage.ClipboardCopyElementToken;
foreach (SceneElement element in pastePackage.Elements)
{
SceneElement sceneElement = PasteCommand.PasteElement(viewModel, element, elementsToTranslateLater, insertionPoint);
if (sceneElement != null)
{
Microsoft.Expression.DesignSurface.Utility.ResourceHelper.UpdateImageReferences(sceneElement.DocumentNode, imageMap, pastePackage, viewModel);
list.Add((SceneNode)sceneElement);
sceneElement.ClearValue(DesignTimeProperties.CopyTokenProperty);
}
}
if (copyElementToken != null)
{
pastePackage.SetGlobalCopyElementToken(copyElementToken);
PastePackage.PasteSelectionChangePending = true;
}
foreach (SceneNode childProperty in pastePackage.ChildPropertyNodes)
{
PasteCommand.PasteChildProperty(viewModel, childProperty, (IList <SceneNode>)list);
}
foreach (StoryboardTimelineSceneNode storyboard in pastePackage.Storyboards)
{
PasteCommand.PasteStoryboard(viewModel, storyboard, (IList <SceneNode>)list);
}
viewModel.Document.OnUpdatedEditTransaction();
viewModel.DefaultView.UpdateLayout();
using (viewModel.ForceBaseValue())
{
Rect empty = Rect.Empty;
foreach (PasteCommand.DelayedElementTranslationInfo elementTranslationInfo in elementsToTranslateLater)
{
empty.Union(elementTranslationInfo.Bounds);
}
foreach (PasteCommand.DelayedElementTranslationInfo elementTranslationInfo in elementsToTranslateLater)
{
elementTranslationInfo.UpdateTranslation(designerForParent, empty);
}
}
}
else
{
canceledPasteOperation = true;
}
}
}
else if (dataObject.GetDataPresent(DataFormats.FileDrop))
{
DesignerContext designerContext = viewModel.DesignerContext;
string[] supportedFiles = FileDropToolBehavior.CreateImageOrMediaDrop(designerContext).GetSupportedFiles(ClipboardService.GetDataObject());
if (supportedFiles.Length > 0)
{
IEnumerable <IProjectItem> importedItems = designerContext.ActiveProject.AddItems(Enumerable.Select <string, DocumentCreationInfo>((IEnumerable <string>)supportedFiles, (Func <string, DocumentCreationInfo>)(file => new DocumentCreationInfo()
{
SourcePath = file
})));
FileDropToolBehavior.AddItemsToDocument(viewModel.DefaultView, importedItems, new Point(0.0, 0.0), viewModel.ActiveSceneInsertionPoint);
}
else
{
viewModel.DesignerContext.MessageDisplayService.ShowError(StringTable.PasteElementsFailedDialogMessage);
}
}
else if (dataObject.GetDataPresent(DataFormats.Bitmap))
{
DesignerContext designerContext = viewModel.DesignerContext;
IProjectItem projectItem = CutBuffer.AddImageDataFromClipboard(designerContext.ProjectManager, designerContext.ActiveProject);
if (projectItem != null)
{
FileDropToolBehavior.AddItemsToDocument(viewModel.DefaultView, (IEnumerable <IProjectItem>) new List <IProjectItem>()
{
projectItem
}, new Point(0.0, 0.0), viewModel.ActiveSceneInsertionPoint);
}
else
{
viewModel.DesignerContext.MessageDisplayService.ShowError(StringTable.PasteElementsFailedDialogMessage);
}
}
else
{
viewModel.DesignerContext.MessageDisplayService.ShowError(StringTable.PasteElementsFailedDialogMessage);
}
return((ICollection <SceneNode>)list);
}
private static ModelVisual3DElement CreateModelVisual3DContainer(Model3DElement model3DElement, SceneViewModel sceneViewModel)
{
ModelVisual3DElement modelVisual3Delement = (ModelVisual3DElement)sceneViewModel.CreateSceneNode(PlatformTypes.ModelVisual3D);
modelVisual3Delement.Content = (SceneNode)model3DElement;
modelVisual3Delement.Name = (model3DElement.Name ?? "") + "Container";
return(modelVisual3Delement);
}
private static SceneElement PasteElement(SceneViewModel viewModel, SceneElement element, List <PasteCommand.DelayedElementTranslationInfo> elementsToTranslateLater, ISceneInsertionPoint insertionPoint)
{
SceneNodeIDHelper sceneNodeIdHelper = new SceneNodeIDHelper(viewModel, (SceneNode)insertionPoint.SceneNode.StoryboardContainer);
SceneElement element1 = (SceneElement)null;
using (viewModel.ForceBaseValue())
{
PasteCommand.StripStoryboardsAndTriggers(element);
PasteCommand.StripExtraNamespaces(element);
BaseFrameworkElement frameworkElement = element as BaseFrameworkElement;
if (frameworkElement != null || element is DataGridColumnNode)
{
if (!(insertionPoint.SceneElement is Viewport3DElement) && !(insertionPoint.SceneElement is Base3DElement))
{
if (insertionPoint.CanInsert((ITypeId)element.Type))
{
if (!PlatformTypes.FrameworkTemplate.IsAssignableFrom((ITypeId)insertionPoint.SceneElement.Type) && (!PlatformTypes.UserControl.Equals((object)insertionPoint.SceneElement.Type) || insertionPoint.SceneElement.DocumentNode.DocumentRoot.RootNode != insertionPoint.SceneElement.DocumentNode))
{
if (element.Name != null)
{
string validCopiedElementId = sceneNodeIdHelper.GetValidCopiedElementID((SceneNode)element, element.Name);
sceneNodeIdHelper.SetLocalName((SceneNode)element, validCopiedElementId);
}
sceneNodeIdHelper.FixNameConflicts((SceneNode)element);
}
if (viewModel.DesignerContext.PrototypingService != null)
{
viewModel.DesignerContext.PrototypingService.ProcessElementBeforeInsertion(insertionPoint, element);
}
insertionPoint.Insert((SceneNode)element);
if (element.GetLocalValue(DesignTimeProperties.LayoutRectProperty) != null && frameworkElement != null)
{
elementsToTranslateLater.Add(new PasteCommand.DelayedElementTranslationInfo(frameworkElement));
}
element1 = element;
}
}
else if (element.TargetType == typeof(Image))
{
GeometryModel3DElement geometryModel3Delement = GeometryCreationHelper3D.ConvertImageTo3D(viewModel, frameworkElement, element.Name);
IChildContainer3D childContainer3D = insertionPoint.SceneElement as IChildContainer3D;
if (childContainer3D != null)
{
childContainer3D.AddChild(viewModel, (Base3DElement)geometryModel3Delement);
element1 = (SceneElement)geometryModel3Delement;
}
}
}
else
{
Base3DElement child;
if ((child = element as Base3DElement) != null)
{
if (child.Name != null)
{
string validCopiedElementId = sceneNodeIdHelper.GetValidCopiedElementID((SceneNode)child, child.Name);
sceneNodeIdHelper.SetLocalName((SceneNode)child, validCopiedElementId);
}
DependencyPropertyReferenceStep propertyReferenceStep = insertionPoint.Property as DependencyPropertyReferenceStep;
if (propertyReferenceStep != null && propertyReferenceStep.DependencyProperty == ModelVisual3D.ContentProperty)
{
Model3DElement model3Delement = BaseElement3DCoercionHelper.CoerceToModel3D(viewModel, (SceneElement)child);
if (model3Delement != null)
{
insertionPoint.Insert((SceneNode)model3Delement);
element1 = (SceneElement)model3Delement;
}
}
else
{
IChildContainer3D childContainer3D = insertionPoint.SceneElement as IChildContainer3D;
if (childContainer3D != null)
{
element1 = childContainer3D.AddChild(viewModel, child);
}
}
}
}
if (element1 != null)
{
if (!(viewModel.ActiveEditingContainer is FrameworkTemplateElement))
{
PasteCommand.StripTemplateBindings(element1);
}
}
}
return(element1);
}
public static GeometryModel3DElement ConvertImageTo3D(SceneViewModel viewModel, BaseFrameworkElement imageElement, string newName)
{
ImageBrushNode imageBrush;
return(GeometryCreationHelper3D.ConvertImageTo3D(viewModel, imageElement, newName, out imageBrush));
}
/// <summary>
/// Opens a file and returns the corresponding MDViewModel
/// </summary>
/// <param name="info">The string location of the file</param>
/// <returns>The <see cref="MDViewModel"/> for the file.</returns>
public ContentViewModel OpenContent(object info, object param)
{
var location = info as string;
if (location != null)
{
SceneDataModel model = null;
SceneViewModel vm = VEFModule.UnityContainer.Resolve(typeof(SceneViewModel), "") as SceneViewModel;
var view = VEFModule.UnityContainer.Resolve(typeof(SceneView), "") as SceneView;
try
{
ISceneService sceneService = VEFModule.UnityContainer.Resolve(typeof(ISceneService), "") as ISceneService;
IProjectTreeService pfExplorerService = VEFModule.UnityContainer.Resolve(typeof(IProjectTreeService), "") as IProjectTreeService;
// string[] split = Regex.Split(info.ToString(), ":##:");
//if (split.Count() == 2)
//{
// string identifier = split[0];
// string ID = split[1];
// if (identifier == "SceneID")
// {
var scene = sceneService.Scenes.Where(x => x.ContentID == info.ToString());
if (scene.Any())
{
sceneService.SelectedScene = scene.First();
sceneService.SelectedScene.Open(info);
}
else //new scene
{
// SceneDataModel newScene = new SceneDataModel() { Name = "Scene NEW", ContentID = "SceneID:##:" };
// newScene.Parent = parent;
if (pfExplorerService.SelectedItem is SceneDataModel)
{ // pfExplorerService.SelectedItem.Items.Add(newScene);
var newScene = pfExplorerService.SelectedItem as SceneDataModel;
if (newScene != null)
{
sceneService.Scenes.Add(newScene);
// sceneService.SelectedScene = newScene;
newScene.Open(-1);
model = newScene;
}
}
}
//Model details
if (model == null)
{
model = VEFModule.UnityContainer.Resolve(typeof(SceneDataModel), "") as SceneDataModel;
}
model.SetLocation(info);
// model.SetLocation("AuftragID:##:" + info + "");
// model.Document.Text = File.ReadAllText(location);
model.SetDirty(true);
// }
}
catch (Exception exception)
{
_loggerService.Log(exception.Message, LogCategory.Exception, LogPriority.High);
_loggerService.Log(exception.StackTrace, LogCategory.Exception, LogPriority.High);
return(null);
}
//Clear the undo stack
// model.Document.UndoStack.ClearAll();
//Set the model and view
vm.SetModel(model);
vm.SetView(view);
vm.Title = model.Name ?? "Scene";//model.nae // Path.GetFileName("Scene gefunden");
(vm.View as UserControl).DataContext = model;
return(vm);
}
return(null);
}
public static GeometryModel3DElement ConvertImageTo3D(SceneViewModel viewModel, BaseFrameworkElement imageElement, string newName, out ImageBrushNode imageBrush)
{
imageBrush = (ImageBrushNode)viewModel.CreateSceneNode(typeof(ImageBrush));
string uri = ((ImageElement)imageElement).Uri;
SceneNode valueAsSceneNode = imageElement.GetLocalValueAsSceneNode(ImageElement.SourceProperty);
if (valueAsSceneNode != null)
{
imageBrush.ImageSource = viewModel.GetSceneNode(valueAsSceneNode.DocumentNode.Clone(viewModel.Document.DocumentContext));
}
double num = 1.0;
double imageWidth = 1.0;
double imageHeight = 1.0;
double width = 1.0;
double height = 1.0;
Stretch stretch = Stretch.Fill;
ImageSource imageSource;
if (imageElement.Visual != null)
{
Rect computedTightBounds = imageElement.GetComputedTightBounds();
num = computedTightBounds.Width / computedTightBounds.Height;
imageWidth = computedTightBounds.Width;
imageHeight = computedTightBounds.Height;
imageSource = imageElement.GetComputedValue(ImageElement.SourceProperty) as ImageSource;
stretch = (Stretch)imageElement.GetComputedValue(ImageElement.StretchProperty);
}
else
{
imageSource = imageElement.GetLocalOrDefaultValue(ImageElement.SourceProperty) as ImageSource;
object localOrDefaultValue = imageElement.GetLocalOrDefaultValue(ImageElement.StretchProperty);
if (localOrDefaultValue is Stretch)
{
stretch = (Stretch)localOrDefaultValue;
}
}
if (imageSource != null)
{
width = imageSource.Width;
height = imageSource.Height;
}
imageBrush.SetValue(TileBrushNode.StretchProperty, (object)stretch);
if (stretch == Stretch.None)
{
double x = 0.0;
double y = 0.0;
if (imageWidth > width)
{
x = (imageWidth - width) / 2.0;
}
if (imageHeight > height)
{
y = (imageHeight - height) / 2.0;
}
imageBrush.SetValue(TileBrushNode.ViewportUnitsProperty, (object)BrushMappingMode.Absolute);
imageBrush.SetValue(TileBrushNode.ViewportProperty, (object)new Rect(x, y, width, height));
}
GeometryModel3D geometryModel3D = new GeometryModel3D();
geometryModel3D.Geometry = (Geometry3D)GeometryCreationHelper3D.CreateSubdividedQuad(9, 20.0 * num, 20.0, imageWidth, imageHeight);
GeometryModel3DElement geometryModel3Delement = (GeometryModel3DElement)viewModel.CreateSceneNode((object)geometryModel3D);
geometryModel3Delement.Name = SceneNodeIDHelper.ToCSharpID(newName);
geometryModel3Delement.DesignTimeBounds = geometryModel3D.Bounds;
DiffuseMaterialNode diffuseMaterialNode = (DiffuseMaterialNode)viewModel.CreateSceneNode(typeof(DiffuseMaterial));
diffuseMaterialNode.Brush = (SceneNode)imageBrush;
geometryModel3Delement.Material = (MaterialNode)diffuseMaterialNode;
BitmapImageNode bitmapImageNode = imageBrush.ImageSource as BitmapImageNode;
if (bitmapImageNode != null && uri != null)
{
bitmapImageNode.SetValue(BitmapImageNode.UriSourceProperty, (object)new Uri(uri, UriKind.RelativeOrAbsolute));
}
return(geometryModel3Delement);
}
