static public void TransformPoints(PointF[] points, PointF origin, bool diagonal, bool horizontal, bool vertical)
{
Matrix translate = new Matrix();
Matrix rotate = new Matrix();
// Put the points into origin/local space
translate.Translate(-origin.X, -origin.Y);
translate.TransformPoints(points);
// Apply the flips/rotations (order matters)
if (horizontal)
{
Matrix h = new Matrix(-1, 0, 0, 1, 0, 0);
rotate.Multiply(h);
}
if (vertical)
{
Matrix v = new Matrix(1, 0, 0, -1, 0, 0);
rotate.Multiply(v);
}
if (diagonal)
{
Matrix d = new Matrix(0, 1, 1, 0, 0, 0);
rotate.Multiply(d);
}
// Apply the combined flip/rotate transformation
rotate.TransformPoints(points);
// Put points back into world space
translate.Invert();
translate.TransformPoints(points);
}
//-----------------------------------------------------------------------------------------------
public void DisplayGrids(Graphics g, Matrix2D trans_D2C, float zoom) //g: Client窗口设备坐标系
{
g.Transform = trans_D2C;
using (Pen pen = new Pen(Color.FromArgb(80, 180, 180, 180)))
{
for (int y = 0; y < num_Y_grids + 1; y++)
{
g.DrawLine(pen, 0, y << 6, num_X_grids << 6, y << 6);
}
for (int x = 0; x < num_X_grids + 1; x++)
{
g.DrawLine(pen, x << 6, 0, x << 6, num_Y_grids << 6);
}
}
g.ResetTransform();
using (Font font = new Font("Tahoma", 24 * zoom))
using (Brush brush = new SolidBrush(Color.GreenYellow))
{
PointF[] pos = { new PointF() };
for (int x = 0; x < num_X_grids; x++)
{
//坐标系级调整
pos[0].X = (x << 6) + 32;
pos[0].Y = 0;
trans_D2C.TransformPoints(pos);
//像素级调整
SizeF size = g.MeasureString(x.ToString(), font);
pos[0].X -= size.Width / 2;
g.DrawString(x.ToString(), font, brush, pos[0]);
}
for (int y = 0; y < num_Y_grids; y++)
{
//坐标系级调整
pos[0].X = 0;
pos[0].Y = (y << 6) + 32;
trans_D2C.TransformPoints(pos);
//像素级调整
SizeF size = g.MeasureString(y.ToString(), font);
pos[0].X -= size.Width;
pos[0].Y -= size.Height / 2;
g.DrawString(y.ToString(), font, brush, pos[0]);
}
}
}
public static float[] GetGradientLine(GradientFill gf)
{
float[] result = new float[4];
System.Drawing.PointF[] pts = GradientFill.GradientVexRect.SysPointFs();
using (Draw2D.Matrix m = gf.Transform.SysMatrix())
{
m.TransformPoints(pts);
}
if (gf.GradientType == GradientType.Linear)
{
result[0] = pts[0].X;
result[1] = pts[0].Y;
result[2] = pts[1].X;
result[3] = pts[1].Y;
}
else // radial is center to rightCenter edge
{
result[0] = pts[0].X + (pts[1].X - pts[0].X) / 2;
result[1] = pts[0].Y + (pts[2].Y - pts[0].Y) / 2;
result[2] = pts[1].X;
result[3] = pts[1].Y + (pts[2].Y - pts[0].Y) / 2;
}
return(result);
}
partial void TransformPointsImpl(PointF [] pts)
{
var tmp = ToSDDPoints(pts);
t.TransformPoints(tmp);
Copy(tmp, pts);
}
/// <summary>
/// use matrix to transform point
/// </summary>
/// <param name="pts">contain the points to be transform</param>
private void TransFormPoints(Point[] pts)
{
System.Drawing.Drawing2D.Matrix matrix = new System.Drawing.Drawing2D.Matrix(
1, 0, 0, 1, this.openingPictureBox.Width / 2, this.openingPictureBox.Height / 2);
matrix.Invert();
matrix.TransformPoints(pts);
}
/// <summary>
/// Returned points 1-4 are the left track, points 5-8 are the right track, 9-16 are the turret
/// They should be drawn individually
/// </summary>
public static PointF[] TankPolygonPoints(int offsetX, int offsetY, float rotDegrees, float size)
{
var points = new PointF[16] {
// Left track
new PointF(-1, -1),
new PointF(-1, 1),
new PointF(-0.5f, 1),
new PointF(-0.5f, -1),
// Right track
new PointF(0.5f, -1),
new PointF(1, -1),
new PointF(1, 1),
new PointF(0.5f, 1),
// Turret
new PointF(-0.5f, -0.5f),
new PointF(0.5f, -0.5f),
new PointF(-0.5f, 0.5f),
new PointF(-0.25f, 0.5f),
new PointF(-0.25f, 1.75f),
new PointF(0.25f, 1.75f),
new PointF(0.25f, 0.5f),
new PointF(0.5f, 0.5f)
};
var matrix = new Matrix();
matrix.Rotate(rotDegrees, MatrixOrder.Append);
matrix.Translate(offsetX, offsetY, MatrixOrder.Append);
matrix.Scale(size, size);
matrix.TransformPoints(points);
return points;
}
/// <summary>
/// Will convert the given array of Points from points in WorldSpace to points in PixelSpace
/// </summary>
/// <param name="targetPoints">Points to be converted</param>
public void convertToPixelCoordinates(Point[] targetPoints)
{
if (targetPoints != null)
{
updateCameraTransform();
cameraTransform.TransformPoints(targetPoints);
if (drawBuffers != null)
{
for (int loop = 0; loop < targetPoints.Length; loop++)
{
targetPoints[loop].X = (int)((float)targetPoints[loop].X * ((float)base.Width) / (float)drawBuffers[0].Width);
targetPoints[loop].Y = (int)((float)targetPoints[loop].Y * ((float)base.Height) / (float)drawBuffers[0].Height);
}
}
}
}
public override void OnPaint(PaintEventArgs e, ViewPortData viewPortData)
{
Graphics graphics = e.Graphics;
Bitmap memoryBitmap = viewPortData.MemoryBitmap;
Rectangle rect = new Rectangle(Point.Empty, memoryBitmap.Size);
graphics.FillRectangle(AmbientTheme.WorkspaceBackgroundBrush, rect);
if (((base.parentView.RootDesigner != null) && (base.parentView.RootDesigner.Bounds.Width >= 0)) && (base.parentView.RootDesigner.Bounds.Height >= 0))
{
GraphicsContainer container = graphics.BeginContainer();
Matrix matrix = new Matrix();
matrix.Scale(viewPortData.Scaling.Width, viewPortData.Scaling.Height, MatrixOrder.Prepend);
Point[] pts = new Point[] { viewPortData.LogicalViewPort.Location };
matrix.TransformPoints(pts);
matrix.Translate((float) (-pts[0].X + viewPortData.ShadowDepth.Width), (float) (-pts[0].Y + viewPortData.ShadowDepth.Height), MatrixOrder.Append);
graphics.Transform = matrix;
using (Region region = new Region(ActivityDesignerPaint.GetDesignerPath(base.parentView.RootDesigner, false)))
{
Region clip = graphics.Clip;
graphics.Clip = region;
AmbientTheme ambientTheme = WorkflowTheme.CurrentTheme.AmbientTheme;
graphics.FillRectangle(Brushes.White, base.parentView.RootDesigner.Bounds);
if (ambientTheme.WorkflowWatermarkImage != null)
{
ActivityDesignerPaint.DrawImage(graphics, ambientTheme.WorkflowWatermarkImage, base.parentView.RootDesigner.Bounds, new Rectangle(Point.Empty, ambientTheme.WorkflowWatermarkImage.Size), ambientTheme.WatermarkAlignment, 0.25f, false);
}
graphics.Clip = clip;
}
graphics.EndContainer(container);
}
}
/**
For each pixel location in the new buffer P' (NewX, NewY), do:
Find corresponding old location, P = W-1.P'
Validate that this old location lie inside the original image boundary (i.e. 0 ≤ OldX < W, 0 ≤ Old Y < H). Otherwise, set the new empty pixel to 0 and continue to next location.
If Validated, apply Bilinear Interpolation Algorithm to get the new pixel value, as follows:(Refer to above figure)
*/
public BufferedImage apply_transformation_matrix_to_bitmap_or_buffer(Matrix _transformations_matrix, BufferedImage _src_img, int _new_width, int _new_height, TextBox _console)
{
BufferedImage ret = new BufferedImage(_new_width, _new_height);
BilinearInterpolation obj_bi_lin_interpol = new BilinearInterpolation();
for (int i = 0; i < _new_width; i++)
{
for (int j = 0; j < _new_height; j++)
{
PointF[] points = {
new PointF(i, j)
};
_transformations_matrix.TransformPoints(points);
_console.Text += "P = (" + points[0].X + ", " + points[0].Y + ")";
_console.Text += Environment.NewLine;
_console.Text += "P' = (" + i + ", " + j + ")";
_console.Text += Environment.NewLine;
Color _color = Color.FromArgb(0);
if(points[0].X >= 0 && points[0].X < _src_img.width && points[0].Y >= 0 && points[0].Y < _src_img.height)
_color = obj_bi_lin_interpol.calculate(_src_img, points[0].X, points[0].Y);
ret.buffer[i, j] = _color;
}
}
return ret;
}
/// <summary>
/// Transform a single PointF object and return the result.
/// </summary>
/// <param name="mat"></param>
/// <param name="p"></param>
/// <returns></returns>
public static PointF eTransformSinglePointF(this d2d.Matrix mat, PointF p)
{
var tmp = new PointF[] { p };
mat.TransformPoints(tmp);
return(tmp[0]);
}
public int GetSelectedPhrase(Point location, float scale, Point Translate)
{
System.Drawing.Drawing2D.Matrix m = new System.Drawing.Drawing2D.Matrix();
//m.Translate(Translate.X, Translate.Y, MatrixOrder.Append);
m.Scale(scale, scale, System.Drawing.Drawing2D.MatrixOrder.Append);
System.Drawing.Drawing2D.Matrix mt = new System.Drawing.Drawing2D.Matrix();
mt.Translate(Translate.X, Translate.Y, MatrixOrder.Append);
mt.Scale(scale, scale, System.Drawing.Drawing2D.MatrixOrder.Append);
//e.IGraphics.Transform = m;
Point[] scaledps = new Point[] { new Point(28, 28) };
for (int i = phrases.Count - 1; i >= 0; i--)
{
Point[] scaledp = new Point[] { new Point(phrases[i].position.X - 4, phrases[i].position.Y - 4) };
//scaledp
mt.TransformPoints(scaledp);
m.TransformPoints(scaledps);
if (Program.HitTest(location.X, location.Y,
scaledp[0].X, scaledp[0].Y, scaledps[0].X, scaledps[0].Y))
{
return(i);
}
}
return(-1);
}
public override void Transform(Matrix matrix) {
Point[] points = capturePoints.ToArray();
matrix.TransformPoints(points);
capturePoints.Clear();
capturePoints.AddRange(points);
RecalculatePath();
}
public BoundingBox Transform(System.Drawing.Drawing2D.Matrix matrix)
{
System.Drawing.PointF[] points = new System.Drawing.PointF[2];
points[0] = new System.Drawing.PointF((float)XMin, (float)YMin);
points[1] = new System.Drawing.PointF((float)XMax, (float)YMax);
matrix.TransformPoints(points);
return(new BoundingBox(points[0].X, points[1].X, points[0].Y, points[1].Y));
}
/// <summary>Expands the triangle by the specified length and width, keepings its center position constant.</summary>
/// <param name="width">The number of units to add to the width.</param>
/// <param name="height">The number of units to add to the height.</param>
public void Scale(float width, float height)
{
using (System.Drawing.Drawing2D.Matrix trans = new System.Drawing.Drawing2D.Matrix())
{
trans.Scale(width, height);
trans.TransformPoints(new PointF[] { this.PointA, this.PointB, this.PointC });
}
}
private void drawGraphLine(Graphics graphics, PointF[] points, Pen pen, float yScale, float xScale)
{
var matrix = new Matrix();
matrix.Scale(xScale, yScale);
matrix.Translate(5, 5, MatrixOrder.Append);
matrix.TransformPoints(points);
graphics.DrawLines(pen, points);
}
//***************************************************************************
// Static Methods
//
public static TriangleF Rotate(TriangleF tri, float degrees, PointF center)
{
PointF[] p = new PointF[] { new PointF(tri.PointA.X, tri.PointA.Y), new PointF(tri.PointB.X, tri.PointB.Y), new PointF(tri.PointC.X, tri.PointC.Y) };
using (System.Drawing.Drawing2D.Matrix mat = new System.Drawing.Drawing2D.Matrix())
{
mat.RotateAt(degrees, center);
mat.TransformPoints(p);
}
return(new TriangleF(p[0], p[1], p[2]));
}
public void EraseHighlight(Graphics g, Matrix xformWorldToPixel, Brush eraseBrush)
{
PointF[] pts = { new PointF(rect.Left, rect.Bottom), new PointF(rect.Right, rect.Top) };
xformWorldToPixel.TransformPoints(pts);
RectangleF rectPixel = RectangleF.FromLTRB(pts[0].X, pts[0].Y, pts[1].X, pts[1].Y);
rectPixel.Inflate(penWidth / 2F, penWidth / 2F);
Rectangle r = Util.Round(rectPixel);
g.FillRectangle(eraseBrush, r);
}
public void DrawHighlight(Graphics g, Matrix xformWorldToPixel)
{
using (Pen redPen = new Pen(Color.Red, penWidth))
using (Brush blueBrush = new HatchBrush(HatchStyle.Percent25, Color.DarkBlue, Color.Transparent)) {
PointF[] pts = { new PointF(rect.Left, rect.Bottom), new PointF(rect.Right, rect.Top) };
xformWorldToPixel.TransformPoints(pts);
RectangleF rectPixel = RectangleF.FromLTRB(pts[0].X, pts[0].Y, pts[1].X, pts[1].Y);
g.FillRectangle(blueBrush, rectPixel.X, rectPixel.Y, rectPixel.Width, rectPixel.Height);
g.DrawRectangle(redPen, rectPixel.X, rectPixel.Y, rectPixel.Width, rectPixel.Height);
}
}
public void Paint(Matrix2D T, double x0, double x1, Graphics G)
{
Pen pen = Pen;
List <PointF[]> points = Evaluate(x0, x1);
foreach (PointF[] i in points)
{
T.TransformPoints(i);
G.DrawLines(pen, i);
}
}
protected void Transform(Matrix matrixValueToScreen, bool isLog, PointF[] points)
{
if (isLog)
{
for (int i = 0; i < points.Length; i++)
{
points[i] = new PointF(points[i].X, points[i].Y < 0 ? (float)-Math.Log10(-points[i].Y + 1) : (float)Math.Log10(points[i].Y + 1));
}
}
matrixValueToScreen.TransformPoints(points);
}
public Bitmap RotateBitmap(Bitmap bm, float angle)
{
// Make a Matrix to represent rotation
// by this angle.
Matrix rotate_at_origin = new Matrix();
rotate_at_origin.Rotate(angle);
// Rotate the image's corners to see how big
// it will be after rotation.
PointF[] points =
{
new PointF(0, 0),
new PointF(bm.Width, 0),
new PointF(bm.Width, bm.Height),
new PointF(0, bm.Height),
};
rotate_at_origin.TransformPoints(points);
float xmin, xmax, ymin, ymax;
GetPointBounds(points, out xmin, out xmax,
out ymin, out ymax);
// Make a bitmap to hold the rotated result.
int wid = (int)Math.Round(xmax - xmin);
int hgt = (int)Math.Round(ymax - ymin);
Bitmap result = new Bitmap(wid, hgt);
// Create the real rotation transformation.
Matrix rotate_at_center = new Matrix();
rotate_at_center.RotateAt(angle,
new PointF(0, 0));
// Draw the image onto the new bitmap rotated.
using (Graphics gr = Graphics.FromImage(result))
{
// Use smooth image interpolation.
gr.InterpolationMode = InterpolationMode.HighQualityBilinear;
// Clear with the color in the image's upper left corner.
gr.Clear(bm.GetPixel(0, 0));
gr.Clear(Color.White);
// Set up the transformation to rotate.
gr.Transform = rotate_at_center;
// Draw the image centered on the bitmap.
int x = 0;
int y = 0;
gr.DrawImage(bm, x, y);
}
// Return the result bitmap.
return result;
}
public PointF PointToScreenSpace(PointF pntIn)
{
System.Drawing.Drawing2D.Matrix mat = new System.Drawing.Drawing2D.Matrix();
PointF[] tempPoints = new PointF[1];
tempPoints[0] = new PointF(pntIn.X, pntIn.Y);
mat.RotateAt(selectionSet[0].RotationAngle, new PointF((float)(selectionSet[0].X), (float)(selectionSet[0].Y)));
mat.TransformPoints(tempPoints);
return(tempPoints[0]);
}
/// <summary>
/// Applies the geometric transform represented by this System.Drawing.Drawing2D.Matrix
/// to a specified array of Opentk.Vector2
/// </summary>
/// <param name="mat"></param>
/// <param name="vecs"></param>
public static void eTransformVector2(this d2d.Matrix mat, tk.Vector2[] vecs)
{
PointF[] tmp = vecs.Select(vec => new PointF(vec.X, vec.Y)).ToArray();
mat.TransformPoints(tmp);
// set them equal this way we dont mess up if other
// objects kept pointers to some vector and we just override it
for (int i = 0; i < vecs.Length; i++)
{
vecs[i].X = tmp[i].X;
vecs[i].Y = tmp[i].Y;
}
}
public void ChangeDirection(Point pt, Size sz)
{
float angle = 90;
Matrix matrix = new Matrix();
matrix.RotateAt(angle, pt);
int n = pointList.Count;
Point[] points = new Point[n];
pointList.CopyTo(points);
matrix.TransformPoints(points);
for (int i = 0; i < n; i++)
{
Rectangle rc = new Rectangle(0, 0, sz.Width, sz.Height);
if (!rc.Contains(points[i]))
{
if (points[n - 2].X == points[n - 1].X)
{
int height = Math.Abs(points[1].Y - points[0].Y);
if (points[i].Y < 0)
{
points[0].Y = 1;
points[1].Y = points[0].Y + height;
}
else if (points[i].Y > sz.Height)
{
points[0].Y = sz.Height - 2;
points[1].Y = points[0].Y - height;
}
}
else if (points[n - 2].Y == points[n - 1].Y)
{
int width = Math.Abs(points[1].X - points[0].X);
if (points[i].X < 0)
{
points[0].X = 1;
points[1].X = points[0].X + width;
}
else if (points[i].X > sz.Width)
{
points[0].X = sz.Width - 2;
points[1].X = points[0].X - width;
}
}
pointList.Clear();
pointList.AddRange(points);
return;
}
}
pointList.Clear();
pointList.AddRange(points);
}
/// <summary>
/// фун для матричного преобразования в даном случае увеличения
/// </summary>
/// <param name="temp"></param>
public void myMatrixTransformScale(ref LittleShape2 temp)
{
System.Drawing.Drawing2D.Matrix matrix = new System.Drawing.Drawing2D.Matrix();
System.Drawing.Drawing2D.Matrix test = new System.Drawing.Drawing2D.Matrix(1, 0, 0, 1, 0, 0);
// трансформация из double[,] в pointF[]
PointF[] arr = temp.getPointF(rank);
// увеличение
matrix.Scale(50, 50);
// применение увеличения
matrix.TransformPoints(arr);
// уже увеличеная фигура (точки)
temp.setPointF(arr);
}
public static PointF[] RectToPolygon(RectangleF r, double orientation)
{
PointF center = new PointF(r.X + r.Width / 2.0F, r.Y + r.Height / 2.0F);
PointF TL = new PointF(r.Left, r.Top);
PointF TR = new PointF(r.Right, r.Top);
PointF BL = new PointF(r.Left, r.Bottom);
PointF BR = new PointF(r.Right, r.Bottom);
PointF[] points = new PointF[] { BL, TL, TR, BR, BL };
System.Drawing.Drawing2D.Matrix m = new System.Drawing.Drawing2D.Matrix();
m.RotateAt((float)orientation, center);
m.TransformPoints(points);
return(points);
}
private static void DrawPointMass(IPointMass pointMass, Pen pen, Brush brush, Graphics g)
{
var triangle = new[] { new PointF(1, 0), new PointF(-0.7f, 0.7f), new PointF(-0.7f, -0.7f) };
using (var m = new Matrix())
{
m.Translate(pointMass.Position.X, pointMass.Position.Y);
m.Rotate((float)(Math.Atan2(pointMass.Velocity.Y, pointMass.Velocity.X) * 180 / Math.PI));
m.Scale(pointMass.Radius*0.9f, pointMass.Radius*0.9f);
m.TransformPoints(triangle);
}
g.FillPolygon(brush, triangle);
g.DrawCircle(pen, pointMass.Position, pointMass.Radius);
}
// Transform a rectangle with a transform, and return the new rectangle that bounds the corners of the transformed one.
public static RectangleF BoundsOfTransformedRectangle(RectangleF rect, Matrix transform)
{
PointF[] corners = { new PointF(rect.Left, rect.Top), new PointF(rect.Right, rect.Top),
new PointF(rect.Left, rect.Bottom), new PointF(rect.Right, rect.Bottom) };
transform.TransformPoints(corners);
float minX = float.MaxValue, maxX = float.MinValue, minY = float.MaxValue, maxY = float.MinValue;
for (int i = 0; i < corners.Length; ++i) {
if (corners[i].X < minX) minX = corners[i].X;
if (corners[i].X > maxX) maxX = corners[i].X;
if (corners[i].Y < minY) minY = corners[i].Y;
if (corners[i].Y > maxY) maxY = corners[i].Y;
}
return new RectangleF(minX, minY, maxX - minX, maxY - minY);
}
public static Point[] MinePolygonPoints(int offsetX, int offsetY, float size)
{
var points = new Point[4] {
new Point(-1, -1),
new Point(-1, 1),
new Point(1, 1),
new Point(1, -1)
};
var matrix = new Matrix();
matrix.Translate(offsetX, offsetY);
matrix.Scale(size, size);
matrix.TransformPoints(points);
return points;
}
private SizeF ConvertSize(SizeF size, float angle)
{
System.Drawing.Drawing2D.Matrix matrix = new System.Drawing.Drawing2D.Matrix();
matrix.Rotate(angle);
// 旋转矩形四个顶点
PointF[] pts = new PointF[4];
pts[0].X = -size.Width / 2f;
pts[0].Y = -size.Height / 2f;
pts[1].X = -size.Width / 2f;
pts[1].Y = size.Height / 2f;
pts[2].X = size.Width / 2f;
pts[2].Y = size.Height / 2f;
pts[3].X = size.Width / 2f;
pts[3].Y = -size.Height / 2f;
matrix.TransformPoints(pts);
// 求取四个顶点的包围盒
float left = float.MaxValue;
float right = float.MinValue;
float top = float.MaxValue;
float bottom = float.MinValue;
foreach (PointF pt in pts)
{
// 求取并集
if (pt.X < left)
{
left = pt.X;
}
if (pt.X > right)
{
right = pt.X;
}
if (pt.Y < top)
{
top = pt.Y;
}
if (pt.Y > bottom)
{
bottom = pt.Y;
}
}
SizeF result = new SizeF(right - left, bottom - top);
return(result);
}
//-----------------------------------------------------------------------------------------------
public void DisplayWaypoints(Graphics g, Matrix2D trans_D2C, Waypoint w) //g: Client窗口设备坐标系
{
if (w != null)
{
g.SmoothingMode = SmoothingMode.HighQuality;
using (Pen pen = new Pen(Color.Yellow, 3f))
using (Brush brush = new SolidBrush(Color.Yellow))
{
pen.EndCap = LineCap.ArrowAnchor; //很酷...
Waypoint c = w;
Waypoint p = w.parent;
//绘制路径
while (p != null)
{
PointF[] pos = { new PointF(p.fp.x, p.fp.y), new PointF(c.fp.x, c.fp.y) };
trans_D2C.TransformPoints(pos);
//路径起点为一个圆点
if (p.parent == null)
{
pen.StartCap = LineCap.RoundAnchor;
}
g.DrawLine(pen, pos[0], pos[1]);
c = p;
p = c.parent;
}
//绘制位点
//g.Transform = trans_D2C;
//c = w;
//do
//{
// g.FillRectangle(brush, c.fp.x - 5, c.fp.y - 5, 10, 10);
// c = c.parent;
//} while (c != null);
//g.ResetTransform();
}
g.SmoothingMode = SmoothingMode.Default;
}
}
/// <summary>
/// Draw loops on graphics with the specified
/// transform and graphics attributes.
/// </summary>
static void DrawLoopsOnGraphics(
Graphics graphics,
List<Point[]> loops,
Matrix transform )
{
foreach( Point[] loop in loops )
{
GraphicsPath path = new GraphicsPath();
transform.TransformPoints( loop );
path.AddLines( loop );
graphics.DrawPath( Pen, path );
}
}
internal PointF [] GetMedianeEnclosingRect(float x1, float y1, float x2, float y2, float rotateAngle)
{
float width = x2 - x1;
float height = y2 - y1;
PointF rectCenter = new PointF(x1 + width / 2, y1 + height / 2);
float gradLen = width * Math.Abs((float)Math.Cos(rotateAngle * Math.PI / 180)) +
height * Math.Abs((float)Math.Sin(rotateAngle * Math.PI / 180));
PointF [] points = new PointF [] { new PointF(rectCenter.X - gradLen / 2, rectCenter.Y),
new PointF(rectCenter.X + gradLen / 2, rectCenter.Y) };
Matrix mx = new Matrix();
mx.RotateAt((float)rotateAngle, rectCenter);
mx.TransformPoints(points);
return(points);
}
// http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/drawingwithquartz2d/dq_shadings/dq_shadings.html#//apple_ref/doc/uid/TP30001066-CH207-BBCECJBF
internal override void Setup(Graphics graphics, bool fill)
{
CGContext context = graphics.context;
// if fill is false then we are being called from a Pen stroke so
// we need to setup a transparency layer
// http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/drawingwithquartz2d/dq_shadings/dq_shadings.html#//apple_ref/doc/uid/TP30001066-CH207-BBCECJBF
if (!fill)
{
context.BeginTransparencyLayer();
hasTransparencyLayer = true;
// Make sure we set a color here so that the gradient shows up
graphics.lastBrushColor = Color.Black;
return;
}
// if this is the same as the last that was set and no changes have been made
// then return.
if (graphics.LastBrush != this || changed)
{
//setupShadingColors();
}
// Transform the start and end points using the brush's transformation matrix
gradientTransform.TransformPoints(pathPoints);
RasterizePolygon(context, centerPoint, pathPoints, surroundColors, centerColor);
// If we are in a Transparency layer then we need to end the transparency
if (hasTransparencyLayer)
{
context.EndTransparencyLayer();
}
changed = false;
graphics.LastBrush = this;
// We will reset the last pen so that it can be setup again
// so that we do not loose the settings after stroking the gradient
// not sure where the setting are being reset so this may be a hack
// and things are just not being restored correctly.
graphics.LastPen = null;
// I am setting this to be used for Text coloring in DrawString
graphics.lastBrushColor = surroundColors[surroundColors.Length - 1];
}
public static Icon TankIcon()
{
var bitmap = new Bitmap(32, 32);
using (var g = Graphics.FromImage(bitmap))
{
var points = TankPolygonPoints(16, 16, 180, 5);
var matrix = new Matrix();
matrix.Scale(1.5f, 1.5f);
matrix.Translate(-5, -5);
matrix.TransformPoints(points);
var pen = new Pen(Color.Black);
g.DrawPolygon(pen, points);
g.FillPolygon(pen.Brush, points);
pen.Dispose();
}
return Icon.FromHandle(bitmap.GetHicon());
}
//http://www.tinaja.com/glib/bezcirc2.pdf
private CircularBezier(PointD start, PointD center, PointD end)
{
double Θ = new VectorD(center, start).GetAngleWith(new VectorD(center, end));
double φ = Θ/2;
double x0 = Math.Cos(φ);
double y0 = Math.Sin(φ);
double x3 = x0;
double y3 = -y0;
double x1 = (4 - x0)/3;
double y1 = ((1 - x0)*(3 - x0))/(3*y0);
double x2 = x1;
double y2 = -y1;
var points = new PointF[] {new PointD(x0, y3), new PointD(x1, y2), new PointD(x2, y1), new PointD(x3, y0)};
var matrix = new Matrix();
matrix.Rotate(
Convert.ToSingle(Geometrics.RadianToDegree(Math.Atan2(start.Y - center.Y, start.X - center.X) + φ)) +
360);
matrix.Scale(Convert.ToSingle(new LineD(start, center).Length),
Convert.ToSingle(new LineD(start, center).Length));
matrix.TransformPoints(points);
matrix = new Matrix();
matrix.Translate(Convert.ToSingle(center.X), Convert.ToSingle(center.Y));
matrix.TransformPoints(points);
p0 = points[0];
p1 = points[1];
p2 = points[2];
p3 = points[3];
p0f = points[0];
p1f = points[1];
p2f = points[2];
p3f = points[3];
this.center = center;
Length = getlength();
}
/// <summary>
/// Gets a rectangular bounding box that encompasses the specified rectangle after the specified transformation has
/// been applied.
/// </summary>
/// <param name="rect">The rectangle whose transformation is considered</param>
/// <param name="transform">The transformation considered</param>
/// <returns>A bounding box that encompasses the specified the specified rectangle after the specified transformation
/// has been applied</returns>
public static Rectangle Transform(this Rectangle rect, Matrix transform)
{
//Transform each corner of the rectangle
Point[] corners = {
new Point(rect.Left, rect.Top),
new Point(rect.Right, rect.Top),
new Point(rect.Left, rect.Bottom),
new Point(rect.Right, rect.Bottom) };
transform.TransformPoints(corners);
// Fit a bounding box on the transformed rectangle
int x1 = (from c in corners select c.X).Min();
int x2 = (from c in corners select c.X).Max();
int y1 = (from c in corners select c.Y).Min();
int y2 = (from c in corners select c.Y).Max();
return new Rectangle(x1, y1, x2 - x1, y2 - y1);
}
/// <summary>
/// Converts the size.
/// </summary>
/// <param name="size">The size.</param>
/// <param name="angle">The angle.</param>
/// <returns>SizeF.</returns>
public static SizeF ConvertSize(SizeF size, float angle)
{
System.Drawing.Drawing2D.Matrix matrix = new System.Drawing.Drawing2D.Matrix();
matrix.Rotate(angle);
PointF[] array = new PointF[4];
array[0].X = (0f - size.Width) / 2f;
array[0].Y = (0f - size.Height) / 2f;
array[1].X = (0f - size.Width) / 2f;
array[1].Y = size.Height / 2f;
array[2].X = size.Width / 2f;
array[2].Y = size.Height / 2f;
array[3].X = size.Width / 2f;
array[3].Y = (0f - size.Height) / 2f;
matrix.TransformPoints(array);
float num = float.MaxValue;
float num2 = float.MinValue;
float num3 = float.MaxValue;
float num4 = float.MinValue;
PointF[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
PointF pointF = array2[i];
if (pointF.X < num)
{
num = pointF.X;
}
if (pointF.X > num2)
{
num2 = pointF.X;
}
if (pointF.Y < num3)
{
num3 = pointF.Y;
}
if (pointF.Y > num4)
{
num4 = pointF.Y;
}
}
return(new SizeF(num2 - num, num4 - num3));
}
public void DisplayLOS(Graphics g, Matrix2D trans_D2C, List <FPoint> losw) //g: Client窗口设备坐标系
{
g.ResetTransform();
g.SmoothingMode = SmoothingMode.HighQuality;
if (losw == null)
{
return;
}
if (losw.Count == 0)
{
return;
}
PointF[] pos = new PointF[losw.Count];
for (int i = 0; i < losw.Count; i++)
{
pos[i] = new PointF();
pos[i].X = losw[i].x;
pos[i].Y = losw[i].y;
}
trans_D2C.TransformPoints(pos);
using (Pen line_pen = new Pen(Color.DeepPink, 3F))
using (Pen dot_pen = new Pen(Color.Yellow, 2f))
{
line_pen.EndCap = LineCap.ArrowAnchor;
for (int i = 1; i < losw.Count; i++)
{
g.DrawLine(line_pen, pos[i - 1], pos[i]);
}
for (int i = 0; i < losw.Count; i++)
{
g.DrawLine(dot_pen, pos[i].X - 3, pos[i].Y - 3, pos[i].X + 3, pos[i].Y + 3);
g.DrawLine(dot_pen, pos[i].X - 3, pos[i].Y + 3, pos[i].X + 3, pos[i].Y - 3);
}
}
}
public void TransformPoints(Point[] pts)
{
Drawing2D.Matrix m = new Drawing2D.Matrix
(
this.ScaleX,
this.Rotate0,
this.Rotate1,
this.ScaleY,
this.TranslateX,
this.TranslateY
);
System.Drawing.PointF[] dpts = new System.Drawing.PointF[pts.Length];
for (int i = 0; i < pts.Length; i++)
{
dpts[i] = new System.Drawing.PointF(pts[i].X, pts[i].Y);
}
m.TransformPoints(dpts);
for (int i = 0; i < pts.Length; i++)
{
pts[i] = new Point(dpts[i].X, dpts[i].Y);
}
}
internal PointF [] GetMedianeEnclosingRect(float x1, float y1, float x2, float y2, bool forwardDiagonal)
{
float width = x2 - x1;
float height = y2 - y1;
PointF rectCenter = new PointF(x1 + width / 2, y1 + height / 2);
float rotateAngle = (float)Math.Atan2(width, height);
float gradLen = width * (float)Math.Cos(rotateAngle);
if (!forwardDiagonal)
{
rotateAngle = -rotateAngle;
}
PointF [] points = new PointF [] { new PointF(rectCenter.X - gradLen, rectCenter.Y),
new PointF(rectCenter.X + gradLen, rectCenter.Y) };
Matrix mx = new Matrix();
mx.RotateAt((float)rotateAngle * (float)(180 / Math.PI), rectCenter);
mx.TransformPoints(points);
return(points);
}
public override void OnPaint(PaintEventArgs e, ViewPortData viewPortData)
{
base.OnPaint(e, viewPortData);
Graphics graphics = e.Graphics;
if (((base.parentView.RootDesigner != null) && (base.parentView.RootDesigner.Bounds.Width >= 0)) && (base.parentView.RootDesigner.Bounds.Height >= 0))
{
GraphicsContainer container = graphics.BeginContainer();
Matrix matrix = new Matrix();
matrix.Scale(viewPortData.Scaling.Width, viewPortData.Scaling.Height, MatrixOrder.Prepend);
Point[] pts = new Point[] { viewPortData.LogicalViewPort.Location };
matrix.TransformPoints(pts);
matrix.Translate((float) (-pts[0].X + viewPortData.ShadowDepth.Width), (float) (-pts[0].Y + viewPortData.ShadowDepth.Height), MatrixOrder.Append);
graphics.Transform = matrix;
Rectangle bounds = base.parentView.RootDesigner.Bounds;
graphics.ExcludeClip(bounds);
bounds.Inflate(DefaultWorkflowLayout.Separator.Width / 2, DefaultWorkflowLayout.Separator.Height / 2);
ActivityDesignerPaint.DrawDropShadow(graphics, bounds, AmbientTheme.WorkflowBorderPen.Color, 4, LightSourcePosition.Top | LightSourcePosition.Left, 0.2f, false);
graphics.FillRectangle(WorkflowTheme.CurrentTheme.AmbientTheme.BackgroundBrush, bounds);
graphics.DrawRectangle(AmbientTheme.WorkflowBorderPen, bounds);
graphics.EndContainer(container);
}
}
// Function to Fire the Arrow
private void FireArrow()
{
// If the Player is currently Aiming
if (meTargetPracticeState == ETargetPracticeGameStates.Aiming)
{
// Switch to Shooting the Arrow
meTargetPracticeState = ETargetPracticeGameStates.FiredArrow;
// Set the Arrows Velocity based on the current Pitch and Amplitude of the Players voice
// Find the Middle Point of the Bow And Arrow to Rotate around
PointF sMiddlePoint = new Point();
sMiddlePoint.X = mrBOW_AND_ARROW_POSITION.X + (mrBOW_AND_ARROW_POSITION.Width / 2.0f);
sMiddlePoint.Y = mrBOW_AND_ARROW_POSITION.Y + (mrBOW_AND_ARROW_POSITION.Height / 2.0f);
// Rotate the Bow And Arrow by the specified Bow And Arrow Rotation Amount
System.Drawing.Drawing2D.Matrix sRotationMatrix = new System.Drawing.Drawing2D.Matrix(1, 0, 0, 1, 0, 0);
sRotationMatrix.RotateAt(miBowAndArrowRotation, sMiddlePoint);
PointF[] sPoint = new PointF[1];
sPoint[0].X = sMiddlePoint.X + 1;
sPoint[0].Y = sMiddlePoint.Y;
sRotationMatrix.TransformPoints(sPoint);
// Set the Arrows initial Direction to travel
mcArrowVelocity.X = sPoint[0].X - sMiddlePoint.X;
mcArrowVelocity.Y = sPoint[0].Y - sMiddlePoint.Y;
mcArrowVelocity.Normalize();
// Set the Arrows initial speed
mcArrowVelocity *= (mfUnitBowAndArrowPower * 300.0f);
mcArrowVelocity.X += 100.0f;
// Set the Arrows Rotation to be the same as the Bow And Arrow initially
miArrowRotation = miBowAndArrowRotation;
// Play the Fire Arrow sound
CFMOD.PlaySound(msSoundFire, false);
}
}
public int GetSelectedTimeLine(Point location, float scale, Point Translate)
{
System.Drawing.Drawing2D.Matrix m = new System.Drawing.Drawing2D.Matrix();
m.Scale(scale, scale, System.Drawing.Drawing2D.MatrixOrder.Append);
//e.IGraphics.Transform = m;
System.Drawing.Drawing2D.Matrix mt = new System.Drawing.Drawing2D.Matrix();
mt.Translate(Translate.X, Translate.Y, MatrixOrder.Append);
mt.Scale(scale, scale, System.Drawing.Drawing2D.MatrixOrder.Append);
for (int i = 0; i < timelines.Count; i++)
{
Point[] scaledp = new Point[] { new Point(timelines[i]._dragtag.X - 4, timelines[i]._dragtag.Y - 4) };
Point[] scaledps = new Point[] { new Point(19, 19) };
//scaledp
mt.TransformPoints(scaledp);
m.TransformPoints(scaledps);
if (Program.HitTest(location.X, location.Y,
scaledp[0].X, scaledp[0].Y, scaledps[0].X, scaledps[0].Y))
{
return(i);
}
}
return(-1);
}
/**
For each pixel location in the new buffer P' (NewX, NewY), do:
Find corresponding old location, P = W-1.P'
Validate that this old location lie inside the original image boundary (i.e. 0 ≤ OldX < W, 0 ≤ Old Y < H). Otherwise, set the new empty pixel to 0 and continue to next location.
If Validated, apply Bilinear Interpolation Algorithm to get the new pixel value, as follows:(Refer to above figure)
*/
public bufferedLockBitmap apply_transformation_matrix_to_bitmap_or_buffer(Matrix _transformations_matrix, bufferedLockBitmap _src_img, int _new_width, int _new_height)
{
Bitmap temp = new Bitmap(_new_width, _new_height);
bufferedLockBitmap ret = new bufferedLockBitmap(temp);
ret.LockBits();
BilinearInterpolation obj_bi_lin_interpol = new BilinearInterpolation();
for (int i = 0; i < _new_width; i++)
{
for (int j = 0; j < _new_height; j++)
{
PointF[] points = {
new PointF(i, j)
};
_transformations_matrix.TransformPoints(points);
Color _color = Color.FromArgb(0);
if (points[0].X >= 0 && points[0].X < _src_img.source.Width && points[0].Y >= 0 && points[0].Y < _src_img.source.Height)
_color = obj_bi_lin_interpol.calculate(_src_img, points[0].X, points[0].Y, _new_width, _new_height);
ret.SetPixel(i, j, _color);
}
}
ret.UnlockBits();
return ret;
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="line"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, XLine line, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
Brush fillLine = ToSolidBrush(line.Style.Fill);
Pen strokeLine = ToPen(line.Style, _scaleToPage);
Brush fillStartArrow = ToSolidBrush(line.Style.StartArrowStyle.Fill);
Pen strokeStartArrow = ToPen(line.Style.StartArrowStyle, _scaleToPage);
Brush fillEndArrow = ToSolidBrush(line.Style.EndArrowStyle.Fill);
Pen strokeEndArrow = ToPen(line.Style.EndArrowStyle, _scaleToPage);
double _x1 = line.Start.X + dx;
double _y1 = line.Start.Y + dy;
double _x2 = line.End.X + dx;
double _y2 = line.End.Y + dy;
XLine.SetMaxLength(line, ref _x1, ref _y1, ref _x2, ref _y2);
float x1 = _scaleToPage(_x1);
float y1 = _scaleToPage(_y1);
float x2 = _scaleToPage(_x2);
float y2 = _scaleToPage(_y2);
var sas = line.Style.StartArrowStyle;
var eas = line.Style.EndArrowStyle;
float a1 = (float)(Math.Atan2(y1 - y2, x1 - x2) * 180.0 / Math.PI);
float a2 = (float)(Math.Atan2(y2 - y1, x2 - x1) * 180.0 / Math.PI);
var t1 = new Matrix();
var c1 = new PointF(x1, y1);
t1.RotateAt(a1, c1);
var t2 = new Matrix();
var c2 = new PointF(x2, y2);
t2.RotateAt(a2, c2);
PointF pt1;
PointF pt2;
double radiusX1 = sas.RadiusX;
double radiusY1 = sas.RadiusY;
double sizeX1 = 2.0 * radiusX1;
double sizeY1 = 2.0 * radiusY1;
switch (sas.ArrowType)
{
default:
case ArrowType.None:
{
pt1 = new PointF(x1, y1);
}
break;
case ArrowType.Rectangle:
{
var pts = new PointF[] { new PointF(x1 - (float)sizeX1, y1) };
t1.TransformPoints(pts);
pt1 = pts[0];
var rect = new Rect2(x1 - sizeX1, y1 - radiusY1, sizeX1, sizeY1);
var gs = _gfx.Save();
_gfx.MultiplyTransform(t1);
DrawRectangleInternal(_gfx, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref rect);
_gfx.Restore(gs);
}
break;
case ArrowType.Ellipse:
{
var pts = new PointF[] { new PointF(x1 - (float)sizeX1, y1) };
t1.TransformPoints(pts);
pt1 = pts[0];
var gs = _gfx.Save();
_gfx.MultiplyTransform(t1);
var rect = new Rect2(x1 - sizeX1, y1 - radiusY1, sizeX1, sizeY1);
DrawEllipseInternal(_gfx, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref rect);
_gfx.Restore(gs);
}
break;
case ArrowType.Arrow:
{
var pts = new PointF[]
{
new PointF(x1, y1),
new PointF(x1 - (float)sizeX1, y1 + (float)sizeY1),
new PointF(x1, y1),
new PointF(x1 - (float)sizeX1, y1 - (float)sizeY1),
new PointF(x1, y1)
};
t1.TransformPoints(pts);
pt1 = pts[0];
var p11 = pts[1];
var p21 = pts[2];
var p12 = pts[3];
var p22 = pts[4];
DrawLineInternal(_gfx, strokeStartArrow, sas.IsStroked, ref p11, ref p21);
DrawLineInternal(_gfx, strokeStartArrow, sas.IsStroked, ref p12, ref p22);
}
break;
}
double radiusX2 = eas.RadiusX;
double radiusY2 = eas.RadiusY;
double sizeX2 = 2.0 * radiusX2;
double sizeY2 = 2.0 * radiusY2;
switch (eas.ArrowType)
{
default:
case ArrowType.None:
{
pt2 = new PointF(x2, y2);
}
break;
case ArrowType.Rectangle:
{
var pts = new PointF[] { new PointF(x2 - (float)sizeX2, y2) };
t2.TransformPoints(pts);
pt2 = pts[0];
var rect = new Rect2(x2 - sizeX2, y2 - radiusY2, sizeX2, sizeY2);
var gs = _gfx.Save();
_gfx.MultiplyTransform(t2);
DrawRectangleInternal(_gfx, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref rect);
_gfx.Restore(gs);
}
break;
case ArrowType.Ellipse:
{
var pts = new PointF[] { new PointF(x2 - (float)sizeX2, y2) };
t2.TransformPoints(pts);
pt2 = pts[0];
var gs = _gfx.Save();
_gfx.MultiplyTransform(t2);
var rect = new Rect2(x2 - sizeX2, y2 - radiusY2, sizeX2, sizeY2);
DrawEllipseInternal(_gfx, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref rect);
_gfx.Restore(gs);
}
break;
case ArrowType.Arrow:
{
var pts = new PointF[]
{
new PointF(x2, y2),
new PointF(x2 - (float)sizeX2, y2 + (float)sizeY2),
new PointF(x2, y2),
new PointF(x2 - (float)sizeX2, y2 - (float)sizeY2),
new PointF(x2, y2)
};
t2.TransformPoints(pts);
pt2 = pts[0];
var p11 = pts[1];
var p21 = pts[2];
var p12 = pts[3];
var p22 = pts[4];
DrawLineInternal(_gfx, strokeEndArrow, eas.IsStroked, ref p11, ref p21);
DrawLineInternal(_gfx, strokeEndArrow, eas.IsStroked, ref p12, ref p22);
}
break;
}
_gfx.DrawLine(strokeLine, pt1, pt2);
fillLine.Dispose();
strokeLine.Dispose();
fillStartArrow.Dispose();
strokeStartArrow.Dispose();
fillEndArrow.Dispose();
strokeEndArrow.Dispose();
}
public virtual bool HitTest(PointF pntTest)
{
System.Drawing.Drawing2D.Matrix mat = new System.Drawing.Drawing2D.Matrix();
mat.RotateAt(-RotationAngle, new PointF(X , Y ));
PointF[] tempPoints = new PointF[1];
tempPoints[0].X = pntTest.X;
tempPoints[0].Y = pntTest.Y;
mat.TransformPoints( tempPoints);
RectangleF rect = new RectangleF((X-(Width/2)), (Y-(Height/2)), Width, Height);
if (rect.Contains(tempPoints[0]))
{
return true;
}
return false;
}
public static void NormalizePoints2(Point[] points, Rectangle rectangle, Rectangle needRectangle)
{
if (rectangle.Height == 0 || rectangle.Width == 0)
return;
float k1 = 1f * needRectangle.Width / rectangle.Width;
float k2 = 1f * needRectangle.Height / rectangle.Height;
float k = Math.Min(k1, k2);
Matrix m = new Matrix();
m.Scale(k, k);
m.Translate(needRectangle.X / k - rectangle.X, needRectangle.Y / k - rectangle.Y);
m.TransformPoints(points);
}
public MatrixComponents GetMatrixComponents()
{
System.Drawing.Drawing2D.Matrix srcMatrix = new System.Drawing.Drawing2D.Matrix(
this.ScaleX,
this.Rotate0,
this.Rotate1,
this.ScaleY,
this.TranslateX,
this.TranslateY);
System.Drawing.Drawing2D.Matrix m = new System.Drawing.Drawing2D.Matrix(1, 0, 0, 1, 0, 0); // identity
// an 'identity' box
PointF[] modPts = new PointF[]{ new PointF(0,0),
new PointF(1,0),
new PointF(1,1),
new PointF(0,1) };
float sx, sy, rot, shear, tx, ty;
srcMatrix.TransformPoints(modPts);
// translation
tx = srcMatrix.OffsetX;
ty = srcMatrix.OffsetY;
m.Translate(-tx, -ty);
m.TransformPoints(modPts);
m.Reset();
// rotation
rot = (float)Math.Atan2(modPts[1].Y, modPts[1].X); // x axis
rot = (float)(rot / Math.PI * 180);
if (rot == -0) rot = 0;
if (rot == -180) rot = 180;
m.Rotate(-1 * rot);
m.TransformPoints(modPts);
m.Reset();
// scale
//sx = Dist(modPts[0], modPts[3]); // bug it seems..?
sx = Dist(modPts[0], modPts[1]);
sy = Dist(modPts[0], new PointF(0, modPts[3].Y));
if (modPts[0].Y > modPts[3].Y)
{
sy *= -1;
}
m.Scale(1 / sx, 1 / sy);
m.TransformPoints(modPts);
m.Reset();
// skew
// ySkew is impossible at this rotation
shear = modPts[3].X / Dist(modPts[0], modPts[1]);
// rounding
shear = Math.Abs(shear) < 0.001 ? 0 : shear;
m.Shear(-shear, 0);
m.TransformPoints(modPts);
m.Dispose();
srcMatrix.Dispose();
return new MatrixComponents(sx, sy, rot, shear, tx, ty);
}
public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts)
{
if (pts == null)
throw new ArgumentNullException ("pts");
Matrix transform = new Matrix();
ConversionHelpers.GetGraphicsTransform (this, destSpace, srcSpace, ref transform);
transform.TransformPoints (pts);
}
public static void NormalizePoints(Point[] points, Rectangle rectangle)
{
if (rectangle.Height == 0 || rectangle.Width == 0)
return;
Matrix m = new Matrix();
m.Translate(rectangle.Center().X, rectangle.Center().Y);
if (rectangle.Width > rectangle.Height)
m.Scale(1, 1f * rectangle.Width / rectangle.Height);
else
m.Scale(1f * rectangle.Height / rectangle.Width, 1);
m.Translate(-rectangle.Center().X, -rectangle.Center().Y);
m.TransformPoints(points);
}
public bool MouseMove(MouseEventArgs e, Matrix transform)
{
Point[] pp = new Point[] { e.Location };
transform.TransformPoints(pp);
Point location = pp[0];
if (state == State.DRAGGEDINSIDE)
{
lock (dragged)
{
if ((Control.ModifierKeys & Keys.Control) != 0)
{
if (((DateTime.Now - lastCtrlTime).Milliseconds > 200) || ((lastCtrlLocation.X - location.X) * (lastCtrlLocation.X - location.X) + (lastCtrlLocation.Y - location.Y) * (lastCtrlLocation.Y - location.Y) > 100))
{
dragged.SetPosition(location, true);
lastCtrlTime = DateTime.Now;
lastCtrlLocation = location;
}
}
else
{
dragged.SetPosition(location, false);
}
}
TakeSample();
return true;
}
else if (state == State.DRAGGEDOUTSIDE)
{
dragged.SetSecondParameterAgainstPosition(location);
TakeSample();
return true;
}
else if ((state == State.NONE) && (e.Button == MouseButtons.None))
{
IDragable inside = getInsideDragabe(location);
IDragable outside = getOutsideDragabe(location);
if (inside != null)
{
if (inselected != inside)
{
graphicControl.Cursor = Cursors.Hand;
if (inselected != null) inselected.SetSelectedState(0, 0);
inselected = inside;
outselected = null;
inselected.SetSelectedState(1, 0);
}
return true;
}
else if (outside != null)
{
if (outselected != outside)
{
graphicControl.Cursor = Cursors.NoMove2D;
if (outselected != null) outselected.SetSelectedState(0, 0);
outselected = outside;
inselected = null;
outselected.SetSelectedState(0, 1);
}
return true;
}
else
{
if ((outselected != null) || (inselected != null))
{
graphicControl.Cursor = Cursors.Arrow;
if (outselected != null) outselected.SetSelectedState(0, 0);
if (inselected != null) inselected.SetSelectedState(0, 0);
outselected = null;
inselected = null;
return true;
}
return false;
}
}
return false;
}
/// <summary>
/// This method is called on a DrawableContainers when:
/// 1) The capture on the surface is modified in such a way, that the elements would not be placed correctly.
/// 2) Currently not implemented: an element needs to be moved, scaled or rotated.
/// This basis implementation makes sure the coordinates of the element, including the TargetGripper, is correctly rotated/scaled/translated.
/// But this implementation doesn't take care of any changes to the content!!
/// </summary>
/// <param name="matrix"></param>
public virtual void Transform(Matrix matrix) {
if (matrix == null) {
return;
}
SuspendLayout();
Point topLeft = new Point(Left, Top);
Point bottomRight = new Point(Left + Width, Top + Height);
Point[] points;
if (TargetGripper != null) {
points = new[] {topLeft, bottomRight, TargetGripper.Location};
} else {
points = new[] { topLeft, bottomRight };
}
matrix.TransformPoints(points);
Left = points[0].X;
Top = points[0].Y;
Width = points[1].X - points[0].X;
Height = points[1].Y - points[0].Y;
if (TargetGripper != null) {
TargetGripper.Location = points[points.Length-1];
}
ResumeLayout();
}
public bool MouseUp(MouseEventArgs e, Matrix transform)
{
Point[] pp = new Point[] { e.Location };
transform.TransformPoints(pp);
Point location = pp[0];
if (e.Button == MouseButtons.Left)
{
state = State.NONE;
}
return false;
}
protected override void RenderPath(FillStyle fs, StrokeStyle ss, List <IShapeData> sh, bool silverlight)
{
// <Path Fill="#FFFF0000"
// StrokeThickness="0.00491913" StrokeLineJoin="Round" Stroke="#FF014393"
// Data="M 196.667,4L 388.667,100L 388.667,292L 196.667,388L 4.66669,292L 4.66669,100L 196.667,4 Z "/>
if (sh.Count == 0)
{
return;
}
xw.WriteStartElement("Path");
bool isGradient = false;
bool isTiledBitmap = false;
if (fs != null)
{
if (fs.FillType == FillType.Solid)
{
Color c = ((SolidFill)fs).Color;
xw.WriteStartAttribute("Fill");
xw.WriteColor(c);
xw.WriteEndAttribute();
// try to clean up faint edges
if (ss == null && c != new Color(0xFF, 0xFF, 0xFF) && c.A != 0)
{
ss = new SolidStroke(0.3F, c);
}
}
else if (
fs.FillType == FillType.Linear ||
fs.FillType == FillType.Radial ||
fs.FillType == FillType.Focal)
{
isGradient = true;
}
else if (fs.FillType == FillType.Image)
{
// Fill="{StaticResource vb_1}"
ImageFill img = (ImageFill)fs;
if (img.IsTiled || silverlight)
{
isTiledBitmap = true;// this causes bitmap to be written inline
}
else
{
string brushName = imageBrushes[img.ImagePath];
xw.WriteStartAttribute("Fill");
xw.WriteValue("{StaticResource " + brushName + "}");
xw.WriteEndAttribute();
}
}
}
if (ss != null)
{
if (ss is SolidStroke)
{
// StrokeThickness="3" StrokeLineJoin="Round" Stroke="#FF014393"
// StrokeStartLineCap="Round"
// StrokeEndLineCap="Round"
SolidStroke st = (SolidStroke)ss;
xw.WriteStartAttribute("StrokeThickness");
xw.WriteFloat(st.LineWidth);
xw.WriteEndAttribute();
xw.WriteStartAttribute("StrokeLineJoin");
xw.WriteString("Round");
xw.WriteEndAttribute();
xw.WriteStartAttribute("StrokeStartLineCap");
xw.WriteString("Round");
xw.WriteEndAttribute();
xw.WriteStartAttribute("StrokeEndLineCap");
xw.WriteString("Round");
xw.WriteEndAttribute();
xw.WriteStartAttribute("Stroke");
xw.WriteColor(st.Color);
xw.WriteEndAttribute();
}
}
float minX = float.PositiveInfinity;
float minY = float.PositiveInfinity;
float maxX = float.NegativeInfinity;
float maxY = float.NegativeInfinity;
xw.WriteStartAttribute("Data");
xw.WriteMoveTo(sh[0].StartPoint);
Point lastPoint = sh[0].StartPoint;
for (int i = 0; i < sh.Count; i++)
{
IShapeData sd = sh[i];
if (lastPoint != sd.StartPoint)
{
xw.WriteMoveTo(sd.StartPoint);
}
switch (sd.SegmentType)
{
case SegmentType.Line:
xw.WriteLineTo(sd.EndPoint);
lastPoint = sd.EndPoint;
break;
case SegmentType.CubicBezier:
CubicBezier cb = (CubicBezier)sd;
xw.WriteCubicCurveTo(cb.Control0, cb.Control1, cb.Anchor1);
lastPoint = cb.EndPoint;
minX = Math.Min(minX, cb.Control0.X);
maxX = Math.Max(maxX, cb.Control0.X);
minY = Math.Min(minY, cb.Control0.Y);
maxY = Math.Max(maxY, cb.Control0.Y);
minX = Math.Min(minX, cb.Control1.X);
maxX = Math.Max(maxX, cb.Control1.X);
minY = Math.Min(minY, cb.Control1.Y);
maxY = Math.Max(maxY, cb.Control1.Y);
break;
case SegmentType.QuadraticBezier:
QuadBezier qb = (QuadBezier)sd;
xw.WriteQuadraticCurveTo(qb.Control, qb.Anchor1);
lastPoint = qb.EndPoint;
minX = Math.Min(minX, qb.Control.X);
maxX = Math.Max(maxX, qb.Control.X);
minY = Math.Min(minY, qb.Control.Y);
maxY = Math.Max(maxY, qb.Control.Y);
break;
}
// need bounds for gradient :(
if (isGradient)
{
minX = Math.Min(minX, sd.StartPoint.X);
maxX = Math.Max(maxX, sd.StartPoint.X);
minY = Math.Min(minY, sd.StartPoint.Y);
maxY = Math.Max(maxY, sd.StartPoint.Y);
minX = Math.Min(minX, sd.EndPoint.X);
maxX = Math.Max(maxX, sd.EndPoint.X);
minY = Math.Min(minY, sd.EndPoint.Y);
maxY = Math.Max(maxY, sd.EndPoint.Y);
}
}
xw.WriteEndAttribute();
if (isGradient)
{
GradientFill gf = (GradientFill)fs;
// need a gradient def here
if (fs.FillType == FillType.Linear)
{
//<Path.Fill>
// <LinearGradientBrush StartPoint="0.14706,0.532137" EndPoint="1.14962,0.55353">
// <LinearGradientBrush.GradientStops>
// <GradientStop Color="#FF4A4A4A" Offset="0"/>
// <GradientStop Color="#FFB0B0B0" Offset="0.412067"/>
// <GradientStop Color="#FFBBBBBB" Offset="0.638141"/>
// <GradientStop Color="#FF545454" Offset="1"/>
// </LinearGradientBrush.GradientStops>
// </LinearGradientBrush>
//</Path.Fill>
xw.WriteStartElement("Path.Fill");
xw.WriteStartElement("LinearGradientBrush");
Matrix m = gf.Transform;
Rectangle r = GradientFill.GradientVexRect;
sysDraw2D.Matrix m2 = new sysDraw2D.Matrix(m.ScaleX, m.Rotate0, m.Rotate1, m.ScaleY, m.TranslateX, m.TranslateY);
float midY = r.Point.Y + (r.Size.Height / 2);
sysDraw.PointF pt0 = new sysDraw.PointF(r.Point.X, midY);
sysDraw.PointF pt1 = new sysDraw.PointF(r.Point.X + r.Size.Width, midY);
sysDraw.PointF[] pts = new sysDraw.PointF[] { pt0, pt1 };
m2.TransformPoints(pts);
float ratX = 1 / (maxX - minX);
float ratY = 1 / (maxY - minY);
float d0x = (pts[0].X - minX) * ratX;
float d0y = (pts[0].Y - minY) * ratY;
float d1x = (pts[1].X - minX) * ratX;
float d1y = (pts[1].Y - minY) * ratY;
xw.WriteStartAttribute("StartPoint");
xw.WritePoint(new Point(d0x, d0y));
xw.WriteEndAttribute();
xw.WriteStartAttribute("EndPoint");
xw.WritePoint(new Point(d1x, d1y));
xw.WriteEndAttribute();
xw.WriteStartAttribute("SpreadMethod");
xw.WriteValue("Pad");
xw.WriteEndAttribute();
xw.WriteStartElement("LinearGradientBrush.GradientStops");
for (int i = 0; i < gf.Stops.Count; i++)
{
xw.WriteStartElement("GradientStop");
xw.WriteStartAttribute("Color");
xw.WriteColor(gf.Fills[i]);
xw.WriteEndAttribute();
xw.WriteStartAttribute("Offset");
xw.WriteFloat(gf.Stops[i]);
xw.WriteEndAttribute();
xw.WriteEndElement(); // GradientStop
}
xw.WriteEndElement(); // LinearGradientBrush.GradientStops
xw.WriteEndElement(); // LinearGradientBrush
xw.WriteEndElement(); // Path.Fill
}
else if (fs.FillType == FillType.Radial)
{
//<Ellipse.Fill>
// <RadialGradientBrush RadiusX="0.622359" RadiusY="0.604589" Center="0.5,0.5" GradientOrigin="0.5,0.5">
// <RadialGradientBrush.RelativeTransform>
// <TransformGroup/>
// </RadialGradientBrush.RelativeTransform>
// <GradientStop Color="#95000000" Offset="0.347222"/>
// <GradientStop Color="#007877A7" Offset="0.773148"/>
// </RadialGradientBrush>
//</Ellipse.Fill>
xw.WriteStartElement("Path.Fill");
xw.WriteStartElement("RadialGradientBrush");
Matrix m = gf.Transform;
Rectangle r = GradientFill.GradientVexRect;
sysDraw2D.Matrix m2 = new sysDraw2D.Matrix(m.ScaleX, m.Rotate0, m.Rotate1, m.ScaleY, m.TranslateX, m.TranslateY);
float midX = r.Point.X + (r.Size.Width / 2);
float midY = r.Point.Y + (r.Size.Height / 2);
sysDraw.PointF pt0 = new sysDraw.PointF(midX, midY); // center
sysDraw.PointF pt1 = new sysDraw.PointF(r.Point.X + r.Size.Width, midY); // radius vector
sysDraw.PointF[] pts = new sysDraw.PointF[] { pt0, pt1 };
m2.TransformPoints(pts);
float ratX = 1 / (maxX - minX);
float ratY = 1 / (maxY - minY);
float d0x = (pts[0].X - minX) * ratX;
float d0y = (pts[0].Y - minY) * ratY;
float d1x = (pts[1].X - pts[0].X);
//float d1y = (pts[1].Y - pts[0].Y) * ratY;
float rad = (float)Math.Sqrt(d1x * d1x);
xw.WriteStartAttribute("RadiusX");
xw.WriteFloat(rad * ratX);
xw.WriteEndAttribute();
xw.WriteStartAttribute("RadiusY");
xw.WriteFloat(rad * ratY);
xw.WriteEndAttribute();
xw.WriteStartAttribute("Center");
xw.WritePoint(new Point(d0x, d0y));
xw.WriteEndAttribute();
xw.WriteStartAttribute("GradientOrigin");
xw.WritePoint(new Point(d0x, d0y));
xw.WriteEndAttribute();
xw.WriteStartAttribute("SpreadMethod");
xw.WriteValue("Pad");
xw.WriteEndAttribute();
//xw.WriteStartElement("RadialGradientBrush.GradientStops");
for (int i = 0; i < gf.Stops.Count; i++)
{
xw.WriteStartElement("GradientStop");
xw.WriteStartAttribute("Color");
xw.WriteColor(gf.Fills[i]);
xw.WriteEndAttribute();
xw.WriteStartAttribute("Offset");
xw.WriteFloat(1 - gf.Stops[i]); // xaml fill is reversed from gdi
xw.WriteEndAttribute();
xw.WriteEndElement(); // GradientStop
}
//xw.WriteEndElement(); // LinearGradientBrush.GradientStops
xw.WriteEndElement(); // LinearGradientBrush
xw.WriteEndElement(); // Path.Fill
}
}
else if (isTiledBitmap)
{
//<Path.Fill>
// <ImageBrush ImageSource="Resources\bmp_1.jpg" TileMode="Tile" RelativeTransform=".2,0,0,.2,0,0"/>
//</Path.Fill>
ImageFill img = (ImageFill)fs;
xw.WriteStartElement("Path.Fill");
xw.WriteStartElement("ImageBrush");
xw.WriteStartAttribute("ImageSource");
xw.WriteValue(img.ImagePath);
xw.WriteEndAttribute();
if (!silverlight)
{
xw.WriteStartAttribute("TileMode");
xw.WriteValue("Tile");
xw.WriteEndAttribute();
}
//xw.WriteStartAttribute("ViewportUnits");
//xw.WriteValue("Absolute");
//xw.WriteEndAttribute();
Matrix pMatrix = ApplyMatrixToShape(sh, img.Matrix, images[img.ImagePath].StrokeBounds);
//Matrix pMatrix = ApplyMatrixToImage(img.Matrix, images[img.ImagePath].Bounds);
xw.WriteStartAttribute("RelativeTransform");
xw.WriteMatrix(pMatrix);
//xw.WriteMatrix(img.Matrix);
xw.WriteEndAttribute();
xw.WriteEndElement(); // Path.Fill
xw.WriteEndElement(); // ImageBrush
}
xw.WriteEndElement(); // Path
}
public MatrixComponents GetMatrixComponents()
{
System.Drawing.Drawing2D.Matrix srcMatrix = new System.Drawing.Drawing2D.Matrix(
this.ScaleX,
this.Rotate0,
this.Rotate1,
this.ScaleY,
this.TranslateX,
this.TranslateY);
System.Drawing.Drawing2D.Matrix m = new System.Drawing.Drawing2D.Matrix(1, 0, 0, 1, 0, 0); // identity
// an 'identity' box
PointF[] modPts = new PointF[] { new PointF(0, 0),
new PointF(1, 0),
new PointF(1, 1),
new PointF(0, 1) };
float sx, sy, rot, shear, tx, ty;
srcMatrix.TransformPoints(modPts);
// translation
tx = srcMatrix.OffsetX;
ty = srcMatrix.OffsetY;
m.Translate(-tx, -ty);
m.TransformPoints(modPts);
m.Reset();
// rotation
rot = (float)Math.Atan2(modPts[1].Y, modPts[1].X); // x axis
rot = (float)(rot / Math.PI * 180);
if (rot == -0)
{
rot = 0;
}
if (rot == -180)
{
rot = 180;
}
m.Rotate(-1 * rot);
m.TransformPoints(modPts);
m.Reset();
// scale
//sx = Dist(modPts[0], modPts[3]); // bug it seems..?
sx = Dist(modPts[0], modPts[1]);
sy = Dist(modPts[0], new PointF(0, modPts[3].Y));
if (modPts[0].Y > modPts[3].Y)
{
sy *= -1;
}
m.Scale(1 / sx, 1 / sy);
m.TransformPoints(modPts);
m.Reset();
// skew
// ySkew is impossible at this rotation
shear = modPts[3].X / Dist(modPts[0], modPts[1]);
// rounding
shear = Math.Abs(shear) < 0.001 ? 0 : shear;
m.Shear(-shear, 0);
m.TransformPoints(modPts);
m.Dispose();
srcMatrix.Dispose();
return(new MatrixComponents(sx, sy, rot, shear, tx, ty));
}
/// <summary>
/// Without this change, labels render upside down and don't all scale readably.
/// </summary>
/// <param name="g"></param>
/// <param name="ro"></param>
/// <returns></returns>
protected RectangleF AdjustForLabel(Graphics g, GdiRenderObject ro)
{
// this transform goes from the underlying coordinates to
// screen coordinates, but for some reason renders text upside down
// we cannot just scale by 1, -1 because offsets are affected also
GdiMatrix m = g.Transform;
// used to scale text size for the current zoom level
float scale = Math.Abs(m.Elements[0]);
// get the bounds of the label in the underlying coordinate space
Point ll = new Point((Int32)ro.Bounds.X, (Int32)ro.Bounds.Y);
Point ur = new Point((Int32)(ro.Bounds.X + ro.Bounds.Width),
(Int32)(ro.Bounds.Y + ro.Bounds.Height));
Point[] transformedPoints1 =
{
new Point((Int32)ro.Bounds.X, (Int32)ro.Bounds.Y),
new Point((Int32)(ro.Bounds.X + ro.Bounds.Width),
(Int32)(ro.Bounds.Y + ro.Bounds.Height))
};
// get the label bounds transformed into screen coordinates
// note that if we just render this as-is the label is upside down
m.TransformPoints(transformedPoints1);
// for labels, we're going to use an identity matrix and screen coordinates
GdiMatrix newM = new GdiMatrix();
Boolean scaleText = true;
/*
* if (ro.Layer != null)
* {
* Double min = ro.Layer.Style.MinVisible;
* Double max = ro.Layer.Style.MaxVisible;
* float scaleMult = Double.IsInfinity(max) ? 2.0f : 1.0f;
*
* //max = Math.Min(max, _presenter.MaximumWorldWidth);
* max = Math.Min(max, Map.Extents.Width);
* //Double pct = (max - _presenter.WorldWidth) / (max - min);
* Double pct = 1 - (Math.Min(_presenter.WorldWidth, Map.Extents.Width) - min) / (max - min);
*
* if (scaleMult > 1)
* {
* pct = Math.Max(.5, pct * 2);
* }
*
* scale = (float)pct*scaleMult;
* labelScale = scale;
* }
*/
// ok, I lied, if we're scaling labels we need to scale our new matrix, but still no offsets
if (scaleText)
{
newM.Scale(scale, scale);
}
else
{
scale = 1.0f;
}
g.Transform = newM;
Int32 pixelWidth = ur.X - ll.X;
Int32 pixelHeight = ur.Y - ll.Y;
// if we're scaling text, then x,y position will get multiplied by our
// scale, so adjust for it here so that we can use actual pixel x,y
// Also center our label on the coordinate instead of putting the label origin on the coordinate
RectangleF newBounds = new RectangleF(transformedPoints1[0].X / scale,
(transformedPoints1[0].Y / scale) - pixelHeight,
pixelWidth,
pixelHeight);
//RectangleF newBounds = new RectangleF(transformedPoints1[0].X / scale - (pixelWidth / 2), transformedPoints1[0].Y / scale - (pixelHeight / 2), pixelWidth, pixelHeight);
return(newBounds);
}
public void Transform(Matrix matrix)
{
matrix.TransformPoints(points);
}
private Rectangle GetTransformedRectangle(DockState dockState, Rectangle rect)
{
if (dockState != DockState.DockLeftAutoHide && dockState != DockState.DockRightAutoHide)
return rect;
PointF[] pts = new PointF[1];
// the center of the rectangle
pts[0].X = (float)rect.X + (float)rect.Width / 2;
pts[0].Y = (float)rect.Y + (float)rect.Height / 2;
Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
Matrix matrix = new Matrix();
matrix.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
(float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
matrix.TransformPoints(pts);
return new Rectangle((int)(pts[0].X - (float)rect.Height / 2 + .5F),
(int)(pts[0].Y - (float)rect.Width / 2 + .5F),
rect.Height, rect.Width);
}
// http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/drawingwithquartz2d/dq_shadings/dq_shadings.html#//apple_ref/doc/uid/TP30001066-CH207-BBCECJBF
internal override void Setup(Graphics graphics, bool fill)
{
CGContext context = graphics.context;
// if fill is false then we are being called from a Pen stroke so
// we need to setup a transparency layer
// http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/drawingwithquartz2d/dq_shadings/dq_shadings.html#//apple_ref/doc/uid/TP30001066-CH207-BBCECJBF
if (!fill)
{
context.BeginTransparencyLayer();
hasTransparencyLayer = true;
// Make sure we set a color here so that the gradient shows up
graphics.lastBrushColor = Color.Black;
return;
}
// if this is the same as the last that was set and no changes have been made
// then return.
if (graphics.LastBrush != this || changed)
{
setupShadingColors();
}
CGSize gradientRegionCg = context.GetClipBoundingBox().Size;
SizeF gradientRegion = new SizeF((float)gradientRegionCg.Width, (float)gradientRegionCg.Height);
// SizeF gradientRegionPath = context.GetPathBoundingBox().Size;
PointF sp = startPoint;
PointF ep = endPoint;
PointF[] points = { sp, ep };
// Transform the start and end points using the brush's transformation matrix
gradientTransform.TransformPoints(points);
sp = points[0];
ep = points[1];
var cgf = CyclicGradientFunction(gradientRegion,
ref sp, ref ep);
var colorSpace = CGColorSpace.CreateDeviceRGB();
CGPoint cgsp = new CGPoint(sp.X, sp.Y), cgep = new CGPoint(ep.X, ep.Y);
var shading = CGShading.CreateAxial(colorSpace, cgsp, cgep, cgf, false, false);
colorSpace.Dispose();
context.SaveState();
// if path is empty here then we are being called from a Pen stroke so
// we set the blend mode for strokes and clip the path for fills
if (!context.IsPathEmpty())
{
context.Clip();
}
else
{
context.SetBlendMode(CGBlendMode.SourceIn);
}
context.DrawShading(shading);
context.RestoreState();
// If we are in a Transparency layer then we need to end the transparency
if (hasTransparencyLayer)
{
context.EndTransparencyLayer();
}
cgf.Dispose();
shading.Dispose();
shading = null;
changed = false;
graphics.LastBrush = this;
// We will reset the last pen so that it can be setup again
// so that we do not loose the settings after stroking the gradient
// not sure where the setting are being reset so this may be a hack
// and things are just not being restored correctly.
graphics.LastPen = null;
// I am setting this to be used for Text coloring in DrawString
graphics.lastBrushColor = colors[0];
}
