public void SetTimeRegion(double originalRegionBegin, double originalRegionEnd, double finalRegionBegin, double finalRegionEnd)
{
using (SceneEditTransaction editTransaction = this.ViewModel.CreateEditTransaction(StringTable.UndoUnitMoveScheduledProperties))
{
double scaleFactor = (finalRegionEnd - finalRegionBegin) / (originalRegionEnd - originalRegionBegin);
TimeRegionChangeDetails details = TimeRegionChangeDetails.None;
if (Tolerances.AreClose(originalRegionEnd - originalRegionBegin, 0.0))
{
details |= TimeRegionChangeDetails.FromZero;
}
if (Tolerances.AreClose(finalRegionEnd - finalRegionBegin, 0.0))
{
details |= TimeRegionChangeDetails.ToZero;
}
if (!Tolerances.AreClose(scaleFactor, 1.0))
{
details |= TimeRegionChangeDetails.Scale;
}
if (!Tolerances.AreClose(originalRegionBegin, finalRegionBegin))
{
details |= TimeRegionChangeDetails.Translate;
}
this.RecursiveSetTimeRegion(details, scaleFactor, originalRegionBegin, originalRegionEnd, finalRegionBegin, finalRegionEnd);
editTransaction.Commit();
}
}
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 virtual void ComputeMarginOverrides()
{
bool flag = false;
double left = this.Settings.Margin.Left;
double right = this.Settings.Margin.Right;
double top = this.Settings.Margin.Top;
double bottom = this.Settings.Margin.Bottom;
if (!Tolerances.AreClose(this.SettingsFromElement.Margin.Left, this.Settings.Margin.Left) || !Tolerances.AreClose(this.SettingsFromElement.Margin.Right, this.Settings.Margin.Right))
{
this.Settings.LayoutOverrides |= LayoutOverrides.HorizontalMargin;
left = this.SettingsFromElement.Margin.Left;
right = this.SettingsFromElement.Margin.Right;
flag = true;
}
if (!Tolerances.AreClose(this.SettingsFromElement.Margin.Top, this.Settings.Margin.Top) || !Tolerances.AreClose(this.SettingsFromElement.Margin.Bottom, this.Settings.Margin.Bottom))
{
this.Settings.LayoutOverrides |= LayoutOverrides.VerticalMargin;
top = this.SettingsFromElement.Margin.Top;
bottom = this.SettingsFromElement.Margin.Bottom;
flag = true;
}
if (!flag)
{
return;
}
this.Settings.Margin = new Thickness(left, top, right, bottom);
}
public static Rotation3D GetRotation3DFromDirection(Vector3D direction)
{
direction.Normalize();
Vector3D axis = Vector3D.CrossProduct(Vector3DEditor.pointingDirection, direction);
double d = Vector3D.DotProduct(Vector3DEditor.pointingDirection, direction);
return(!Tolerances.AreClose(axis.LengthSquared, 0.0) ? (Rotation3D) new AxisAngleRotation3D(axis, Math.Acos(d) * 57.2957795130823) : (!Tolerances.AreClose(d, 1.0) ? (Rotation3D) new AxisAngleRotation3D(Vector3DEditor.perpendicularDirection, 180.0) : Rotation3D.Identity));
}
public static bool LessThan(double value1, double value2)
{
if (value1 < value2)
{
return(!Tolerances.AreClose(value1, value2));
}
return(false);
}
public static bool LessThanOrClose(double value1, double value2)
{
if (value1 >= value2)
{
return(Tolerances.AreClose(value1, value2));
}
return(true);
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
if (!Tolerances.AreClose(this.LastTangent, new Vector(0.0, 0.0)))
{
this.LastTangent = new Vector(0.0, 0.0);
}
base.OnBegin(pathEditContext, mouseDevice);
}
public static bool GreaterThan(double value1, double value2)
{
if (value1 > value2)
{
return(!Tolerances.AreClose(value1, value2));
}
return(false);
}
public static bool AreClose(Point point1, Point point2)
{
if (Tolerances.AreClose(point1.X, point2.X) && Tolerances.AreClose(point1.Y, point2.Y))
{
return(true);
}
return(false);
}
protected override void Finish()
{
if (Tolerances.AreClose(this.initialRenderTransformOrigin, this.EditingElementSet.RenderTransformOrigin))
{
return;
}
this.EnsureEditTransaction();
this.EditingElement.ViewModel.Document.AddUndoUnit((IUndoUnit) new MultipleElementCenterEditUndoUnit(this.EditingElementSet, this.initialRenderTransformOrigin, this.EditingElementSet.RenderTransformOrigin));
}
private bool ReadCanonicalForm(Transform3D transform, bool useIfChangeable)
{
if (!CanonicalTransform3D.IsCanonical(transform))
{
return(false);
}
Transform3DGroup transform3Dgroup = (Transform3DGroup)transform;
ScaleTransform3D scaleTransform3D = transform3Dgroup.Children[1] as ScaleTransform3D;
RotateTransform3D rotateTransform3D = transform3Dgroup.Children[2] as RotateTransform3D;
TranslateTransform3D translateTransform3D1 = transform3Dgroup.Children[3] as TranslateTransform3D;
TranslateTransform3D translateTransform3D2 = transform3Dgroup.Children[4] as TranslateTransform3D;
this.center = new Point3D(translateTransform3D1.OffsetX, translateTransform3D1.OffsetY, translateTransform3D1.OffsetZ);
this.scale = new Vector3D(scaleTransform3D.ScaleX, scaleTransform3D.ScaleY, scaleTransform3D.ScaleZ);
this.translation = new Vector3D(translateTransform3D2.OffsetX, translateTransform3D2.OffsetY, translateTransform3D2.OffsetZ);
if (useIfChangeable && !transform3Dgroup.IsFrozen)
{
this.transformGroup = transform3Dgroup;
}
else
{
this.InitializeTransformGroup();
Vector3D? nullable = (Vector3D?)rotateTransform3D.GetValue(CanonicalTransform3D.EulerAnglesProperty);
bool flag = nullable.HasValue;
AxisAngleRotation3D axisAngleRotation3D = rotateTransform3D.Rotation as AxisAngleRotation3D;
Quaternion orientation = Quaternion.Identity;
if (axisAngleRotation3D != null)
{
orientation = new Quaternion(axisAngleRotation3D.Axis, axisAngleRotation3D.Angle);
}
if (flag)
{
Quaternion quaternion = Helper3D.QuaternionFromEulerAngles(nullable.Value);
if (!Tolerances.AreClose(quaternion.Angle, orientation.Angle) || !Tolerances.AreClose(quaternion.Axis, orientation.Axis))
{
flag = false;
}
}
if (!flag)
{
nullable = new Vector3D?(Helper3D.EulerAnglesFromQuaternion(orientation));
}
this.RotationAngles = nullable.Value;
}
return(true);
}
public void Update(Rect rect, Thickness margin, Matrix4x4 transformToRoot, double density)
{
double unitsPerPixel = 1 / density;
boundingBox = DpiHelper.RoundToPixel(rect, unitsPerPixel);
marginZones.Clear();
if (margin == new Thickness())
{
return;
}
// If transform to root is more than just an offset (i.e. element or
// some of its ancestors are scaled/rotated/etc.) then no margins to
// render. This matches WPF, UWP and WinUI adorners.
if (!Tolerances.AreClose(transformToRoot.M11, 1) ||
!Tolerances.AreClose(transformToRoot.M22, 1) ||
!Tolerances.AreClose(transformToRoot.M12, 0) ||
!Tolerances.AreClose(transformToRoot.M21, 0))
{
return;
}
// Create up to 4 rectangles for margins. Keep in mind that some of
// margin values can be negative, e.g. Margin="-10, 20, 30, -40".
// Left
if (!Tolerances.NearZero(margin.Left))
{
Rect rc = new Rect();
rc.Left = Math.Min(rect.Left - margin.Left, rect.Left);
rc.Width = Math.Abs(margin.Left);
rc.Top = rect.Top;
rc.Bottom = rect.Bottom;
TryAddMarginZone(rc, unitsPerPixel);
}
// Right
if (!Tolerances.NearZero(margin.Right))
{
Rect rc = new Rect();
rc.Left = Math.Min(rect.Right, rect.Right + margin.Right);
rc.Width = Math.Abs(margin.Right);
rc.Top = rect.Top;
rc.Bottom = rect.Bottom;
TryAddMarginZone(rc, unitsPerPixel);
}
// Top
if (!Tolerances.NearZero(margin.Top))
{
Rect rc = new Rect();
rc.Left = rect.Left - Math.Max(0, margin.Left);
rc.Right = rect.Right + Math.Max(0, margin.Right);
rc.Top = Math.Min(rect.Top - margin.Top, rect.Top);
rc.Height = Math.Abs(margin.Top);
TryAddMarginZone(rc, unitsPerPixel);
}
// Bottom
if (!Tolerances.NearZero(margin.Bottom))
{
Rect rc = new Rect();
rc.Left = rect.Left - Math.Max(0, margin.Left);
rc.Right = rect.Right + Math.Max(0, margin.Right);
rc.Top = Math.Min(rect.Bottom + margin.Bottom, rect.Bottom);
rc.Height = Math.Abs(margin.Bottom);
TryAddMarginZone(rc, unitsPerPixel);
}
}
protected static void UpdateElementTransform(SceneElement element, CanonicalDecomposition newTransform, AdornedToolBehavior.TransformPropertyFlags properties)
{
Transform transform = element.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty) as Transform;
CanonicalDecomposition canonicalDecomposition = new CanonicalDecomposition();
if (transform != null)
{
canonicalDecomposition = new CanonicalTransform(transform).Decomposition;
}
double num1 = RoundingHelper.RoundScale(newTransform.ScaleX);
double num2 = RoundingHelper.RoundScale(newTransform.ScaleY);
double num3 = RoundingHelper.RoundLength(newTransform.TranslationX);
double num4 = RoundingHelper.RoundLength(newTransform.TranslationY);
double num5 = RoundingHelper.RoundLength(newTransform.SkewX);
double num6 = RoundingHelper.RoundLength(newTransform.SkewY);
double num7 = RoundingHelper.RoundAngle(newTransform.RotationAngle);
if ((properties & AdornedToolBehavior.TransformPropertyFlags.ScaleX) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.ScaleX, num1))
{
element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformScaleX, (object)num1);
}
if ((properties & AdornedToolBehavior.TransformPropertyFlags.ScaleY) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.ScaleY, num2))
{
element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformScaleY, (object)num2);
}
if ((properties & AdornedToolBehavior.TransformPropertyFlags.TranslationX) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.TranslationX, num3))
{
element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformTranslationX, (object)num3);
}
if ((properties & AdornedToolBehavior.TransformPropertyFlags.TranslationY) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.TranslationY, num4))
{
element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformTranslationY, (object)num4);
}
if ((properties & AdornedToolBehavior.TransformPropertyFlags.SkewX) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.SkewX, num5))
{
element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformSkewX, (object)num5);
}
if ((properties & AdornedToolBehavior.TransformPropertyFlags.SkewY) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.SkewY, num6))
{
element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformSkewY, (object)num6);
}
if ((properties & AdornedToolBehavior.TransformPropertyFlags.RotatationAngle) == AdornedToolBehavior.TransformPropertyFlags.None || Tolerances.AreClose(canonicalDecomposition.RotationAngle, num7))
{
return;
}
element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformRotationAngle, (object)num7);
}
protected virtual void SetMarginChanges()
{
bool flag1 = false;
bool flag2 = false;
double left = this.Settings.Margin.Left;
double right = this.Settings.Margin.Right;
double top = this.Settings.Margin.Top;
double bottom = this.Settings.Margin.Bottom;
if (!Tolerances.AreClose(this.SettingsFromElement.Margin.Left, this.Settings.Margin.Left) || !Tolerances.AreClose(this.SettingsFromElement.Margin.Right, this.Settings.Margin.Right))
{
if ((this.LayoutOverrides & LayoutOverrides.HorizontalMargin) != LayoutOverrides.None && (this.OverridesToIgnore & (this.Settings.HorizontalAlignment == HorizontalAlignment.Center ? LayoutOverrides.CenterHorizontalMargin : LayoutOverrides.HorizontalMargin)) == LayoutOverrides.None)
{
left = this.SettingsFromElement.Margin.Left;
right = this.SettingsFromElement.Margin.Right;
flag1 = true;
}
else
{
flag2 = true;
}
this.ExplicitOverrides &= ~LayoutOverrides.HorizontalMargin;
if (double.IsNaN(this.Settings.Width) && (this.OverridesToIgnore & LayoutOverrides.Width) != LayoutOverrides.None && !Tolerances.AreClose(this.SettingsFromElement.Margin.Left + this.SettingsFromElement.Margin.Right, this.Settings.Margin.Left + this.Settings.Margin.Right))
{
this.ExplicitOverrides &= ~LayoutOverrides.Width;
}
}
else if ((this.LayoutOverrides & LayoutOverrides.HorizontalMargin) != LayoutOverrides.None && (this.SettingsFromElement.LayoutOverrides & LayoutOverrides.HorizontalMargin) == LayoutOverrides.None)
{
this.ExplicitOverrides |= LayoutOverrides.HorizontalMargin;
}
if (!Tolerances.AreClose(this.SettingsFromElement.Margin.Top, this.Settings.Margin.Top) || !Tolerances.AreClose(this.SettingsFromElement.Margin.Bottom, this.Settings.Margin.Bottom))
{
if ((this.LayoutOverrides & LayoutOverrides.VerticalMargin) != LayoutOverrides.None && (this.OverridesToIgnore & (this.Settings.VerticalAlignment == VerticalAlignment.Center ? LayoutOverrides.CenterVerticalMargin : LayoutOverrides.VerticalMargin)) == LayoutOverrides.None)
{
top = this.SettingsFromElement.Margin.Top;
bottom = this.SettingsFromElement.Margin.Bottom;
flag1 = true;
}
else
{
flag2 = true;
}
this.ExplicitOverrides &= ~LayoutOverrides.VerticalMargin;
if (double.IsNaN(this.Settings.Height) && (this.OverridesToIgnore & LayoutOverrides.Height) != LayoutOverrides.None && !Tolerances.AreClose(this.SettingsFromElement.Margin.Top + this.SettingsFromElement.Margin.Bottom, this.Settings.Margin.Top + this.Settings.Margin.Bottom))
{
this.ExplicitOverrides &= ~LayoutOverrides.Height;
}
}
else if ((this.LayoutOverrides & LayoutOverrides.VerticalMargin) != LayoutOverrides.None && (this.SettingsFromElement.LayoutOverrides & LayoutOverrides.VerticalMargin) == LayoutOverrides.None)
{
this.ExplicitOverrides |= LayoutOverrides.VerticalMargin;
}
if (flag1)
{
this.Settings.Margin = new Thickness(left, top, right, bottom);
}
if (!flag2)
{
return;
}
this.Child.SetValueAsWpf(BaseFrameworkElement.MarginProperty, (object)this.Settings.Margin);
}
private CanonicalDecomposition CalculateSharedTransform(bool scaleByZoom, bool addParentToRoot)
{
bool flag = false;
CanonicalDecomposition canonicalDecomposition1 = new CanonicalDecomposition();
this.hasHomogenousRotation = true;
this.hasHomogenousSkew = true;
foreach (SceneElement sceneElement in this.elements)
{
if (sceneElement is BaseFrameworkElement)
{
if (!sceneElement.IsAttached)
{
return(new CanonicalDecomposition());
}
Transform identity = Transform.Identity;
Transform transform = sceneElement.GetComputedValueAsWpf(sceneElement.Platform.Metadata.CommonProperties.RenderTransform) as Transform ?? Transform.Identity;
CanonicalDecomposition canonicalDecomposition2 = new CanonicalDecomposition();
CanonicalDecomposition canonicalDecomposition3 = !CanonicalTransform.IsCanonical(transform) ? new CanonicalDecomposition(transform.Value) : new CanonicalTransform(transform).Decomposition;
if (!double.IsNaN(canonicalDecomposition3.ScaleX) && !double.IsNaN(canonicalDecomposition3.ScaleY))
{
if (!flag)
{
canonicalDecomposition1 = canonicalDecomposition3;
canonicalDecomposition1.ScaleX = (double)Math.Sign(canonicalDecomposition1.ScaleX);
canonicalDecomposition1.ScaleY = (double)Math.Sign(canonicalDecomposition1.ScaleY);
flag = true;
}
else
{
if (Math.Sign(canonicalDecomposition3.ScaleX) != Math.Sign(canonicalDecomposition1.ScaleX))
{
canonicalDecomposition1.ScaleX = 1.0;
}
if (Math.Sign(canonicalDecomposition3.ScaleY) != Math.Sign(canonicalDecomposition1.ScaleY))
{
canonicalDecomposition1.ScaleY = 1.0;
}
if (!Tolerances.AreClose(canonicalDecomposition3.RotationAngle, canonicalDecomposition1.RotationAngle) || !Tolerances.AreClose(canonicalDecomposition3.SkewX, canonicalDecomposition1.SkewX) || !Tolerances.AreClose(canonicalDecomposition3.SkewY, canonicalDecomposition1.SkewY))
{
canonicalDecomposition1.RotationAngle = 0.0;
canonicalDecomposition1.SkewX = 0.0;
canonicalDecomposition1.SkewY = 0.0;
this.hasHomogenousSkew = false;
this.hasHomogenousRotation = false;
}
}
}
}
}
double zoom = this.DesignerContext.ActiveView.Artboard.Zoom;
if (scaleByZoom)
{
canonicalDecomposition1.ScaleX = zoom * canonicalDecomposition1.ScaleX;
canonicalDecomposition1.ScaleY = zoom * canonicalDecomposition1.ScaleY;
}
canonicalDecomposition1.Translation = new Vector(0.0, 0.0);
if (addParentToRoot && this.PrimaryElement.VisualElementAncestor != null)
{
Matrix computedTransformToRoot = this.ViewModel.DefaultView.GetComputedTransformToRoot(this.PrimaryElement.VisualElementAncestor.Visual);
Transform transform = this.ViewModel.DefaultView.Artboard.CalculateTransformFromContentToArtboard();
computedTransformToRoot.Append(transform.Value);
computedTransformToRoot.OffsetX = 0.0;
computedTransformToRoot.OffsetY = 0.0;
CanonicalDecomposition canonicalDecomposition2 = new CanonicalDecomposition(computedTransformToRoot);
canonicalDecomposition1.Scale = new Vector(canonicalDecomposition1.ScaleX * (canonicalDecomposition2.ScaleX / zoom), canonicalDecomposition1.ScaleY * (canonicalDecomposition2.ScaleY / zoom));
canonicalDecomposition1.Skew += canonicalDecomposition2.Skew;
canonicalDecomposition1.RotationAngle *= (double)(Math.Sign(canonicalDecomposition2.ScaleX) * Math.Sign(canonicalDecomposition2.ScaleY));
canonicalDecomposition1.RotationAngle += canonicalDecomposition2.RotationAngle;
canonicalDecomposition1.Translation += canonicalDecomposition2.Translation;
}
return(canonicalDecomposition1);
}
private DefinitionBase SearchForAdjustableDefinition(int index, bool searchForwards, bool shrinkingInSearchDirection)
{
Grid grid = this.Parent as Grid;
if (grid == null)
{
return((DefinitionBase)null);
}
ExpandoList expandoList = grid.TemplatedParent as ExpandoList;
IList list = this.IsAdjustingHorizontal ? (IList)grid.ColumnDefinitions : (IList)grid.RowDefinitions;
while (index >= 0 && index < list.Count)
{
DefinitionBase definition = (DefinitionBase)list[index];
if (expandoList != null && ((ExpandoListItemModel)expandoList.Items[index]).IsExpanded && (!shrinkingInSearchDirection || !Tolerances.AreClose(this.GetActualLength(definition), this.GetMinLength(definition))))
{
return(definition);
}
index += searchForwards ? 1 : -1;
}
return((DefinitionBase)null);
}
private RegistrationPointFlags FindRegistrationPointForElement(BaseFrameworkElement element)
{
if (!element.IsViewObjectValid)
{
return(RegistrationPointFlags.None);
}
Point elementCoordinates = element.RenderTransformOriginInElementCoordinates;
Point point1 = elementCoordinates;
if (this.IsRenderTransform)
{
Rect computedTightBounds = element.GetComputedTightBounds();
point1 = new Point(elementCoordinates.X - computedTightBounds.Left, elementCoordinates.Y - computedTightBounds.Top);
Point point2 = (Point)element.GetComputedValueAsWpf(Base2DElement.RenderTransformOriginProperty);
Point point3 = new Point();
bool flag = false;
if (!Tolerances.NearZero(computedTightBounds.Width))
{
point1.X /= computedTightBounds.Width;
}
else if (!Tolerances.NearZero(point1.X))
{
point1.X = -1.0;
}
if (!Tolerances.NearZero(computedTightBounds.Height))
{
point1.Y /= computedTightBounds.Height;
}
else if (!Tolerances.NearZero(point1.Y))
{
point1.Y = -1.0;
}
if (!double.IsNaN(point2.X) && !double.IsNaN(point2.Y))
{
point3.X = point2.X;
point3.Y = point2.Y;
flag = true;
}
if ((Tolerances.NearZero(computedTightBounds.Width) || Tolerances.NearZero(computedTightBounds.Height)) && flag)
{
if (!Tolerances.NearZero(computedTightBounds.Width) && Tolerances.AreClose(point1.X, point3.X) && Tolerances.NearZero(point1.Y))
{
point1 = point3;
}
else if (!Tolerances.NearZero(computedTightBounds.Height) && Tolerances.AreClose(point1.Y, point3.Y) && Tolerances.NearZero(point1.X))
{
point1 = point3;
}
else if (Tolerances.NearZero(computedTightBounds.Width) && Tolerances.NearZero(computedTightBounds.Height) && Tolerances.NearZero(point1))
{
point1 = point3;
}
}
}
foreach (RegistrationPointFlags registrationPoint in Enum.GetValues(typeof(RegistrationPointFlags)))
{
if ((this.CenterFromRegistrationPoint(registrationPoint) - point1).LengthSquared <= RegistrationPointModel.RegistrationPointTolerance)
{
return(registrationPoint);
}
}
return(RegistrationPointFlags.None);
}
