public Size CalcCombinedSize(SceneViewModel viewModel)
{
Size size = new Size();
for (int index = 0; index < this.records.Count; ++index)
{
if (index > 0)
{
size.Height += CanvasLikeDataViewLayoutBuilder.defaultInnerMargin.Height;
}
CanvasLikeDataViewLayoutBuilder.LabelField labelField = this.records[index];
BaseFrameworkElement frameworkElement = (BaseFrameworkElement)viewModel.GetSceneNode(labelField.Label);
Rect computedTightBounds1 = ((Base2DElement)viewModel.GetSceneNode(labelField.Field)).GetComputedTightBounds();
if (frameworkElement != null)
{
Rect computedTightBounds2 = frameworkElement.GetComputedTightBounds();
size.Height += Math.Max(computedTightBounds2.Height, computedTightBounds1.Height);
size.Width = Math.Max(size.Width, computedTightBounds2.Width + computedTightBounds1.Width + CanvasLikeDataViewLayoutBuilder.defaultInnerMargin.Width);
}
else
{
size.Width += computedTightBounds1.Width;
size.Height += computedTightBounds1.Height;
}
}
return(size);
}
public void ApplyActiveUserThemeStyle(SceneViewModel viewModel)
{
for (int index = 0; index < this.records.Count; ++index)
{
CanvasLikeDataViewLayoutBuilder.LabelField labelField = this.records[index];
AssetLibrary.ApplyActiveUserThemeStyle(viewModel.GetSceneNode(labelField.Label));
AssetLibrary.ApplyActiveUserThemeStyle(viewModel.GetSceneNode(labelField.Field));
}
}
protected override DocumentNodePath ProvideEditingContainer(SceneElement targetElement, PropertyReference targetProperty, DocumentNode resourceNode)
{
if (this.UseStyle)
{
if (this.SceneView.IsEditable && targetElement.IsViewObjectValid && (this.SceneView.GetViewState((SceneNode)targetElement) & this.RequiredSelectionViewState) == this.RequiredSelectionViewState)
{
Type runtimeType = this.SceneViewModel.ProjectContext.ResolveType(PlatformTypes.FrameworkTemplate).RuntimeType;
return(this.SceneView.GetCorrespondingNodePath(this.SceneViewModel.ProjectContext.Platform.ViewObjectFactory.Instantiate(targetElement.GetComputedValue((IPropertyId)this.ProvideTemplateProperty(SingleTargetCommandBase.GetTypeOfElement(targetElement)))), true));
}
SceneNode sceneNode = targetElement.GetLocalValueAsSceneNode(targetProperty);
if (sceneNode == null && resourceNode != null && resourceNode.IsInDocument)
{
SceneViewModel viewModel = SceneViewModel.GetViewModel(this.ViewHost, resourceNode.DocumentRoot, false);
if (viewModel != null)
{
sceneNode = viewModel.GetSceneNode(resourceNode);
}
}
if (sceneNode != null)
{
return(sceneNode.GetLocalValueAsDocumentNode((IPropertyId)this.ProvideTemplateProperty(SingleTargetCommandBase.GetTypeOfElement(targetElement))));
}
}
return(targetElement.GetLocalValueAsDocumentNode(targetProperty));
}
private static DocumentNode GetTemplateNode(SceneNode newElement, DocumentCompositeNode styleNode, out StyleNode styleElement)
{
DocumentCompositeNode documentCompositeNode1 = styleNode.Properties[DictionaryEntryNode.ValueProperty] as DocumentCompositeNode;
SceneViewModel viewModel = newElement.ViewModel.GetViewModel(documentCompositeNode1.DocumentRoot, false);
if (viewModel == null)
{
styleElement = (StyleNode)null;
return((DocumentNode)null);
}
styleElement = viewModel.GetSceneNode((DocumentNode)documentCompositeNode1) as StyleNode;
DependencyPropertyReferenceStep propertyReferenceStep = (DependencyPropertyReferenceStep)newElement.ViewModel.ProjectContext.ResolveProperty(ControlElement.TemplateProperty);
if (documentCompositeNode1 != null)
{
DocumentCompositeNode documentCompositeNode2 = documentCompositeNode1.Properties[StyleNode.SettersProperty] as DocumentCompositeNode;
if (documentCompositeNode2 != null)
{
foreach (DocumentNode documentNode1 in (IEnumerable <DocumentNode>)documentCompositeNode2.Children)
{
DocumentCompositeNode documentCompositeNode3 = documentNode1 as DocumentCompositeNode;
if (documentCompositeNode3 != null)
{
IMemberId memberId = (IMemberId)DocumentPrimitiveNode.GetValueAsMember(documentCompositeNode3.Properties[SetterSceneNode.PropertyProperty]);
DocumentNode documentNode2 = documentCompositeNode3.Properties[SetterSceneNode.ValueProperty];
if (memberId != null && documentNode2 != null && propertyReferenceStep.Equals((object)memberId))
{
return(documentNode2);
}
}
}
}
}
return((DocumentNode)null);
}
private static DictionaryEntryNode ResolveResourceConflict(ResourceEvaluation resourceEvaluation, IList <SceneNode> elements, SceneNode destination, ResourceConflictResolution resolution)
{
DictionaryEntryNode originalResource = resourceEvaluation.OriginalResource;
DocumentNode evaluatedResource = resourceEvaluation.EvaluatedResource;
DictionaryEntryNode dictionaryEntryNode = (DictionaryEntryNode)null;
if (resolution == ResourceConflictResolution.RenameNew)
{
DocumentNode newKey = ResourceHelper.GenerateUniqueResourceKey(originalResource.Key.ToString(), destination);
ResourceHelper.ChangeKey(elements, originalResource, originalResource.KeyNode.DocumentNode, newKey);
dictionaryEntryNode = originalResource;
}
else if (resolution == ResourceConflictResolution.OverwriteOld)
{
DocumentCompositeNode parent = evaluatedResource.Parent;
if (parent != null && typeof(DictionaryEntry).IsAssignableFrom(parent.TargetType))
{
SceneViewModel viewModel = SceneViewModel.GetViewModel((ISceneViewHost)destination.ProjectContext.GetService(typeof(ISceneViewHost)), parent.DocumentRoot, false);
if (viewModel != null)
{
using (SceneEditTransaction editTransaction = viewModel.CreateEditTransaction(StringTable.UndoResourceOverwrite))
{
((DictionaryEntryNode)viewModel.GetSceneNode((DocumentNode)parent)).Value = viewModel.GetSceneNode(originalResource.Value.DocumentNode.Clone(viewModel.Document.DocumentContext));
editTransaction.Commit();
}
}
}
dictionaryEntryNode = (DictionaryEntryNode)null;
}
else if (resolution == ResourceConflictResolution.UseExisting)
{
dictionaryEntryNode = (DictionaryEntryNode)null;
}
return(dictionaryEntryNode);
}
internal static BehaviorTriggerBaseNode CloneTrigger(BehaviorTriggerBaseNode trigger, SceneViewModel viewModel)
{
DocumentCompositeNode documentCompositeNode = (DocumentCompositeNode)trigger.DocumentNode.Clone(trigger.DocumentContext);
documentCompositeNode.Properties[BehaviorTriggerBaseNode.BehaviorActionsProperty] = (DocumentNode)null;
return((BehaviorTriggerBaseNode)viewModel.GetSceneNode((DocumentNode)documentCompositeNode));
}
public static void CopyBehaviorNodes(SceneViewModel viewModel, IList <BehaviorBaseNode> behaviorNodes)
{
PastePackage pastePackage = new PastePackage(viewModel);
using (viewModel.ForceBaseValue())
{
foreach (SceneNode childPropertyNode in (IEnumerable <BehaviorBaseNode>)behaviorNodes)
{
if (ProjectNeutralTypes.Behavior.IsAssignableFrom((ITypeId)childPropertyNode.Type))
{
pastePackage.AddChildPropertyNode(childPropertyNode);
}
else
{
BehaviorTriggerActionNode triggerActionNode1 = (BehaviorTriggerActionNode)childPropertyNode;
BehaviorTriggerBaseNode behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)triggerActionNode1.Parent;
if (behaviorTriggerBaseNode.Actions.Count > 1)
{
DocumentNode node1 = triggerActionNode1.DocumentNode.Clone(viewModel.Document.DocumentContext);
BehaviorTriggerActionNode triggerActionNode2 = (BehaviorTriggerActionNode)viewModel.GetSceneNode(node1);
DocumentNode node2 = behaviorTriggerBaseNode.DocumentNode.Clone(viewModel.Document.DocumentContext);
behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)viewModel.GetSceneNode(node2);
behaviorTriggerBaseNode.Actions.Clear();
behaviorTriggerBaseNode.Actions.Add((SceneNode)triggerActionNode2);
}
pastePackage.AddChildPropertyNode((SceneNode)behaviorTriggerBaseNode);
}
}
}
pastePackage.SendToClipboard();
}
public override void ApplyChange(SceneViewModel viewModel)
{
if (this.Change.BreakingChange)
{
return;
}
viewModel.GetSceneNode((DocumentNode)this.DocumentNode).SetLocalValue((IPropertyId)this.PathProperty, (object)this.Change.NewPath);
}
protected override DocumentNodePath ProvideEditingContainer(SceneElement targetElement, PropertyReference targetProperty, DocumentNode resourceNode)
{
SceneViewModel viewModel = targetElement.ViewModel.GetViewModel(resourceNode.DocumentRoot, false);
DocumentNodePath documentNodePath = targetElement.GetLocalValueAsDocumentNode(targetProperty) ?? new DocumentNodePath(resourceNode.DocumentRoot.RootNode, resourceNode);
DocumentNode documentNode = (viewModel.GetSceneNode(resourceNode) as StyleNode).GetLocalValueAsSceneNode(ControlElement.TemplateProperty).DocumentNode;
return(documentNodePath.GetPathInContainer((DocumentNode)documentNode.Parent).GetPathInSubContainer(documentNode.SitePropertyKey, documentNode));
}
internal static bool CopyResourcesToNewResourceSite(IList <DocumentCompositeNode> auxillaryResources, SceneViewModel resourcesHostViewModel, DocumentCompositeNode resourcesHostNode, DocumentCompositeNode insertedResourceNode, int indexInResourceSite)
{
if (auxillaryResources == null || auxillaryResources.Count <= 0)
{
return(true);
}
bool flag = true;
ResourceConflictResolution conflictResolution = ResourceConflictResolution.Undetermined;
SceneNode sceneNode = resourcesHostViewModel.GetSceneNode((DocumentNode)resourcesHostNode);
List <DictionaryEntryNode> list1 = new List <DictionaryEntryNode>();
List <SceneNode> list2 = new List <SceneNode>();
foreach (DocumentNode documentNode in (IEnumerable <DocumentCompositeNode>)auxillaryResources)
{
DocumentNode node = documentNode.Clone(resourcesHostViewModel.Document.DocumentContext);
DictionaryEntryNode dictionaryEntryNode = (DictionaryEntryNode)resourcesHostViewModel.GetSceneNode(node);
list1.Add(dictionaryEntryNode);
if (dictionaryEntryNode.Value != null)
{
list2.Add(dictionaryEntryNode.Value);
}
}
if (insertedResourceNode != null)
{
list2.Add(resourcesHostViewModel.GetSceneNode((DocumentNode)insertedResourceNode));
}
IList <ResourceEvaluation> list3 = ResourceHelper.EvaluateResources((IList <DictionaryEntryNode>)list1, sceneNode);
if (ResourceHelper.CheckEvaluationResults(list3, ResourceEvaluationResult.ConflictingResourceExists, ResourceEvaluationResult.ConflictingResourceIsMasked))
{
conflictResolution = ResourceHelper.PromptForResourceConflictResolution(ResourceConflictResolution.RenameNew | ResourceConflictResolution.OverwriteOld);
if (conflictResolution == ResourceConflictResolution.Undetermined)
{
flag = false;
}
}
if (flag)
{
ResourceHelper.EnsureResourceDictionaryNode(sceneNode);
ResourceHelper.AddResources(list3, (IList <SceneNode>)list2, conflictResolution, sceneNode, indexInResourceSite);
}
return(flag);
}
public void SelectElements(SceneViewModel viewModel)
{
List <SceneElement> list = new List <SceneElement>(this.records.Count * 2);
for (int index = 0; index < this.records.Count; ++index)
{
CanvasLikeDataViewLayoutBuilder.LabelField labelField = this.records[index];
SceneElement sceneElement1 = (SceneElement)viewModel.GetSceneNode(labelField.Label);
SceneElement sceneElement2 = (SceneElement)viewModel.GetSceneNode(labelField.Field);
if (sceneElement1 != null)
{
list.Add(sceneElement1);
}
list.Add(sceneElement2);
}
if (list.Count < 1)
{
return;
}
viewModel.ElementSelectionSet.SetSelection((ICollection <SceneElement>)list, (SceneElement)null);
}
public void RebindFields(SceneViewModel viewModel, ISchema schema, IList <DataSchemaNodePath> viewEntries)
{
for (int index = 0; index < viewEntries.Count; ++index)
{
DataSchemaNodePath dataSchemaNodePath = viewEntries[index];
DataSchemaNodePath bindingPath = new DataSchemaNodePath(schema, dataSchemaNodePath.Node);
DocumentCompositeNode fieldNode = (DocumentCompositeNode)this.records[index].Field;
SceneNode sceneNode = viewModel.GetSceneNode((DocumentNode)fieldNode);
IProperty property = Enumerable.First <IProperty>((IEnumerable <IProperty>)fieldNode.Properties.Keys, (Func <IProperty, bool>)(p => fieldNode.Properties[(IPropertyId)p].Type.IsBinding));
viewModel.BindingEditor.CreateAndSetBindingOrData(sceneNode, (IPropertyId)property, bindingPath);
}
}
public void CompleteLayout(SceneViewModel viewModel, Point startPoint)
{
ILayoutDesigner layoutDesigner = (ILayoutDesigner)null;
Point point = startPoint;
for (int index = 0; index < this.records.Count; ++index)
{
if (index > 0)
{
point.Y += CanvasLikeDataViewLayoutBuilder.defaultInnerMargin.Height;
}
CanvasLikeDataViewLayoutBuilder.LabelField labelField = this.records[index];
BaseFrameworkElement element1 = (BaseFrameworkElement)viewModel.GetSceneNode(labelField.Label);
BaseFrameworkElement element2 = (BaseFrameworkElement)viewModel.GetSceneNode(labelField.Field);
if (layoutDesigner == null)
{
layoutDesigner = viewModel.GetLayoutDesignerForChild((SceneElement)element2, true);
}
Rect rect1 = element1 != null?element1.GetComputedTightBounds() : Rect.Empty;
Rect computedTightBounds = element2.GetComputedTightBounds();
Point location = point;
double num = element1 != null?Math.Max(rect1.Height, computedTightBounds.Height) : computedTightBounds.Height;
if (element1 != null)
{
location.Y += (num - rect1.Height) / 2.0;
Rect rect2 = new Rect(location, rect1.Size);
CanvasLikeDataViewLayoutBuilder.SetElementRect(layoutDesigner, element1, rect2);
location.Y -= (num - rect1.Height) / 2.0;
location.X = rect2.Right + CanvasLikeDataViewLayoutBuilder.defaultInnerMargin.Width;
}
location.Y += (num - computedTightBounds.Height) / 2.0;
Rect rect3 = new Rect(location, computedTightBounds.Size);
CanvasLikeDataViewLayoutBuilder.SetElementRect(layoutDesigner, element2, rect3);
double right = rect3.Right;
double y = point.Y;
point.Y += num;
}
}
private static SceneNode SetActiveEditingContainerInternal(ControlStylingOperations.EditScope scope)
{
SceneViewModel viewModel = scope.TargetElement.ViewModel.GetViewModel(scope.Node.DocumentRoot, true);
if (viewModel == null)
{
return((SceneNode)null);
}
SceneElement selectionToSet = (SceneElement)viewModel.GetSceneNode(scope.Node);
if (selectionToSet.IsLocked)
{
using (SceneEditTransaction editTransaction = viewModel.CreateEditTransaction(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.UndoUnitEditStyleTemplate, new object[1]
{
(object)scope.TargetProperty.Name
})))
{
selectionToSet.IsLocked = false;
editTransaction.Commit();
}
}
if (viewModel == scope.TargetElement.ViewModel && scope.EditInPlace)
{
if (scope.NodePath != null)
{
viewModel.ActiveEditingContainerPath = scope.NodePath;
}
}
else
{
IPropertyId ancestorPropertyKey = (IPropertyId)scope.TargetProperty;
if (scope.NodePath != null)
{
DocumentNodePath documentNodePath = scope.NodePath;
ancestorPropertyKey = (IPropertyId)documentNodePath.ContainerOwnerProperty;
while ((documentNodePath = documentNodePath.GetContainerOwnerPath()) != null && documentNodePath.Node != scope.TargetElement.DocumentNode)
{
ancestorPropertyKey = (IPropertyId)documentNodePath.ContainerOwnerProperty;
}
}
BaseFrameworkElement frameworkElement = scope.TargetElement as BaseFrameworkElement;
Size preferredSize = frameworkElement == null || !frameworkElement.IsViewObjectValid || !ControlStylingOperations.DoesPropertyAffectRoot((IPropertyId)scope.TargetProperty) ? Size.Empty : frameworkElement.GetComputedBounds((Base2DElement)frameworkElement).Size;
viewModel.SetViewRoot(scope.TargetElement.ViewModel.DefaultView, scope.TargetElement, ancestorPropertyKey, scope.Node, preferredSize);
viewModel.DefaultView.EnsureDesignSurfaceVisible();
}
if (viewModel.IsEditable)
{
viewModel.ElementSelectionSet.SetSelection(selectionToSet);
}
return(viewModel.ActiveEditingContainer);
}
public override void ApplyChange(SceneViewModel viewModel)
{
if (this.Change.BreakingChange)
{
return;
}
BindingSceneNode bindingSceneNode = viewModel.GetSceneNode((DocumentNode)this.DocumentNode) as BindingSceneNode;
if (bindingSceneNode == null)
{
return;
}
bindingSceneNode.SetPath(this.Change.NewPath);
}
public override void ApplyChange(SceneViewModel viewModel)
{
if (this.Change.BreakingChange)
{
return;
}
SceneNode sceneNode = viewModel.GetSceneNode((DocumentNode)this.DocumentNode);
if (sceneNode == null)
{
return;
}
sceneNode.SetLocalValue(SampleDataDocumentChangeProcessor.ChangePropertyActionNameProperty, (object)this.Change.NewPath);
}
private bool CopyResourceCore()
{
if (this.resourceManager.SelectedResourceContainers.Count == 0 && this.resourceManager.SelectedResourceItems.Count == 1)
{
ResourceEntryItem resourceEntryItem = this.resourceManager.SelectedResourceItems[0] as ResourceEntryItem;
if (resourceEntryItem != null)
{
SceneViewModel viewModel = resourceEntryItem.Container.ViewModel;
PastePackage pastePackage = new PastePackage(viewModel);
pastePackage.AddResource(viewModel.GetSceneNode((DocumentNode)resourceEntryItem.Resource.ResourceNode) as DictionaryEntryNode);
pastePackage.SendToClipboard();
return(true);
}
}
return(false);
}
public override void InteractiveDelete()
{
ReferencesFoundModel referencingResources = this.InteractiveGetReferencingResources(ReferencesFoundModel.UseScenario.DeleteResource);
if (referencingResources == null || referencingResources.ReferenceNames.Count > 0 && !this.ShowReferencesFoundDialog(referencingResources).GetValueOrDefault(false))
{
return;
}
PerformanceUtility.StartPerformanceSequence(PerformanceEvent.DeleteResourceItem);
SceneViewModel viewModel = this.Container.ViewModel;
using (SceneEditTransaction editTransaction = viewModel.CreateEditTransaction(StringTable.UndoUnitDeleteResource))
{
this.Container.ResourceDictionaryNode.Remove((DictionaryEntryNode)viewModel.GetSceneNode((DocumentNode)this.resource.ResourceNode));
editTransaction.Commit();
}
PerformanceUtility.EndPerformanceSequence(PerformanceEvent.DeleteResourceItem);
}
public static bool CanEditInPlace(SceneElement targetElement, ReferenceStep targetProperty, DocumentNodePath template)
{
DocumentNodePath documentNodePath = targetElement.DocumentNodePath;
SceneViewModel viewModel = targetElement.ViewModel.GetViewModel(template.Node.DocumentRoot, true);
if (targetElement.IsViewObjectValid && (targetElement.IsInstantiatedElementVisible || PlatformTypes.Style.IsAssignableFrom((ITypeId)template.Node.Type) && (targetProperty.Equals((object)BaseFrameworkElement.StyleProperty) || targetProperty == StyleNode.BasedOnProperty)) && (viewModel == targetElement.ViewModel && documentNodePath.IsAncestorOf(template)))
{
if (viewModel.DefaultView.GetInstantiatedElements(template).Count > 0)
{
return(true);
}
if (!viewModel.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf) && PlatformTypes.FrameworkTemplate.IsAssignableFrom((ITypeId)template.Node.Type))
{
SceneNode valueAsSceneNode = viewModel.GetSceneNode(template.Node).GetLocalValueAsSceneNode(viewModel.ProjectContext.PlatformMetadata.KnownProperties.FrameworkTemplateVisualTree);
if (valueAsSceneNode != null)
{
IViewVisual viewVisual = targetElement.ViewTargetElement as IViewVisual;
if (viewVisual == null && ProjectNeutralTypes.DataGridColumn.IsAssignableFrom((ITypeId)targetElement.Type))
{
DataGridElement dataGridElement = targetElement.Parent as DataGridElement;
if (dataGridElement != null && targetElement.DocumentNode.IsChild && (targetElement.DocumentNode.Parent.IsProperty && DataGridElement.ColumnsProperty.Equals((object)targetElement.DocumentNode.Parent.SitePropertyKey)))
{
viewVisual = dataGridElement.ViewTargetElement as IViewVisual;
}
}
if (viewVisual != null)
{
DocumentNodePath pathInContainer = template.GetPathInContainer(valueAsSceneNode.DocumentNode);
foreach (IViewObject viewObject in (IEnumerable <IViewObject>)viewModel.DefaultView.GetInstantiatedElements(pathInContainer))
{
IViewVisual visual = viewObject as IViewVisual;
if (visual != null && viewVisual.IsAncestorOf(visual))
{
return(true);
}
}
}
}
}
}
return(false);
}
private static IEnumerable <DocumentNode> TraverseDocumentDescendants(DocumentNode node, ISearchPredicate continueTester, SceneViewModel viewModel)
{
if (node.ChildNodesCount != 0)
{
IEnumerator <DocumentNode> descendantEnumerator = node.DescendantNodes.GetEnumerator();
while (descendantEnumerator.MoveNext())
{
DocumentNode current = descendantEnumerator.Current;
yield return(current);
if (continueTester != null && !continueTester.Test(viewModel.GetSceneNode(current)))
{
IDescendantEnumerator descendantEnumerator1 = descendantEnumerator as IDescendantEnumerator;
if (descendantEnumerator1 != null)
{
descendantEnumerator1.SkipPastDescendants(current);
}
}
}
}
}
internal ReferencesFoundModel InteractiveGetReferencingResources(ReferencesFoundModel.UseScenario useScenario)
{
SceneViewModel viewModel = this.Container.ViewModel;
List <SceneNode> list = new List <SceneNode>();
viewModel.FindInternalResourceReferences(this.resource.ResourceNode, (ICollection <SceneNode>)list);
ITypeId type = (ITypeId)viewModel.RootNode.Type;
bool flag = PlatformTypes.ResourceDictionary.IsAssignableFrom(type) || PlatformTypes.Application.IsAssignableFrom(type);
ReferencesFoundModel model = new ReferencesFoundModel(viewModel.GetSceneNode((DocumentNode)this.resource.ResourceNode), (ICollection <SceneNode>)list, useScenario);
if (list.Count > 0 || flag)
{
if (!new AsyncProcessDialog((AsyncProcess) new SerialAsyncProcess((IAsyncMechanism) new CurrentDispatcherAsyncMechanism(DispatcherPriority.Background), new AsyncProcess[2]
{
(AsyncProcess) new ExternalOpenSceneResourceReferenceAnalyzer(model),
(AsyncProcess) new ExternalClosedSceneResourceReferenceAnalyzer(model)
}), this.DesignerContext.ExpressionInformationService).ShowDialog().GetValueOrDefault(false))
{
model = (ReferencesFoundModel)null;
}
}
return(model);
}
public static SceneNode CreateClrObjectDataSource(out string dataSourceName, out Type dataSourceType, DataPanelModel model)
{
SceneNode sceneNode = (SceneNode)null;
dataSourceName = (string)null;
dataSourceType = (Type)null;
ClrObjectDataSourceDialog dataSourceDialog = new ClrObjectDataSourceDialog(model);
bool?nullable = dataSourceDialog.ShowDialog();
if ((!nullable.GetValueOrDefault() ? 0 : (nullable.HasValue ? true : false)) != 0)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.AddClrDataSource);
dataSourceType = dataSourceDialog.ObjectType;
dataSourceName = dataSourceDialog.DataSourceName;
if (dataSourceDialog.ObjectType != (Type)null)
{
dataSourceName = dataSourceName.Trim();
SceneViewModel activeSceneViewModel = model.DesignerContext.ActiveSceneViewModel;
DocumentNode node = (DocumentNode)activeSceneViewModel.Document.DocumentContext.CreateNode(dataSourceDialog.ObjectType);
sceneNode = activeSceneViewModel.GetSceneNode(node);
}
}
return(sceneNode);
}
private void ActivateTemplateEditingMode(SceneElement targetElement)
{
object computedValue = targetElement.GetComputedValue(ControlElement.TemplateProperty);
if (computedValue == null)
{
return;
}
DocumentNodePath correspondingNodePath = this.SceneView.GetCorrespondingNodePath(this.SceneViewModel.ProjectContext.Platform.ViewObjectFactory.Instantiate(computedValue), true);
if (correspondingNodePath == null)
{
return;
}
SceneViewModel viewModel = this.SceneViewModel.GetViewModel(correspondingNodePath.Node.DocumentRoot, true);
if (this.SceneViewModel == viewModel)
{
viewModel.ActiveEditingContainerPath = correspondingNodePath;
}
else
{
IPropertyId ancestorPropertyKey = (IPropertyId)(this.SceneViewModel.ProjectContext.ResolveProperty(BaseFrameworkElement.StyleProperty) as ReferenceStep);
BaseFrameworkElement frameworkElement = targetElement as BaseFrameworkElement;
Size preferredSize = frameworkElement == null || !frameworkElement.IsViewObjectValid ? Size.Empty : frameworkElement.GetComputedBounds((Base2DElement)frameworkElement).Size;
viewModel.SetViewRoot(this.SceneViewModel.DefaultView, targetElement, ancestorPropertyKey, correspondingNodePath.Node, preferredSize);
viewModel.DefaultView.EnsureDesignSurfaceVisible();
}
if (!viewModel.IsEditable)
{
return;
}
SceneElement selectionToSet = viewModel.GetSceneNode(correspondingNodePath.Node) as SceneElement;
viewModel.ElementSelectionSet.SetSelection(selectionToSet);
}
public static object GetTemplateDataContext(DocumentNode rootNode, SceneViewModel viewModel)
{
if (!PlatformTypes.DataTemplate.IsAssignableFrom((ITypeId)rootNode.Type))
{
return((object)null);
}
DataContextInfo dataContextInfo = new DataContextEvaluator().Evaluate(viewModel.GetSceneNode(rootNode));
if (dataContextInfo.DataSource == null || !dataContextInfo.DataSource.IsValidWithSource)
{
return((object)null);
}
object obj = (object)null;
if (dataContextInfo.DataSource.Category == DataSourceCategory.Clr)
{
obj = DataContextEvaluator.CreateClrDataContext(dataContextInfo.DataSource, viewModel);
}
else if (dataContextInfo.DataSource.Category == DataSourceCategory.Xml)
{
obj = DataContextEvaluator.CreateXmlDataContext(dataContextInfo.DataSource, viewModel);
}
return(obj);
}
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);
}
public SceneNode GetOwnerSceneNode(SceneViewModel viewModel)
{
if (this.Owner == null)
{
return((SceneNode)null);
}
return(viewModel.IsExternal((DocumentNode)this.Owner) ? viewModel.GetViewModel(this.Owner.DocumentRoot, false).GetSceneNode((DocumentNode)this.Owner) : viewModel.GetSceneNode((DocumentNode)this.Owner));
}
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;
}
}
}
}
private BehaviorTriggerBaseNode CopyTriggerAndActionNode(BehaviorTriggerActionNode actionNode)
{
SceneViewModel viewModel = this.InsertionPoint.SceneNode.ViewModel;
DocumentNode node1 = actionNode.DocumentNode.Clone(viewModel.Document.DocumentContext);
DocumentNode node2 = actionNode.Parent.DocumentNode.Clone(viewModel.Document.DocumentContext);
BehaviorTriggerBaseNode behaviorTriggerBaseNode = (BehaviorTriggerBaseNode)viewModel.GetSceneNode(node2);
BehaviorTriggerActionNode triggerActionNode = (BehaviorTriggerActionNode)viewModel.GetSceneNode(node1);
behaviorTriggerBaseNode.Actions.Clear();
behaviorTriggerBaseNode.Actions.Add((SceneNode)triggerActionNode);
return(behaviorTriggerBaseNode);
}
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;
}
}
internal static DocumentCompositeNode LookupResource(SceneViewModel viewModel, DocumentCompositeNode findMe)
{
DocumentNode resourceKey = ResourceNodeHelper.GetResourceKey(findMe);
if (resourceKey != null)
{
DocumentNode documentNode = new ExpressionEvaluator(viewModel.DocumentRootResolver).EvaluateResource(viewModel.GetSceneNode((DocumentNode)findMe).DocumentNodePath, DocumentNodeUtilities.IsDynamicResource((DocumentNode)findMe) ? ResourceReferenceType.Dynamic : ResourceReferenceType.Static, resourceKey);
if (documentNode != null)
{
return(documentNode.Parent);
}
}
return((DocumentCompositeNode)null);
}