protected override void OnDraw(Xwt.Drawing.Context ctx, Rectangle dirtyRect)
{
if (Bounds.IsEmpty)
{
return;
}
ctx.Rectangle(0, 0, Bounds.Width, Bounds.Height);
Gradient g = null;
if (Linear)
{
g = new LinearGradient(0, 0, Bounds.Width, Bounds.Height);
}
else
{
g = new RadialGradient(Bounds.Width / 2, Bounds.Height / 2, Bounds.Width / 2, Bounds.Width / 2, Bounds.Height / 2, Bounds.Width / 4);
}
g.AddColorStop(0, new Color(1, 0, 0));
g.AddColorStop(1, new Color(0, 1, 0));
ctx.Pattern = g;
ctx.Fill();
Rectangle r = rect.Inflate(5, 5);
ctx.Rectangle(r);
ctx.SetColor(new Color(0, 0, 1));
ctx.SetLineWidth(1);
ctx.Stroke();
}
public virtual void Rotate(Xwt.Drawing.Context ctx, double x, double y)
{
ctx.Save();
ctx.Translate(x + 30, y + 30);
ctx.SetLineWidth(3);
// Rotation
double end = 270;
for (double n = 0; n <= end; n += 5)
{
ctx.Save();
ctx.Rotate(n);
ctx.MoveTo(0, 0);
ctx.RelLineTo(30, 0);
double c = n / end;
ctx.SetColor(new Color(c, c, c));
ctx.Stroke();
ctx.Restore();
}
//ctx.ResetTransform();
ctx.Restore();
}
protected override void OnDraw(Context ctx)
{
ctx.SetLineWidth (5);
ctx.SetColor (new Color (1.0f, 0f, 0.5f));
ctx.Rectangle (5, 5, 200, 100);
ctx.FillPreserve ();
ctx.SetColor (new Color (0f, 0f, 1f));
ctx.Stroke ();
}
public void PatternsAndImages (Context ctx, double x, double y)
{
ctx.Save ();
ctx.Translate (x, y);
ctx.SetColor (Colors.Black);
// Dashed lines
ctx.SetLineWidth (2);
ctx.SetLineDash (15, 10, 10, 5, 5);
ctx.Rectangle (10, 10, 100, 100);
ctx.Stroke ();
ctx.SetLineDash (0);
// Image
var arcColor = new Color (1, 0, 1);
ImageBuilder ib = new ImageBuilder (30, 30);
ib.Context.Arc (15, 15, 15, 0, 360);
ib.Context.SetColor (arcColor);
ib.Context.Fill ();
ib.Context.SetColor (Colors.DarkKhaki);
ib.Context.Rectangle (0, 0, 5, 5);
ib.Context.Fill ();
var img = ib.ToVectorImage ();
ctx.DrawImage (img, 0, 0);
ctx.DrawImage (img, 0, 50, 50, 10);
ctx.Arc (100, 100, 15, 0, 360);
arcColor.Alpha = 0.4;
ctx.SetColor (arcColor);
ctx.Fill ();
// ImagePattern
ctx.Save ();
ctx.Translate (x + 130, y);
ctx.Pattern = new ImagePattern (img);
ctx.Rectangle (0, 0, 100, 100);
ctx.Fill ();
ctx.Restore ();
ctx.Restore ();
// Setting pixels
ctx.SetLineWidth (1);
for (int i=0; i<50;i++) {
for (var j=0; j<50;j++) {
Color c = Color.FromHsl (0.5, (double)i / 50d, (double)j / 50d);
ctx.Rectangle (i, j, 1, 1);
ctx.SetColor (c);
ctx.Fill ();
}
}
}
void InternalDraw(int markerStart, int markerEnd, TextEditor editor, Xwt.Drawing.Context cr, TextLayout layout, bool selected, int startOffset, int endOffset, double y, double startXPos, double endXPos)
{
if (markerStart >= markerEnd)
{
return;
}
double @from;
double to;
if (markerStart < startOffset && endOffset < markerEnd)
{
@from = startXPos;
to = endXPos;
}
else
{
int start = startOffset < markerStart ? markerStart : startOffset;
int end = endOffset < markerEnd ? endOffset : markerEnd;
double /*lineNr,*/ x_pos;
x_pos = layout.GetCoordinateFromIndex(start - startOffset).X;
@from = startXPos + (int)(x_pos);
x_pos = layout.GetCoordinateFromIndex(end - startOffset).X;
to = startXPos + (int)(x_pos);
}
@from = System.Math.Max(@from, editor.TextViewMargin.XOffset);
to = System.Math.Max(to, editor.TextViewMargin.XOffset);
if (@from >= to)
{
return;
}
double height = editor.LineHeight / 5;
if (selected)
{
cr.SetSourceColor(editor.ColorStyle.SelectedText.Foreground);
}
else
{
cr.SetSourceColor(ColorName == null ? Color : editor.ColorStyle.GetChunkStyle(ColorName).Foreground);
}
if (Wave)
{
//Pango.CairoHelper.ShowErrorUnderline(cr, @from, y + editor.LineHeight - height, to - @from, height);
}
else
{
cr.SetLineWidth(1);
cr.MoveTo(@from, y + editor.LineHeight - 1.5);
cr.LineTo(to, y + editor.LineHeight - 1.5);
cr.Stroke();
}
}
/// <summary>
/// Visual test for pixel alignment and odd/even line widths
/// </summary>
public void Lines (Context ctx)
{
ctx.Save ();
ctx.SetColor (Colors.Black);
int nPairs = 4;
double length = 90;
double gap = 2;
// set half-pixel y-coordinate for sharp single-pixel-wide line
// on first line of Canvas, extending to match line pairs below
ctx.SetLineWidth (1);
double x = 0;
double y = 0.5;
double end = x + 2*(length - 1) + gap;
ctx.MoveTo (x, y);
ctx.LineTo (end, y);
ctx.Stroke ();
// draw pairs of lines with odd and even widths,
// each pair aligned on half-pixel y-coordinates
y = 4.5;
for (int w = 1; w <= nPairs; ++w) {
x = 0;
ctx.SetLineWidth (w);
ctx.MoveTo (x, y);
ctx.RelLineTo (length-1, 0);
ctx.Stroke ();
ctx.SetLineWidth (w + 1);
x += (gap + length - 1);
ctx.MoveTo (x, y);
ctx.RelLineTo (length-1, 0);
ctx.Stroke ();
y += w * 2 + gap;
}
ctx.Restore ();
}
protected override void OnDraw(Context ctx, Rectangle cellArea)
{
var pct = GetValue (ValueField);
var size = (cellArea.Width * pct) / 100f;
cellArea.Width = (int) size;
ctx.SetLineWidth (1);
ctx.Rectangle (cellArea.Inflate (-0.5, -0.5));
ctx.SetColor (Colors.LightBlue);
ctx.FillPreserve ();
ctx.SetColor (Colors.Gray);
ctx.Stroke ();
}
protected void InitBlank (int width = 50, int height = 50)
{
if (builder != null)
builder.Dispose ();
builder = new ImageBuilder (width, height);
context = builder.Context;
context.Rectangle (0, 0, width, height);
context.SetColor (Colors.White);
context.Fill ();
context.SetColor (Colors.Black);
context.SetLineWidth (1);
}
public virtual void Rotate(Xwt.Drawing.Context ctx, double x, double y)
{
// draws a line along the x-axis from (0,0) to (r,0) with a constant translation and an increasing
// rotational component. This composite transform is then applied to a vertical line, with inverse
// color, and an additional x-offset, to form a mirror image figure for easy visual comparison.
// These transformed points must be drawn with the identity CTM, hence the Restore() each time.
ctx.Save(); // save caller's context (assumed to be the Identity CTM)
ctx.SetLineWidth(3); // should align exactly if drawn with half-pixel coordinates
// Vector length (pixels) and rotation limit (degrees)
double r = 30;
double end = 270;
for (double n = 0; n <= end; n += 5)
{
ctx.Save(); // save context and identity CTM for each line
// Set up translation to centre point of first figure, ensuring pixel alignment
ctx.Translate(x + 30.5, y + 30.5);
ctx.Rotate(n);
ctx.MoveTo(0, 0);
ctx.RelLineTo(r, 0);
double c = n / end;
ctx.SetColor(new Color(c, c, c));
ctx.Stroke(); // stroke first figure with composite Translation and Rotation CTM
// Generate mirror image figure as a visual test of TransformPoints
Point p0 = new Point(0, 0);
Point p1 = new Point(0, -r);
Point[] p = new Point[] { p0, p1 };
ctx.TransformPoints(p); // using composite transformation
ctx.Restore(); // restore identity CTM
ctx.Save(); // save again (to restore after additional Translation)
ctx.Translate(2 * r + 1, 0); // extra x-offset to clear first figure
ctx.MoveTo(p[0]);
ctx.LineTo(p[1]);
c = 1 - c;
ctx.SetColor(new Color(c, c, c));
ctx.Stroke(); // stroke transformed points with offset in CTM
ctx.Restore(); // restore identity CTM for next line
}
ctx.Restore(); // restore caller's context
}
protected override void OnDraw(Xwt.Drawing.Context ctx, Rectangle dirtyRect)
{
ctx.Rectangle(0, 0, Bounds.Width, Bounds.Height);
var g = new LinearGradient(0, 0, Bounds.Width, Bounds.Height);
g.AddColorStop(0, new Color(1, 0, 0));
g.AddColorStop(1, new Color(0, 1, 0));
ctx.Pattern = g;
ctx.Fill();
Rectangle r = rect.Inflate(5, 5);
ctx.Rectangle(r);
ctx.SetColor(new Color(0, 0, 1));
ctx.SetLineWidth(1);
ctx.Stroke();
}
protected override void OnDraw(Context ctx, Rectangle dirtyRect)
{
base.OnDraw(ctx, dirtyRect);
ctx.SetColor(Colors.Gray);
ctx.SetLineWidth(1);
ctx.RoundRectangle(0, Padding.Top / 2 - .5, Width - 4.5, Height - Padding.Bottom * 1.5, 3);
ctx.Stroke();
var tl = new TextLayout(this) { Text = title, Width = Width - Padding.Left - Padding.Right / 2 };
ctx.SetColor(Colors.White);
ctx.Rectangle(Padding.Left, 0, tl.GetSize().Width, Padding.Top);
ctx.Fill();
ctx.SetColor(Colors.Black);
ctx.DrawTextLayout(tl, Padding.Left, 0);
}
protected override void OnDraw(Xwt.Drawing.Context cr, Rectangle rect)
{
if (BorderVisible)
{
{
cr.SetLineWidth(1);
var alloc = rect;
var right = alloc.RightInside();
var bottom = alloc.BottomInside();
cr.SharpLineX(alloc.X, alloc.Y, alloc.X, bottom);
cr.SharpLineX(right, alloc.Y, right, bottom);
cr.SharpLineY(alloc.X, alloc.Y, right, alloc.Y);
cr.SharpLineY(alloc.X, bottom, right, bottom);
cr.SetColor(Colors.Gray);
cr.Stroke();
}
}
}
protected override void OnDraw (Context ctx, Rectangle bounds)
{
var lineWidth = bounds.Width / 32d;
var section = ((bounds.Width / 2) - lineWidth / 2) / 3;
ctx.SetLineWidth (lineWidth);
ctx.SetColor (Colors.Black);
ctx.Arc (bounds.Center.X, bounds.Center.Y, 1, 0, 360);
ctx.Stroke ();
ctx.SetColor (Colors.Red);
ctx.Arc (bounds.Center.X, bounds.Center.Y, section, 0, 360);
ctx.Stroke ();
ctx.SetColor (Colors.Green);
ctx.Arc (bounds.Center.X, bounds.Center.Y, section * 2, 0, 360);
ctx.Stroke ();
ctx.SetColor (Colors.Blue);
ctx.Arc (bounds.Center.X, bounds.Center.Y, section * 3, 0, 360);
ctx.Stroke ();
}
public virtual void Curves1(Context ctx, double x, double y)
{
ctx.Save ();
ctx.Translate (x, y);
ctx.SetLineWidth (1);
Action curve1 = () => {
ctx.MoveTo (0, 30);
ctx.CurveTo (20, 0, 50, 0, 60, 25);
};
// curve2 with lineTo; curve1 is closed
Action curve2 = () => {
ctx.LineTo (0, 0);
ctx.CurveTo (20, 30, 50, 30, 60, 5);
};
Action paint = () => {
curve1 ();
curve2 ();
ctx.ClosePath ();
ctx.SetColor (new Color (0, 0, 0, .5));
ctx.StrokePreserve ();
ctx.SetColor (new Color (1, 0, 1, .5));
ctx.Fill ();
};
paint ();
ctx.Translate (0, 40);
// curve2 with moveTo; curve1 is open
curve2 = () => {
ctx.MoveTo (0, 0);
ctx.CurveTo (20, 30, 50, 30, 60, 5);
};
paint ();
ctx.Restore ();
//Todo: same stuff with arc
}
public virtual void Rotate(Xwt.Drawing.Context ctx, double x, double y)
{
ctx.Save();
ctx.Translate(x + 30, y + 30);
ctx.SetLineWidth(3);
// Rotation
double end = 270;
double r = 30;
for (double n = 0; n <= end; n += 5)
{
ctx.Save();
ctx.Rotate(n);
ctx.MoveTo(0, 0);
ctx.RelLineTo(r, 0);
double c = n / end;
ctx.SetColor(new Color(c, c, c));
ctx.Stroke();
// Visual test for TransformPoints
Point p0 = new Point(0, 0);
Point p1 = new Point(0, -r);
Point[] p = new Point[] { p0, p1 };
ctx.TransformPoints(p);
ctx.ResetTransform();
ctx.Translate(2 * r + 1, 0);
ctx.MoveTo(p[0]);
ctx.LineTo(p[1]);
c = 1 - c;
ctx.SetColor(new Color(c, c, c));
ctx.Stroke();
ctx.Restore();
}
ctx.Restore();
}
void DrawFocus(Context ctx, Point p)
{
// Draw a 'zoom'-style Focus at specified point
double focusRadius = 32;
double r = 12, w = focusRadius - 1;
Point o = Point.Zero; // Drawing origin
// Align single-thickness lines on 0.5 pixel coords
o.X += 0.5;
o.Y += 0.5;
ctx.Save ();
ctx.Translate (p); // Final translation
// Hairlines in X-direction
ctx.MoveTo (o.X + r, o.Y);
ctx.LineTo (o.X + w, o.Y);
ctx.MoveTo (o.X - r, o.Y);
ctx.LineTo (o.X - w, o.Y);
// Hairlines in Y-direction
ctx.MoveTo (o.X, o.Y + r);
ctx.LineTo (o.X, o.Y + w);
ctx.MoveTo (o.X, o.Y - r);
ctx.LineTo (o.X, o.Y - w);
// Inner single-thickness circle
ctx.MoveTo (o.X + r, o.Y);
ctx.Arc (o.X, o.Y, r, 0, 360);
ctx.SetColor (Colors.Black);
ctx.SetLineWidth (1);
ctx.Stroke ();
// Double thickness outer arcs. Draw at (0,0) and rotate
o = Point.Zero;
r = 22;
ctx.Rotate (5);
ctx.MoveTo (r, 0);
ctx.Arc (o.X, o.Y, r, 0, 80);
ctx.MoveTo (o.X, r);
ctx.Arc (o.X, o.Y, r, 90, 170);
ctx.MoveTo (-r, o.Y);
ctx.Arc (o.X, o.Y, r, 180, 260);
ctx.MoveTo (o.X, -r);
ctx.Arc (o.X, o.Y, r, 270, 350);
ctx.SetLineWidth (2);
ctx.Stroke ();
ctx.Restore ();
}
public virtual void Rectangles (Context ctx, double x, double y)
{
ctx.Save ();
ctx.Translate (x, y);
// Simple rectangles
ctx.SetLineWidth (1);
ctx.Rectangle (0, 0, 10, 10);
ctx.SetColor (Colors.Black);
ctx.Fill ();
ctx.Rectangle (15, 0, 10, 10);
ctx.SetColor (Colors.Black);
ctx.Stroke ();
ctx.SetLineWidth (3);
ctx.Rectangle (0, 15, 10, 10);
ctx.SetColor (Colors.Black);
ctx.Fill ();
ctx.Rectangle (15, 15, 10, 10);
ctx.SetColor (Colors.Black);
ctx.Stroke ();
ctx.Restore ();
// Rectangle with hole
ctx.Save ();
ctx.Translate (x + 50, y);
ctx.Rectangle (0, 0, 40, 40);
ctx.MoveTo (35, 35);
ctx.RelLineTo (0, -20);
ctx.RelLineTo (-20, 0);
ctx.RelLineTo (0, 20);
ctx.ClosePath ();
ctx.SetColor (Colors.Black);
ctx.Fill ();
ctx.Restore ();
// Rounded Rectangle with Arcs
ctx.Save ();
ctx.Translate (x + 120, y);
var r = 5;
var l = 0;
var t = 0;
var w = 50;
var h = 30;
ctx.SetColor (Colors.Black);
// top left
ctx.Arc (l + r, t + r, r, 180, 270);
// top right
ctx.Arc (l + w - r, t + r, r, 270, 0);
// bottom right
ctx.Arc (l + w - r, t + h - r, r, 0, 90);
// bottom left
ctx.Arc (l + r, t + h - r, r, 90, 180);
ctx.ClosePath ();
ctx.StrokePreserve ();
ctx.SetColor (Colors.AntiqueWhite);
ctx.Fill ();
ctx.Restore ();
}
void DrawAxis (Context ctx, Axis ax)
{
ctx.SetLineWidth (1);
double minStep = GetMinTickStep (ax.Dimension);
TickEnumerator enumSmall = ax.GetTickEnumerator (minStep);
if (enumSmall == null)
return;
TickEnumerator enumBig = ax.GetTickEnumerator (minStep * 2);
if (enumBig == null) {
DrawTicks (ctx, enumSmall, ax.Position, ax.Dimension, ax.TickSize, ax.ShowLabels);
} else {
DrawTicks (ctx, enumSmall, ax.Position, ax.Dimension, ax.TickSize / 2, false);
DrawTicks (ctx, enumBig, ax.Position, ax.Dimension, ax.TickSize, ax.ShowLabels);
}
}
protected override void OnDraw(Xwt.Drawing.Context ctx)
{
base.OnDraw(ctx);
// Simple rectangles
ctx.SetLineWidth(1);
ctx.Rectangle(100, 5, 10, 10);
ctx.SetColor(Color.Black);
ctx.Fill();
ctx.Rectangle(115, 5, 10, 10);
ctx.SetColor(Color.Black);
ctx.Stroke();
//
ctx.SetLineWidth(3);
ctx.Rectangle(100, 20, 10, 10);
ctx.SetColor(Color.Black);
ctx.Fill();
ctx.Rectangle(115, 20, 10, 10);
ctx.SetColor(Color.Black);
ctx.Stroke();
// Rectangle with hole
ctx.Rectangle(10, 100, 40, 40);
ctx.MoveTo(45, 135);
ctx.RelLineTo(0, -20);
ctx.RelLineTo(-20, 0);
ctx.RelLineTo(0, 20);
ctx.ClosePath();
ctx.SetColor(Color.Black);
ctx.Fill();
// Dashed lines
ctx.SetLineDash(15, 10, 10, 5, 5);
ctx.Rectangle(100, 100, 100, 100);
ctx.Stroke();
ctx.SetLineDash(0);
ImageBuilder ib = new ImageBuilder(30, 30, ImageFormat.ARGB32);
ib.Context.Arc(15, 15, 15, 0, 360);
ib.Context.SetColor(new Color(1, 0, 1));
ib.Context.Rectangle(0, 0, 5, 5);
ib.Context.Fill();
var img = ib.ToImage();
ctx.DrawImage(img, 90, 90);
ctx.DrawImage(img, 90, 140, 50, 10);
ctx.Arc(190, 190, 15, 0, 360);
ctx.SetColor(new Color(1, 0, 1, 0.4));
ctx.Fill();
ctx.Save();
ctx.Translate(90, 220);
ctx.Pattern = new ImagePattern(img);
ctx.Rectangle(0, 0, 100, 70);
ctx.Fill();
ctx.Restore();
ctx.Translate(30, 30);
double end = 270;
for (double n = 0; n <= end; n += 5)
{
ctx.Save();
ctx.Rotate(n);
ctx.MoveTo(0, 0);
ctx.RelLineTo(30, 0);
double c = n / end;
ctx.SetColor(new Color(c, c, c));
ctx.Stroke();
ctx.Restore();
}
ctx.ResetTransform();
}
protected override void OnDraw (Context ctx, Rectangle dirtyRect)
{
if (colorBox == null) {
using (var ib = new ImageBuilder (size, size)) {
for (int i=0; i<size; i++) {
for (int j=0; j<size; j++) {
ib.Context.Rectangle (i, j, 1, 1);
ib.Context.SetColor (GetColor (i,j));
ib.Context.Fill ();
}
}
if (ParentWindow != null)
colorBox = ib.ToBitmap (this); // take screen scale factor into account
else
colorBox = ib.ToBitmap ();
}
}
ctx.DrawImage (colorBox, padding, padding);
ctx.SetLineWidth (1);
ctx.SetColor (Colors.Black);
ctx.Rectangle (selection.X + padding - 2 + 0.5, selection.Y + padding - 2 + 0.5, 4, 4);
ctx.Stroke ();
}
void DrawText(Context ctx, TextLayout tl, ref double y)
{
double x = 10;
var s = tl.GetSize ();
var rect = new Rectangle (x, y, s.Width, s.Height).Inflate (0.5, 0.5);
ctx.SetLineWidth (1);
ctx.SetColor (Colors.Blue);
ctx.Rectangle (rect);
ctx.Stroke ();
ctx.SetColor (Colors.Black);
ctx.DrawTextLayout (tl, x, y);
y += s.Height + 20;
}
/// <summary>
/// Draw the axis. This involves three steps:
/// (1) Draw the axis line.
/// (2) Draw the tick marks.
/// (3) Draw the label.
/// </summary>
/// <param name="ctx">The Drawing Context with which to draw.</param>
/// <param name="physicalMin">The physical position corresponding to the world minimum of the axis.</param>
/// <param name="physicalMax">The physical position corresponding to the world maximum of the axis.</param>
/// <param name="boundingBox">out The bounding rectangle of the axis including axis line, label, tick marks and tick mark labels</param>
public virtual void Draw(Context ctx, Point physicalMin, Point physicalMax, out Rectangle boundingBox)
{
// calculate the bounds of the axis line only.
double x1 = Math.Min (physicalMin.X, physicalMax.X);
double x2 = Math.Max (physicalMin.X, physicalMax.X);
double y1 = Math.Min (physicalMin.Y, physicalMax.Y);
double y2 = Math.Max (physicalMin.Y, physicalMax.Y);
Rectangle bounds = new Rectangle (x1, y1, x2-x1, y2-y1);
if (!Hidden) {
// (1) Draw the axis line.
ctx.Save ();
ctx.SetLineWidth (1);
ctx.SetColor (LineColor);
ctx.MoveTo (physicalMin.X+0.5, physicalMin.Y+0.5);
ctx.LineTo (physicalMax.X+0.5, physicalMax.Y+0.5);
ctx.Stroke ();
ctx.Restore ();
// (2) draw tick marks (subclass responsibility).
object labelOffset;
object tickBounds;
DrawTicks (ctx, physicalMin, physicalMax, out labelOffset, out tickBounds);
// (3) draw the axis label
object labelBounds = null;
if (!HideTickText) {
labelBounds = DrawLabel (ctx, (Point)labelOffset, physicalMin, physicalMax);
}
// (4) merge bounds and return.
if (labelBounds != null) {
bounds = Rectangle.Union (bounds, (Rectangle)labelBounds);
}
if (tickBounds != null) {
bounds = Rectangle.Union (bounds, (Rectangle)tickBounds);
}
}
boundingBox = bounds;
}
/// <summary>
/// Draws the arrow on a plot surface.
/// </summary>
/// <param name="ctx">the Drawing Context with which to draw</param>
/// <param name="xAxis">The X-Axis to draw against.</param>
/// <param name="yAxis">The Y-Axis to draw against.</param>
public void Draw(Context ctx, PhysicalAxis xAxis, PhysicalAxis yAxis )
{
if (To.X > xAxis.Axis.WorldMax || To.X < xAxis.Axis.WorldMin) {
return;
}
if (To.Y > yAxis.Axis.WorldMax || To.Y < yAxis.Axis.WorldMin) {
return;
}
ctx.Save ();
TextLayout layout = new TextLayout ();
layout.Font = textFont_;
layout.Text = text_;
double angle = angle_;
if (angle_ < 0.0) {
int mul = -(int)(angle_ / 360.0) + 2;
angle = angle_ + 360.0 * (double)mul;
}
double normAngle = (double)angle % 360.0; // angle in range 0 -> 360.
Point toPoint = new Point (
xAxis.WorldToPhysical (to_.X, true).X,
yAxis.WorldToPhysical (to_.Y, true).Y);
double xDir = Math.Cos (normAngle * 2.0 * Math.PI / 360.0);
double yDir = Math.Sin (normAngle * 2.0 * Math.PI / 360.0);
toPoint.X += xDir*headOffset_;
toPoint.Y += yDir*headOffset_;
double xOff = physicalLength_ * xDir;
double yOff = physicalLength_ * yDir;
Point fromPoint = new Point(
(int)(toPoint.X + xOff),
(int)(toPoint.Y + yOff) );
ctx.SetLineWidth (1);
ctx.SetColor (arrowColor_);
ctx.MoveTo (fromPoint);
ctx.LineTo (toPoint);
ctx.Stroke ();
xOff = headSize_ * Math.Cos ((normAngle-headAngle_/2) * 2.0 * Math.PI / 360.0);
yOff = headSize_ * Math.Sin ((normAngle-headAngle_/2) * 2.0 * Math.PI / 360.0);
ctx.LineTo (toPoint.X + xOff, toPoint.Y + yOff);
double xOff2 = headSize_ * Math.Cos ((normAngle+headAngle_/2) * 2.0 * Math.PI / 360.0);
double yOff2 = headSize_ * Math.Sin ((normAngle+headAngle_/2) * 2.0 * Math.PI / 360.0);
ctx.LineTo (toPoint.X + xOff2, toPoint.Y + yOff2);
ctx.LineTo (toPoint);
ctx.ClosePath ();
ctx.SetColor (arrowColor_);
ctx.Fill ();
Size textSize = layout.GetSize ();
Size halfSize = new Size (textSize.Width/2, textSize.Height/2);
double quadrantSlideLength = halfSize.Width + halfSize.Height;
double quadrantD = normAngle / 90.0; // integer part gives quadrant.
int quadrant = (int)quadrantD; // quadrant in.
double prop = quadrantD - (double)quadrant; // proportion of way through this qadrant.
double dist = prop * quadrantSlideLength; // distance along quarter of bounds rectangle.
// now find the offset from the middle of the text box that the
// rear end of the arrow should end at (reverse this to get position
// of text box with respect to rear end of arrow).
//
// There is almost certainly an elgant way of doing this involving
// trig functions to get all the signs right, but I'm about ready to
// drop off to sleep at the moment, so this blatent method will have
// to do.
Point offsetFromMiddle = new Point (0, 0);
switch (quadrant) {
case 0:
if (dist > halfSize.Height) {
dist -= halfSize.Height;
offsetFromMiddle = new Point ( -halfSize.Width + dist, halfSize.Height );
}
else {
offsetFromMiddle = new Point ( -halfSize.Width, - dist );
}
break;
case 1:
if (dist > halfSize.Width) {
dist -= halfSize.Width;
offsetFromMiddle = new Point ( halfSize.Width, halfSize.Height - dist );
}
else {
offsetFromMiddle = new Point ( dist, halfSize.Height );
}
break;
case 2:
if (dist > halfSize.Height) {
dist -= halfSize.Height;
offsetFromMiddle = new Point ( halfSize.Width - dist, -halfSize.Height );
}
else {
offsetFromMiddle = new Point ( halfSize.Width, -dist );
}
break;
case 3:
if (dist > halfSize.Width) {
dist -= halfSize.Width;
offsetFromMiddle = new Point ( -halfSize.Width, -halfSize.Height + dist );
}
else {
offsetFromMiddle = new Point ( -dist, -halfSize.Height );
}
break;
default:
throw new XwPlotException( "Programmer error." );
}
ctx.SetColor (textColor_);
double x = fromPoint.X - halfSize.Width - offsetFromMiddle.X;
double y = fromPoint.Y - halfSize.Height + offsetFromMiddle.Y;
ctx.DrawTextLayout (layout, x, y);
ctx.Restore ();
}
void DrawSerie (Context ctx, Serie serie)
{
ctx.NewPath ();
ctx.Rectangle (left, top, width + 1, height + 1);
ctx.Clip ();
ctx.NewPath ();
ctx.SetColor (serie.Color);
ctx.SetLineWidth (serie.LineWidth);
bool first = true;
bool blockMode = serie.DisplayMode == DisplayMode.BlockLine;
double lastY = 0;
foreach (Data d in serie.GetData (startX, endX)) {
double x, y;
GetPoint (d.X, d.Y, out x, out y);
if (first) {
ctx.MoveTo (x, y);
lastY = y;
first = false;
} else {
if (blockMode) {
if (lastY != y)
ctx.LineTo (x, lastY);
ctx.LineTo (x, y);
} else
ctx.LineTo (x, y);
}
lastY = y;
}
ctx.Stroke ();
}
protected override void OnDraw(Context ctx, Rectangle dirtyRect)
{
base.OnDraw(ctx, dirtyRect);
if (image != null) {
if (Heighlighted && IsThumbnail) {
ctx.RoundRectangle(new Rectangle(Point.Zero, image.Size), 3);
ctx.SetColor(Colors.LightSteelBlue);
ctx.Fill();
}
ctx.DrawImage(image, (new Rectangle(Point.Zero, image.Size)).Inflate(-3, -3));
if (mask != null && ShowMask) {
ctx.DrawImage(MaskBitmap, (new Rectangle(Point.Zero, image.Size)).Inflate(-3, -3), 0.6);
}
}
if (isEditMode) {
Point scaleFactor = new Point(
scan.Size.Width / image.Size.Width,
scan.Size.Height / image.Size.Height);
ctx.SetColor(Mask.maskColor);
foreach (MaskEntry p in scan.Mask.MaskPositions) {
switch (p.type) {
case MaskEntryType.Point:
ctx.SetLineWidth(p.pointerSize / scaleFactor.Y * 2);
ctx.LineTo(p.position.X / scaleFactor.X, p.position.Y / scaleFactor.Y);
ctx.Stroke();
ctx.Arc(
p.position.X / scaleFactor.X, p.position.Y / scaleFactor.Y,
p.pointerSize / scaleFactor.Y, 0, 360);
ctx.Fill();
ctx.MoveTo(p.position.X / scaleFactor.X, p.position.Y / scaleFactor.Y);
break;
case MaskEntryType.Space:
ctx.Stroke();
ctx.ClosePath();
break;
case MaskEntryType.Delete:
ctx.Arc(
p.position.X / scaleFactor.X, p.position.Y / scaleFactor.Y,
p.pointerSize / scaleFactor.Y, 0, 360);
ctx.Save();
ctx.Clip();
int newX = (int) Math.Min(Math.Max(
p.position.X / scaleFactor.X - pointerSize / scaleFactor.Y, 0), scan.Size.Width);
int newY = (int) Math.Min(Math.Max(
p.position.Y / scaleFactor.Y - pointerSize / scaleFactor.Y, 0), scan.Size.Height);
using (ImageBuilder ib =
new ImageBuilder((pointerSize / scaleFactor.Y * 2), (pointerSize / scaleFactor.Y * 2))) {
BitmapImage bi = ib.ToBitmap();
image.WithBoxSize(image.Size).ToBitmap().CopyArea(
newX, newY,
(int) (pointerSize / scaleFactor.Y * 2), (int) (pointerSize / scaleFactor.Y * 2),
bi, 0, 0);
ctx.DrawImage(bi, new Point(newX, newY));
}
ctx.Restore();
ctx.ClosePath();
break;
}
}
ctx.Stroke();
if (mousePosition != Point.Zero) {
ctx.Arc(mousePosition.X, mousePosition.Y, pointerSize / Math.Max(scaleFactor.X, scaleFactor.Y), 0, 360);
ctx.Fill();
if (mousePositionStart != Point.Zero) {
ctx.SetLineWidth((pointerSize / Math.Max(scaleFactor.X, scaleFactor.Y)) * 2);
ctx.SetColor(Mask.maskColor);
ctx.Arc(mousePositionStart.X, mousePositionStart.Y, pointerSize / Math.Max(scaleFactor.X, scaleFactor.Y), 0, 360);
ctx.Fill();
ctx.MoveTo(mousePosition);
ctx.LineTo(mousePositionStart);
ctx.Stroke();
}
}
}
}
/// <summary>
/// Draws the horizontal line plot using the Context and the x and y axes specified
/// </summary>
/// <param name="ctx">The Context with which to draw.</param>
/// <param name="xAxis">The X-Axis to draw against.</param>
/// <param name="yAxis">The Y-Axis to draw against.</param>
public void Draw(Context ctx, PhysicalAxis xAxis, PhysicalAxis yAxis)
{
double xMin = xAxis.PhysicalMin.X;
double xMax = xAxis.PhysicalMax.X;
xMin += pixelIndent_;
xMax -= pixelIndent_;
double length = Math.Abs (xMax - xMin);
double lengthDiff = length - length*scale_;
double indentAmount = lengthDiff/2;
xMin += indentAmount;
xMax -= indentAmount;
double yPos = yAxis.WorldToPhysical (value_, false).Y;
ctx.Save ();
ctx.SetLineWidth (1);
ctx.SetColor (color_);
ctx.MoveTo (xMin, yPos);
ctx.LineTo (xMax, yPos);
ctx.Stroke ();
ctx.Restore ();
// todo: clip and proper logic for flipped axis min max.
}
protected override void OnDraw(Context ctx, Rectangle dirtyRect)
{
if (colorBox == null) {
using (var ib = new ImageBuilder (size, size)) {
for (int i=0; i<size; i++) {
for (int j=0; j<size; j++) {
ib.Context.Rectangle (i, j, 1, 1);
ib.Context.SetColor (GetColor (i,j));
ib.Context.Fill ();
}
}
colorBox = ib.ToImage ();
}
}
ctx.DrawImage (colorBox, padding, padding);
ctx.SetLineWidth (1);
ctx.SetColor (Colors.Black);
ctx.Rectangle (selection.X + padding - 2 + 0.5, selection.Y + padding - 2 + 0.5, 4, 4);
ctx.Stroke ();
}
protected override void OnDraw(Context ctx, Rectangle cellArea)
{
ctx.Rectangle (BackgroundBounds);
ctx.SetColor (new Color (0.9, 0.9, 0.9));
ctx.Fill ();
ctx.Rectangle (Bounds);
ctx.SetColor (new Color (0.7, 0.7, 0.7));
ctx.Fill ();
var pct = GetValue (ValueField);
var size = (cellArea.Width * pct.Value) / 100f;
cellArea.Width = (int) size;
ctx.SetLineWidth (1);
ctx.Rectangle (cellArea.Inflate (-0.5, -0.5));
ctx.SetColor (Selected ? Colors.Blue : Colors.LightBlue);
ctx.FillPreserve ();
ctx.SetColor (Colors.Gray);
ctx.Stroke ();
if (pct.YPos != -1) {
ctx.MoveTo (cellArea.Right, Bounds.Y + pct.YPos);
ctx.Arc (cellArea.Right, Bounds.Y + pct.YPos, 2.5, 0, 360);
ctx.SetColor (Colors.Red);
ctx.Fill ();
}
}
/// <summary>
/// Draws the candle plot with the specified Drawing Context and X,Y axes
/// </summary>
/// <param name="ctx">The Drawing Context with which to draw</param>
/// <param name="xAxis">The physical X-Axis to draw against</param>
/// <param name="yAxis">The physical Y-Axis to draw against</param>
public void Draw(Context ctx, PhysicalAxis xAxis, PhysicalAxis yAxis)
{
CandleDataAdapter cd = new CandleDataAdapter (DataSource, DataMember,
AbscissaData, OpenData, LowData, HighData, CloseData);
double offset = 0;
if (Centered) {
offset = CalculatePhysicalSeparation (cd,xAxis)/2;
}
double addAmount = StickWidth/2;
double stickWidth = StickWidth;
if (StickWidth == AutoScaleStickWidth) {
// default
addAmount = 2;
stickWidth = 4;
double minDist = CalculatePhysicalSeparation (cd, xAxis);
addAmount = minDist / 3;
stickWidth = addAmount * 2;
}
ctx.Save ();
ctx.SetLineWidth (1);
/*
// brant hyatt proposed.
if (Style == Styles.Stick)
{
p.Width = stickWidth;
addAmount = stickWidth + 2;
}
*/
for (int i=0; i<cd.Count; ++i) {
PointOLHC point = (PointOLHC)cd [i];
if ((!double.IsNaN (point.Open)) && (!double.IsNaN(point.High))
&& (!double.IsNaN (point.Low)) && (!double.IsNaN(point.Close))) {
double xPos = (xAxis.WorldToPhysical (point.X, false)).X;
if (xPos + offset + addAmount < xAxis.PhysicalMin.X || xAxis.PhysicalMax.X < xPos + offset - addAmount) {
continue;
}
double yLo = (yAxis.WorldToPhysical (point.Low, false)).Y;
double yHi = (yAxis.WorldToPhysical (point.High, false)).Y;
double yOpn = (yAxis.WorldToPhysical (point.Open, false)).Y;
double yCls = (yAxis.WorldToPhysical (point.Close,false)).Y;
if (Style == Styles.Stick) {
/*
// brant hyatt proposed.
if (i > 0)
{
if ( ((PointOLHC)cd[i]).Close > ((PointOLHC)cd[i-1]).Close)
{
p.Color = BullishColor;
}
else
{
p.Color = BearishColor;
}
}
*/
ctx.SetColor (Color);
ctx.MoveTo (xPos+offset, yLo);
ctx.LineTo (xPos+offset, yHi); // Low to High line
ctx.MoveTo (xPos-addAmount+offset, yOpn);
ctx.LineTo (xPos+offset, yOpn); // Open line
ctx.MoveTo (xPos+addAmount+offset, yCls);
ctx.LineTo (xPos+offset, yCls); // Close line
ctx.Stroke ();
}
else if (Style == Styles.Filled) {
ctx.MoveTo (xPos+offset, yLo);
ctx.LineTo (xPos+offset, yHi);
ctx.Stroke ();
if (yOpn > yCls) {
ctx.SetColor (BullishColor);
ctx.Rectangle (xPos-addAmount+offset, yCls, stickWidth, yOpn - yCls);
ctx.FillPreserve ();
ctx.SetColor (Color);
ctx.Stroke ();
}
else if (yOpn < yCls) {
ctx.SetColor (BearishColor);
ctx.Rectangle (xPos-addAmount+offset, yOpn, stickWidth, yCls - yOpn);
ctx.FillPreserve ();
ctx.SetColor (Color);
ctx.Stroke ();
}
else { // Cls == Opn
ctx.MoveTo (xPos-addAmount+offset, yOpn);
ctx.LineTo (xPos-addAmount+stickWidth+offset, yCls);
ctx.Stroke ();
}
}
}
}
ctx.Restore ();
}
/// <summary>
/// Draws the step plot using a Drawing Context against the provided x and y axes.
/// </summary>
/// <param name="ctx">The Drawing Context with which to draw.</param>
/// <param name="xAxis">The X-Axis to draw against.</param>
/// <param name="yAxis">The Y-Axis to draw against.</param>
public virtual void Draw(Context ctx, PhysicalAxis xAxis, PhysicalAxis yAxis )
{
SequenceAdapter data =
new SequenceAdapter (DataSource, DataMember, OrdinateData, AbscissaData);
double leftCutoff = xAxis.PhysicalToWorld(xAxis.PhysicalMin, false);
double rightCutoff = xAxis.PhysicalToWorld(xAxis.PhysicalMax, false);
for (int i=0; i<data.Count; ++i) {
Point p1 = data[i];
if (Double.IsNaN(p1.X) || Double.IsNaN(p1.Y)) {
continue;
}
Point p2;
Point p3;
if (i+1 != data.Count) {
p2 = data[i+1];
if (Double.IsNaN(p2.X) || Double.IsNaN(p2.Y)) {
continue;
}
p2.Y = p1.Y;
p3 = data[i+1];
}
else {
// Check that we are not dealing with a DataSource of 1 point.
// This check is done here so it is only checked on the end
// condition and not for every point in the DataSource.
if (data.Count > 1) {
p2 = data[i - 1];
}
else {
// TODO: Once log4net is set up post a message to the user that a step-plot of 1 really does not make any sense.
p2 = p1;
}
double offset = p1.X - p2.X;
p2.X = p1.X + offset;
p2.Y = p1.Y;
p3 = p2;
}
if (center_) {
double offset = ( p2.X - p1.X ) / 2.0;
p1.X -= offset;
p2.X -= offset;
p3.X -= offset;
}
Point xPos1 = xAxis.WorldToPhysical (p1.X, false);
Point yPos1 = yAxis.WorldToPhysical (p1.Y, false);
Point xPos2 = xAxis.WorldToPhysical (p2.X, false);
Point yPos2 = yAxis.WorldToPhysical (p2.Y, false);
Point xPos3 = xAxis.WorldToPhysical (p3.X, false);
Point yPos3 = yAxis.WorldToPhysical (p3.Y, false);
// do horizontal clipping here, to speed up
if ((p1.X<leftCutoff && p2.X<leftCutoff && p3.X<leftCutoff) || (p1.X>rightCutoff && p2.X>rightCutoff && p3.X>rightCutoff)) {
continue;
}
ctx.Save ();
ctx.SetColor (Color);
ctx.SetLineWidth (1);
if (!this.hideHorizontalSegments_) {
if (scale_ != 1) {
double middle = (xPos2.X + xPos1.X) / 2;
double width = xPos2.X - xPos1.X;
width *= this.scale_;
ctx.MoveTo (middle-width/2, yPos1.Y);
ctx.LineTo (middle+width/2, yPos2.Y);
}
else {
ctx.MoveTo (xPos1.X, yPos1.Y);
ctx.LineTo (xPos2.X, yPos2.Y);
}
ctx.Stroke ();
}
if (!this.hideVerticalSegments_) {
ctx.MoveTo (xPos2.X, yPos2.Y);
ctx.LineTo (xPos3.X, yPos3.Y);
ctx.Stroke ();
}
ctx.Restore ();
}
}
/// <summary>
/// Draws the line plot using the Context and Physical Axes provided
/// </summary>
/// <param name="ctx">The Drawing Context with which to draw.</param>
/// <param name="xAxis">The X-Axis to draw against.</param>
/// <param name="yAxis">The Y-Axis to draw against.</param>
/// <param name="drawShadow">If true draw the shadow for the line. If false, draw line.</param>
public void DrawLineOrShadow(Context ctx, PhysicalAxis xAxis, PhysicalAxis yAxis, bool drawShadow)
{
SequenceAdapter data = new SequenceAdapter (DataSource, DataMember, OrdinateData, AbscissaData);
ITransform2D t = Transform2D.GetTransformer (xAxis, yAxis);
int numberPoints = data.Count;
if (data.Count == 0) {
return;
}
ctx.Save ();
ctx.SetLineWidth (lineWidth_);
// clipping is now handled assigning a clip region in the
// graphic object before this call
if (numberPoints == 1) {
Point physical = t.Transform (data[0]);
if (drawShadow) {
ctx.SetColor (shadowColor_);
ctx.MoveTo (physical.X - 0.5 + ShadowOffset.X, physical.Y + ShadowOffset.Y);
ctx.LineTo (physical.X + 0.5 + ShadowOffset.X, physical.Y + ShadowOffset.Y);
ctx.Stroke ();
}
else {
ctx.SetColor (lineColor_);
ctx.MoveTo (physical.X-0.5, physical.Y);
ctx.LineTo (physical.X+0.5, physical.Y);
ctx.Stroke ();
}
}
else {
// prepare for clipping
double leftCutoff = xAxis.PhysicalToWorld (xAxis.PhysicalMin, false);
double rightCutoff = xAxis.PhysicalToWorld (xAxis.PhysicalMax, false);
if (leftCutoff > rightCutoff) {
Utils.Swap (ref leftCutoff, ref rightCutoff);
}
if (drawShadow) {
// correct cut-offs
double shadowCorrection =
xAxis.PhysicalToWorld (ShadowOffset, false) - xAxis.PhysicalToWorld (new Point(0,0), false);
leftCutoff -= shadowCorrection;
rightCutoff -= shadowCorrection;
}
for (int i = 1; i < numberPoints; ++i) {
// check to see if any values null. If so, then continue.
double dx1 = data[i-1].X;
double dx2 = data[i].X;
double dy1 = data[i-1].Y;
double dy2 = data[i].Y;
if (Double.IsNaN(dx1) || Double.IsNaN(dy1) || Double.IsNaN(dx2) || Double.IsNaN(dy2)) {
continue;
}
// do horizontal clipping here, to speed up
if ((dx1 < leftCutoff && dx2 < leftCutoff) || (rightCutoff < dx1 && rightCutoff < dx2)) {
continue;
}
// else draw line.
Point p1 = t.Transform (data[i-1]);
Point p2 = t.Transform (data[i]);
// when very far zoomed in, points can fall ontop of each other,
// and g.DrawLine throws an overflow exception
if (p1.Equals(p2)) {
continue;
}
if (drawShadow) {
ctx.SetColor (shadowColor_);
ctx.MoveTo (p1.X + ShadowOffset.X, p1.Y + ShadowOffset.Y);
ctx.LineTo (p2.X + ShadowOffset.X, p2.Y + ShadowOffset.Y);
ctx.Stroke ();
}
else {
ctx.SetColor (lineColor_);
ctx.MoveTo (p1.X, p1.Y);
ctx.LineTo (p2.X, p2.Y);
ctx.Stroke ();
}
}
}
ctx.Restore ();
}
/// <summary>
/// Draw a tick on the axis.
/// </summary>
/// <param name="ctx">The Drawing Context with on which to draw.</param>
/// <param name="w">The tick position in world coordinates.</param>
/// <param name="size">The size of the tick (in pixels)</param>
/// <param name="text">The text associated with the tick</param>
/// <param name="textOffset">The Offset to draw from the auto calculated position</param>
/// <param name="axisPhysMin">The minimum physical extent of the axis</param>
/// <param name="axisPhysMax">The maximum physical extent of the axis</param>
/// <param name="boundingBox">out: The bounding rectangle for the tick and tickLabel drawn</param>
/// <param name="labelOffset">out: offset from the axies required for axis label</param>
public virtual void DrawTick(
Context ctx,
double w,
double size,
string text,
Point textOffset,
Point axisPhysMin,
Point axisPhysMax,
out Point labelOffset,
out Rectangle boundingBox )
{
// determine physical location where tick touches axis.
Point tickStart = WorldToPhysical (w, axisPhysMin, axisPhysMax, true);
// determine offset from start point.
Point axisDir = Utils.UnitVector (axisPhysMin, axisPhysMax);
// rotate axisDir anti-clockwise by TicksAngle radians to get tick direction. Note that because
// the physical (pixel) origin is at the top left, a RotationTransform by a positive angle will
// be clockwise. Consequently, for anti-clockwise rotations, use cos(A-B), sin(A-B) formulae
double x1 = Math.Cos (TicksAngle) * axisDir.X + Math.Sin (TicksAngle) * axisDir.Y;
double y1 = Math.Cos (TicksAngle) * axisDir.Y - Math.Sin (TicksAngle) * axisDir.X;
// now get the scaled tick vector.
Point tickVector = new Point (TickScale * size * x1, TickScale * size * y1);
if (TicksCrossAxis) {
tickStart.X -= tickVector.X / 2;
tickStart.Y -= tickVector.Y / 2;
}
// and the end point [point off axis] of tick mark.
Point tickEnd = new Point (tickStart.X + tickVector.X, tickStart.Y + tickVector.Y);
// and draw it
ctx.SetLineWidth (1);
ctx.SetColor (LineColor);
ctx.MoveTo (tickStart.X+0.5, tickStart.Y+0.5);
ctx.LineTo (tickEnd.X+0.5, tickEnd.Y+0.5);
ctx.Stroke ();
// calculate bounds of tick.
double minX = Math.Min (tickStart.X, tickEnd.X);
double minY = Math.Min (tickStart.Y, tickEnd.Y);
double maxX = Math.Max (tickStart.X, tickEnd.X);
double maxY = Math.Max (tickStart.Y, tickEnd.Y);
boundingBox = new Rectangle (minX, minY, maxX-minX, maxY-minY);
// by default, label offset from axis is 0. TODO: revise this.
labelOffset = new Point (-tickVector.X, -tickVector.Y);
// ------------------------
// now draw associated text.
// **** TODO ****
// The following code needs revising. A few things are hard coded when
// they should not be. Also, angled tick text currently just works for
// the bottom x-axis. Also, it's a bit hacky.
if (text != "" && !HideTickText) {
TextLayout layout = new TextLayout ();
layout.Font = tickTextFontScaled;
layout.Text = text;
Size textSize = layout.GetSize ();
// determine the center point of the tick text.
double textCenterX;
double textCenterY;
// if text is at pointy end of tick.
if (!TickTextNextToAxis) {
// offset due to tick.
textCenterX = tickStart.X + tickVector.X*1.2;
textCenterY = tickStart.Y + tickVector.Y*1.2;
// offset due to text box size.
textCenterX += 0.5 * x1 * textSize.Width;
textCenterY += 0.5 * y1 * textSize.Height;
}
// else it's next to the axis.
else {
// start location.
textCenterX = tickStart.X;
textCenterY = tickStart.Y;
// offset due to text box size.
textCenterX -= 0.5 * x1 * textSize.Width;
textCenterY -= 0.5 * y1 * textSize.Height;
// bring text away from the axis a little bit.
textCenterX -= x1*(2.0+FontScale);
textCenterY -= y1*(2.0+FontScale);
}
// If tick text is angled..
if (TickTextAngle != 0) {
// determine the point we want to rotate text about.
Point textScaledTickVector = new Point (
TickScale * x1 * (textSize.Height/2),
TickScale * y1 * (textSize.Height/2) );
Point rotatePoint;
if (TickTextNextToAxis) {
rotatePoint = new Point (
tickStart.X - textScaledTickVector.X,
tickStart.Y - textScaledTickVector.Y);
}
else {
rotatePoint = new Point (
tickEnd.X + textScaledTickVector.X,
tickEnd.Y + textScaledTickVector.Y);
}
double actualAngle;
if (FlipTickText) {
double radAngle = TickTextAngle * Math.PI / 180;
rotatePoint.X += textSize.Width * Math.Cos (radAngle);
rotatePoint.Y += textSize.Width * Math.Sin (radAngle);
actualAngle = TickTextAngle + 180;
}
else {
actualAngle = TickTextAngle;
}
ctx.Save ();
ctx.Translate (rotatePoint.X, rotatePoint.Y);
ctx.Rotate (actualAngle);
Point [] recPoints = new Point [2];
recPoints[0] = new Point (0.0, -textSize.Height/2);
recPoints[1] = new Point (textSize.Width, textSize.Height);
ctx.TransformPoints (recPoints);
double t_x1 = Math.Min (recPoints[0].X, recPoints[1].X);
double t_x2 = Math.Max (recPoints[0].X, recPoints[1].X);
double t_y1 = Math.Min (recPoints[0].Y, recPoints[1].Y);
double t_y2 = Math.Max (recPoints[0].Y, recPoints[1].Y);
boundingBox = Rectangle.Union (boundingBox, new Rectangle (t_x1, t_y1, (t_x2-t_x1), (t_y2-t_y1)));
ctx.DrawTextLayout (layout, 0, -textSize.Height/2);
t_x2 -= tickStart.X;
t_y2 -= tickStart.Y;
t_x2 *= 1.25;
t_y2 *= 1.25;
labelOffset = new Point (t_x2, t_y2);
ctx.Restore ();
//ctx.Rectangle (boundingBox.X, boundingBox.Y, boundingBox.Width, boundingBox.Height);
//ctx.Stroke ();
}
else {
double bx1 = (textCenterX - textSize.Width/2);
double by1 = (textCenterY - textSize.Height/2);
double bx2 = textSize.Width;
double by2 = textSize.Height;
Rectangle drawRect = new Rectangle (bx1, by1, bx2, by2);
// ctx.Rectangle (drawRect);
boundingBox = Rectangle.Union (boundingBox, drawRect);
// ctx.Rectangle (boundingBox);
ctx.DrawTextLayout (layout, bx1, by1);
textCenterX -= tickStart.X;
textCenterY -= tickStart.Y;
textCenterX *= 2.3;
textCenterY *= 2.3;
labelOffset = new Point (textCenterX, textCenterY);
}
}
}
public virtual void Curves2 (Context ctx, double sx, double sy)
{
ctx.Save ();
ctx.Translate (sx, sy);
ctx.SetColor (Colors.Black);
double x = 0, y = 40;
double x1 = y - x, y1 = x1 + y, x2 = x + y, y2 = x, x3 = y1, y3 = y;
ctx.MoveTo (x, y);
ctx.CurveTo (x1, y1, x2, y2, x3, y3);
ctx.SetLineWidth (2.0);
ctx.Stroke ();
ctx.SetColor (new Color (1, 0.2, 0.2, 0.6));
ctx.SetLineWidth (1.0);
ctx.MoveTo (x, y);
ctx.LineTo (x1, y1);
ctx.MoveTo (x2, y2);
ctx.LineTo (x3, y3);
ctx.Stroke ();
ctx.Restore ();
}
public virtual void Texts(Xwt.Drawing.Context ctx, double x, double y)
{
ctx.Save();
ctx.Translate(x, y);
ctx.SetColor(Colors.Black);
var col1 = new Rectangle();
var col2 = new Rectangle();
var text = new TextLayout();
text.Font = this.Font.WithSize(24);
Console.WriteLine(text.Font.Size);
// first text
text.Text = "Lorem ipsum dolor sit amet,";
var size1 = text.GetSize();
col1.Width = size1.Width;
col1.Height += size1.Height + 10;
ctx.DrawTextLayout(text, 0, 0);
// proofing width; test should align with text above
ctx.SetColor(Colors.DarkMagenta);
text.Text = "consetetur sadipscing elitr, sed diam nonumy";
text.Width = col1.Width;
var size2 = text.GetSize();
ctx.DrawTextLayout(text, 0, col1.Bottom);
col1.Height += size2.Height + 10;
ctx.SetColor(Colors.Black);
// proofing scale, on second col
ctx.Save();
ctx.SetColor(Colors.Red);
col2.Left = col1.Right + 10;
text.Text = "eirmod tempor invidunt ut.";
var scale = 1.2;
text.Width = text.Width / scale;
var size3 = text.GetSize();
col2.Height = size3.Height * scale;
col2.Width = size3.Width * scale + 5;
ctx.Scale(scale, scale);
ctx.DrawTextLayout(text, col2.Left / scale, col2.Top / scale);
ctx.Restore();
// proofing heigth, on second col
ctx.Save();
ctx.SetColor(Colors.DarkCyan);
text.Text = "Praesent ac lacus nec dolor pulvinar feugiat a id elit.";
var size4 = text.GetSize();
text.Height = size4.Height / 2;
text.Trimming = TextTrimming.WordElipsis;
ctx.DrawTextLayout(text, col2.Left, col2.Bottom + 5);
ctx.SetLineWidth(1);
ctx.SetColor(Colors.Blue);
ctx.Rectangle(new Rectangle(col2.Left, col2.Bottom + 5, text.Width, text.Height));
ctx.Stroke();
ctx.Restore();
// drawing col line
ctx.SetLineWidth(1);
ctx.SetColor(Colors.Black.WithAlpha(.5));
ctx.MoveTo(col1.Right + 5, col1.Top);
ctx.LineTo(col1.Right + 5, col1.Bottom);
ctx.Stroke();
ctx.MoveTo(col2.Right + 5, col2.Top);
ctx.LineTo(col2.Right + 5, col2.Bottom);
ctx.Stroke();
ctx.SetColor(Colors.Black);
// proofing rotate, and printing size to see the values
ctx.Save();
text.Font = this.Font.WithSize(10);
text.Text = string.Format("Size 1 {0}\r\nSize 2 {1}\r\nSize 3 {2} Scale {3}",
size1, size2, size3, scale);
text.Width = -1; // this clears textsize
text.Height = -1;
ctx.Rotate(5);
// maybe someone knows a formula with angle and textsize to calculyte ty
var ty = 30;
ctx.DrawTextLayout(text, ty, col1.Bottom + 10);
ctx.Restore();
// scale example here:
ctx.Restore();
TextLayout tl0 = new TextLayout(this);
tl0.Font = this.Font.WithSize(10);
tl0.Text = "This text contains attributes.";
tl0.SetUnderline(0, "This".Length);
tl0.SetForeground(new Color(0, 1.0, 1.0), "This ".Length, "text".Length);
tl0.SetBackground(new Color(0, 0, 0), "This ".Length, "text".Length);
tl0.SetFontWeight(FontWeight.Bold, "This text ".Length, "contains".Length);
tl0.SetFontStyle(FontStyle.Italic, "This text ".Length, "contains".Length);
tl0.SetStrikethrough("This text contains ".Length, "attributes".Length);
ctx.DrawTextLayout(tl0, col2.Left, col2.Bottom + 100);
// Text boces
y = 180;
// Without wrapping
TextLayout tl = new TextLayout(this);
tl.Text = "Stright text";
DrawText(ctx, tl, ref y);
// With wrapping
tl = new TextLayout(this);
tl.Text = "The quick brown fox jumps over the lazy dog";
tl.Width = 100;
DrawText(ctx, tl, ref y);
// With blank lines
tl = new TextLayout(this);
tl.Text = "\nEmpty line above\nLine break above\n\nEmpty line above\n\n\nTwo empty lines above\nEmpty line below\n";
tl.Width = 200;
DrawText(ctx, tl, ref y);
}
public void Path (Context ctx, double px, double py)
{
ctx.Save ();
ctx.Translate (px, py);
var path = new DrawingPath ();
path.MoveTo (0.44, 18);
path.LineTo (-1, 18);
path.LineTo (-1, 26);
path.LineTo (0.44, 26);
path.LineTo (0, 42);
path.LineTo (29, 21.98);
path.LineTo (29, 21.98);
path.LineTo (0, 2);
path.LineTo (0.44, 18);
ctx.AppendPath (path);
ctx.SetColor (Colors.Black);
ctx.SetLineWidth (2);
ctx.Stroke ();
var path2 = path.CopyPath ();
path2.LineTo (15, 8);
path2.ClosePath ();
ctx.Rotate (180);
ctx.AppendPath (path2);
ctx.SetColor (Colors.Red);
ctx.SetLineDash (0, 5);
ctx.Stroke ();
ctx.Restore ();
}
protected override void OnDraw (Context ctx, Rectangle dirtyRect)
{
double width = Size.Width - padding * 2;
int range = (int)Size.Height - padding * 2;
for (int n=0; n < range; n++) {
ctx.Rectangle (padding, padding + n, width, 1);
ctx.SetColor (Color.FromHsl (hue, saturation, (double)(range - n - 1) / (double)(range - 1)));
ctx.Fill ();
}
ctx.Rectangle (0.5, padding + (int)(((double)range) * (1-light)) + 0.5 - 2, Size.Width - 1, 4);
ctx.SetColor (Colors.Black);
ctx.SetLineWidth (1);
ctx.Stroke ();
}
public virtual void Scale(Context ctx, double ax, double ay)
{
ctx.Save ();
ctx.Translate (ax, ay);
ctx.SetColor (Colors.Black);
ctx.SetLineWidth (1);
var x = 0d;
var y = 0d;
var w = 10d;
var inc = .1d;
for (var i = inc; i < 3.5d; i +=inc) {
ctx.Save ();
ctx.Scale (i, i);
ctx.Rectangle (x, y, w, w);
ctx.SetColor (Colors.Yellow.WithAlpha (1 / i));
ctx.FillPreserve ();
ctx.SetColor (Colors.Red.WithAlpha (1 / i));
ctx.Stroke ();
ctx.MoveTo (x += w * inc, y += w * inc / 3);
ctx.Restore ();
}
ctx.Restore ();
}
/// <summary>
/// Draws a representation of the horizontal line in the legend.
/// </summary>
/// <param name="ctx">The Drawing Context with which to draw</param>
/// <param name="startEnd">A rectangle specifying the bounds of the area in the legend set aside for drawing</param>
public void DrawInLegend(Context ctx, Rectangle startEnd)
{
ctx.Save ();
ctx.MoveTo (startEnd.Left, (startEnd.Top + startEnd.Bottom)/2);
ctx.LineTo (startEnd.Right, (startEnd.Top + startEnd.Bottom)/2);
ctx.SetColor (color_);
ctx.SetLineWidth (1);
ctx.Stroke ();
ctx.Restore ();
}
void Draw (Context ctx, bool fill)
{
var parent = (RoundedFrameBox)Parent;
var border = parent.BorderSpacing;
var radius = parent.cornerRadius;
var rect = Bounds;
ctx.MoveTo (rect.X, rect.Y);
if (border.Top > 0) {
ctx.NewPath ();
if (radius.TopLeft > 0)
ctx.Arc (rect.Left + radius.TopLeft + border.Left / 2, rect.Top + radius.TopLeft + border.Top / 2, radius.TopLeft, 180, 270);
else
PathTo (ctx, rect.Left, rect.Top + border.Top / 2, fill);
if (radius.TopRight > 0) {
ctx.LineTo (rect.Right - (radius.TopRight + border.Right / 2), rect.Top + border.Top / 2);
ctx.Arc (rect.Right - (radius.TopRight + border.Right / 2), rect.Top + radius.TopRight + border.Top / 2, radius.TopRight, 270, 0);
} else
ctx.LineTo (rect.Right, rect.Top + border.Top / 2);
} else
PathTo (ctx, rect.Right - border.Right / 2, rect.Top, fill);
if (border.Right > 0)
// TODO: round corners if top/bottom border disabled
ctx.LineTo (rect.Right - border.Right / 2, rect.Bottom - (border.Bottom > 0 ? radius.BottomRight : 0));
else
PathTo (ctx, rect.Right - border.Right / 2, rect.Bottom - (border.Bottom > 0 ? radius.BottomRight : 0), fill);
if (border.Bottom > 0) {
if (radius.BottomRight > 0)
ctx.Arc (rect.Right - (radius.BottomRight + border.Right / 2), rect.Bottom - (radius.BottomRight + border.Bottom / 2), radius.BottomRight, 0, 90);
else
PathTo (ctx, rect.Right, rect.Bottom - border.Bottom / 2, fill);
if (radius.BottomLeft > 0) {
ctx.LineTo (rect.Left + (radius.BottomLeft + border.Left / 2), rect.Bottom - border.Bottom / 2);
ctx.Arc (rect.Left + radius.BottomLeft + border.Left / 2, rect.Bottom - (radius.BottomLeft + border.Bottom / 2), radius.BottomLeft, 90, 180);
} else
ctx.LineTo (rect.Left + border.Left / 2, rect.Bottom - border.Bottom / 2);
} else
PathTo (ctx, rect.Left + border.Left / 2, rect.Bottom - border.Bottom / 2, fill);
if (border.Left > 0)
// TODO: round corners if top/bottom border disabled
ctx.LineTo (rect.Left + border.Left / 2, rect.Top + (border.Top > 0 ? radius.TopLeft : 0));
else
PathTo (ctx, rect.Left + border.Left / 2, rect.Top + (border.Top > 0 ? radius.TopLeft : 0), fill);
if (fill) {
ctx.SetColor (parent.innerColor);
ctx.Fill ();
} else {
ctx.SetColor (parent.borderColor);
ctx.SetLineWidth (parent.borderWidth);
ctx.Stroke ();
}
}
