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();
}
}
protected override bool OnButtonDown(Point pointerPosition)
{
this.initialElementToContextMatrix = this.ActiveView.GetComputedTransformToRoot(this.EditingElement);
this.initialContextToElementMatrix = ElementUtilities.GetInverseMatrix(this.initialElementToContextMatrix);
this.initialCenterInBrush = this.ActiveAdorner.BrushCenter;
this.rootToBrushMatrix = this.initialContextToElementMatrix * this.ActiveAdorner.GetCompleteInverseBrushTransformMatrix(true);
this.brushToRootMatrix = ElementUtilities.GetInverseMatrix(this.rootToBrushMatrix);
this.initialCenterInDocument = this.ActiveAdorner.TransformPoint(this.initialCenterInBrush, true) * this.initialElementToContextMatrix;
this.initialPointerPosition = pointerPosition;
Point startPoint;
Point endPoint;
if (this.ActiveAdorner.GetBrushEndpoints(out startPoint, out endPoint))
{
double offset = 1.0;
if (this.ActiveAdorner.Kind == RadialGradientAdornerKind.GradientOriginPoint)
{
offset = 0.0;
}
Point S = startPoint * this.brushToRootMatrix;
Point E = endPoint * this.brushToRootMatrix;
Vector perpendicular;
this.dragOffset = GradientStopBehavior.VectorProjection(S, E, pointerPosition, offset, out perpendicular);
this.dragOffset = Math.Abs(this.dragOffset * (E - S).Length);
}
this.CancelEditTransaction();
return(true);
}
protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParams)
{
Point hitPoint = hitTestParams.HitPoint;
if (Tolerances.AreClose(hitPoint, this.lastPoint))
{
return(base.HitTestCore(hitTestParams));
}
this.lastPoint = hitPoint;
double num;
if (((LayoutBehavior)this.AdornerSet.Behavior).IsNewGridlineEnabled && Mouse.LeftButton != MouseButtonState.Pressed && Mouse.RightButton != MouseButtonState.Pressed)
{
Matrix inverseMatrix = ElementUtilities.GetInverseMatrix(this.AdornerSet.Matrix);
Point point = hitPoint * inverseMatrix;
Point pointBegin;
Point pointEnd;
this.GetPoints(out pointBegin, out pointEnd, this.AdornerSet.Matrix);
num = !new Rect(pointBegin, pointEnd).Contains(point) ? double.NaN : (!this.IsX ? point.Y : point.X);
}
else
{
num = double.NaN;
}
if (!this.position.Equals(num))
{
this.position = num;
if (this.isMouseOver)
{
this.InvalidateRender();
this.AdornerSet.Update();
}
}
return(base.HitTestCore(hitTestParams));
}
protected override bool OnButtonDown(Point pointerPosition)
{
Matrix computedTransformToRoot = this.ActiveView.GetComputedTransformToRoot(this.EditingElement);
this.rootToBrushMatrix = ElementUtilities.GetInverseMatrix(computedTransformToRoot);
this.rootToBrushMatrix *= this.ActiveAdorner.GetCompleteInverseBrushTransformMatrix(true);
this.brushToRootMatrix = ElementUtilities.GetInverseMatrix(this.rootToBrushMatrix);
if (this.ActiveAdorner.Kind == LinearGradientAdornerKind.StartRotation || this.ActiveAdorner.Kind == LinearGradientAdornerKind.EndRotation)
{
Point startPoint = this.ActiveAdorner.StartPoint;
Point endPoint = this.ActiveAdorner.EndPoint;
Point point = startPoint * computedTransformToRoot;
Vector vector = 0.5 * (endPoint * computedTransformToRoot - point);
this.centerInRootCoordinates = point + vector;
this.radiusInRootCoordinates = vector.Length;
}
else if (this.ActiveAdorner.GetBrushEndpoints(out this.initialStartPoint, out this.initialEndPoint))
{
double offset = 0.0;
if (this.ActiveAdorner.Kind == LinearGradientAdornerKind.EndPoint)
{
offset = 1.0;
}
Point S = this.initialStartPoint * this.brushToRootMatrix;
Point E = this.initialEndPoint * this.brushToRootMatrix;
Vector perpendicular;
this.dragOffset = GradientStopBehavior.VectorProjection(S, E, pointerPosition, offset, out perpendicular);
this.dragOffset = Math.Abs(this.dragOffset * (E - S).Length);
}
return(true);
}
protected override void ApplyScale(Vector scale, Point center)
{
Rect elementBounds = this.EditingElementSet.ElementBounds;
Matrix m = this.startSharedTransform;
Matrix inverseMatrix = ElementUtilities.GetInverseMatrix(m);
Matrix matrix1 = new Matrix();
matrix1.Translate(-center.X, -center.Y);
foreach (SceneElement element in this.EditingElementSet.Elements)
{
Matrix matrix2 = this.elementToElementsTransformDictionary[element] * matrix1;
Point point1 = this.startCentersDictionary[element];
Matrix matrix3 = this.startTransformsDictionary[element];
Rect rect = this.startBoundsDictionary[element];
Point point2 = new Point(rect.X + rect.Width * point1.X, rect.Y + rect.Height * point1.Y);
Point point3 = matrix2.Transform(point2);
Vector vector = new Point(scale.X * point3.X, scale.Y * point3.Y) - point3;
Matrix matrix4 = matrix3 * inverseMatrix;
matrix4.ScaleAt(scale.X, scale.Y, matrix4.OffsetX, matrix4.OffsetY);
matrix4.Translate(vector.X, vector.Y);
CanonicalDecomposition newTransform = new CanonicalDecomposition(matrix4 * m);
newTransform.ScaleX = RoundingHelper.RoundScale(newTransform.ScaleX);
newTransform.ScaleY = RoundingHelper.RoundScale(newTransform.ScaleY);
newTransform.SkewX = RoundingHelper.RoundAngle(newTransform.SkewX);
newTransform.SkewY = RoundingHelper.RoundAngle(newTransform.SkewY);
newTransform.RotationAngle = RoundingHelper.RoundAngle(newTransform.RotationAngle);
newTransform.TranslationX = RoundingHelper.RoundLength(newTransform.TranslationX);
newTransform.TranslationY = RoundingHelper.RoundLength(newTransform.TranslationY);
AdornedToolBehavior.UpdateElementTransform(element, newTransform, AdornedToolBehavior.TransformPropertyFlags.All);
}
}
protected override void ApplyScale(Vector scale, Point center)
{
Dictionary <SceneElement, Size> dictionary = this.CalculateClampedSizes(ref scale);
Vector vector1 = new Vector(scale.X < 0.0 ? -1.0 : 1.0, scale.Y < 0.0 ? -1.0 : 1.0);
Matrix startSharedTransform = this.StartSharedTransform;
Matrix inverseMatrix = ElementUtilities.GetInverseMatrix(startSharedTransform);
ILayoutDesigner designerForChild = this.ActiveSceneViewModel.GetLayoutDesignerForChild(this.EditingElementSet.PrimaryElement, true);
foreach (SceneElement index in this.EditingElementSet.Elements)
{
double width = dictionary[index].Width;
double height = dictionary[index].Height;
Rect rect1 = this.StartBoundsDictionary[index];
Point renderTransformOrigin = ((Base2DElement)index).RenderTransformOrigin;
Point point1 = new Point(rect1.X + rect1.Width * renderTransformOrigin.X, rect1.Y + rect1.Height * renderTransformOrigin.Y);
Matrix matrix1 = this.ElementToElementsTransformDictionary[index];
Matrix matrix2 = new Matrix();
matrix2.Translate(-center.X, -center.Y);
matrix1 *= matrix2;
Point point2 = matrix1.Transform(point1);
Vector vector2 = new Point(point2.X * scale.X, point2.Y * scale.Y) - point2;
Vector vector3 = new Vector((width - rect1.Width) * renderTransformOrigin.X, (height - rect1.Height) * renderTransformOrigin.Y);
Vector vector4 = vector2 * startSharedTransform - vector3;
Matrix matrix3 = this.StartTransformsDictionary[index];
Matrix m = new Matrix();
m.Scale(scale.X, scale.Y);
Matrix matrix4 = ElementUtilities.GetInverseMatrix(m) * matrix3 * inverseMatrix;
Vector vector5 = new Vector(matrix3.OffsetX, matrix3.OffsetY) * inverseMatrix;
matrix4.ScaleAt(scale.X, scale.Y, vector5.X, vector5.Y);
CanonicalDecomposition newTransform = new CanonicalDecomposition(matrix4 * startSharedTransform);
newTransform.ScaleX *= vector1.X;
newTransform.ScaleY *= vector1.Y;
newTransform.Translation += vector4;
AdornedToolBehavior.UpdateElementTransform(index, newTransform, AdornedToolBehavior.TransformPropertyFlags.Scale | AdornedToolBehavior.TransformPropertyFlags.Skew | AdornedToolBehavior.TransformPropertyFlags.RotatationAngle);
Rect rect2 = this.initialRects[index];
rect2.Offset(newTransform.TranslationX - this.initialTransforms[index].TranslationX, newTransform.TranslationY - this.initialTransforms[index].TranslationY);
rect2.Width = width;
rect2.Height = height;
BaseFrameworkElement child = (BaseFrameworkElement)index;
LayoutOverrides overridesToIgnore = (LayoutOverrides)(0 | (!object.Equals((object)width, (object)rect1.Width) ? 16 : 0) | (!object.Equals((object)height, (object)rect1.Height) ? 32 : 0));
designerForChild.SetChildRect(child, rect2, this.initialOverrides[index], overridesToIgnore, LayoutOverrides.None);
if (!object.Equals((object)width, (object)rect1.Width) || !object.Equals((object)height, (object)rect1.Height))
{
PathElement.EnsureStretchIsFill((SceneNode)index);
}
PathElement.PathTransformHelper pathTransformHelper;
if (this.pathTransformHelpers.TryGetValue(index, out pathTransformHelper))
{
pathTransformHelper.Update(scale.X * vector1.X, scale.Y * vector1.Y);
}
}
}
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();
}
}
}
public static Matrix RefineTransformToAdornerLayer(SceneElement element, Matrix matrix)
{
Matrix matrix1 = Matrix.Identity;
Matrix identity = Matrix.Identity;
BaseFrameworkElement frameworkElement = element as BaseFrameworkElement;
if (frameworkElement != null)
{
matrix1 = ElementUtilities.GetInverseMatrix(frameworkElement.GetRenderTransform());
Point elementCoordinates = frameworkElement.RenderTransformOriginInElementCoordinates;
identity.Translate(elementCoordinates.X, elementCoordinates.Y);
}
return(matrix1 * identity * matrix);
}
protected override void Initialize()
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.MultipleElementRotate);
this.FireNotifications(false);
CanonicalDecomposition canonicalDecomposition = this.EditingElementSet.CalculateSharedTransform();
this.UnsnappedAngle = canonicalDecomposition.RotationAngle;
this.initialBounds = this.EditingElementSet.Bounds;
this.intialRenderTransformOrigin = this.EditingElementSet.RenderTransformOrigin;
this.initialSharedTransform = canonicalDecomposition;
this.initialElementSetCenter = this.EditingElementSet.RenderTransformOriginInElementCoordinates;
foreach (SceneElement element in this.EditingElementSet.Elements)
{
this.initialTransforms[element] = new CanonicalTransform((Transform)element.GetComputedValueAsWpf(element.Platform.Metadata.CommonProperties.RenderTransform));
this.elementsToElement[element] = ElementUtilities.GetInverseMatrix(this.EditingElementSet.GetTransformToElementSpaceFromMemberElement(element));
}
this.initialArtboardOrigin = this.EditingElement.DesignerContext.ActiveView.Artboard.ArtboardBounds.TopLeft;
}
public static Matrix ComputeBaseValueMatrix(SceneElement element, IViewObject ancestorViewObject)
{
if (!element.IsViewObjectValid || ancestorViewObject == null)
{
return(Matrix.Identity);
}
Matrix matrixFromTransform = VectorUtilities.GetMatrixFromTransform(element.ViewModel.DefaultView.ComputeTransformToVisual(element.ViewTargetElement, ancestorViewObject));
Matrix matrix = Matrix.Identity;
Matrix identity = Matrix.Identity;
BaseFrameworkElement frameworkElement = element as BaseFrameworkElement;
if (frameworkElement != null)
{
matrix = ElementUtilities.GetInverseMatrix(frameworkElement.GetRenderTransform());
Point elementCoordinates = frameworkElement.RenderTransformOriginInElementCoordinates;
identity.Translate(elementCoordinates.X, elementCoordinates.Y);
}
return(matrix * identity * matrixFromTransform);
}
private void EnsureBounds()
{
if (this.boundsCached)
{
return;
}
Rect empty = Rect.Empty;
Matrix inverseMatrix = ElementUtilities.GetInverseMatrix(this.SharedTransformToRootVisual.Value);
foreach (SceneElement sceneElement in this.elements)
{
IViewObject viewTargetElement = sceneElement.ViewTargetElement;
if (viewTargetElement != null)
{
Matrix matrixFromTransform = VectorUtilities.GetMatrixFromTransform(this.ViewModel.DefaultView.ComputeTransformToVisual(viewTargetElement, this.RootVisual));
Rect actualBounds = this.ViewModel.DefaultView.GetActualBounds(viewTargetElement);
actualBounds.Transform(matrixFromTransform * inverseMatrix);
empty.Union(actualBounds);
}
}
this.cachedBounds = empty;
this.boundsCached = true;
}
public Matrix GetTransformToElementSpaceFromMemberElement(SceneElement element)
{
return(VectorUtilities.GetMatrixFromTransform(element.ViewModel.DefaultView.ComputeTransformToVisual(element.Visual, this.RootVisual)) * ElementUtilities.GetInverseMatrix(this.GetTransformMatrixToAdornerLayer(false)));
}
public static Matrix GetCompleteInverseBrushTransformMatrix(Base2DElement element, object brush, bool includeTransformFromElementToBrushCoordinates)
{
return(ElementUtilities.GetInverseMatrix(BrushAdorner.GetCompleteBrushTransformMatrix(element, brush, includeTransformFromElementToBrushCoordinates)));
}
