public ApplyResourceCommand(ResourceToolBehavior behavior, SceneElement targetElement, ReferenceStep targetProperty, ResourceEntryItem resource)
{
this.behavior = behavior;
this.targetElement = targetElement;
this.resource = resource;
this.targetProperty = targetProperty;
}
public void Execute()
{
if (!this.IsEnabled)
{
return;
}
ResourceEntryItem resourceEntryItem = (ResourceEntryItem)this.resourceManager.SelectedItems.Selection[0];
SceneNode sceneNode = resourceEntryItem.Container.ViewModel.GetSceneNode(resourceEntryItem.Resource.ValueNode);
ConvertibleDrawing convertibleDrawing = ConvertibleDrawing.CreateConvertibleDrawing((object)(Brush)this.designerContext.ActiveSceneViewModel.CreateInstance(sceneNode.DocumentNodePath), sceneNode.ProjectContext.ProjectPath);
if (convertibleDrawing == null)
{
return;
}
DocumentCompositeNode documentCompositeNode = (DocumentCompositeNode)sceneNode.DocumentNode;
string valueAsString = DocumentPrimitiveNode.GetValueAsString(resourceEntryItem.Resource.KeyNode);
string documentUrl = documentCompositeNode.DocumentRoot.DocumentContext.DocumentUrl;
SceneViewModel activeSceneViewModel = this.designerContext.ActiveSceneViewModel;
using (SceneEditTransaction editTransaction = activeSceneViewModel.CreateEditTransaction(this.CommandName))
{
BaseFrameworkElement child = (BaseFrameworkElement)activeSceneViewModel.CreateSceneNode((object)convertibleDrawing.Convert());
activeSceneViewModel.ActiveSceneInsertionPoint.Insert((SceneNode)child);
child.SetLocalValue(DesignTimeProperties.BrushDocumentReferenceProperty, (object)documentUrl);
child.SetLocalValue(DesignTimeProperties.BrushKeyProperty, (object)valueAsString);
child.Name = valueAsString + "_1";
this.point *= ElementUtilities.GetInverseMatrix(activeSceneViewModel.DefaultView.GetComputedTransformToRoot(activeSceneViewModel.ActiveSceneInsertionPoint.SceneElement));
Rect rect = new Rect(this.point, new Size(child.Width, child.Height));
activeSceneViewModel.GetLayoutDesignerForChild((SceneElement)child, true).SetChildRect(child, rect, LayoutOverrides.None, LayoutOverrides.Width | LayoutOverrides.Height, LayoutOverrides.None);
this.designerContext.SelectionManager.ElementSelectionSet.SetSelection((SceneElement)child);
editTransaction.Commit();
}
}
private IType GetType(ResourceEntryItem resource)
{
IType type = (IType)null;
if (resource != null && resource.Resource != null)
{
TypedResourceItem typedResourceItem = (TypedResourceItem)null;
StyleResourceItem styleResourceItem;
if ((styleResourceItem = resource as StyleResourceItem) != null)
{
typedResourceItem = (TypedResourceItem)styleResourceItem;
}
else if (resource is BrushResourceItem)
{
type = resource.DocumentNode.TypeResolver.ResolveType(PlatformTypes.Rectangle);
}
else if (resource is DrawingImageResourceItem)
{
type = resource.DocumentNode.TypeResolver.ResolveType(PlatformTypes.Image);
}
else
{
ControlTemplateResourceItem templateResourceItem = resource as ControlTemplateResourceItem;
if (templateResourceItem != null)
{
typedResourceItem = (TypedResourceItem)templateResourceItem;
}
}
if (typedResourceItem != null && typedResourceItem.Type != null && !typedResourceItem.Type.IsAbstract)
{
type = typedResourceItem.Type;
}
}
return(type);
}
public CreateInstanceCommand(ResourceToolBehavior behavior, Point dropPoint, IType type, ResourceEntryItem resource)
{
this.behavior = behavior;
this.dropPoint = dropPoint;
this.type = type;
this.resource = resource;
}
private void AddValidElementProperties(ContextMenu menu, IDataObject data, SceneElement hitElement)
{
ResourceEntryItem resourceEntry = this.GetResourceEntry(data);
if (resourceEntry == null || resourceEntry.Resource == null || hitElement == null)
{
return;
}
ResourceManager resourceManager = this.ActiveSceneViewModel.DesignerContext.ResourceManager;
DocumentReference documentReference = resourceEntry.Container.DocumentReference;
if (!PlatformTypes.PlatformsCompatible(hitElement.ProjectContext.PlatformMetadata, resourceEntry.DocumentNode.PlatformMetadata) || !resourceEntry.Resource.IsResourceReachable((SceneNode)hitElement) && (!(documentReference != resourceManager.ActiveRootContainer.DocumentReference) || !(documentReference != resourceManager.TopLevelResourceContainer.DocumentReference)))
{
return;
}
int count = menu.Items.Count;
this.AddProperties(hitElement, resourceEntry, menu.Items);
if (menu.Items.Count <= count)
{
return;
}
string headerText = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.DragDropResourceExistingControlPopupHeader, new object[1]
{
(object)(string.IsNullOrEmpty(hitElement.Name) ? "[" + hitElement.TargetType.Name + "]" : hitElement.Name)
});
this.AddHeaderItem(menu, headerText, 1);
}
private ResourceEntryItem GetResourceEntry(IDataObject dataObject)
{
ResourceEntryItem resourceEntryItem = (ResourceEntryItem)null;
if (dataObject != null && dataObject.GetDataPresent("ResourceEntryItem", true))
{
resourceEntryItem = (ResourceEntryItem)dataObject.GetData("ResourceEntryItem", true);
}
return(resourceEntryItem);
}
private void CreateInstance(Point dropPoint, ResourceEntryItem resource, IType type)
{
ISceneInsertionPoint pointFromPosition = this.ActiveSceneViewModel.GetActiveSceneInsertionPointFromPosition(new InsertionPointContext(dropPoint));
TypeAsset typeAsset = new TypeAsset(type);
if (!typeAsset.CanCreateInstance(pointFromPosition))
{
return;
}
this.ToolBehaviorContext.SnappingEngine.Start(this.ToolBehaviorContext, (BaseFrameworkElement)null, (IList <BaseFrameworkElement>)null);
dropPoint = this.ToolBehaviorContext.SnappingEngine.SnapPoint(dropPoint, EdgeFlags.All);
this.ToolBehaviorContext.SnappingEngine.Stop();
Matrix inverseMatrix = ElementUtilities.GetInverseMatrix(this.ActiveView.GetComputedTransformToRoot(pointFromPosition.SceneElement));
dropPoint *= inverseMatrix;
using (SceneEditTransaction editTransaction = this.ActiveDocument.CreateEditTransaction(StringTable.CreateResourceViaToolUndoUnit))
{
using (this.ActiveSceneViewModel.DesignerContext.AmbientPropertyManager.SuppressApplyAmbientProperties())
{
typeAsset.CreateInstance(this.ActiveSceneViewModel.DesignerContext.LicenseManager, pointFromPosition, new Rect(dropPoint, new Size(double.PositiveInfinity, double.PositiveInfinity)), (OnCreateInstanceAction)(sceneNode =>
{
SceneElement targetElement = sceneNode as SceneElement;
if (targetElement == null)
{
return;
}
if (resource is StyleResourceItem)
{
this.ApplyResourceOnExistingElement(targetElement, BaseFrameworkElement.StyleProperty, resource);
}
else if (resource is ControlTemplateResourceItem)
{
this.ApplyResourceOnExistingElement(targetElement, ControlElement.TemplateProperty, resource);
}
else if (resource is DrawingImageResourceItem)
{
this.ApplyResourceOnExistingElement(targetElement, ImageElement.SourceProperty, resource);
}
else
{
if (!(resource is BrushResourceItem))
{
return;
}
this.ApplyResourceOnExistingElement(targetElement, ShapeElement.FillProperty, resource);
targetElement.SetValue(ShapeElement.StrokeProperty, (object)null);
}
}));
editTransaction.Commit();
}
}
}
private bool CanUseBrushReference(RegroupToResourceCommand.ConvertibleBrushReference brushReference)
{
if (!brushReference.HasReferenceInfo)
{
return(false);
}
ResourceEntryItem resourceEntryItem = this.FindResourceItem(brushReference) as ResourceEntryItem;
if (resourceEntryItem != null)
{
return(RegroupToResourceCommand.IsTypeSupported(resourceEntryItem.Resource.ValueNode.TargetType));
}
return(this.designerContext.ResourceManager.FindResourceContainer(brushReference.DocumentUrl) != null);
}
private void AddElementPropertiesWithTypeFilter(SceneElement targetElement, ResourceEntryItem resource, System.Windows.Controls.ItemCollection menuItems, Type filterType)
{
SceneNode[] selection = new SceneNode[1]
{
(SceneNode)targetElement
};
foreach (TargetedReferenceStep targetedReferenceStep in (IEnumerable <TargetedReferenceStep>)PropertyMerger.GetMergedProperties((IEnumerable <SceneNode>)selection))
{
ReferenceStep referenceStep = targetedReferenceStep.ReferenceStep;
if (referenceStep.Name != "Name" && PropertyInspectorModel.IsPropertyBrowsable(selection, targetedReferenceStep) && (PropertyInspectorModel.IsAttachedPropertyBrowsable(selection, targetElement.Type, targetedReferenceStep, (ITypeResolver)targetElement.ProjectContext) && PlatformTypeHelper.GetPropertyType((IProperty)referenceStep) != (Type)null) && (PlatformTypeHelper.GetPropertyType((IProperty)referenceStep).IsAssignableFrom(resource.Resource.Type.RuntimeType) && (filterType == (Type)null || filterType.IsAssignableFrom(PlatformTypeHelper.GetPropertyType((IProperty)referenceStep)))))
{
menuItems.Add((object)this.BuildPropertyMenuItem(targetElement, referenceStep, resource));
}
}
}
private ResourceItem FindResourceItem(RegroupToResourceCommand.ConvertibleBrushReference brushReference)
{
ResourceContainer resourceContainer = this.designerContext.ResourceManager.FindResourceContainer(brushReference.DocumentUrl);
if (resourceContainer != null)
{
foreach (ResourceItem resourceItem in (Collection <ResourceItem>)resourceContainer.ResourceItems)
{
ResourceEntryItem resourceEntryItem = resourceItem as ResourceEntryItem;
if (resourceEntryItem != null && DocumentPrimitiveNode.GetValueAsString(resourceEntryItem.Resource.KeyNode) == brushReference.Key)
{
return((ResourceItem)resourceEntryItem);
}
}
}
return((ResourceItem)null);
}
private void AddTargetType(ContextMenu menu, Point dropPoint, ResourceEntryItem resource)
{
IType type = this.GetType(resource);
ISceneInsertionPoint pointFromPosition = this.ActiveSceneViewModel.GetActiveSceneInsertionPointFromPosition(new InsertionPointContext(dropPoint));
if (type == null || !new TypeAsset(type).CanCreateInstance(pointFromPosition))
{
return;
}
MenuItem menuItem = new MenuItem();
menuItem.SetValue(AutomationElement.IdProperty, (object)type.Name);
menuItem.Header = (object)type.Name;
menuItem.Command = (ICommand) new ResourceToolBehavior.CreateInstanceCommand(this, dropPoint, type, resource);
menuItem.Tag = (object)0;
menu.Items.Add((object)menuItem);
this.AddHeaderItem(menu, StringTable.DragDropResourceCreateNewControlPopupHeader, 0);
}
public void UpdateIsEnabled()
{
bool flag = false;
if (this.designerContext.ActiveSceneViewModel != null && this.designerContext.ActiveSceneViewModel.ActiveSceneInsertionPoint != null && (this.resourceManager.SelectedItems.Count == 1 && this.designerContext.ActiveSceneViewModel.ActiveSceneInsertionPoint != null))
{
ResourceEntryItem resourceEntryItem = this.resourceManager.SelectedItems.Selection[0] as ResourceEntryItem;
if (resourceEntryItem != null)
{
DocumentNode valueNode = resourceEntryItem.Resource.ValueNode;
this.isVisible = ConvertibleDrawing.IsResourceTypeSupported(valueNode.Type);
flag = ConvertibleDrawing.CanCreateConvertibleDrawing(valueNode);
}
}
else
{
flag = false;
this.isVisible = false;
}
this.IsEnabled = flag;
}
private void AddProperties(SceneElement targetElement, ResourceEntryItem resource, System.Windows.Controls.ItemCollection menuItems)
{
Type filterType = (Type)null;
bool flag = true;
if (PlatformTypes.Brush.IsAssignableFrom((ITypeId)resource.Resource.Type))
{
filterType = typeof(Brush);
}
else if (PlatformTypes.DrawingImage.IsAssignableFrom((ITypeId)resource.Resource.Type))
{
filterType = typeof(ImageSource);
}
else if (PlatformTypes.PlatformsCompatible(resource.Resource.ValueNode.Type.PlatformMetadata, targetElement.Type.PlatformMetadata))
{
IType styleOrTemplateType;
ITypeId typeAndTargetType = DocumentNodeUtilities.GetStyleOrTemplateTypeAndTargetType(resource.Resource.ValueNode, out styleOrTemplateType);
if (typeAndTargetType != null)
{
flag = typeAndTargetType.IsAssignableFrom((ITypeId)targetElement.Type);
filterType = styleOrTemplateType.RuntimeType;
}
}
else
{
flag = false;
}
if (!flag)
{
return;
}
int count = menuItems.Count;
this.AddElementPropertiesWithTypeFilter(targetElement, resource, menuItems, filterType);
if (menuItems.Count != count)
{
return;
}
this.AddElementPropertiesWithTypeFilter(targetElement, resource, menuItems, (Type)null);
}
protected override bool OnDragOver(DragEventArgs args)
{
args.Effects = DragDropEffects.None;
Point position = args.GetPosition((IInputElement)this.ActiveView.ViewRootContainer);
SceneElement index = this.ActiveView.GetSelectableElementAtPoint(position, SelectionFor3D.Deep, false) ?? this.ActiveView.GetElementAtPoint(position, new HitTestModifier(this.ActiveView.GetSelectableElement), (InvisibleObjectHitTestModifier)null, (ICollection <BaseFrameworkElement>)null);
if (index != null)
{
ContextMenu menu = (ContextMenu)null;
bool flag;
if (!this.cachedApplyProperties.TryGetValue(index, out flag))
{
menu = new ContextMenu();
ResourceEntryItem resourceEntry = this.GetResourceEntry(args.Data);
this.AddTargetType(menu, position, resourceEntry);
int count = menu.Items.Count;
this.AddValidElementProperties(menu, args.Data, index);
this.cachedApplyProperties.Add(index, menu.Items.Count - count > 0);
this.cachedCanDrop.Add(index, menu.Items.Count >= 2);
}
if (this.cachedCanDrop[index] && (menu == null || menu.Items.Count >= 2))
{
args.Effects = flag ? DragDropEffects.Copy : DragDropEffects.Move;
}
}
else
{
ContextMenu menu = new ContextMenu();
this.TryAddGenericCommands(menu, position);
if (menu.Items.Count >= 1)
{
args.Effects = DragDropEffects.Copy;
}
}
base.OnDragOver(args);
return(true);
}
private void ApplyResourceOnExistingElement(SceneElement targetElement, IPropertyId targetProperty, ResourceEntryItem resource)
{
if (resource.Resource.KeyNode != null || targetProperty.Equals((object)BaseFrameworkElement.StyleProperty))
{
using (SceneEditTransaction editTransaction = this.ActiveDocument.CreateEditTransaction(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.PropertySetUndo, new object[1]
{
(object)targetProperty.Name
})))
{
if (resource.Resource.KeyNode != null)
{
IDocumentContext documentContext = this.ActiveSceneViewModel.Document.DocumentContext;
IProjectContext projectContext = this.ActiveSceneViewModel.Document.ProjectContext;
DocumentNode keyNode = resource.Resource.KeyNode.Clone(documentContext);
DocumentNode documentNode = !(projectContext.ResolveProperty(targetProperty) is DependencyPropertyReferenceStep) || !JoltHelper.TypeSupported((ITypeResolver)projectContext, PlatformTypes.DynamicResource) ? (DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(documentContext, keyNode) : (DocumentNode)DocumentNodeUtilities.NewDynamicResourceNode(documentContext, keyNode);
targetElement.SetValue(targetProperty, (object)documentNode);
}
else if (targetProperty.Equals((object)BaseFrameworkElement.StyleProperty))
{
targetElement.ClearValue(targetProperty);
}
editTransaction.Commit();
}
}
ResourceManager resourceManager = this.ActiveSceneViewModel.DesignerContext.ResourceManager;
DocumentReference documentReference = resource.Container.DocumentReference;
if (resource.Resource.IsResourceReachable((SceneNode)targetElement) || !(documentReference != resourceManager.ActiveRootContainer.DocumentReference) || !(documentReference != resourceManager.TopLevelResourceContainer.DocumentReference))
{
return;
}
resourceManager.LinkToResource(resourceManager.TopLevelResourceContainer, documentReference);
}
private MenuItem BuildPropertyMenuItem(SceneElement targetElement, ReferenceStep targetProperty, ResourceEntryItem resource)
{
MenuItem menuItem = new MenuItem();
menuItem.SetValue(AutomationElement.IdProperty, (object)targetProperty.Name);
menuItem.Header = (object)targetProperty.Name;
menuItem.Command = (ICommand) new ResourceToolBehavior.ApplyResourceCommand(this, targetElement, targetProperty, resource);
menuItem.Tag = (object)1;
return(menuItem);
}
