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));
}
