private IInstanceBuilderContext GetUnopenedDocumentContext(IDocumentRoot documentRoot) { SceneView sceneView; if (!this.hiddenDocumentsViews.TryGetValue(documentRoot, out sceneView)) { ++this.isInitializingUnopenedView; try { SceneDocument sceneDocument = ViewRootResolver.GetSceneDocument(this.designerContext, documentRoot); if (sceneDocument != null) { sceneView = (SceneView)sceneDocument.CreateDefaultView(); this.hiddenDocumentsViews[documentRoot] = sceneView; sceneView.Initialize(); } } finally { --this.isInitializingUnopenedView; } UIThreadDispatcher.Instance.BeginInvoke(DispatcherPriority.Send, (Action)(() => this.NotifyViewCreated(sceneView))); } if (sceneView == null) { return((IInstanceBuilderContext)null); } return(sceneView.InstanceBuilderContext); }
private void SetDocumentRootRecursively(IDocumentRoot documentRoot) { if (this.documentRoot == documentRoot) { return; } if (this.documentRoot != null) { this.documentRoot.OnNodeUnsetDocumentRoot(this); } this.documentRoot = documentRoot; if (this.documentRoot != null) { this.documentRoot.OnNodeSetDocumentRoot(this); } else if (this.marker != null) { this.marker.SetDeleted(); this.marker = (DocumentNodeMarker)null; } foreach (DocumentNode documentNode in this.ChildNodes) { documentNode.SetDocumentRootRecursively(documentRoot); } }
private void ApplyChangesToExternalDocuments(IProjectContext projectContext) { Dictionary <IDocumentRoot, List <PathChange> > dictionary = new Dictionary <IDocumentRoot, List <PathChange> >(); for (int index = this.pathChanges.Count - 1; index >= 0; --index) { PathChange pathChange = this.pathChanges[index]; if ((IProjectContext)pathChange.DocumentNode.TypeResolver != projectContext) { List <PathChange> list; if (!dictionary.TryGetValue(pathChange.DocumentNode.DocumentRoot, out list)) { list = new List <PathChange>(); dictionary[pathChange.DocumentNode.DocumentRoot] = list; } list.Add(pathChange); this.pathChanges.RemoveAt(index); } } foreach (KeyValuePair <IDocumentRoot, List <PathChange> > keyValuePair in dictionary) { IDocumentRoot key = keyValuePair.Key; this.ApplyChangesInternal(((IProjectContext)key.DocumentContext.TypeResolver).OpenDocument(key.DocumentContext.DocumentUrl).Document as SceneDocument, keyValuePair.Value); } }
public IInstanceBuilderContext GetViewContext(IDocumentRoot documentRoot) { IInstanceBuilderContext instanceBuilderContext; instanceBuilderContext = (this.CrossDocumentUpdateContext == null ? this.viewRootResolver.GetViewContext(documentRoot) : this.CrossDocumentUpdateContext.GetViewContext(documentRoot)); return(instanceBuilderContext); }
private DocumentNode GetResolvedDocumentRootForSourceUri(IDocumentRootResolver documentRootResolver, DocumentCompositeNode resourceDictionaryNode, ICollection <string> warnings) { DocumentNode documentNode; DocumentCompositeNode rootNode; DocumentCompositeNode documentCompositeNode = null; IDocumentRoot documentRoot = null; Uri uriValue = resourceDictionaryNode.GetUriValue(KnownProperties.ResourceDictionarySourceProperty); Uri uri = uriValue; if (uri != null) { uri = this.documentContext.MakeDesignTimeUri(uri); } if (uri != null) { try { documentRoot = documentRootResolver.GetDocumentRoot(uri.OriginalString); if (documentRoot != null) { if (PlatformTypes.PlatformsCompatible(documentRoot.TypeResolver.PlatformMetadata, resourceDictionaryNode.TypeResolver.PlatformMetadata)) { if (documentRoot.IsEditable) { rootNode = documentRoot.RootNode as DocumentCompositeNode; } else { rootNode = null; } documentCompositeNode = rootNode; } else { if (warnings != null) { CultureInfo currentCulture = CultureInfo.CurrentCulture; string resourceDictionaryTargetFrameworkNotMatching = StringTable.ResourceDictionaryTargetFrameworkNotMatching; object[] fullName = new object[] { uriValue, documentRoot.TypeResolver.PlatformMetadata.TargetFramework.FullName, resourceDictionaryNode.TypeResolver.PlatformMetadata.TargetFramework.FullName }; warnings.Add(string.Format(currentCulture, resourceDictionaryTargetFrameworkNotMatching, fullName)); } documentNode = null; return(documentNode); } } return(documentCompositeNode); } catch (IOException oException) { return(documentCompositeNode); } catch (NotSupportedException notSupportedException) { return(documentCompositeNode); } return(documentNode); } return(documentCompositeNode); }
private static SceneElement ChangeLayoutType(SceneElement sourceElement, ITypeId layoutType, ref SceneElement elementContainingChildren) { IDocumentRoot documentRoot = sourceElement.DocumentNode.DocumentRoot; IDocumentContext documentContext = documentRoot.DocumentContext; SceneViewModel viewModel = sourceElement.ViewModel; Size size = Size.Empty; BaseFrameworkElement frameworkElement = sourceElement as BaseFrameworkElement; if (frameworkElement != null) { size = frameworkElement.GetComputedTightBounds().Size; } using (viewModel.ForceBaseValue()) { SceneElement sceneElement = (SceneElement)viewModel.CreateSceneNode(layoutType); using (viewModel.DisableUpdateChildrenOnAddAndRemove()) { using (viewModel.DisableDrawIntoState()) { viewModel.AnimationEditor.DeleteAllAnimations((SceneNode)sourceElement); Dictionary <IPropertyId, SceneNode> properties = SceneElementHelper.StoreProperties((SceneNode)sourceElement); Dictionary <IPropertyId, List <SceneNode> > storedChildren = ChangeLayoutTypeCommand.StoreChildren(sourceElement); if (sourceElement.DocumentNode == documentRoot.RootNode) { documentRoot.RootNode = sceneElement.DocumentNode; sceneElement.DocumentNode.NameScope = new DocumentNodeNameScope(); } else { ISceneNodeCollection <SceneNode> collectionContainer = sourceElement.GetCollectionContainer(); int index = collectionContainer.IndexOf((SceneNode)sourceElement); sourceElement.Remove(); collectionContainer.Insert(index, (SceneNode)sceneElement); } SceneElementHelper.ApplyProperties((SceneNode)sceneElement, properties); elementContainingChildren = ChangeLayoutTypeCommand.ApplyChildren(sceneElement, storedChildren, size); } } if (sceneElement is GridElement || sceneElement is CanvasElement) { ILayoutDesigner designerForChild = sceneElement.ViewModel.GetLayoutDesignerForChild(sceneElement, true); if ((designerForChild.GetWidthConstraintMode((BaseFrameworkElement)sceneElement) & LayoutConstraintMode.CanvasLike) != LayoutConstraintMode.NonOverlappingGridlike) { sceneElement.SetValue(BaseFrameworkElement.WidthProperty, (object)size.Width); } if ((designerForChild.GetHeightConstraintMode((BaseFrameworkElement)sceneElement) & LayoutConstraintMode.CanvasLike) != LayoutConstraintMode.NonOverlappingGridlike) { sceneElement.SetValue(BaseFrameworkElement.HeightProperty, (object)size.Height); } } return(sceneElement); } }
private static IType GetDesignDataType(DocumentCompositeNode designDataNode) { if (designDataNode.DocumentRoot == null) { return((IType)null); } IType type = (IType)null; IDocumentRoot sourceXamlDocument = DesignDataInstanceBuilder.GetSourceXamlDocument(designDataNode); if (sourceXamlDocument != null && sourceXamlDocument.RootNode != null) { type = DataContextHelper.GetDataType(sourceXamlDocument.RootNode); } return(type); }
internal static void PreserveFormatting(IDocumentRoot documentRoot, DocumentNode node) { if (node.SourceContext != null) { documentRoot.SetSourceContext(node, node.SourceContext.FreezeText(false)); } if (node.ContainerSourceContext != null) { documentRoot.SetContainerSourceContext(node, node.ContainerSourceContext.FreezeText(false)); } foreach (DocumentNode node1 in node.ChildNodes) { DocumentNodeHelper.PreserveFormatting(documentRoot, node1); } }
public IInstanceBuilderContext GetViewContext(IDocumentRoot documentRoot) { if (documentRoot == null) { return((IInstanceBuilderContext)null); } foreach (IView view in (IEnumerable <IView>) this.ViewService.Views) { SceneView sceneView = view as SceneView; if (sceneView != null && !sceneView.IsClosing && sceneView.DocumentRoot == documentRoot) { return(sceneView.RootInstanceBuilderContext); } } return(this.GetUnopenedDocumentContext(documentRoot)); }
private static IDocumentRoot GetSourceXamlDocumentInternal(DocumentCompositeNode designDataNode, string fullPath) { IDocumentRoot documentRoot = null; try { if (!string.IsNullOrEmpty(fullPath)) { documentRoot = designDataNode.Context.GetDocumentRoot(fullPath); } } catch (InvalidOperationException invalidOperationException) { } catch (IOException oException) { } return(documentRoot); }
private static void FindReferencedDictionaryFromSource(DocumentCompositeNode resourceDictionaryNode, HashSet <Uri> dictionaries) { DocumentCompositeNode rootNode; Uri uriValue = resourceDictionaryNode.GetUriValue(KnownProperties.ResourceDictionarySourceProperty); if (uriValue != null) { uriValue = resourceDictionaryNode.Context.MakeDesignTimeUri(uriValue); if (uriValue != null && uriValue.IsAbsoluteUri && !dictionaries.Contains(uriValue)) { dictionaries.Add(uriValue); DocumentCompositeNode documentCompositeNode = null; IDocumentRoot documentRoot = null; try { documentRoot = resourceDictionaryNode.Context.GetDocumentRoot(uriValue.OriginalString); if (documentRoot != null) { if (documentRoot.IsEditable) { rootNode = documentRoot.RootNode as DocumentCompositeNode; } else { rootNode = null; } documentCompositeNode = rootNode; } } catch (IOException oException) { } catch (NotSupportedException notSupportedException) { } if (documentCompositeNode != null && PlatformTypes.ResourceDictionary.IsAssignableFrom(documentCompositeNode.Type)) { ResourceNodeHelper.FindReferencedDictionariesInternal(documentCompositeNode, dictionaries); } } } }
private DocumentCompositeNode FindResourceInRelatedDocument(IDocumentRootResolver documentRootResolver, DocumentNode keyNode, ICollection <DocumentCompositeNode> resourcesHostNodePath, ICollection <IDocumentRoot> relatedRoots, ResourceSite.ResourceDictionaryLink container, DocumentNode rootNode) { IDocumentRoot documentRoot = rootNode.DocumentRoot; for (ResourceSite.ResourceDictionaryLink i = container; i != null; i = i.Container) { if (i.DocumentRoot == documentRoot) { return(null); } } ResourceSite resourceSite = new ResourceSite(rootNode); DocumentCompositeNode documentCompositeNode = resourceSite.FindResource(documentRootResolver, keyNode, resourcesHostNodePath, relatedRoots, new ResourceSite.ResourceDictionaryLink(container, documentRoot), -1, null); if (documentCompositeNode != null && relatedRoots != null) { relatedRoots.Add(documentRoot); } return(documentCompositeNode); }
private void InitializeClassName(SceneViewModel viewModel) { if (viewModel == null) { return; } IDocumentRoot documentRoot = viewModel.DocumentRoot; if (this.nameScope != documentRoot.RootNode.NameScope) { return; } ITypeId typeId = (ITypeId)documentRoot.CodeBehindClass; if (typeId == null) { return; } this.className = typeId.Name; }
private static void RefreshSiblingOrdering(DocumentNode node) { IDocumentRoot documentRoot = node.DocumentRoot; if (documentRoot == null || node.Parent == null) { return; } foreach (KeyValuePair <IProperty, DocumentNode> keyValuePair in (IEnumerable <KeyValuePair <IProperty, DocumentNode> >)node.Parent.Properties) { if (node != keyValuePair.Value) { XamlSourceContext xamlSourceContext1 = keyValuePair.Value.ContainerSourceContext as XamlSourceContext; if (xamlSourceContext1 != null) { XamlSourceContext xamlSourceContext2 = (XamlSourceContext)xamlSourceContext1.Clone(true); xamlSourceContext2.RefreshOrdering(); documentRoot.SetContainerSourceContext(keyValuePair.Value, (INodeSourceContext)xamlSourceContext2); } } } }
internal static void EditControl(SceneElement sceneElement) { if (sceneElement == null || sceneElement.DocumentNode == null) { return; } IType type = sceneElement.DocumentNode.Type; if (type.XamlSourcePath == null) { return; } try { IDocumentRoot documentRoot = sceneElement.ProjectContext.GetDocumentRoot(type.XamlSourcePath); ISceneViewHost sceneViewHost = sceneElement.ProjectContext as ISceneViewHost; if (sceneViewHost == null || documentRoot == null) { return; } sceneViewHost.OpenView(documentRoot, true); } catch (Exception ex) { if (ex is ArgumentException || ex is IOException || (ex is InvalidOperationException || ex is UnauthorizedAccessException)) { string message = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.FileOpenFailedDialogMessage, new object[2] { (object)Path.GetFileName(type.XamlSourcePath), (object)ex.Message }); sceneElement.DesignerContext.MessageDisplayService.ShowError(message); } else { throw; } } }
public IInstanceBuilderContext GetViewContext(IDocumentRoot documentRoot) { IInstanceBuilderContext viewContext = this.viewRootResolver.GetViewContext(documentRoot); if (viewContext == null) { return(null); } ViewNode root = viewContext.ViewNodeManager.Root; if (root != null && root.InstanceState == InstanceState.Invalid) { using (IDisposable disposable = viewContext.ChangeCrossDocumentUpdateContext(this)) { viewContext.ViewNodeManager.UpdateInstances(null); } if (this.contexts != null) { this.GetContextInfo(viewContext, true); } } return(viewContext); }
public override bool ShouldInstantiatePreviewControl(IDocumentRoot documentRoot) { if (base.ShouldInstantiatePreviewControl(documentRoot)) { return(true); } IProjectDocument projectDocument = this.viewModel.ProjectContext.OpenDocument(documentRoot.DocumentContext.DocumentUrl); if (projectDocument != null && projectDocument.IsDirty) { return(true); } IAssembly projectAssembly = documentRoot.TypeResolver.ProjectAssembly; if (projectAssembly.IsLoaded) { FileInfo fileInfo = new FileInfo(projectAssembly.Location); if (fileInfo.Exists && projectDocument != null) { return(new FileInfo(projectDocument.Path).LastWriteTimeUtc > fileInfo.LastWriteTimeUtc); } } return(false); }
public static void PrepareNodeForTextDeletion(IDocumentRoot documentRoot, DocumentNode node) { node.ClearOldSourceContainerContext(); DocumentNodeHelper.PreserveFormatting(documentRoot, node); }
public virtual bool ShouldInstantiatePreviewControl(IDocumentRoot documentRoot) { return(!documentRoot.TypeResolver.ProjectAssembly.IsLoaded); }
public DocumentCompositeNode FindResource(IDocumentRootResolver documentRootResolver, DocumentNode keyNode, ICollection <DocumentCompositeNode> resourcesHostNodePath, ICollection <IDocumentRoot> relatedRoots, int numberOfChildrenToSearch, ICollection <string> warnings) { IDocumentRoot documentRoot = this.resourcesHost.HostNode.DocumentRoot; return(this.FindResource(documentRootResolver, keyNode, resourcesHostNodePath, relatedRoots, new ResourceSite.ResourceDictionaryLink(null, documentRoot), numberOfChildrenToSearch, warnings)); }
public MultiDocumentReferenceChangeModel(string oldReferenceValue, string newReferenceValue, IDocumentRoot documentRoot, IProjectContext projectContext) : base(oldReferenceValue, newReferenceValue) { this.NodesForLocalUpdate = (ICollection <ChangedNodeInfo>) new List <ChangedNodeInfo>(); this.NodesForExternalUpdate = (ICollection <ChangedNodeInfo>) new List <ChangedNodeInfo>(); this.DocumentRoot = documentRoot; this.ProjectContext = projectContext; }
public IProjectDocument GetDocument(IDocumentRoot documentRoot) { return(this.actualProjectContext.GetDocument(documentRoot)); }
private bool IsSampleDataXamlContext(IInstanceBuilderContext context, IDocumentRoot sampleDataXamlDocumentRoot) { return(sampleDataXamlDocumentRoot != null && context.ContainerRoot != null && context.ContainerRoot.DocumentNode.DocumentRoot == sampleDataXamlDocumentRoot); }
public IProjectDocument GetDocument(IDocumentRoot documentRoot) { throw new NotImplementedException(); }
internal static SceneDocument GetSceneDocument(DesignerContext designerContext, IDocumentRoot documentRoot) { foreach (IDocument document in (IEnumerable <IDocument>)designerContext.DocumentService.Documents) { SceneDocument sceneDocument = document as SceneDocument; if (sceneDocument != null && sceneDocument.DocumentRoot == documentRoot) { return(sceneDocument); } } return((SceneDocument)null); }
public abstract IProjectDocument GetDocument(IDocumentRoot documentRoot);
public virtual void SetDocumentRoot(IDocumentRoot documentRoot) { this.SetDocumentRootRecursively(documentRoot); }
public ResourceDictionaryLink(ResourceSite.ResourceDictionaryLink container, IDocumentRoot documentRoot) { this.container = container; this.documentRoot = documentRoot; }
public override IProjectDocument GetDocument(IDocumentRoot documentRoot) { return((IProjectDocument)null); }
public IProjectDocument GetDocument(IDocumentRoot documentRoot) { return(this.sourceContext.GetDocument(documentRoot)); }