public static GridBox GetGridBoxFromElement(SceneElement element) { int colBegin = Math.Max(0, (int)element.GetComputedValue(GridElement.ColumnProperty)); int colEnd = colBegin + Math.Max(1, (int)element.GetComputedValue(GridElement.ColumnSpanProperty)); int rowBegin = Math.Max(0, (int)element.GetComputedValue(GridElement.RowProperty)); int rowEnd = rowBegin + Math.Max(1, (int)element.GetComputedValue(GridElement.RowSpanProperty)); return(new GridBox(colBegin, colEnd, rowBegin, rowEnd)); }
public static double GetStrokeWidth(SceneElement element) { if (element.GetComputedValue(ShapeElement.StrokeProperty) != null) { double d = (double)element.GetComputedValue(ShapeElement.StrokeThicknessProperty); if (!double.IsNaN(d) && !double.IsInfinity(d)) { return(d); } } return(0.0); }
private void UpdateTranslation(bool scrollNow) { SceneView activeView = this.ActiveView; SceneViewModel viewModel = activeView.ViewModel; Vector delta = this.dragCurrentPosition - this.dragStartPosition; if (this.isConstraining) { delta = this.ConstrainDeltaToAxis(delta); } if (delta == this.lastMove || this.IsAltDown) { return; } this.EnsureEditTransaction(); Vector vector1 = delta - this.lastMove; SceneElement primarySelection = viewModel.ElementSelectionSet.PrimarySelection; if (primarySelection == null) { return; } PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)primarySelection); if (propertyReference == null) { return; } object computedValue = primarySelection.GetComputedValue(propertyReference); if (computedValue != null && !PlatformTypes.IsInstance(computedValue, PlatformTypes.SolidColorBrush, (ITypeResolver)primarySelection.ProjectContext)) { Vector vector2 = vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, true); if (PlatformTypes.IsInstance(computedValue, PlatformTypes.LinearGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool) { ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.StartPointProperty); ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.EndPointProperty); Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2); Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2); this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point1); this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point2); } else if (PlatformTypes.IsInstance(computedValue, PlatformTypes.RadialGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool) { ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.CenterProperty); ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.GradientOriginProperty); Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2); Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2); this.SetBrushValue(RadialGradientBrushNode.CenterProperty, (object)point1); this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point2); } else { this.TranslateBrushPosition(vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, false), primarySelection); } } activeView.EnsureVisible(this.dragStartPosition + delta, scrollNow); this.lastMove = delta; this.UpdateEditTransaction(); }
protected void CopyPrimaryBrushToSelection() { this.EnsureEditTransaction(); SceneElement primarySelection = this.ActiveView.ViewModel.ElementSelectionSet.PrimarySelection; if (primarySelection == null) { return; } PropertyReference propertyReference1 = this.GetBrushPropertyReference((SceneNode)primarySelection); if (propertyReference1 == null) { return; } object computedValue = primarySelection.GetComputedValue(propertyReference1); foreach (SceneElement sceneElement in this.ActiveView.ViewModel.ElementSelectionSet.Selection) { if (sceneElement != primarySelection) { PropertyReference propertyReference2 = this.ActiveView.DesignerContext.PropertyManager.FilterProperty((SceneNode)sceneElement, propertyReference1); if (propertyReference2 != null) { sceneElement.SetValue(propertyReference2, computedValue); } } } this.UpdateEditTransaction(); }
public void TranslateBrushPosition(Vector elementDelta, SceneElement element) { PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)element); if (propertyReference == null) { return; } object computedValue = element.GetComputedValue(propertyReference); if (computedValue == null || PlatformTypes.IsInstance(computedValue, PlatformTypes.SolidColorBrush, (ITypeResolver)element.ProjectContext)) { return; } ReferenceStep referenceStep = (ReferenceStep)element.Platform.Metadata.ResolveProperty(BrushNode.RelativeTransformProperty); object obj = element.ViewModel.DefaultView.ConvertToWpfValue(referenceStep.GetCurrentValue(computedValue)); CanonicalTransform canonicalTransform = !(obj is Transform) ? new CanonicalTransform(Matrix.Identity) : new CanonicalTransform((Transform)obj); elementDelta *= canonicalTransform.TransformGroup.Value; double valueToSet1 = RoundingHelper.RoundLength(canonicalTransform.TranslationX + elementDelta.X); double valueToSet2 = RoundingHelper.RoundLength(canonicalTransform.TranslationY + elementDelta.Y); this.SetBrushTransformValue(element.Platform.Metadata.CommonProperties.BrushTranslationXReference, valueToSet1); this.SetBrushTransformValue(element.Platform.Metadata.CommonProperties.BrushTranslationYReference, valueToSet2); }
protected object ResolveCurrentStyle(SceneElement targetElement, PropertyReference propertyReference, bool allowDefaultStyle) { ReferenceStep referenceStep = propertyReference[0]; object computedValue = targetElement.GetComputedValue(propertyReference); StyleNode styleNode = targetElement.GetLocalOrDefaultValue(propertyReference) as StyleNode; bool flag = computedValue == null || styleNode != null && styleNode.IsDefaultStyle; if (!allowDefaultStyle && flag && referenceStep.Equals((object)BaseFrameworkElement.StyleProperty)) { return((object)null); } if (computedValue != null) { Style style = computedValue as Style; if (style != null) { foreach (SetterBase setterBase in (Collection <SetterBase>)style.Setters) { Setter setter = setterBase as Setter; FrameworkTemplate frameworkTemplate; if (setter != null && (frameworkTemplate = setter.Value as FrameworkTemplate) != null && frameworkTemplate.VisualTree != null) { return((object)null); } } } } return(computedValue); }
private void ApplyEyedropperSceneElement(SceneElement hitElement) { PropertyManager propertyManager = (PropertyManager)this.ToolBehaviorContext.PropertyManager; IPlatform platform = this.ActiveDocument.ProjectContext.Platform; IPlatformMetadata platformMetadata = (IPlatformMetadata)platform.Metadata; this.EnsureEditTransaction(); foreach (IPropertyId propertyId in PropertyToolBehavior.PropertyList) { ReferenceStep singleStep = platformMetadata.ResolveProperty(propertyId) as ReferenceStep; if (singleStep != null && singleStep.PropertyType.PlatformMetadata == platform.Metadata) { PropertyReference propertyReference1 = new PropertyReference(singleStep); PropertyReference propertyReference2 = propertyManager.FilterProperty((SceneNode)hitElement, propertyReference1); if (propertyReference2 != null) { object second = propertyManager.GetValue(propertyReference2); object computedValue = hitElement.GetComputedValue(propertyReference2); if (computedValue != MixedProperty.Mixed && !PropertyUtilities.Compare(computedValue, second, hitElement.ViewModel.DefaultView)) { propertyManager.SetValue(propertyReference2, computedValue); } } } } this.UpdateEditTransaction(); }
public static bool UpdateLayoutRounding(SceneElement element) { if (!LayoutRoundingHelper.ShouldConsiderLayoutRoundingAdjustment(element)) { return(false); } IPropertyId propertyKey = (IPropertyId)LayoutRoundingHelper.ResolveUseLayoutRoundingProperty((SceneNode)element); if (propertyKey == null) { return(false); } bool flag1 = element.IsSet(propertyKey) == PropertyState.Set; if (PlatformTypes.Path.IsAssignableFrom((ITypeId)element.Type)) { if (!flag1 && (bool)element.GetComputedValue(propertyKey)) { element.SetLocalValue(Base2DElement.UseLayoutRoundingProperty, (object)false); LayoutRoundingHelper.SetAutoLayoutRounding(element, false); return(true); } } else if (!flag1 || LayoutRoundingHelper.GetAutoLayoutRounding(element)) { bool flag2 = (bool)element.GetComputedValue(propertyKey); if (LayoutRoundingHelper.IsAxisAligned(element)) { if (!flag2) { element.ClearValue(propertyKey); LayoutRoundingHelper.SetAutoLayoutRounding(element, false); return(true); } } else if (flag2) { element.SetValue(propertyKey, (object)false); LayoutRoundingHelper.SetAutoLayoutRounding(element, true); return(true); } } return(false); }
public static LayoutSettings GetLayoutSettingsFromElement(SceneElement element) { LayoutSettings layoutSettings = new LayoutSettings(); layoutSettings.LayoutOverrides = (LayoutOverrides)element.GetComputedValue(DesignTimeProperties.LayoutOverridesProperty); if (element.Parent is GridElement) { layoutSettings.GridBox = LayoutUtilities.GetGridBoxFromElement(element); if (LayoutUtilities.PropertyIsExpression((SceneNode)element, GridElement.ColumnProperty) || LayoutUtilities.PropertyIsExpression((SceneNode)element, GridElement.ColumnSpanProperty) || (LayoutUtilities.PropertyIsExpression((SceneNode)element, GridElement.RowProperty) || LayoutUtilities.PropertyIsExpression((SceneNode)element, GridElement.RowSpanProperty))) { layoutSettings.LayoutOverrides |= LayoutOverrides.GridBox; } } layoutSettings.HorizontalAlignment = (HorizontalAlignment)element.GetComputedValue(BaseFrameworkElement.HorizontalAlignmentProperty); if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.HorizontalAlignmentProperty)) { layoutSettings.LayoutOverrides |= LayoutOverrides.HorizontalAlignment; } layoutSettings.VerticalAlignment = (VerticalAlignment)element.GetComputedValue(BaseFrameworkElement.VerticalAlignmentProperty); if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.VerticalAlignmentProperty)) { layoutSettings.LayoutOverrides |= LayoutOverrides.VerticalAlignment; } layoutSettings.Width = (double)element.GetComputedValue(BaseFrameworkElement.WidthProperty); if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.WidthProperty)) { layoutSettings.LayoutOverrides |= LayoutOverrides.Width; } layoutSettings.Height = (double)element.GetComputedValue(BaseFrameworkElement.HeightProperty); if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.HeightProperty)) { layoutSettings.LayoutOverrides |= LayoutOverrides.Height; } layoutSettings.Margin = (Thickness)element.GetComputedValueAsWpf(BaseFrameworkElement.MarginProperty); if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.MarginProperty)) { layoutSettings.LayoutOverrides |= LayoutOverrides.Margin; } return(layoutSettings); }
public static DocumentNodePath ProvideStyleOrTemplateNodePath(SceneElement targetElement, PropertyReference targetPropertyReference) { DocumentNodePath documentNodePath = (DocumentNodePath)null; ReferenceStep targetProperty = targetPropertyReference[0]; StyleNode styleNode = targetElement as StyleNode; if (targetPropertyReference.TargetType.IsAssignableFrom(targetElement.TargetType) || styleNode != null && targetPropertyReference.TargetType.IsAssignableFrom(styleNode.StyleTargetType)) { IViewObjectFactory viewObjectFactory = targetElement.Platform.ViewObjectFactory; object computedValue = targetElement.GetComputedValue(targetPropertyReference); DocumentNodePath valuePath = (DocumentNodePath)null; if (computedValue != null) { IViewObject instance = viewObjectFactory.Instantiate(computedValue); valuePath = targetElement.ViewModel.DefaultView.GetCorrespondingNodePath(instance, true); } if (valuePath == null && !BaseFrameworkElement.StyleProperty.Equals((object)targetProperty)) { BaseFrameworkElement frameworkElement = targetElement as BaseFrameworkElement; if (frameworkElement != null) { frameworkElement.FindMissingImplicitStyle(); } if (computedValue != null) { IViewObject instance = viewObjectFactory.Instantiate(computedValue); DocumentNodePath correspondingNodePath = targetElement.ViewModel.DefaultView.GetCorrespondingNodePath(instance, true); if (correspondingNodePath != null) { valuePath = ControlStylingOperations.FindTemplateWithinStyle(correspondingNodePath, targetElement, (IPropertyId)targetProperty, (IPropertyId)targetProperty); } } } if (ControlStylingOperations.ShouldSetEditingContextToNodePath(valuePath, targetElement, targetProperty)) { documentNodePath = valuePath; } } if (documentNodePath == null && styleNode != null && targetElement.IsSet(targetPropertyReference) == PropertyState.Set) { DocumentNodePath valueAsDocumentNode = targetElement.GetLocalValueAsDocumentNode(targetPropertyReference); if (ControlStylingOperations.ShouldSetEditingContextToNodePath(valueAsDocumentNode, targetElement, targetProperty)) { documentNodePath = valueAsDocumentNode; } } return(documentNodePath); }
public override System.Windows.Media.Geometry GetRenderedGeometryAsWpf(SceneElement shapeElement) { IViewObject element = shapeElement != null ? shapeElement.ViewObject : (IViewObject)null; if (element == null) { return((System.Windows.Media.Geometry) new PathGeometry()); } Rect actualBounds = this.GetActualBounds(element); if (!actualBounds.IsEmpty && (Brush)shapeElement.GetComputedValueAsWpf(ShapeElement.StrokeProperty) != null) { double num1 = (double)shapeElement.GetComputedValue(ShapeElement.StrokeThicknessProperty); if (!double.IsNaN(num1) && !double.IsInfinity(num1)) { double num2 = Math.Min(actualBounds.Width, num1) / 2.0; double num3 = Math.Min(actualBounds.Height, num1) / 2.0; actualBounds.Inflate(-num2, -num3); } } System.Windows.Media.Geometry geometry = this.platformSurface.GetShapeRenderedGeometry(element.PlatformSpecificObject, actualBounds); if (geometry == null) { if (ProjectNeutralTypes.PrimitiveShape.IsAssignableFrom((ITypeId)shapeElement.Type)) { geometry = shapeElement.GetComputedValueAsWpf(PrimitiveShapeElement.RenderedGeometryProperty) as System.Windows.Media.Geometry; } else if (PlatformTypes.Path.IsAssignableFrom((ITypeId)shapeElement.Type)) { geometry = shapeElement.GetComputedValueAsWpf(PathElement.DataProperty) as System.Windows.Media.Geometry; } } if (geometry == null) { geometry = (System.Windows.Media.Geometry) new PathGeometry(); } if (!PlatformTypes.Rectangle.Equals((object)shapeElement.Type) && !PlatformTypes.Ellipse.Equals((object)shapeElement.Type)) { MatrixTransform matrixTransform = shapeElement.GetComputedValueAsWpf(ShapeElement.GeometryTransformProperty) as MatrixTransform; if (matrixTransform != null && !matrixTransform.Matrix.IsIdentity) { Matrix matrix = geometry.Transform != null ? geometry.Transform.Value * matrixTransform.Matrix : matrixTransform.Matrix; geometry.Transform = (Transform) new MatrixTransform(matrix); } } return(geometry); }
public static bool GetUseLayoutRounding(SceneElement element) { if (element != null && element.Type != null) { IProperty propertyKey = LayoutRoundingHelper.ResolveUseLayoutRoundingProperty((SceneNode)element); if (propertyKey != null) { if (propertyKey.DeclaringType.IsAssignableFrom((ITypeId)element.Type)) { return((bool)element.GetComputedValue((IPropertyId)propertyKey)); } FrameworkTemplateElement frameworkTemplateElement = element as FrameworkTemplateElement; if (frameworkTemplateElement != null) { IViewObject viewTargetElement = frameworkTemplateElement.ViewTargetElement; if (viewTargetElement != null && propertyKey.DeclaringType.IsAssignableFrom((ITypeId)viewTargetElement.GetIType((ITypeResolver)element.ProjectContext))) { return((bool)viewTargetElement.GetCurrentValue(propertyKey)); } } } } return(false); }
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); }
private void UpdateTranslation(bool scrollNow) { SceneView activeView = this.ActiveView; SceneViewModel viewModel = activeView.ViewModel; if (!this.HasMouseMovedAfterDown) { this.hasInitializedBrush = false; } SceneElement primarySelection = this.ActiveView.ElementSelectionSet.PrimarySelection; if (primarySelection == null) { return; } PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)primarySelection); if (propertyReference == null || Adorner.NonAffineTransformInParentStack(primarySelection)) { return; } this.EnsureEditTransaction(); if (!this.hasInitializedBrush) { if (!PlatformTypes.IsInstance(this.ActiveView.ElementSelectionSet.PrimarySelection.GetComputedValue(propertyReference), PlatformTypes.GradientBrush, (ITypeResolver)primarySelection.ProjectContext)) { object lastUsed = BrushCategory.GetLastUsed(this.ActiveView.DesignerContext, this.ActiveView.Document.DocumentContext, BrushCategory.Gradient); this.ActiveView.ElementSelectionSet.PrimarySelection.SetValueAsWpf(propertyReference, lastUsed); this.UpdateEditTransaction(); } this.CopyPrimaryBrushToSelection(); this.hasInitializedBrush = true; } object computedValue = primarySelection.GetComputedValue(propertyReference); Matrix matrix = activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, true); Point point1 = this.dragStartPosition * matrix; Point point2 = this.dragCurrentPosition * matrix; Point point3 = RoundingHelper.RoundPosition(point1); Point point4 = RoundingHelper.RoundPosition(point2); if (PlatformTypes.IsInstance(computedValue, PlatformTypes.LinearGradientBrush, (ITypeResolver)primarySelection.ProjectContext)) { this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point3); this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point4); } else if (PlatformTypes.IsInstance(computedValue, PlatformTypes.RadialGradientBrush, (ITypeResolver)primarySelection.ProjectContext)) { this.SetBrushValue(RadialGradientBrushNode.CenterProperty, (object)point3); this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point3); if (this.IsShiftDown) { Vector vector = point4 - point3; this.SetBrushValue(RadialGradientBrushNode.RadiusXProperty, (object)vector.Length); this.SetBrushValue(RadialGradientBrushNode.RadiusYProperty, (object)vector.Length); } else { Point point5 = RoundingHelper.RoundPosition(new Point(Math.Abs(point3.X - point4.X), Math.Abs(point3.Y - point4.Y))); this.SetBrushValue(RadialGradientBrushNode.RadiusXProperty, (object)point5.X); this.SetBrushValue(RadialGradientBrushNode.RadiusYProperty, (object)point5.Y); } } activeView.EnsureVisible(this.dragStartPosition + this.dragCurrentPosition - this.dragStartPosition, scrollNow); this.UpdateEditTransaction(); }
public static LayoutOverrides GetLayoutOverrides(SceneElement element) { return((LayoutOverrides)element.GetComputedValue(DesignTimeProperties.LayoutOverridesProperty)); }
protected DocumentNode ProvideCurrentTemplate(SceneElement targetElement, PropertyReference targetPropertyReference, out IList <DocumentCompositeNode> auxillaryResources) { IPlatform platform = this.SceneViewModel.ProjectContext.Platform; FrameworkTemplateElement frameworkTemplateElement1 = (FrameworkTemplateElement)null; auxillaryResources = (IList <DocumentCompositeNode>)null; if (targetElement.IsSet(targetPropertyReference) == PropertyState.Set) { FrameworkTemplateElement frameworkTemplateElement2 = targetElement.GetLocalValueAsSceneNode(targetPropertyReference) as FrameworkTemplateElement; if (frameworkTemplateElement2 != null) { frameworkTemplateElement1 = targetElement.ClonePropertyValueAsSceneNode(targetPropertyReference) as FrameworkTemplateElement; if (frameworkTemplateElement1 != null) { auxillaryResources = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.FindReferencedResources(frameworkTemplateElement2.DocumentNode); } } } if (frameworkTemplateElement1 == null) { object computedValue = targetElement.GetComputedValue(targetPropertyReference); DocumentNode root = computedValue == null ? (DocumentNode)null : this.SceneView.GetCorrespondingDocumentNode(platform.ViewObjectFactory.Instantiate(computedValue), true); IPropertyId targetProperty = (IPropertyId)targetElement.Platform.Metadata.ResolveProperty(BaseFrameworkElement.StyleProperty); DocumentCompositeNode documentCompositeNode1 = targetElement.DocumentNode as DocumentCompositeNode; if (!targetElement.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf) && documentCompositeNode1 != null && (root == null && targetPropertyReference.ReferenceSteps.Count == 1)) { ITypeId styleTargetType = (ITypeId)targetElement.Type; DocumentNode currentStyle = (DocumentNode)null; ReferenceStep referenceStep = targetPropertyReference.ReferenceSteps[0]; object defaultStyleKey = this.GetDefaultStyleKey(targetElement, styleTargetType, targetProperty); if (defaultStyleKey != null) { bool isThemeStyle; IList <DocumentCompositeNode> auxillaryResources1; this.ResolveDefaultStyle(targetElement, defaultStyleKey, true, out currentStyle, out isThemeStyle, out auxillaryResources1); } DocumentCompositeNode documentCompositeNode2 = currentStyle as DocumentCompositeNode; if (documentCompositeNode2 != null) { DocumentCompositeNode documentCompositeNode3 = documentCompositeNode2.Properties[StyleNode.SettersProperty] as DocumentCompositeNode; if (documentCompositeNode3 != null) { foreach (DocumentNode documentNode1 in (IEnumerable <DocumentNode>)documentCompositeNode3.Children) { DocumentCompositeNode documentCompositeNode4 = documentNode1 as DocumentCompositeNode; if (documentCompositeNode4 != null) { IMemberId memberId = (IMemberId)DocumentPrimitiveNode.GetValueAsMember(documentCompositeNode4.Properties[SetterSceneNode.PropertyProperty]); DocumentNode documentNode2 = documentCompositeNode4.Properties[SetterSceneNode.ValueProperty]; if (memberId != null && documentNode2 != null && referenceStep.Equals((object)memberId)) { root = documentNode2; break; } } } } } } if (root != null) { frameworkTemplateElement1 = this.SceneViewModel.GetSceneNode(root.Clone(this.SceneViewModel.Document.DocumentContext)) as FrameworkTemplateElement; auxillaryResources = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.FindReferencedResources(root); } else { frameworkTemplateElement1 = this.SceneViewModel.CreateSceneNode(computedValue) as FrameworkTemplateElement; } } if (frameworkTemplateElement1 == null) { return((DocumentNode)null); } return(frameworkTemplateElement1.DocumentNode); }
private Dictionary <SceneElement, Size> CalculateClampedSizes(ref Vector scale) { Dictionary <SceneElement, Size> dictionary = new Dictionary <SceneElement, Size>(); Vector vector = new Vector(Math.Abs(scale.X), Math.Abs(scale.Y)); bool flag1 = false; bool flag2 = false; for (int index1 = 0; index1 < this.EditingElementSet.Elements.Count; ++index1) { SceneElement index2 = this.EditingElementSet.Elements[index1]; Rect rect = this.StartBoundsDictionary[index2]; Size size = new Size(); bool flag3 = Math.Abs(rect.Width) < 1E-06; bool flag4 = Math.Abs(rect.Height) < 1E-06; size.Width = !flag3 || !this.ActiveAdorner.TestFlags(EdgeFlags.LeftOrRight) ? rect.Width * vector.X : Math.Abs(this.CurrentPointerPosition.X - this.StartPointerPosition.X); size.Height = !flag4 || !this.ActiveAdorner.TestFlags(EdgeFlags.TopOrBottom) ? rect.Height * vector.Y : Math.Abs(this.CurrentPointerPosition.Y - this.StartPointerPosition.Y); double num = index2 is ShapeElement ? (double)index2.GetComputedValue(ShapeElement.StrokeThicknessProperty) : 0.0; if (rect.Width < num || rect.Height < num) { bool flag5 = false; if (!flag1 && rect.Height < num) { scale.X = 1.0; vector.X = 1.0; flag1 = true; flag5 = true; size.Height = rect.Height; } if (!flag2 && rect.Width < num) { scale.Y = 1.0; vector.Y = 1.0; flag2 = true; flag5 = true; size.Width = rect.Width; } if (flag5) { index1 = -1; continue; } } else if (size.Width < num || size.Height < num) { if (!flag1 && size.Width < num) { scale.X = Math.Min(1.0, (num + 0.1) / rect.Width); vector.X = Math.Abs(scale.X); } if (!flag2 && size.Height < num) { scale.Y = Math.Min(1.0, (num + 0.1) / rect.Height); vector.Y = Math.Abs(scale.Y); } index1 = -1; continue; } dictionary[index2] = size; } return(dictionary); }
public override void Execute() { SceneElement targetElement = this.TargetElement; if (targetElement is StyleNode) { this.useStyle = new bool?(false); } else { IList <DocumentCompositeNode> auxillaryResources1; DocumentNode documentNode1 = this.ProvideCurrentStyle(targetElement, this.Type, new PropertyReference((ReferenceStep)targetElement.ProjectContext.ResolveProperty(BaseFrameworkElement.StyleProperty)), false, out auxillaryResources1); IList <DocumentCompositeNode> auxillaryResources2; DocumentNode other = this.ProvideCurrentTemplate(targetElement, new PropertyReference(this.ActiveTemplateProperty), out auxillaryResources2); bool flag = false; if ((other == null || other.DocumentRoot == null) && documentNode1 != null) { using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.UndoUnitEditCopyStyle, true)) { if (auxillaryResources1 != null && auxillaryResources1.Count > 0) { ResourceSite resourceSite = new ResourceSite(targetElement.DocumentNode); resourceSite.EnsureResourceCollection(); foreach (DocumentCompositeNode entryNode in (IEnumerable <DocumentCompositeNode>)auxillaryResources1) { DocumentNode resourceEntryKey = ResourceNodeHelper.GetResourceEntryKey(entryNode); DocumentNode documentNode2 = entryNode.Properties[DictionaryEntryNode.ValueProperty]; if (resourceEntryKey != null && documentNode2 != null) { DictionaryEntryNode dictionaryEntryNode = (DictionaryEntryNode)this.SceneViewModel.CreateSceneNode(PlatformTypes.DictionaryEntry); dictionaryEntryNode.KeyNode = this.SceneViewModel.GetSceneNode(resourceEntryKey.Clone(this.SceneViewModel.Document.DocumentContext)); dictionaryEntryNode.Value = this.SceneViewModel.GetSceneNode(documentNode2.Clone(this.SceneViewModel.Document.DocumentContext)); resourceSite.ResourcesDictionary.Children.Add(dictionaryEntryNode.DocumentNode); } } } documentNode1 = documentNode1.Clone(this.SceneViewModel.Document.DocumentContext); DocumentCompositeNode documentCompositeNode = documentNode1 as DocumentCompositeNode; if (documentCompositeNode != null && documentCompositeNode.NameProperty != null && documentCompositeNode.Properties.Contains(documentCompositeNode.NameProperty)) { documentCompositeNode.ClearValue((IPropertyId)documentCompositeNode.NameProperty); } targetElement.SetValue(this.TargetPropertyReference, (object)documentNode1); DocumentNodePath valueAsDocumentNode = targetElement.GetLocalValueAsDocumentNode(this.TargetPropertyReference); documentNode1 = valueAsDocumentNode != null ? valueAsDocumentNode.Node : (DocumentNode)null; editTransaction.Update(); object computedValue = targetElement.GetComputedValue(new PropertyReference(this.ActiveTemplateProperty)); if (computedValue != null) { DocumentNodePath correspondingNodePath = this.SceneView.GetCorrespondingNodePath(this.SceneViewModel.ProjectContext.Platform.ViewObjectFactory.Instantiate(computedValue), true); if (correspondingNodePath != null) { flag = valueAsDocumentNode.IsAncestorOf(correspondingNodePath); other = correspondingNodePath != null ? correspondingNodePath.Node : other; } } editTransaction.Cancel(); } } this.useStyle = new bool?(flag || other != null && documentNode1 != null && documentNode1.IsAncestorOf(other)); } base.Execute(); this.useStyle = new bool?(); }
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 void UpdateScale() { SceneElement primarySelection = this.ActiveView.ElementSelectionSet.PrimarySelection; if (primarySelection == null) { return; } PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)primarySelection); if (propertyReference == null) { return; } this.EnsureEditTransaction(); if (!this.HasMouseMovedAfterDown) { this.CopyPrimaryBrushToSelection(); } ReferenceStep referenceStep1 = (ReferenceStep)this.ActiveView.ProjectContext.ResolveProperty(RadialGradientBrushNode.RadiusXProperty); ReferenceStep referenceStep2 = (ReferenceStep)this.ActiveView.ProjectContext.ResolveProperty(RadialGradientBrushNode.RadiusYProperty); if (!this.HasMouseMovedAfterDown) { object computedValue = primarySelection.GetComputedValue(propertyReference); this.radiusX = (double)referenceStep1.GetCurrentValue(computedValue); this.radiusY = (double)referenceStep2.GetCurrentValue(computedValue); } Vector vector = new Vector(0.0, 0.0); bool flag = false; if (this.ActiveAdorner.TestFlags(EdgeFlags.LeftOrRight)) { vector.X = this.currentPointerPosition.X - this.initialPointerPosition.X; if (this.ActiveAdorner.TestFlags(EdgeFlags.Left) && this.radiusX > 0.0 || this.ActiveAdorner.TestFlags(EdgeFlags.Right) && this.radiusX < 0.0) { vector.X *= -1.0; } if (this.constrainAspectRatio && Math.Abs(this.radiusX) > 0.001) { vector.Y = vector.X * this.radiusY / this.radiusX; flag = true; } } if (this.ActiveAdorner.TestFlags(EdgeFlags.TopOrBottom)) { vector.Y = this.currentPointerPosition.Y - this.initialPointerPosition.Y; if (this.ActiveAdorner.TestFlags(EdgeFlags.Top) && this.radiusY > 0.0 || this.ActiveAdorner.TestFlags(EdgeFlags.Bottom) && this.radiusY < 0.0) { vector.Y *= -1.0; } if (this.constrainAspectRatio && Math.Abs(this.radiusY) > 0.001) { vector.X = vector.Y * this.radiusX / this.radiusY; flag = true; } } vector.X = RoundingHelper.RoundLength(vector.X + this.radiusX); vector.Y = RoundingHelper.RoundLength(vector.Y + this.radiusY); if (this.ActiveAdorner.TestFlags(EdgeFlags.LeftOrRight) || flag) { this.SetBrushValue(RadialGradientBrushNode.RadiusXProperty, (object)vector.X); } if (this.ActiveAdorner.TestFlags(EdgeFlags.TopOrBottom) || flag) { this.SetBrushValue(RadialGradientBrushNode.RadiusYProperty, (object)vector.Y); } this.UpdateEditTransaction(); }