internal static Line Transform(this RotateTransform transform, Line line)
{
var p1 = transform.Transform(line.StartPoint);
var p2 = transform.Transform(line.EndPoint);
return(new Line(p1, p2));
}
public void Rotate()
{
if (!IsDestroyed)
{
if (IsRotatingClockwise || IsRotatingCounterClockwise)
{
int degrees = 0;
if (IsRotatingClockwise)
{
degrees = 5;
}
else if (IsRotatingCounterClockwise)
{
degrees = -5;
}
var rotation = new RotateTransform(degrees, Center.X, Center.Y);
PointCollection rotated = new PointCollection();
foreach (Point vert in Geometry.Points)
{
rotated.Add(rotation.Transform(vert));
}
Geometry.Points = rotated;
Trajectory = rotation.Transform(Trajectory);
ThrustStart = rotation.Transform(ThrustStart);
ThrustEnd = rotation.Transform(ThrustEnd);
}
}
}
/// <summary>
/// Draws an equilateral triangle from the given center point and rotation. Also applies the global rotation
/// </summary>
private void CreateTriangle(double x, double y, double rotation, int panelId, Transform globalRotationTransform)
{
//First assume that we draw the triangle facing up:
// A
// /\
// / \
// /____\
// B C
var A = new Point(x, y - ((Math.Sqrt(3) / 3) * _defaultTriangleSize));
var B = new Point(x - (_defaultTriangleSize / 2), y + ((Math.Sqrt(3) / 6) * _defaultTriangleSize));
var C = new Point(x + (_defaultTriangleSize / 2), y + ((Math.Sqrt(3) / 6) * _defaultTriangleSize));
var rotateTransform = new RotateTransform(rotation, x, y);
//Apply transformation and add points to polygon
var triangle = new Polygon();
triangle.Points.Add(globalRotationTransform.Transform(rotateTransform.Transform(A)));
triangle.Points.Add(globalRotationTransform.Transform(rotateTransform.Transform(B)));
triangle.Points.Add(globalRotationTransform.Transform(rotateTransform.Transform(C)));
triangle.Stroke = _borderColor;
triangle.HorizontalAlignment = HorizontalAlignment.Left;
triangle.VerticalAlignment = VerticalAlignment.Top;
triangle.StrokeThickness = 2;
_unscaledTriangles.Add(new DrawablePanel
{
MidPoint = globalRotationTransform.Transform(new Point(x, y)),
PanelId = panelId,
Polygon = triangle
});
}
private void MouseAndTouchDown(Point downPoint)
{
oldX = ViewModel.Left;
oldY = ViewModel.Top;
//Transform MousePoint with the rotation to get the real x,y Point
transformedDownLocation = rotateTransform.Transform(downPoint);
//Signal we are moving this instance manually
ViewModel.IsMoving = true;
}
private PathFigure GetRotatedPathFigure(Size thermostatSize, Point start, Point end, double angle)
{
RotateTransform rotateTransform = GetRotateTransform(thermostatSize);
rotateTransform.Angle = angle;
Point rotatedStart = rotateTransform.Transform(start);
Point rotatedEnd = rotateTransform.Transform(end);
return(GetPathFigure(rotatedStart, rotatedEnd));
}
void DrawLineCap(DrawingContext dc, Point point, Vector vector,
PenLineCap startLineCap, PenLineCap endLineCap)
{
if (startLineCap == PenLineCap.Flat && endLineCap == PenLineCap.Flat)
{
return;
}
// Construct really tiny horizontal line
vector.Normalize();
double angle = Math.Atan2(vector.Y, vector.X);
RotateTransform rotate = new RotateTransform(-180 * angle / Math.PI, point.X, point.Y);
Point point1 = rotate.Transform(point);
Point point2 = rotate.Transform(point + 0.25 * vector);
// Construct pen for that line
Pen pen = new Pen()
{
Thickness = StrokeThickness,
StartLineCap = startLineCap,
EndLineCap = endLineCap
};
pen.Freeze();
// Why don't I just call dc.DrawLine at this point? Well, to avoid gaps between
// the tetragons, I had to draw them with an 'outlinePenWidth' pen based on the
// same brush as the fill. If I just called dc.DrawLine here, the caps would
// look a little smaller than the line, so....
LineGeometry lineGeo = new LineGeometry(point1, point2);
PathGeometry pathGeo = lineGeo.GetWidenedPathGeometry(pen);
Brush brush = null;
if (GradientMode == GradientMode.Perpendicular)
{
brush = new LinearGradientBrush(GradientStops, new Point(0, 0), new Point(0, 1));
(brush as LinearGradientBrush).ColorInterpolationMode = ColorInterpolationMode;
}
else
{
double offset = endLineCap == PenLineCap.Flat ? 0 : 1;
brush = new SolidColorBrush(GetColorFromGradientStops(offset));
brush.Freeze();
}
pen = new Pen(brush, outlinePenWidth);
pen.Freeze();
rotate.Angle = 180 * angle / Math.PI;
dc.PushTransform(rotate);
dc.DrawGeometry(brush, pen, pathGeo);
dc.Pop();
}
public void IsConstrainedFalse_ParentIsRotated_ElementIsPositionedCorrectly()
{
Rectangle rect = CreateRectangleInGrid();
MouseDragElementBehavior behavior = CreateAndAttachMouseDragElementBehavior(rect);
RotateTransform transform = new RotateTransform(30);
((Grid)rect.Parent).RenderTransform = transform;
Point startPoint = transform.Transform(new Point(5, 5));
Point dragPoint = transform.Transform(new Point(50, 50));
this.PerformSingleDrag(behavior, startPoint, dragPoint);
this.VerifyOffset(rect.RenderTransform, 45.0d, 45.0d);
}
/// <summary>
/// Intersects a line with a geometry to return the point of intersection
/// </summary>
/// <param name="node"></param>
/// <param name="p"></param>
/// <param name="centerVector"></param>
/// <param name="t"></param>
/// <returns></returns>
private static Point FindOppositePoint(PathGeometry node, Point p, Vector centerVector, Transform t)
{
Vector xaxis = new Point(1, 0) - new Point(0, 0);
double angleBetween = Vector.AngleBetween(centerVector, xaxis);
RotateTransform r = new RotateTransform(angleBetween, p.X, p.Y);
SortedList pointList = new SortedList();
for (int i = 0; i < node.Figures.Count; i++)
{
PathFigure pf = node.Figures[i];
Point lastPathFigurePoint = r.Transform(pf.StartPoint);
for (int j = 0; j < pf.Segments.Count; j++)
{
if (pf.Segments[j] is PolyLineSegment)
{
PolyLineSegment pls = (PolyLineSegment)pf.Segments[j];
for (int k = 0; k < pls.Points.Count; k++)
{
Point point1 = r.Transform(pls.Points[k]);
CheckLineSegmentForIntersection(p, point1, lastPathFigurePoint, pointList);
lastPathFigurePoint = point1;
}
}
else if (pf.Segments[j] is LineSegment)
{
LineSegment ls = (LineSegment)pf.Segments[j];
Point p1 = r.Transform(ls.Point);
Point p2 = lastPathFigurePoint;
lastPathFigurePoint = p1;
CheckLineSegmentForIntersection(p, p1, p2, pointList);
}
}
}
if (pointList.Count < 1)
{
return(centerVector + p);
}
Point returnPt = new Point((double)pointList.GetByIndex(0), p.Y);
r.Angle = -1 * angleBetween;
returnPt = r.Transform(returnPt);
Vector finalVector = returnPt - p;
if (finalVector.Length > centerVector.Length)
{
return(centerVector + p);
}
return(returnPt);
}
private void DrawLineCap(
DrawingContext dc,
Line line,
PenLineCap startLineCap,
PenLineCap endLineCap)
{
if (startLineCap == PenLineCap.Flat && endLineCap == PenLineCap.Flat)
{
return;
}
var point = endLineCap == PenLineCap.Flat ? line.StartPoint : line.EndPoint;
// Construct really tiny horizontal line
var angle = Math.Atan2(line.Direction.Y, line.Direction.X);
var rotate = new RotateTransform(-180 * angle / Math.PI, point.X, point.Y);
var point1 = rotate.Transform(point);
var point2 = rotate.Transform(point + 0.25 * line.Direction);
// Construct pen for that line
var pen = new Pen()
{
Thickness = this.StrokeThickness, StartLineCap = startLineCap, EndLineCap = endLineCap
};
// Why don't I just call dc.DrawLine at this point? Well, to avoid gaps between
// the tetragons, I had to draw them with an 'outlinePenWidth' pen based on the
// same brush as the fill. If I just called dc.DrawLine here, the caps would
// look a little smaller than the line, so....
var lineGeo = new LineGeometry(point1, point2);
var pathGeo = lineGeo.GetWidenedPathGeometry(pen);
Brush brush;
if (this.GradientMode == GradientMode.Perpendicular)
{
brush = new LinearGradientBrush(this.GradientStops, new Point(0, 0), new Point(0, 1));
((LinearGradientBrush)brush).ColorInterpolationMode = this.ColorInterpolationMode;
}
else
{
double offset = endLineCap == PenLineCap.Flat ? 0 : 1;
brush = new SolidColorBrush(this.GradientStops.GetColorAt(offset, this.ColorInterpolationMode));
}
pen = new Pen(brush, 0);
rotate.Angle = 180 * angle / Math.PI;
dc.PushTransform(rotate);
dc.DrawGeometry(brush, pen, pathGeo);
dc.Pop();
}
private void GetMoveOffset(DragDeltaEventArgs e, ref double xOffset, ref double yOffset)
{
System.Windows.Point dragDelta = new System.Windows.Point(e.HorizontalChange, e.VerticalChange);
RotateTransform rotateTransform = designerItem.RenderTransform as RotateTransform;
if (rotateTransform != null)
{
dragDelta = rotateTransform.Transform(dragDelta);
//Rect rec = rotateTransform.TransformBounds(new Rect(designerItem.RenderSize));
//rotateTransform.
}
xOffset = dragDelta.X;
yOffset = dragDelta.Y;
//If shift key down, move widget by straight line.
if ((Keyboard.Modifiers & ModifierKeys.Shift) != ModifierKeys.None)
{
if (Math.Abs(xOffset) > Math.Abs(yOffset))
{
yOffset = 0;
}
else
{
xOffset = 0;
}
}
IPagePropertyData page = designerCanvas.DataContext as IPagePropertyData;
Snap(page.BoundingRect, ref xOffset, ref yOffset);
}
public MoveThumb()
{
DragStarted += (sender, args) =>
{
_contentControl = DataContext as ContentControl;
if (_contentControl != null)
{
_rotateTransform = _contentControl.RenderTransform as RotateTransform;
}
};
DragDelta += (sender, args) =>
{
if (_contentControl != null)
{
var point = new Point(args.HorizontalChange, args.VerticalChange);
if (_rotateTransform != null)
{
point = _rotateTransform.Transform(point);
}
Canvas.SetTop(_contentControl, Canvas.GetTop(_contentControl) + point.Y);
Canvas.SetLeft(_contentControl, Canvas.GetLeft(_contentControl) + point.X);
}
};
}
public static void CalculateViewFromLocations(IEnumerable <Location> locations, Size viewportSize, double heading, Thickness margin, out Point centerNormalizedMercator, out double zoomLevel)
{
var point1 = new Point(double.MaxValue, double.MaxValue);
var point2 = new Point(double.MinValue, double.MinValue);
var rotateTransform = new RotateTransform(heading)
{
CenterX = 0.5,
CenterY = 0.5
};
foreach (var location in locations)
{
var point3 = rotateTransform.Transform(MercatorCube.Instance.FromLocation(location).ToPoint());
point1.X = Math.Min(point1.X, point3.X);
point1.Y = Math.Min(point1.Y, point3.Y);
point2.X = Math.Max(point2.X, point3.X);
point2.Y = Math.Max(point2.Y, point3.Y);
}
if (point2.X > point1.X && point2.Y > point1.Y)
{
var a = Math.Min((viewportSize.Width - margin.Left - margin.Right) / (DefaultTileSize * (point2.X - point1.X)), (viewportSize.Height - margin.Top - margin.Bottom) / (DefaultTileSize * (point2.Y - point1.Y)));
zoomLevel = Math.Log(a, 2.0);
var num = 1.0 / (DefaultTileSize * Math.Pow(2.0, zoomLevel));
centerNormalizedMercator = rotateTransform.Inverse.Transform(new Point((point2.X + num * margin.Right + point1.X - num * margin.Left) / 2.0, (point2.Y + num * margin.Bottom + point1.Y - num * margin.Top) / 2.0));
}
else
{
if (point1.X != point2.X)
{
throw new InvalidOperationException("Must provide at least one location.");
}
zoomLevel = 1.0;
centerNormalizedMercator = point1;
}
}
private Point RotatePointByTransformation(Point p, double angle)
{
var rotation = new RotateTransform();
rotation.Angle = angle;
return(rotation.Transform(p));
}
public override Rect GetEditingBounds()
{
Rect bounds = GetCustomBound();
RotateTransform rotationTransform = new RotateTransform(shapeStyle.rotation, GetCenter().X, GetCenter().Y);
Point topLeft = rotationTransform.Transform(bounds.TopLeft);
Point topRight = rotationTransform.Transform(bounds.TopRight);
Point bottomLeft = rotationTransform.Transform(bounds.BottomLeft);
Point bottomRight = rotationTransform.Transform(bounds.BottomRight);
double minX = Math.Min(Math.Min(Math.Min(topLeft.X, topRight.X), bottomLeft.X), bottomRight.X);
double maxX = Math.Max(Math.Max(Math.Max(topLeft.X, topRight.X), bottomLeft.X), bottomRight.X);
double minY = Math.Min(Math.Min(Math.Min(topLeft.Y, topRight.Y), bottomLeft.Y), bottomRight.Y);
double maxY = Math.Max(Math.Max(Math.Max(topLeft.Y, topRight.Y), bottomLeft.Y), bottomRight.Y);
bounds = new Rect(new Point(minX - 15, minY - 15), new Point(maxX + 15, maxY + 15));
return(bounds);
}
private Polygon CreateRotatedHexagon(double x, double y, RotateTransform rotateTransform, Transform globalRotationTransform)
{
var polygon = new Polygon();
/* ____
* / \
* / \
* | |
* | |
* \ /
* \____/
*
* A hexagon has 6 sides. Use a loop to draw a hexagon with the x,y midpoint
* and its side length.
*/
const int hexagonSideLength = 67;
for (var currentPoint = 0; currentPoint < 6; currentPoint++)
{
var point = new Point(
x + hexagonSideLength * (float)Math.Cos(currentPoint * 60 * Math.PI / 180f),
y + hexagonSideLength * (float)Math.Sin(currentPoint * 60 * Math.PI / 180f)
);
polygon.Points.Add(globalRotationTransform.Transform(rotateTransform.Transform(point)));
}
return(polygon);
}
public static void RotateGraphicVisual(GraphicVisual graphicVisual, double angle, Point center)
{
RotateTransform tr = new RotateTransform(angle, center.X, center.Y);
graphicVisual.Origin = tr.Transform(graphicVisual.Origin);
graphicVisual.Angle += angle;
}
protected override Size ArrangeOverride(Size finalSize)
{
if (GetValues(this) != null)
{
double total = 0.0;
for (int i = 0; i < InternalChildren.Count; i++)
{
total += (double)(GetValues(this)[i]);
}
double offsetAngle = 0.0;
double radius = finalSize.Width < finalSize.Height ? finalSize.Width / 2 : finalSize.Height / 2;
//radius -= 2;
Point beginFigure = new Point(finalSize.Width / 2, finalSize.Height / 2);
Point lineToBeforeTransform = new Point(beginFigure.X + radius, beginFigure.Y);
for (int i = 0; i < InternalChildren.Count; i++)
{
ContentControl container = InternalChildren[i] as ContentControl;
double wedgeAngle = (double)(GetValues(this)[i]) * 360 / total;
RotateTransform rt = new RotateTransform(offsetAngle, beginFigure.X, beginFigure.Y);
container.SetValue(PiePanel.BeginFigurePointProperty, beginFigure);
container.SetValue(PiePanel.LineToPointProperty, rt.Transform(lineToBeforeTransform));
container.SetValue(PiePanel.WedgeAngleProperty, wedgeAngle);
offsetAngle += wedgeAngle;
Rect r = new Rect(finalSize);
container.Arrange(r);
}
}
return(finalSize);
}
private void RotateGroup()
{
if (selectedNodes.Count <= 0)
{
return;
}
Point gc = new Point();
foreach (Node n in selectedNodes)
{
gc.X += n.X;
gc.Y += n.Y;
}
gc.X /= selectedNodes.Count;
gc.Y /= selectedNodes.Count;
RotateTransform rt = new RotateTransform(angleDelta, gc.X, gc.Y);
Point p1 = new Point();
foreach (Node n in selectedNodes)
{
p1.X = n.X;
p1.Y = n.Y;
Point p2 = rt.Transform(p1);
n.X = p2.X;
n.Y = p2.Y;
}
Redraw();
}
private void DrawCar(Map map)
{
if (lastCar != null)
{
Canvas_trackPlanner.Children.Remove(lastCar);
}
const double CAR_WIDTH = 55;
const double CAR_HEIGHT = 25;
const double FRONT_SHOWER_LENTH = 10;
System.Windows.Shapes.Polyline car = new Polyline();
car.StrokeThickness = 7;
car.Stroke = new SolidColorBrush(Colors.Red);
car.Points = new PointCollection()
{
new Point(map.car.x + CAR_WIDTH / 2, map.car.y + CAR_HEIGHT / 2),
new Point(map.car.x - CAR_WIDTH / 2, map.car.y + CAR_HEIGHT / 2),
new Point(map.car.x - CAR_WIDTH / 2, map.car.y - CAR_HEIGHT / 2),
new Point(map.car.x + CAR_WIDTH / 2, map.car.y - CAR_HEIGHT / 2),
new Point(map.car.x + CAR_WIDTH / 2, map.car.y),
new Point(map.car.x + CAR_WIDTH + FRONT_SHOWER_LENTH / 2, map.car.y),
new Point(map.car.x + CAR_WIDTH / 2, map.car.y),
new Point(map.car.x + CAR_WIDTH / 2, map.car.y + CAR_HEIGHT / 2)
};
RotateTransform rt = new RotateTransform(map.car.angle, map.car.x, map.car.y);
car.Points = new PointCollection(car.Points.Select(x => rt.Transform(x)));
Canvas_trackPlanner.Children.Add(car);
lastCar = car;
}
public override void Move()
{
if (!IsDestroyed)
{
RotateTransform rotated = new RotateTransform(Rotation, Center.X, Center.Y);
PointCollection p = new PointCollection();
foreach (Point vert in Geometry.Points)
{
p.Add(rotated.Transform(vert));
}
Geometry.Points = p;
TranslateTransform translated = new TranslateTransform(OffsetX, OffsetY);
p = new PointCollection();
foreach (Point vert in Geometry.Points)
{
p.Add(translated.Transform(vert));
}
Geometry.Points = p;
Center = translated.Transform(Center);
}
Effects.RemoveAll(effect => { return(!effect.Display() ? RemoveFromDisplay(effect) : false); });
DestroyedTimeoutCooldown();
}
public static Point[] Sample(IList <Point> points, EllipseParams ellipse, int count = 20)
{
Contract.Requires(points != null);
Contract.Requires(points.Count > 6);
Contract.Requires(count > 0);
Contract.Ensures(Contract.Result <Point[]>() != null);
Contract.Ensures(Contract.Result <Point[]>().Length == count);
/*using (StreamWriter writer = File.CreateText("Points.txt"))
* {
* foreach (Point pnt in points)
* {
* writer.Write(pnt.X + " " + pnt.Y);
* writer.Write(writer.NewLine);
* }
* }
* MessageBox.Show("Done Writing Points");*/
/*EllipseParams ellipse = new EllipseParams
* {
* Center = new Point(0.9566, 0.8023),
* XRadius = 0.1149,
* YRadius = 0.0894,
* Degrees = -1.2418 * 180 / Math.PI
* };*/
var result = new Point[count];
var rotMatrix = new RotateTransform(ellipse.Degrees).Value;
for (int i = 0; i < count; ++i)
{
var t = 2 * Math.PI * i / (double)(count - 1);
var vec = new Vector(ellipse.XRadius * Math.Cos(t), ellipse.YRadius * Math.Sin(t));
result[i] = ellipse.Center + rotMatrix.Transform(vec);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="finalSize"></param>
/// <returns></returns>
protected override Size ArrangeOverride(Size finalSize)
{
if (GetValues(this) != null)
{
double total = 0.0;
int leftCount = 0; //饼的左侧拥有的扇形数
int rightCount = 0; //饼的右侧拥有的扇形数
for (int i = 0; i < InternalChildren.Count; i++)
{
total += GetValues(this)[i];
}
double offsetAngle = 0.0;
double radius = finalSize.Width < finalSize.Height ? finalSize.Width / 2 : finalSize.Height / 2;
radius -= 2;
Point beginFigure = new Point(finalSize.Width / 2, finalSize.Height / 2);
Point lineToBeforeTransform = new Point(beginFigure.X + radius, beginFigure.Y);
Point centerBeforeTransform = new Point(beginFigure.X + radius / 2, beginFigure.Y);
for (int i = 0; i < InternalChildren.Count; i++)
{
ContentControl container = InternalChildren[i] as ContentControl;
if (container == null)
{
throw new NoNullAllowedException(string.Format("Child control is null."));
}
double proportion = GetValues(this)[i] / total * 1.0;
double wedgeAngle = proportion * 360;
RotateTransform rt = new RotateTransform(offsetAngle, beginFigure.X, beginFigure.Y);
container.SetValue(BeginFigurePointProperty, beginFigure);
container.SetValue(LineToPointProperty, rt.Transform(lineToBeforeTransform));
container.SetValue(WedgeAngleProperty, wedgeAngle);
container.SetValue(ProportionProperty, proportion);
double wedgeAngle2 = wedgeAngle / 2 + offsetAngle;
RotateTransform rt2 = new RotateTransform(wedgeAngle2, beginFigure.X, beginFigure.Y);
Point centerPoint = rt2.Transform(centerBeforeTransform);
container.SetValue(CenterPointProperty, centerPoint);
container.SetValue(TranslateXProperty, centerPoint.X - beginFigure.X);
container.SetValue(TranslateYProperty, centerPoint.Y - beginFigure.Y);
if (centerPoint.X < 0)
{
leftCount++;
}
if (centerPoint.X >= 0)
{
rightCount++;
}
container.SetValue(LeftCountProperty, leftCount);
container.SetValue(RightCountProperty, rightCount);
offsetAngle += wedgeAngle;
Rect r = new Rect(finalSize);
container.Arrange(r);
}
}
return(finalSize);
}
/// <summary>
/// 旋转操作。
/// Rotation transform operation.
/// </summary>
/// <param name="angle">
/// 旋转角度，单位度。
/// Rotation angle which is in degrees.
/// </param>
/// <param name="center">
/// 旋转中心点。
/// Rotation transform center point.
/// </param>
/// <param name="IsLocalCenter">
/// 旋转中心点位置是否为局部坐标，默认值为 false。
/// Whether the rotation center point is in local coordinate, and default value is false.
/// </param>
public virtual void Rotate(double angle, Point center, bool IsLocalCenter = false)
{
Point cpot = IsLocalCenter ? Transform.Transform(center) : center;
Transform trans = new RotateTransform(angle, cpot.X, cpot.Y);
Origin = trans.Transform(Origin);
Angle += angle;
}
/// <summary>
/// transforming mouse position invers to transformation of image object
/// </summary>
/// <param name="mousePos">initial position to be transformed</param>
/// <returns>transformed position</returns>
private Point transformMouse(Point mousePos)
{
var rt = new RotateTransform(-90, image.ActualWidth / 2.0, image.ActualHeight / 2.0);
var st = new ScaleTransform(-1, 1, image.ActualWidth / 2.0, image.ActualHeight / 2.0);
mousePos = st.Transform(mousePos);
mousePos = rt.Transform(mousePos);
return(mousePos);
}
void Move(DesignerItem item, double x, double y)
{
RotateTransform rotateTransform = item.RenderTransform as RotateTransform;
if (rotateTransform != null)
{
Point p = rotateTransform.Transform(new Point(x, y));
}
}
public bool RotatedRectContains(Rectangle rect, System.Windows.Point location)
{
var rectCorner = new System.Windows.Point(Canvas.GetLeft(rect), Canvas.GetTop(rect));
var rectRotation = (RotateTransform)rect.RenderTransform;
var transform = new RotateTransform(-rectRotation.Angle, rectCorner.X + rectRotation.CenterX, rectCorner.Y + rectRotation.CenterY);
var rotated = transform.Transform(location);
return(rotated.X > rectCorner.X && rotated.X < rectCorner.X + rect.Width && rotated.Y > rectCorner.Y &&
rotated.Y < rectCorner.Y + rect.Height);
}
public bool RotatedRectContains(Rectangle rect, Point location)
{
var rectCorner = new Point(Canvas.GetLeft(rect), Canvas.GetTop(rect));
var rectRotation = rect.RenderTransform as RotateTransform;
if(rectRotation == null)
return false;
var transform = new RotateTransform(-rectRotation.Angle, rectCorner.X + rectRotation.CenterX, rectCorner.Y + rectRotation.CenterY);
var rotated = transform.Transform(location);
return rotated.X > rectCorner.X && rotated.X < rectCorner.X + rect.Width && rotated.Y > rectCorner.Y
&& rotated.Y < rectCorner.Y + rect.Height;
}
/// <summary>
///
/// </summary>
/// <param name="arrangeBounds"></param>
/// <returns></returns>
public StreamGeometry GetClipGeometry(Size arrangeBounds)
{
StreamGeometry clip = new StreamGeometry();
StreamGeometryContext clipGC = clip.Open();
clipGC.BeginFigure(BeginFigurePoint, true, true);
clipGC.LineTo(LineToPoint, false, true);
Vector v = LineToPoint - BeginFigurePoint;
RotateTransform rt = new RotateTransform(WedgeAngle, BeginFigurePoint.X, BeginFigurePoint.Y);
bool isLargeArc = WedgeAngle > 180.0;
clipGC.ArcTo(rt.Transform(LineToPoint), new Size(v.Length, v.Length), WedgeAngle, isLargeArc, SweepDirection.Clockwise, false, true);
clipGC.Close();
return clip;
}
private Polygon CreateRotatedSquare(double x, double y, RotateTransform rotateTransform, Transform globalRotationTransform)
{
var polygon = new Polygon();
/*
* a------------d
* | |
* | |
* | xy |
* | |
* | |
* b------------c
*
* The X and Y positions are given as if they are in the
* middle of the square that should be created.
* For that reason we always need to edit the X and Y position
* to create a correct square.
*
* The Nanoleaf API returns the SideLength as the full length
* of the sides of the square. Because the x and y are in the middle
* Only half of the side length should be either add or removed
* from the X and Y
*/
// This is the distance from one of the corners to the center.
const int squareSideLength = 100;
var distanceToCenter = squareSideLength / (double)2;
var a = new Point(x - distanceToCenter, y + distanceToCenter);
var b = new Point(x - distanceToCenter, y - distanceToCenter);
var c = new Point(x + distanceToCenter, y - distanceToCenter);
var d = new Point(x + distanceToCenter, y + distanceToCenter);
polygon.Points.Add(globalRotationTransform.Transform(rotateTransform.Transform(a)));
polygon.Points.Add(globalRotationTransform.Transform(rotateTransform.Transform(b)));
polygon.Points.Add(globalRotationTransform.Transform(rotateTransform.Transform(c)));
polygon.Points.Add(globalRotationTransform.Transform(rotateTransform.Transform(d)));
return(polygon);
}
private void MoveThumb_DragDelta1111(object sender, DragDeltaEventArgs e)
{
//Initialize
if (bIsMousePressMove == false)
{
AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(designerCanvas);
if (adornerLayer != null)
{
adorner = new PreveiwMoveAdorner(designerCanvas);
if (adorner != null)
{
adornerLayer.Add(adorner);
}
}
foreach (ContentControl item in this.designerCanvas.SelectedItemandGroups)
{
ContentPresenter wrapper = VisualTreeHelper.GetParent(item) as ContentPresenter;
if (wrapper == null)
{
continue;
}
minLeft = Math.Min(Canvas.GetLeft(wrapper), minLeft);
minTop = Math.Min(Canvas.GetTop(wrapper), minTop);
}
}
bIsMousePressMove = true;
if (this.designerItem == null || this.designerCanvas == null)
{
return;
}
//Get x/y offset
Point dragDelta = new Point(e.HorizontalChange, e.VerticalChange);
RotateTransform rotateTransform = designerItem.RenderTransform as RotateTransform;
if (rotateTransform != null)
{
dragDelta = rotateTransform.Transform(dragDelta);
}
double deltaHorizontal = Math.Max(-minLeft, dragDelta.X);
double deltaVertical = Math.Max(-minTop, dragDelta.Y);
if (adorner != null)
{
adorner.PreviewMove(deltaHorizontal, deltaVertical);
}
e.Handled = true;
}
/// <summary>
/// Gets the rotated rect.
/// </summary>
/// <param name="rect">The rect.</param>
/// <param name="rotate">The rotate.</param>
/// <returns></returns>
public Rect GetRotatedRect(Rect rect, RotateTransform rotate)
{
#if !WINRT
Point leftTop = rotate.Transform(new Point(rect.Left, rect.Top));
Point rightTop = rotate.Transform(new Point(rect.Right, rect.Top));
Point leftBottom = rotate.Transform(new Point(rect.Left, rect.Bottom));
Point rightBottom = rotate.Transform(new Point(rect.Right, rect.Bottom));
double left = Math.Min(Math.Min(leftTop.X, rightTop.X), Math.Min(leftBottom.X, rightBottom.X));
double top = Math.Min(Math.Min(leftTop.Y, rightTop.Y), Math.Min(leftBottom.Y, rightBottom.Y));
double right = Math.Max(Math.Max(leftTop.X, rightTop.X), Math.Max(leftBottom.X, rightBottom.X));
double bottom = Math.Max(Math.Max(leftTop.Y, rightTop.Y), Math.Max(leftBottom.Y, rightBottom.Y));
return new Rect(left, top, right - left, bottom - top);
#else
Point leftTop = rotate.TransformPoint(new Point(rect.Left, rect.Top));
Point rightTop = rotate.TransformPoint(new Point(rect.Right, rect.Top));
Point leftBottom = rotate.TransformPoint(new Point(rect.Left, rect.Bottom));
Point rightBottom = rotate.TransformPoint(new Point(rect.Right, rect.Bottom));
double left = Math.Min(Math.Min(leftTop.X, rightTop.X), Math.Min(leftBottom.X, rightBottom.X));
double top = Math.Min(Math.Min(leftTop.Y, rightTop.Y), Math.Min(leftBottom.Y, rightBottom.Y));
double right = Math.Max(Math.Max(leftTop.X, rightTop.X), Math.Max(leftBottom.X, rightBottom.X));
double bottom = Math.Max(Math.Max(leftTop.Y, rightTop.Y), Math.Max(leftBottom.Y, rightBottom.Y));
return new Rect(left, top, right - left, bottom - top);
#endif
}