void DrawFoldSegment(Xwt.Drawing.Context ctx, double x, double y, bool isOpen, bool isSelected) { var drawArea = new Rectangle(System.Math.Floor(x + (Width - foldSegmentSize) / 2) + 0.5, System.Math.Floor(y + (editor.LineHeight - foldSegmentSize) / 2) + 0.5, foldSegmentSize, foldSegmentSize); ctx.Rectangle(drawArea); ctx.SetSourceColor(isOpen ? foldBgGC : foldToggleMarkerBackground); ctx.FillPreserve(); ctx.SetSourceColor(isSelected ? foldLineHighlightedGC : foldLineGC); ctx.Stroke(); ctx.DrawLine(isSelected ? foldLineHighlightedGC : foldToggleMarkerGC, drawArea.X + drawArea.Width * 2 / 10, drawArea.Y + drawArea.Height / 2, drawArea.X + drawArea.Width - drawArea.Width * 2 / 10, drawArea.Y + drawArea.Height / 2); if (!isOpen) { ctx.DrawLine(isSelected ? foldLineHighlightedGC : foldToggleMarkerGC, drawArea.X + drawArea.Width / 2, drawArea.Y + drawArea.Height * 2 / 10, drawArea.X + drawArea.Width / 2, drawArea.Y + drawArea.Height - drawArea.Height * 2 / 10); } }
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 (); }
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 (); }
public override bool DrawBackground(TextEditor editor, Xwt.Drawing.Context cr, double y, LineMetrics metrics) { var caretOffset = editor.Caret.Offset - BaseOffset; foreach (var link in mode.Links) { if (!link.IsEditable) { continue; } bool isPrimaryHighlighted = link.PrimaryLink.Offset <= caretOffset && caretOffset <= link.PrimaryLink.EndOffset; foreach (TextSegment segment in link.Links) { if ((BaseOffset + segment.Offset <= metrics.TextStartOffset && metrics.TextStartOffset < BaseOffset + segment.EndOffset) || (metrics.TextStartOffset <= BaseOffset + segment.Offset && BaseOffset + segment.Offset < metrics.TextEndOffset)) { int strOffset = BaseOffset + segment.Offset - metrics.TextStartOffset; int strEndOffset = BaseOffset + segment.EndOffset - metrics.TextStartOffset; var x_pos = metrics.Layout.Layout.IndexToPos(strOffset).X; var x_pos2 = metrics.Layout.Layout.IndexToPos(strEndOffset).X; x_pos = (int)(x_pos); x_pos2 = (int)(x_pos2); Color fillGc, rectangleGc; if (segment == link.PrimaryLink) { fillGc = isPrimaryHighlighted ? editor.ColorStyle.PrimaryTemplateHighlighted.SecondColor : editor.ColorStyle.PrimaryTemplate.SecondColor; rectangleGc = isPrimaryHighlighted ? editor.ColorStyle.PrimaryTemplateHighlighted.SecondColor : editor.ColorStyle.PrimaryTemplate.SecondColor; } else { fillGc = isPrimaryHighlighted ? editor.ColorStyle.SecondaryTemplateHighlighted.SecondColor : editor.ColorStyle.SecondaryTemplate.SecondColor; rectangleGc = isPrimaryHighlighted ? editor.ColorStyle.SecondaryTemplateHighlighted.Color : editor.ColorStyle.SecondaryTemplate.Color; } // Draw segment double x1 = metrics.TextRenderStartPosition + x_pos - 1; double x2 = metrics.TextRenderStartPosition + x_pos2 - 1 + 0.5; cr.Rectangle(x1 + 0.5, y + 0.5, x2 - x1, editor.LineHeight - 1); cr.SetSourceColor(fillGc); cr.FillPreserve(); cr.SetSourceColor(rectangleGc); cr.Stroke(); } } } return(true); }
void DrawBookmark (Context cr, double x, double y) { var color1 = Style.BookmarkColor1; var color2 = Style.BookmarkColor2; DrawRoundRectangle (cr, x + 1, y + 1, 8, Width - 4, Editor.LineHeight - 4); using (var pat = new LinearGradient (x + Width / 4, y, x + Width / 2, y + Editor.LineHeight - 4)) { pat.AddColorStop (0, color1); pat.AddColorStop (1, color2); cr.Pattern = pat; cr.FillPreserve (); } using (var pat = new LinearGradient (x, y + Editor.LineHeight, x + Width, y)) { pat.AddColorStop (0, color2); //pat.AddColorStop (1, color1); cr.Pattern = pat; cr.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 (); }
void DrawCursor (Context ctx, ChartCursor cursor) { ctx.SetColor (cursor.Color); double x, y; GetPoint (cursor.Value, cursor.Value, out x, out y); if (cursor.Dimension == AxisDimension.X) { double cy = top - AreaBorderWidth - 1; ctx.MoveTo (x, cy); ctx.LineTo (x + (cursor.HandleSize/2), cy - cursor.HandleSize + 1); ctx.LineTo (x - (cursor.HandleSize/2), cy - cursor.HandleSize + 1); ctx.ClosePath (); if (activeCursor == cursor) ctx.FillPreserve (); ctx.Stroke (); ctx.MoveTo (x, top); ctx.RelLineTo (0, height); ctx.Stroke (); } else { throw new NotSupportedException (); } }
/// <summary> /// Draws a representation of this plot in the legend. /// </summary> /// <param name="ctx">The Drawing Context with which to draw.</param> /// <param name="r"> /// A rectangle specifying the bounds of the area in the legend set aside for drawing /// </param> public void DrawInLegend(Context ctx, Rectangle r) { ctx.Save (); ctx.SetLineWidth (1); ctx.Rectangle (r); if (Filled) { if (FillGradient != null) { // Scale FillGradient to bar rectangle double sX = r.X + fillGradient.StartPoint.X * r.Width; double sY = r.Y + fillGradient.StartPoint.Y * r.Height; double eX = r.X + fillGradient.EndPoint.X * r.Width; double eY = r.Y + fillGradient.EndPoint.Y * r.Height; LinearGradient g = new LinearGradient (sX, sY, eX, eY); g.AddColorStop (0, FillGradient.StartColor); g.AddColorStop (1, FillGradient.EndColor); ctx.Pattern = g; } else { ctx.SetColor (FillColor); } ctx.FillPreserve (); } ctx.SetColor (BorderColor); ctx.Stroke (); ctx.Restore (); }
/// <summary> /// Draws a representation of this plot in the legend. /// </summary> /// <param name="g">The graphics surface on which to draw.</param> /// <param name="startEnd">A rectangle specifying the bounds of the area in the legend set aside for drawing.</param> public virtual void DrawInLegend(Context ctx, Rectangle startEnd) { double smallerHeight = (startEnd.Height * 0.5); //double heightToRemove = (startEnd.Height * 0.5f); ctx.Save (); ctx.SetColor (fillColor); Rectangle newRectangle = new Rectangle (startEnd.Left, startEnd.Top + smallerHeight/2, startEnd.Width, smallerHeight); ctx.Rectangle (newRectangle); ctx.FillPreserve (); ctx.SetColor (borderColor); ctx.Stroke (); ctx.Restore (); }
protected override void OnDraw(Context ctx, Rectangle dirtyRect) { base.OnDraw (ctx, dirtyRect); if (!pset) { ParentWindow.BoundsChanged += delegate { QueueDraw (); }; pset = true; } ctx.Rectangle (Bounds); ctx.SetColor (Colors.LightGray); ctx.Fill (); var size = Size; size.Width--; size.Height--; var fx = size.Width / Desktop.Bounds.Width; if (Desktop.Bounds.Height * fx > size.Height) fx = size.Height / Desktop.Bounds.Height; if (Desktop.Bounds.X < 0) ctx.Translate (-Desktop.Bounds.X * fx, 0); if (Desktop.Bounds.Y < 0) ctx.Translate (0, -Desktop.Bounds.Y * fx); ctx.SetLineWidth (1); foreach (var s in Desktop.Screens) { if (s.Bounds != s.VisibleBounds) { var vr = new Rectangle ((int)(s.Bounds.X * fx), (int)(s.Bounds.Y * fx), (int)(s.Bounds.Width * fx), (int)(s.Bounds.Height * fx)); vr = vr.Offset (0.5, 0.5); ctx.Rectangle (vr); ctx.SetColor (Colors.White); ctx.FillPreserve (); ctx.SetColor (Colors.Black); ctx.Stroke (); } var r = new Rectangle ((int)(s.VisibleBounds.X * fx), (int)(s.VisibleBounds.Y * fx), (int)(s.VisibleBounds.Width * fx), (int)(s.VisibleBounds.Height * fx)); r = r.Offset (0.5, 0.5); ctx.Rectangle (r); ctx.SetColor (new Color (0.4, 0.62, 0.83)); ctx.FillPreserve (); ctx.SetColor (Colors.Black); ctx.Stroke (); TextLayout tl = new TextLayout (ctx); tl.Text = s.DeviceName; tl.Font = Font; ctx.DrawTextLayout (tl, r.Center.X - tl.Width / 2, r.Center.Y - tl.Height / 2); } var wr = ParentWindow.ScreenBounds; wr = new Rectangle ((int)(wr.X * fx), (int)(wr.Y * fx), (int)(wr.Width * fx), (int)(wr.Height * fx)); ctx.Rectangle (wr); ctx.SetColor (Colors.Azure.WithAlpha (0.5)); ctx.FillPreserve (); ctx.SetColor (Colors.Azure); ctx.Stroke (); }
/// <summary> /// Draws a representation of this plot 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.Rectangle (startEnd); if (Filled) { ctx.SetColor (fillColor); ctx.FillPreserve (); } ctx.Stroke (); ctx.Restore (); }
/// <summary> /// Draws the histogram. /// </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) { double yoff; SequenceAdapter data = new SequenceAdapter (DataSource, DataMember, OrdinateData, AbscissaData); ctx.Save (); ctx.SetLineWidth (1); for (int i=0; i<data.Count; ++i ) { // (1) determine the top left hand point of the bar (assuming not centered) Point p1 = data[i]; if (double.IsNaN(p1.X) || double.IsNaN(p1.Y)) { continue; } // (2) determine the top right hand point of the bar (assuming not centered) Point p2 = Point.Zero;; if (i+1 != data.Count) { p2 = data[i+1]; if (double.IsNaN(p2.X) || double.IsNaN(p2.Y)) { continue; } p2.Y = p1.Y; } else if (i != 0) { p2 = data[i-1]; if (double.IsNaN(p2.X) || double.IsNaN(p2.Y)) { continue; } double offset = p1.X - p2.X; p2.X = p1.X + offset; p2.Y = p1.Y; } else { double offset = 1.0; p2.X = p1.X + offset; p2.Y = p1.Y; } // (3) now account for plots this may be stacked on top of. HistogramPlot currentPlot = this; yoff = 0.0; double yval = 0.0; while (currentPlot.isStacked_) { SequenceAdapter stackedToData = new SequenceAdapter ( currentPlot.stackedTo_.DataSource, currentPlot.stackedTo_.DataMember, currentPlot.stackedTo_.OrdinateData, currentPlot.stackedTo_.AbscissaData ); yval += stackedToData[i].Y; yoff = yAxis.WorldToPhysical (yval, false).Y; p1.Y += stackedToData[i].Y; p2.Y += stackedToData[i].Y; currentPlot = currentPlot.stackedTo_; } // (4) now account for centering if (center_) { double offset = (p2.X - p1.X) / 2.0; p1.X -= offset; p2.X -= offset; } // (5) now account for BaseOffset (shift of bar sideways). p1.X += baseOffset_; p2.X += baseOffset_; // (6) now get physical coordinates of top two points. Point xPos1 = xAxis.WorldToPhysical (p1.X, false); Point yPos1 = yAxis.WorldToPhysical (p1.Y, false); Point xPos2 = xAxis.WorldToPhysical (p2.X, false); if (isStacked_) { currentPlot = this; while (currentPlot.isStacked_) { currentPlot = currentPlot.stackedTo_; } baseWidth_ = currentPlot.baseWidth_; } double width = xPos2.X - xPos1.X; double height; if (isStacked_) { height = -yPos1.Y+yoff; } else { height = -yPos1.Y+yAxis.PhysicalMin.Y; } double xoff = (1.0 - baseWidth_)/2.0*width; Rectangle r = new Rectangle (xPos1.X+xoff, yPos1.Y, width-2*xoff, height); ctx.Rectangle (r); if (Filled) { if (r.Height != 0 && r.Width != 0) { // room for optimization maybe. ctx.SetColor (fillColor); ctx.FillPreserve (); } } ctx.SetColor (borderColor); ctx.Stroke (); } ctx.Restore (); }
/// <summary> /// Raises the draw event. /// </summary> /// <param name="ctx">Context.</param> /// <param name="dirtyRect">Dirty rect.</param> protected override void OnDraw(Context ctx, Rectangle dirtyRect) { base.OnDraw(ctx, dirtyRect); ctx.SetLineWidth(1.0); if (previous != null && !previous.Active) { ctx.SetColor(deactiveColor); if (Multiple) { ctx.Rectangle(0, 0, Lean.Dx * 2, Size.Height); ctx.Fill(); ctx.SetColor(borderColor); ctx.MoveTo(0, 0); ctx.LineTo(Lean.Dx * 2, 0); ctx.Stroke(); } else { ctx.MoveTo(0, 0); ctx.CurveTo( 0, 0, Lean.Dx, 0, Lean.Dx, Lean.Dy); ctx.LineTo(Lean.Dx, Size.Height - Lean.Dy); ctx.CurveTo( Lean.Dx, Size.Height - Lean.Dy, Lean.Dx, Size.Height + 0.5, Lean.Dx * 2, Size.Height + 0.5); ctx.LineTo(0, Size.Height); ctx.FillPreserve(); ctx.SetColor(borderColor); ctx.Stroke(); } } if (previous == null || Multiple || !previous.Active) { ctx.MoveTo(0, Size.Height + 0.5); ctx.CurveTo( 0, Size.Height + 0.5, Lean.Dx, Size.Height + 0.5, Lean.Dx, Size.Height - Lean.Dy); } else { ctx.MoveTo(Lean.Dx, Size.Height); } ctx.LineTo(Lean.Dx, Lean.Dy); ctx.CurveTo( Lean.Dx, Lean.Dy, Lean.Dx, 0, Lean.Dx * 2, 0); if (next == null) { ctx.LineTo(Size.Width - (Lean.Dx * 2), 0); ctx.CurveTo( Size.Width - (Lean.Dx * 2), 0, Size.Width - Lean.Dx, 0, Size.Width - Lean.Dx, Lean.Dy); ctx.LineTo(Size.Width - Lean.Dx, Size.Height - Lean.Dy); ctx.CurveTo( Size.Width - Lean.Dx, Size.Height - Lean.Dy, Size.Width - Lean.Dx, Size.Height, Size.Width, Size.Height); } else { ctx.LineTo(Size.Width, 0); ctx.LineTo(Size.Width, Size.Height); } ctx.SetColor(Active ? activeColor : deactiveColor); ctx.Fill(); // border if (previous == null || Multiple || !previous.Active) { ctx.MoveTo(0, Size.Height + 0.5); ctx.CurveTo( 0, Size.Height + 0.5, Lean.Dx, Size.Height + 0.5, Lean.Dx, Size.Height - Lean.Dy); } else { ctx.MoveTo(Lean.Dx, Size.Height + 0.5 - Lean.Dy); } ctx.LineTo(Lean.Dx, Lean.Dy); ctx.CurveTo( Lean.Dx, Lean.Dy, Lean.Dx, 0, Lean.Dx * 2, 0); if (next == null) { ctx.LineTo(Size.Width - (Lean.Dx * 2), 0); ctx.CurveTo( Size.Width - (Lean.Dx * 2), 0, Size.Width - Lean.Dx, 0, Size.Width - Lean.Dx, Lean.Dy); ctx.LineTo(Size.Width - Lean.Dx, Size.Height - Lean.Dy); ctx.CurveTo( Size.Width - Lean.Dx, Size.Height - Lean.Dy, Size.Width - Lean.Dx, Size.Height + 0.5, Size.Width, Size.Height + 0.5); } else { ctx.LineTo(Size.Width, 0); } ctx.SetColor(borderColor); ctx.Stroke(); if (previous != null && previous.Active) { ctx.SetColor(activeColor); if (Multiple) { ctx.Rectangle(0, 0, Lean.Dx * 2, Size.Height); ctx.Fill(); ctx.SetColor(borderColor); ctx.MoveTo(0, 0); ctx.LineTo(Lean.Dx * 2, 0); ctx.Stroke(); } else { ctx.MoveTo(0, 0); ctx.CurveTo( 0, 0, Lean.Dx, 0, Lean.Dx, Lean.Dy); ctx.LineTo(Lean.Dx, Size.Height - Lean.Dy); ctx.CurveTo( Lean.Dx, Size.Height - Lean.Dy, Lean.Dx, Size.Height + 0.5, Lean.Dx * 2, Size.Height + 0.5); ctx.LineTo(0, Size.Height); ctx.FillPreserve(); ctx.SetColor(borderColor); ctx.Stroke(); } } // text ctx.SetColor(Active ? Colors.AliceBlue : deactiveTextColor); ctx.DrawTextLayout(text, new Point(padding.Left + Lean.Dx + 2, padding.Top)); // close button if (Closeable) { ctx.DrawImage(Hovered ? closeSelected : (Active ? closeNormalInv : closeNormal), new Point( Size.Width - closeNormal.Width - (next == null ? padding.Right + Lean.Dx : 0), (Size.Height - closeNormal.Height) / 2 ) ); } }
/// <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 marker at the given position /// </summary> /// <param name="ctx">The Drawing Context with which to draw.</param> /// <param name="x">The [physical] x position to draw the marker.</param> /// <param name="y">The [physical] y position to draw the marker.</param> public void Draw(Context ctx, double x, double y ) { ctx.Save (); ctx.SetLineWidth (lineWidth); ctx.SetColor (lineColor); switch (markerType) { case MarkerType.Cross1: ctx.MoveTo (x-h, y+h); ctx.LineTo (x+h, y-h); ctx.MoveTo (x+h, y+h); ctx.LineTo (x-h, y-h); ctx.Stroke (); break; case MarkerType.Cross2: ctx.MoveTo (x, y-h); ctx.LineTo (x, y+h); ctx.MoveTo (x-h, y); ctx.LineTo (x+h, y); ctx.Stroke (); break; case MarkerType.Circle: ctx.MoveTo (x+h,y); ctx.Arc (x, y, h, 0, 360); ctx.ClosePath (); if (filled ) { ctx.SetColor (fillColor); ctx.FillPreserve (); } ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.Square: ctx.Rectangle (x-h, y-h, size, size); ctx.ClosePath (); if (filled) { ctx.SetColor (fillColor); ctx.FillPreserve (); } ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.Triangle: ctx.MoveTo (x-h, y+h); ctx.LineTo (x, y-h); ctx.LineTo (x+h, y+h); ctx.ClosePath (); if (filled) { ctx.SetColor (fillColor); ctx.FillPreserve (); } ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.TriangleDown: ctx.MoveTo (x-h, y-h); ctx.LineTo (x, y+h); ctx.LineTo (x+h, y-h); ctx.ClosePath (); if (filled) { ctx.SetColor (fillColor); ctx.FillPreserve (); } ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.FilledCircle: ctx.MoveTo (x+h,y); ctx.Arc (x, y, h, 0, 360); ctx.ClosePath (); ctx.SetColor (fillColor); ctx.FillPreserve (); ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.FilledSquare: ctx.Rectangle (x-h, y-h, size, size); ctx.ClosePath (); ctx.SetColor (fillColor); ctx.FillPreserve (); ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.FilledTriangle: ctx.MoveTo (x-h, y+h); ctx.LineTo (x, y-h); ctx.LineTo (x+h, y+h); ctx.ClosePath (); ctx.SetColor (fillColor); ctx.FillPreserve (); ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.Diamond: ctx.MoveTo (x-h, y); ctx.LineTo (x, y-h); ctx.LineTo (x+h, y); ctx.LineTo (x, y+h); ctx.ClosePath (); if (filled) { ctx.SetColor (fillColor); ctx.FillPreserve (); } ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.Flag: ctx.MoveTo (x, y-size); ctx.LineTo (x+size, y-size+size/3); ctx.LineTo (x, y-size+2*size/3); ctx.ClosePath (); ctx.MoveTo (x, y); ctx.LineTo (x, y-size); if (filled) { ctx.SetColor (fillColor); ctx.FillPreserve (); } ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.FlagDown: ctx.MoveTo (x, y+size); ctx.LineTo (x+size, y+size-size/3); ctx.LineTo (x, y+size-2*size/3); ctx.ClosePath (); ctx.MoveTo (x, y); ctx.LineTo (x, y+size); if (filled) { ctx.SetColor (fillColor); ctx.FillPreserve (); } ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.FilledFlag: ctx.MoveTo (x, y-size); ctx.LineTo (x+size, y-size+size/3); ctx.LineTo (x, y-size+2*size/3); ctx.ClosePath (); ctx.MoveTo (x, y); ctx.LineTo (x, y-size); ctx.SetColor (fillColor); ctx.FillPreserve (); ctx.SetColor (lineColor); ctx.Stroke (); break; case MarkerType.None: break; } ctx.Restore (); }
/// <summary> /// Draw The legend /// </summary> /// <param name="ctx">The Drawing Context with on which to draw</param> /// <param name="position">The position of the top left of the axis.</param> /// <param name="plots">Array of plot objects to appear in the legend.</param> /// <param name="scale">if the legend is set to scale, the amount to scale by.</param> /// <returns>bounding box</returns> public Rectangle Draw(Context ctx, Point position, ArrayList plots, double scale ) { // first of all determine the Font to use in the legend. Font textFont; if (AutoScaleText) { textFont = font_.WithScaledSize (scale); } else { textFont = font_; } ctx.Save (); // determine max width and max height of label strings and // count the labels. int labelCount = 0; int unnamedCount = 0; double maxHt = 0; double maxWd = 0; TextLayout layout = new TextLayout (); layout.Font = textFont; for (int i=0; i<plots.Count; ++i) { if (!(plots[i] is IPlot)) { continue; } IPlot p = (IPlot)plots[i]; if (!p.ShowInLegend) { continue; } string label = p.Label; if (label == "") { unnamedCount += 1; label = "Series " + unnamedCount.ToString(); } layout.Text = label; Size labelSize = layout.GetSize (); if (labelSize.Height > maxHt) { maxHt = labelSize.Height; } if (labelSize.Width > maxWd) { maxWd = labelSize.Width; } ++labelCount; } bool extendingHorizontally = numberItemsHorizontally_ == -1; bool extendingVertically = numberItemsVertically_ == -1; // determine width in legend items count units. int widthInItemCount = 0; if (extendingVertically) { if (labelCount >= numberItemsHorizontally_) { widthInItemCount = numberItemsHorizontally_; } else { widthInItemCount = labelCount; } } else if (extendingHorizontally) { widthInItemCount = labelCount / numberItemsVertically_; if (labelCount % numberItemsVertically_ != 0) widthInItemCount += 1; } else { throw new NPlotException( "logic error in legend base" ); } // determine height of legend in items count units. int heightInItemCount = 0; if (extendingHorizontally) { if (labelCount >= numberItemsVertically_) { heightInItemCount = numberItemsVertically_; } else { heightInItemCount = labelCount; } } else { // extendingVertically heightInItemCount = labelCount / numberItemsHorizontally_; if (labelCount % numberItemsHorizontally_ != 0) heightInItemCount += 1; } double lineLength = 20; double hSpacing = (int)(5.0f * scale); double vSpacing = (int)(3.0f * scale); double boxWidth = (int) ((float)widthInItemCount * (lineLength + maxWd + hSpacing * 2.0f ) + hSpacing); double boxHeight = (int)((float)heightInItemCount * (maxHt + vSpacing) + vSpacing); double totalWidth = boxWidth; double totalHeight = boxHeight; // draw box around the legend. if (BorderStyle == BorderType.Line) { ctx.SetColor (bgColor_); ctx.Rectangle (position.X, position.Y, boxWidth, boxHeight); ctx.FillPreserve (); ctx.SetColor (borderColor_); ctx.Stroke (); } else if (BorderStyle == BorderType.Shadow) { double offset = (4.0 * scale); Color shade = Colors.Gray; shade.Alpha = 0.5; ctx.SetColor (Colors.Gray); ctx.Rectangle (position.X+offset, position.Y+offset, boxWidth, boxHeight); ctx.Fill (); ctx.SetColor (bgColor_); ctx.Rectangle (position.X, position.Y, boxWidth, boxHeight); ctx.FillPreserve (); ctx.SetColor (borderColor_); ctx.Stroke (); totalWidth += offset; totalHeight += offset; } /* else if ( this.BorderStyle == BorderType.Curved ) { // TODO. make this nice. } */ else { // do nothing. } // now draw entries in box.. labelCount = 0; unnamedCount = 0; int plotCount = -1; for (int i=0; i<plots.Count; ++i) { if (!(plots[i] is IPlot)) { continue; } IPlot p = (IPlot)plots[i]; if (!p.ShowInLegend) { continue; } plotCount += 1; double xpos, ypos; if (extendingVertically) { xpos = plotCount % numberItemsHorizontally_; ypos = plotCount / numberItemsHorizontally_; } else { xpos = plotCount / numberItemsVertically_; ypos = plotCount % numberItemsVertically_; } double lineXPos = (position.X + hSpacing + xpos * (lineLength + maxWd + hSpacing * 2.0)); double lineYPos = (position.Y + vSpacing + ypos * (vSpacing + maxHt)); p.DrawInLegend (ctx, new Rectangle (lineXPos, lineYPos, lineLength, maxHt)); double textXPos = lineXPos + hSpacing + lineLength; double textYPos = lineYPos; string label = p.Label; if (label == "") { unnamedCount += 1; label = "Series " + unnamedCount.ToString(); } layout.Text = label; ctx.DrawTextLayout (layout, textXPos, textYPos); ++labelCount; } ctx.Restore (); return new Rectangle (position.X, position.Y, totalWidth, totalHeight); }
/// <summary> /// Draws the histogram. /// </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) { double yoff; SequenceAdapter data = new SequenceAdapter (DataSource, DataMember, OrdinateData, AbscissaData); ctx.Save (); ctx.SetLineWidth (1); for (int i=0; i<data.Count; ++i ) { // (1) determine the top left hand point of the bar (assuming not centered) Point p1 = data[i]; if (double.IsNaN(p1.X) || double.IsNaN(p1.Y)) { continue; } // (2) determine the top right hand point of the bar (assuming not centered) Point p2 = Point.Zero;; if (i+1 != data.Count) { p2 = data[i+1]; if (double.IsNaN(p2.X) || double.IsNaN(p2.Y)) { continue; } p2.Y = p1.Y; } else if (i != 0) { p2 = data[i-1]; if (double.IsNaN(p2.X) || double.IsNaN(p2.Y)) { continue; } double offset = p1.X - p2.X; p2.X = p1.X + offset; p2.Y = p1.Y; } else { double offset = 1.0; p2.X = p1.X + offset; p2.Y = p1.Y; } // (3) now account for plots this may be stacked on top of. HistogramPlot currentPlot = this; yoff = 0.0; double yval = 0.0; while (currentPlot.IsStacked) { SequenceAdapter stackedToData = new SequenceAdapter ( currentPlot.stackedTo.DataSource, currentPlot.stackedTo.DataMember, currentPlot.stackedTo.OrdinateData, currentPlot.stackedTo.AbscissaData ); yval += stackedToData[i].Y; yoff = yAxis.WorldToPhysical (yval, false).Y; p1.Y += stackedToData[i].Y; p2.Y += stackedToData[i].Y; currentPlot = currentPlot.stackedTo; } // (4) now account for centering if (Center) { double offset = (p2.X - p1.X) / 2.0; p1.X -= offset; p2.X -= offset; } // (5) now account for BaseOffset (shift of bar sideways). p1.X += BaseOffset; p2.X += BaseOffset; // (6) now get physical coordinates of top two points. Point xPos1 = xAxis.WorldToPhysical (p1.X, false); Point yPos1 = yAxis.WorldToPhysical (p1.Y, false); Point xPos2 = xAxis.WorldToPhysical (p2.X, false); if (IsStacked) { currentPlot = this; while (currentPlot.IsStacked) { currentPlot = currentPlot.stackedTo; } baseWidth = currentPlot.baseWidth; } double width = xPos2.X - xPos1.X; double height; if (IsStacked) { height = -yPos1.Y+yoff; } else { height = -yPos1.Y+yAxis.PhysicalMin.Y; } double xoff = (1.0 - baseWidth)/2.0*width; Rectangle bar = new Rectangle (xPos1.X+xoff, yPos1.Y, width-2*xoff, height); ctx.Rectangle (bar); if (Filled) { if (bar.Height != 0 && bar.Width != 0) { if (FillGradient != null) { // Scale FillGradient to bar rectangle double sX = bar.X + fillGradient.StartPoint.X * bar.Width; double sY = bar.Y + fillGradient.StartPoint.Y * bar.Height; double eX = bar.X + fillGradient.EndPoint.X * bar.Width; double eY = bar.Y + fillGradient.EndPoint.Y * bar.Height; LinearGradient g = new LinearGradient (sX, sY, eX, eY); g.AddColorStop (0, FillGradient.StartColor); g.AddColorStop (1, FillGradient.EndColor); ctx.Pattern = g; } else { ctx.SetColor (FillColor); } ctx.FillPreserve (); } } ctx.SetColor (BorderColor); ctx.Stroke (); } ctx.Restore (); }
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 line plot using the Drawing Context and x and y 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> public void Draw(Context ctx, PhysicalAxis xAxis, PhysicalAxis yAxis) { SequenceAdapter dataTop = new SequenceAdapter (DataSource, DataMember, OrdinateDataTop, AbscissaData); SequenceAdapter dataBottom = new SequenceAdapter (DataSource, DataMember, OrdinateDataBottom, AbscissaData); ITransform2D t = Transform2D.GetTransformer (xAxis, yAxis); ctx.Save (); for (int i=0; i<dataTop.Count; ++i) { Point physicalBottom = t.Transform (dataBottom[i]); Point physicalTop = t.Transform (dataTop[i]); if (physicalBottom != physicalTop) { Rectangle r = new Rectangle (physicalBottom.X - BarWidth/2, physicalTop.Y,BarWidth, (physicalBottom.Y - physicalTop.Y) ); ctx.SetColor (fillColor); ctx.Rectangle (r); ctx.FillPreserve (); ctx.SetColor (borderColor); ctx.Stroke (); } } ctx.Restore (); }