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