protected override void OnDraw (Context ctx, Rectangle cellArea) { PackageViewModel packageViewModel = GetValue (PackageField); if (packageViewModel == null) { return; } FillCellBackground (ctx); UpdateTextColor (ctx); DrawCheckBox (ctx, packageViewModel, cellArea); DrawPackageImage (ctx, cellArea); double packageIdWidth = cellArea.Width - packageDescriptionPadding.HorizontalSpacing - packageDescriptionLeftOffset; // Package download count. if (packageViewModel.HasDownloadCount) { var downloadCountTextLayout = new TextLayout (); downloadCountTextLayout.Text = packageViewModel.GetDownloadCountOrVersionDisplayText (); Size size = downloadCountTextLayout.GetSize (); Point location = new Point (cellArea.Right - packageDescriptionPadding.Right, cellArea.Top + packageDescriptionPadding.Top); Point downloadLocation = location.Offset (-size.Width, 0); ctx.DrawTextLayout (downloadCountTextLayout, downloadLocation); packageIdWidth = downloadLocation.X - cellArea.Left - packageIdRightHandPaddingWidth - packageDescriptionPadding.HorizontalSpacing - packageDescriptionLeftOffset; } // Package Id. var packageIdTextLayout = new TextLayout (); packageIdTextLayout.Font = packageIdTextLayout.Font.WithSize (12); packageIdTextLayout.Markup = packageViewModel.GetNameMarkup (); packageIdTextLayout.Trimming = TextTrimming.WordElipsis; Size packageIdTextSize = packageIdTextLayout.GetSize (); packageIdTextLayout.Width = packageIdWidth; ctx.DrawTextLayout ( packageIdTextLayout, cellArea.Left + packageDescriptionPadding.Left + packageDescriptionLeftOffset, cellArea.Top + packageDescriptionPadding.Top); // Package description. var descriptionTextLayout = new TextLayout (); descriptionTextLayout.Font = descriptionTextLayout.Font.WithSize (11); descriptionTextLayout.Width = cellArea.Width - packageDescriptionPadding.HorizontalSpacing - packageDescriptionLeftOffset; descriptionTextLayout.Height = cellArea.Height - packageIdTextSize.Height - packageDescriptionPadding.VerticalSpacing; descriptionTextLayout.Text = packageViewModel.Summary; descriptionTextLayout.Trimming = TextTrimming.Word; ctx.DrawTextLayout ( descriptionTextLayout, cellArea.Left + packageDescriptionPadding.Left + packageDescriptionLeftOffset, cellArea.Top + packageIdTextSize.Height + packageDescriptionPaddingHeight + packageDescriptionPadding.Top); }
protected override void OnDraw (Context ctx, Rectangle dirtyRect) { base.OnDraw (ctx, dirtyRect); ctx.Rectangle (0, 0, Size.Width, Size.Height); ctx.SetColor (Colors.LightGray); ctx.Fill (); ctx.SetColor (Colors.Black); using (var layout = new TextLayout (this)) { layout.Text = text; ctx.DrawTextLayout (layout, new Point (0, 20)); } }
internal protected override void Draw (Context ctx, Rectangle area, long line, double x, double y) { ctx.Rectangle (x, y, Width, Editor.LineHeight); ctx.SetColor (Style.HexOffsetBg); ctx.Fill (); if (line >= 0 && line * Editor.BytesInRow < Data.Length) { LayoutWrapper layout = GetLayout (line); var sz = layout.Layout.GetSize (); ctx.SetColor (line != Caret.Line ? Style.HexOffset : Style.HexOffsetHighlighted); ctx.DrawTextLayout (layout.Layout, x + Width - sz.Width - 4, y); if (layout.IsUncached) layout.Dispose (); } }
protected internal override void Draw(Context cr, Xwt.Rectangle area, DocumentLine line, int lineNumber, double x, double y, double height) { if (lineNumber <= editor.Document.LineCount) { TextLayout layout; if (!layoutDict.TryGetValue(lineNumber, out layout)) { layout = new TextLayout(); layout.Font = editor.Options.EditorFont; layout.Text = lineNumber.ToString(); layoutDict[lineNumber] = layout; } cr.SetColor(Colors.Black); cr.DrawTextLayout(layout, x + leftPadding, y); } }
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); }
/// <summary> /// Draws the title using the Drawing Context, Origin (x,y) and scale /// </summary> /// <returns> /// The Size required for the title /// </returns> /// TODO: Add a MeasureTitle routine, since can measure TextLayout now /// private Size DrawTitle(Context ctx, Point origin, double scale) { ctx.Save (); ctx.SetColor (TitleColor); Font scaled_font; if (AutoScaleTitle) { scaled_font = titleFont.WithScaledSize (scale); } else { scaled_font = titleFont; } TextLayout layout = new TextLayout (); layout.Font = scaled_font; layout.Text = Title; Size titleSize = layout.GetSize (); origin.X -= titleSize.Width/2; ctx.DrawTextLayout (layout, origin); ctx.Restore (); return titleSize; }
/// <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 ) ); } }
public void DrawCaret (Context ctx, Rectangle area) { if (!caretBlink || HexEditorData.IsSomethingSelected) return; long caretY = HexEditorData.Caret.Line * LineHeight - (long)HexEditorData.VAdjustment.Value; double caretX; char ch; if (HexEditorData.Caret.InTextEditor) { caretX = textEditorMargin.CalculateCaretXPos (out ch); } else { caretX = hexEditorMargin.CalculateCaretXPos (out ch); } if (!area.Contains (caretX, (int)caretY)) return; if (HexEditorData.Caret.IsInsertMode) { ctx.Rectangle (caretX, (int)caretY, 2, LineHeight); } else { ctx.Rectangle (caretX, (int)caretY, textEditorMargin.charWidth, LineHeight); } ctx.SetColor (HexEditorStyle.HexDigit); ctx.Fill (); if (!HexEditorData.Caret.IsInsertMode) { using (var layout = new TextLayout (this)) { layout.Font = Options.Font; layout.Text = ch.ToString (); ctx.SetColor (HexEditorStyle.HexDigitBg); ctx.DrawTextLayout (layout, caretX, caretY); } } }
protected override void OnDraw(Context ctx, Rectangle dirtyRect) { base.OnDraw(ctx, dirtyRect); for (int i = 0; i < Size.Width / checkerboard.Width; i++) { for (int j = 0; j < Size.Height / checkerboard.Height; j++) { ctx.DrawImage(checkerboard, i * checkerboard.Width, j * checkerboard.Height); } } ctx.SetLineWidth(1); ctx.SetColor(color); ctx.Rectangle(0, 0, Size.Width - 20, Size.Height); ctx.Fill(); ctx.SetColor(DefaultColor); ctx.Rectangle(Size.Width - 20, 0, 20, Size.Height); ctx.Fill(); ctx.SetColor(Colors.Black); ctx.Rectangle(0, 0, Size.Width, Size.Height); ctx.Stroke(); //ctx.SetColor(Color.Brightness > .5 ? Colors.White : Colors.Black); ctx.SetColor(((-1 * Color.Brightness) + 1) * 1.15 + (Color.Alpha) > 1.2 ? Colors.White : Colors.Black); ctx.DrawTextLayout(new TextLayout(this) { Text = Color.ToHexString().ToUpper() }, 2, 3); if (mover && (IsDefaultColor || mx <= Size.Width - 20)) { ctx.SetColor(new Color(1, 1, 1, .33)); ctx.Rectangle(0, 0, Size.Width - (IsDefaultColor ? 0 : 20), Size.Height); ctx.Fill(); } if (!IsDefaultColor) { if (mover && mx > Size.Width - 20) { ctx.SetColor(new Color(1, 1, 1, .33)); ctx.Rectangle(Size.Width - 20, 0, 20, Size.Height); ctx.Fill(); } ctx.SetColor(Colors.Black); ctx.MoveTo(Size.Width - 19.5, 0); ctx.RelLineTo(0, Size.Height); ctx.Stroke(); if (mover) ctx.DrawImage(resetImage, Size.Width - 18, (Size.Height - 16) / 2, 16, 16); } }
internal protected override void Draw (Context ctx, Rectangle area, long line, double x, double y) { ctx.Rectangle (x, y, Width, Editor.LineHeight); ctx.SetColor (Style.HexDigitBg); ctx.Fill (); LayoutWrapper layout = GetLayout (line); char ch; if (!Data.IsSomethingSelected && Caret.InTextEditor && line == Data.Caret.Line) { ctx.Rectangle (CalculateCaretXPos (false, out ch), y, byteWidth, Editor.LineHeight); ctx.SetColor (Style.HighlightOffset); ctx.Fill (); } ctx.SetColor (Style.HexDigit); ctx.DrawTextLayout (layout.Layout, x, y); if (layout.IsUncached) layout.Dispose (); }
protected override void OnDraw(Context ctx, Rectangle dirtyRect) { base.OnDraw(ctx, dirtyRect); ctx.DrawTextLayout(new TextLayout() { Text = Text }, 0, 0); }
double DrawHeader(Context ctx) { Point textOffset = new Point(8, 4); textLayoutBold.Text = algorithm.Headline(); Size textSize = textLayoutBold.GetSize(); if (textSize.Width >= AbsMaxNodeSize.Width - textSize.Height * 2) { textLayoutBold.Width = textSize.Width = AbsMaxNodeSize.Width; } Point textPosition = bound.Location.Offset(textOffset); // headline background contentOffset.X = 6; contentOffset.Y = textOffset.Y + textSize.Height + 4; ctx.RoundRectangle(bound.Left + 1, bound.Top + 1, bound.Width - 2, contentOffset.Y, NodeRadius); ctx.SetColor(NodeHeadlineBackground); ctx.Fill(); // text ctx.SetColor(NodeHeadlineTextColor); ctx.DrawTextLayout(textLayoutBold, textPosition); // icons double iconWidth = 0.0; foreach (var icon in icons) { if (icon.Value.Visible) { iconWidth = icon.Value.Bounds.Width; icon.Value.Bounds = new Rectangle(bound.Width - icon.Value.Bounds.Width - 10, 3, icon.Value.Bounds.Width, icon.Value.Bounds.Height); ctx.DrawImage( icon.Value.Image, bound.Location.Offset(icon.Value.Bounds.Location) ); } } double width = textSize.Width + iconWidth + 10 + NodeTextMargin; return width; }
/// <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 (); }
/// <summary> /// Draw the Axis Label /// </summary> /// <param name="ctx>The Drawing Context with which to draw.</param> /// <param name="offset">offset from axis. Should be calculated so as to make sure axis label misses tick labels.</param> /// <param name="axisPhysicalMin">The physical position corresponding to the world minimum of the axis.</param> /// <param name="axisPhysicalMax">The physical position corresponding to the world maximum of the axis.</param> /// <returns>boxed Rectangle indicating bounding box of label. null if no label printed.</returns> public object DrawLabel(Context ctx, Point offset, Point axisPhysicalMin, Point axisPhysicalMax) { if (Label != "") { // first calculate any extra offset for axis label spacing. double extraOffsetAmount = LabelOffset; extraOffsetAmount += 2; // empirically determed - text was too close to axis before this. if (AutoScaleText && LabelOffsetScaled) { extraOffsetAmount *= FontScale; } // now extend offset. double offsetLength = Math.Sqrt (offset.X*offset.X + offset.Y*offset.Y); if (offsetLength > 0.01) { double x_component = offset.X / offsetLength; double y_component = offset.Y / offsetLength; x_component *= extraOffsetAmount; y_component *= extraOffsetAmount; if (LabelOffsetAbsolute) { offset.X = x_component; offset.Y = y_component; } else { offset.X += x_component; offset.Y += y_component; } } // determine angle of axis in degrees double theta = Math.Atan2 ( axisPhysicalMax.Y - axisPhysicalMin.Y, axisPhysicalMax.X - axisPhysicalMin.X); theta = theta * 180.0 / Math.PI; Point average = new Point ( (axisPhysicalMax.X + axisPhysicalMin.X)/2, (axisPhysicalMax.Y + axisPhysicalMin.Y)/2); ctx.Save (); ctx.Translate (average.X + offset.X , average.Y + offset.Y); // this is done last. ctx.Rotate (theta); // this is done first. TextLayout layout = new TextLayout (); layout.Font = labelFontScaled; layout.Text = Label; Size labelSize = layout.GetSize (); //Draw label centered around zero. ctx.DrawTextLayout (layout, -labelSize.Width/2, -labelSize.Height/2); // now work out physical bounds of Rotated and Translated label. Point [] recPoints = new Point [2]; recPoints[0] = new Point (-labelSize.Width/2, -labelSize.Height/2); recPoints[1] = new Point ( labelSize.Width/2, labelSize.Height/2); ctx.TransformPoints (recPoints); double x1 = Math.Min (recPoints[0].X, recPoints[1].X); double x2 = Math.Max (recPoints[0].X, recPoints[1].X); double y1 = Math.Min (recPoints[0].Y, recPoints[1].Y); double y2 = Math.Max (recPoints[0].Y, recPoints[1].Y); ctx.Restore (); // and return label bounding box. return new Rectangle (x1, y1, (x2-x1), (y2-y1)); } return null; }
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 (); }
void DrawPopover(Context ctx) { lock (trackerLock) { if (actualTrackerHitResult != null) { var trackerSettings = DefaultTrackerSettings; if (actualTrackerHitResult.Series != null && !string.IsNullOrEmpty(actualTrackerHitResult.Series.TrackerKey)) trackerSettings = trackerDefinitions[actualTrackerHitResult.Series.TrackerKey]; if (trackerSettings.Enabled) { var extents = actualTrackerHitResult.LineExtents; if (Math.Abs(extents.Width) < double.Epsilon) { extents = new OxyRect(actualTrackerHitResult.XAxis.ScreenMin.X, extents.Top, actualTrackerHitResult.XAxis.ScreenMax.X - actualTrackerHitResult.XAxis.ScreenMin.X, extents.Height); } if (Math.Abs(extents.Height) < double.Epsilon) { extents = new OxyRect(extents.Left, actualTrackerHitResult.YAxis.ScreenMin.Y, extents.Width, actualTrackerHitResult.YAxis.ScreenMax.Y - actualTrackerHitResult.YAxis.ScreenMin.Y); } var pos = actualTrackerHitResult.Position; if (trackerSettings.HorizontalLineVisible) { renderContext.DrawLine( new[] { new ScreenPoint(extents.Left, pos.Y), new ScreenPoint(extents.Right, pos.Y) }, trackerSettings.HorizontalLineColor, trackerSettings.HorizontalLineWidth, trackerSettings.HorizontalLineActualDashArray, LineJoin.Miter, true); } if (trackerSettings.VerticalLineVisible) { renderContext.DrawLine( new[] { new ScreenPoint(pos.X, extents.Top), new ScreenPoint(pos.X, extents.Bottom) }, trackerSettings.VerticalLineColor, trackerSettings.VerticalLineWidth, trackerSettings.VerticalLineActualDashArray, LineJoin.Miter, true); } TextLayout text = new TextLayout(); text.Font = trackerSettings.Font; text.Text = actualTrackerHitResult.Text; var arrowTop = actualTrackerHitResult.Position.Y <= Bounds.Height / 2; const int arrowPadding = 10; var textSize = text.GetSize(); var outerSize = new Size(textSize.Width + (trackerSettings.Padding * 2), textSize.Height + (trackerSettings.Padding * 2) + arrowPadding); var trackerBounds = new Rectangle(pos.X - (outerSize.Width / 2), 0, outerSize.Width, outerSize.Height - arrowPadding); if (arrowTop) trackerBounds.Y = pos.Y + arrowPadding + trackerSettings.BorderWidth; else trackerBounds.Y = pos.Y - outerSize.Height - trackerSettings.BorderWidth; var borderColor = trackerSettings.BorderColor.ToXwtColor(); ctx.RoundRectangle(trackerBounds, 6); ctx.SetLineWidth(trackerSettings.BorderWidth); ctx.SetColor(borderColor); ctx.StrokePreserve(); ctx.SetColor(trackerSettings.Background.ToXwtColor()); ctx.Fill(); ctx.Save(); var arrowX = trackerBounds.Center.X; var arrowY = arrowTop ? trackerBounds.Top : trackerBounds.Bottom; ctx.NewPath(); ctx.MoveTo(arrowX, arrowY); var triangleSide = 2 * arrowPadding / Math.Sqrt(3); var halfSide = triangleSide / 2; var verticalModifier = arrowTop ? -1 : 1; ctx.RelMoveTo(-halfSide, 0); ctx.RelLineTo(halfSide, verticalModifier * arrowPadding); ctx.RelLineTo(halfSide, verticalModifier * -arrowPadding); ctx.SetColor(borderColor); ctx.StrokePreserve(); ctx.ClosePath(); ctx.SetColor(trackerSettings.Background.ToXwtColor()); ctx.Fill(); ctx.Restore(); ctx.SetColor(trackerSettings.TextColor.ToXwtColor()); ctx.DrawTextLayout(text, trackerBounds.Left + trackerSettings.Padding, trackerBounds.Top + trackerSettings.Padding); } } } }
protected override void OnDraw(Context ctx, Rectangle dirtyRect) { // Line arround ctx.SetColor(Colors.DarkGray); // Drive line arround ctx.Rectangle(Bounds); ctx.Fill(); ctx.SetColor(Colors.Gray); ctx.Rectangle(Bounds.Inflate(-margin, -margin)); ctx.Fill(); // Draw image ctx.DrawImage(Image.FromResource(Logo), 5.0, 5.0); // Draw text ctx.SetColor(Colors.White); TextLayout _layout = new TextLayout(); _layout.Font = Font.WithSize(22); _layout.Text = Label; _layout.SetFontWeight(FontWeight.Bold, 0, Label.Length); // Cocoa layouts ctx.DrawTextLayout(_layout, 45, ((Config.Cocoa || Config.Gtk) ? 5 : 2)); }
/// <summary> /// Draws the plot using the Drawing Context and X, Y axes supplied. /// </summary> public override void Draw(Context ctx, PhysicalAxis xAxis, PhysicalAxis yAxis) { SequenceAdapter data = new SequenceAdapter (this.DataSource, this.DataMember, this.OrdinateData, this.AbscissaData); TextDataAdapter textData = new TextDataAdapter (this.DataSource, this.DataMember, this.TextData); TextLayout layout = new TextLayout (); layout.Font = Font; ctx.Save (); ctx.SetColor (Colors.Black); for (int i=0; i<data.Count; ++i) { try { Point p = data[i]; if (!Double.IsNaN(p.X) && !Double.IsNaN(p.Y)) { Point xPos = xAxis.WorldToPhysical (p.X, false); Point yPos = yAxis.WorldToPhysical (p.Y, false); // first plot the marker Marker.Draw (ctx, xPos.X, yPos.Y); // then the label if (textData[i] != "") { layout.Text = textData[i]; Size size = layout.GetSize (); switch (labelTextPosition) { case LabelPositions.Above: p.X = xPos.X-size.Width/2; p.Y = yPos.Y-size.Height-Marker.Size*2/3; break; case LabelPositions.Below: p.X = xPos.X-size.Width/2; p.Y = yPos.Y+Marker.Size*2/3; break; case LabelPositions.Left: p.X = xPos.X-size.Width-Marker.Size*2/3; p.Y = yPos.Y-size.Height/2; break; case LabelPositions.Right: p.X = xPos.X+Marker.Size*2/3; p.Y = yPos.Y-size.Height/2; break; } ctx.DrawTextLayout (layout, p); } } } catch { throw new XwPlotException ("Error in TextPlot.Draw"); } } ctx.Restore (); }
/// <summary> /// Draw the marker. /// </summary> /// <param name="ctx">Context.</param> public override void Draw(Context ctx) { ctx.SetColor(PipelineNode.NodeColorBorder); Rectangle bndTmp = Bounds; ctx.RoundRectangle(bndTmp.Inflate(-2, -2), 2); if (compatible.IsFinal()) { ctx.SetColor(Colors.LightGray); } else { ctx.RoundRectangle(bndTmp.Inflate(-1, -1), 3); using (LinearGradient g = new LinearGradient(bndTmp.Left, bndTmp.Top, bndTmp.Right, bndTmp.Bottom)) { g.AddColorStop(0, Colors.Black.BlendWith(NodeColor, 0.7)); g.AddColorStop(1, NodeColor); ctx.Pattern = g; ctx.Fill(); } ctx.SetColor(NodeColor); } ctx.Fill(); if (IsInput) { int inputBufferSize = inputData.Count; List<Result> ihCopy; lock (inputHistoryLock) { ihCopy = new List<Result>(inputHistory); } foreach (Result input in ihCopy) { if (input.IsUsed(parent)) { inputBufferSize++; } else { lock (inputHistoryLock) { inputHistory.Remove(input); } } } if (inputBufferSize > 0) { bool sourceNodeIsAbove = true; if (edges.Count > 0 && edges[0] != null) { if (edges[0].to.Bounds.Center.Y > Bounds.Center.Y - 4.0) { sourceNodeIsAbove = false; } } textLayout.Text = inputBufferSize.ToString(); double textWidth = textLayout.GetSize().Width; double textHeight = textLayout.GetSize().Height; Point inputbufferSizeLocation = Bounds.Location.Offset( -24 -(textWidth/2), sourceNodeIsAbove ? textHeight + 6 : -6 - textHeight); ctx.Arc( inputbufferSizeLocation.X + textWidth / 2, inputbufferSizeLocation.Y + textHeight / 2, Math.Max(textHeight, textWidth) / 2 + 1, 0, 360 ); ctx.Fill(); ctx.SetColor(PipelineNode.NodeColor); ctx.DrawTextLayout(textLayout, inputbufferSizeLocation); } } else { // if this is a final node if (parent.algorithm.Output[positionNo].IsFinal()) { ctx.MoveTo(bndTmp.Right + 4, bndTmp.Top); ctx.LineTo(bndTmp.Right + 4, bndTmp.Bottom); ctx.Stroke(); // draw output size on end nodes (= number of features if (parent.results != null && parent.results.Count > 0 && parent.results[0].Item1 != null && parent.results[0].Item1.Length - 1 >= Position) { textLayout.Text = parent.results.Count.ToString(); double textWidth = textLayout.GetSize().Width; double textHeight = textLayout.GetSize().Height; Point outputbufferSizeLocation = Bounds.Location.Offset(Bounds.Width * 1.8, 0); ctx.Arc( outputbufferSizeLocation.X + textWidth / 2, outputbufferSizeLocation.Y + textHeight / 2, Math.Max(textHeight, textWidth) / 2 + 1, 0, 360 ); ctx.Fill(); ctx.SetColor(PipelineNode.NodeColor); ctx.DrawTextLayout(textLayout, outputbufferSizeLocation); } } } }
void DrawTicks (Context ctx, TickEnumerator e, AxisPosition pos, AxisDimension ad, int tickSize, bool showLabels) { double rheight = Bounds.Height; TextLayout layout = null; if (showLabels) { layout = new TextLayout (); layout.Font = chartFont; } bool isX = pos == AxisPosition.Top || pos == AxisPosition.Bottom; bool isTop = pos == AxisPosition.Top || pos == AxisPosition.Right; double start = GetStart (ad); double end = GetEnd (ad); e.Init (GetOrigin (ad)); while (e.CurrentValue > start) e.MovePrevious (); double lastPosLabel; double lastPos; double lastTw = 0; if (isX) { lastPosLabel = reverseXAxis ? left + width + MinLabelGapX : left - MinLabelGapX; lastPos = left - minTickStep*2; } else { lastPosLabel = reverseYAxis ? top - MinLabelGapY : rheight + MinLabelGapY; lastPos = top + height + minTickStep*2; } for ( ; e.CurrentValue <= end; e.MoveNext ()) { double px, py; double tw = 0, th = 0; int tick = tickSize; GetPoint (e.CurrentValue, e.CurrentValue, out px, out py); if (showLabels) { layout.Text = e.CurrentLabel; var ts = layout.GetSize (); tw = ts.Width; th = ts.Height; } if (isX) { if (Math.Abs ((long)px - (long)lastPos) < minTickStep || px < left || px > left + width) continue; lastPos = px; bool labelFits = false; if ((Math.Abs (px - lastPosLabel) - (tw/2) - (lastTw/2)) >= MinLabelGapX) { lastPosLabel = px; lastTw = tw; labelFits = true; } if (isTop) { if (showLabels) { if (labelFits) ctx.DrawTextLayout (layout, px - (tw/2), top - AreaBorderWidth - th); else tick = tick / 2; } ctx.MoveTo (px, top); ctx.LineTo (px, top + tick); ctx.Stroke (); } else { if (showLabels) { if (labelFits) ctx.DrawTextLayout (layout, px - (tw/2), top + height + AreaBorderWidth); else tick = tick / 2; } ctx.MoveTo (px, top + height); ctx.LineTo (px, top + height - tick); ctx.Stroke (); } } else { if (Math.Abs ((long)lastPos - (long)py) < minTickStep || py < top || py > top + height) continue; lastPos = py; bool labelFits = false; if ((Math.Abs (py - lastPosLabel) - (th/2) - (lastTw/2)) >= MinLabelGapY) { lastPosLabel = py; lastTw = th; labelFits = true; } if (isTop) { if (showLabels) { if (labelFits) ctx.DrawTextLayout (layout, left + width + AreaBorderWidth + 1, py - (th/2)); else tick = tick / 2; } ctx.MoveTo (left + width, py); ctx.LineTo (left + width - tick, py); ctx.Stroke (); } else { if (showLabels) { if (labelFits) ctx.DrawTextLayout (layout, left - AreaBorderWidth - tw - 1, py - (th/2)); else tick = tick / 2; } ctx.MoveTo (left, py); ctx.LineTo (left + tick, py); 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; }
void DrawCursorLabel (Context ctx, ChartCursor cursor) { ctx.SetColor (cursor.Color); int x, y; GetPoint (cursor.Value, cursor.Value, out x, out y); if (cursor.Dimension == AxisDimension.X) { string text; if (cursor.LabelAxis != null) { double minStep = GetMinTickStep (cursor.Dimension); TickEnumerator tenum = cursor.LabelAxis.GetTickEnumerator (minStep); tenum.Init (cursor.Value); text = tenum.CurrentLabel; } else { text = GetValueLabel (cursor.Dimension, cursor.Value); } if (text != null && text.Length > 0) { TextLayout layout = new TextLayout (); layout.Font = chartFont; layout.Text = text; Size ts = layout.GetSize (); double tl = x - ts.Width/2; double tt = top + 4; if (tl + ts.Width + 2 >= left + width) tl = left + width - ts.Width - 1; if (tl < left + 1) tl = left + 1; ctx.SetColor (Colors.White); ctx.Rectangle (tl - 1, tt - 1, ts.Width + 2, ts.Height + 2); ctx.Fill (); ctx.Rectangle (tl - 2, tt - 2, ts.Width + 3, ts.Height + 3); ctx.SetColor (Colors.Black); ctx.DrawTextLayout (layout, tl, tt); } } else { throw new NotSupportedException (); } }
protected internal override void Draw(Context cr, Xwt.Rectangle area, DocumentLine line, int lineNumber, double x, double y, double height) { if (line != null) { TextLayout layout; if (!layoutDict.TryGetValue(line, out layout)) { var mode = editor.Document.SyntaxMode; var style = SyntaxModeService.DefaultColorStyle; var chunks = GetCachedChunks(mode, editor.Document, style, line, line.Offset, line.Length); layout = new TextLayout(); layout.Font = editor.Options.EditorFont; string lineText = editor.Document.GetLineText(lineNumber); var stringBuilder = new StringBuilder(lineText.Length); int currentVisualColumn = 1; for (int i = 0; i < lineText.Length; ++i) { char chr = lineText[i]; if (chr == '\t') { int length = GetNextTabstop(editor, currentVisualColumn) - currentVisualColumn; stringBuilder.Append(' ', length); currentVisualColumn += length; } else { stringBuilder.Append(chr); if (!char.IsLowSurrogate(chr)) { ++currentVisualColumn; } } } layout.Text = stringBuilder.ToString(); int visualOffset = 1; foreach (var chunk in chunks) { var chunkStyle = style.GetChunkStyle(chunk); visualOffset = DrawLinePortion(cr, chunkStyle, layout, line, visualOffset, chunk.Length); } //layoutDict[line] = layout; } cr.DrawTextLayout(layout, x, y); if (editor.CaretVisible && editor.Caret.Line == lineNumber) { cr.SetColor(Colors.Black); cr.Rectangle(x + ColumnToX(line, editor.Caret.Column), y, caretWidth, LineHeight); cr.Fill(); } } }
internal protected override void Draw (Context ctx, Rectangle area, long line, double x, double y) { ctx.Rectangle (x, y, Width, Editor.LineHeight); ctx.SetColor (Style.HexDigitBg); ctx.Fill (); LayoutWrapper layout = GetLayout (line); if (!Data.IsSomethingSelected && !Caret.InTextEditor && line == Data.Caret.Line) { var column = (int)(Caret.Offset % BytesInRow); var xOffset = charWidth * column; ctx.Rectangle (x + xOffset, y, charWidth, Editor.LineHeight); ctx.SetColor (Style.HighlightOffset); ctx.Fill (); } ctx.SetColor (Style.HexDigit); ctx.DrawTextLayout (layout.Layout, x, y); if (layout.IsUncached) layout.Dispose (); }
bool DrawBody(Context ctx, double headlineWidth) { bool ret = false; ctx.SetColor(Colors.Black); double inputMaxWidth = 0.0; double outputMaxWidth = 0.0; foreach (MarkerNode mNode in mNodes) { textLayout.Text = mNode.compatible.ToString(); mNode.Height = textLayout.GetSize().Height; Point pos = mNode.Bounds.Location; if (mNode.IsInput) { pos.X = mNode.Bounds.Right + contentOffset.X; if (pos.X - bound.X + textLayout.GetSize().Width > inputMaxWidth) { inputMaxWidth = pos.X - bound.X + textLayout.GetSize().Width; } } else { pos.X = mNode.Bounds.Left - contentOffset.X - textLayout.GetSize().Width; if (bound.Right - pos.X > outputMaxWidth) { outputMaxWidth = bound.Right - pos.X; } } ctx.DrawTextLayout(textLayout, pos); ctx.Stroke(); // resize height of widget if necessary if (pos.Y + mNode.Height + NodeInOutSpace.Height > bound.Bottom) { bound.Bottom = pos.Y + mNode.Height + NodeInOutSpace.Height; ret = true; } } // resize width double maxWidth = Math.Max(headlineWidth, inputMaxWidth + outputMaxWidth + NodeTextMargin); if (maxWidth > bound.Width) { bound.Width = maxWidth; ret = true; } return ret; }
/// <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); }
static void Draw(Context ctx, LogLevel level, Color color) { using (TextLayout text = new TextLayout()) { text.Text = level.ToString(); double height = text.GetSize().Height; ctx.SetColor(color); ctx.RoundRectangle(0, 1, height - 2, height - 2, 3); ctx.Fill(); // inner shadow ctx.RoundRectangle(0, 1, height - 2, height - 2, 3); LinearGradient g = new LinearGradient(1, 2, height - 2, height - 2); g.AddColorStop(0, Colors.Black.BlendWith(color, 0.7)); g.AddColorStop(1, color); ctx.Pattern = g; ctx.Fill(); ctx.SetColor(Colors.Black); ctx.DrawTextLayout(text, new Point(height + 3, 0)); } }
/// <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); } } }
/// <summary> /// Draw a information on the ListView2Item /// </summary> /// <param name="What">What should be drawed</param> /// <param name="Where">Where (position by X) should be drawed</param> /// <param name="On">On what Drawing.Context the information should be drawed</param> /// <param name="MaxWidth">The limit of the picture's width</param> /// <param name="TextColor">The text foreground color</param> /// <param name="WhatFont">Which font is used to draw the onject</param> private void Draw(object What, double Where, Context On, double MaxWidth, Color TextColor, Font WhatFont) { if (What.GetType() != typeof (Image) && What.GetType() != typeof (DirItem)) { TextLayout tl = new TextLayout(this) { Text = What.ToString(), Font = WhatFont, Width = MaxWidth, Trimming = TextTrimming.WordElipsis }; On.SetColor (TextColor); On.DrawTextLayout(tl, Where + 4, 0); } if (What is Image) { On.DrawImage(What as Image, Where + 2, 0); } }
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); }
/// <summary> /// Illustrates the use of matrix transforms to skew and reflect text /// </summary> public void Reflect (Context ctx, double x, double y) { ctx.Save (); ctx.SetLineWidth (1); TextLayout layout = new TextLayout (); layout.Text = "Reflected and Skewed Text"; layout.Font = Font.WithSize (16); Size size = layout.GetSize (); Rectangle r = new Rectangle (Point.Zero, size); // Draw text with no transformations at (x+0.5, y+0.5) ctx.Translate (x+0.5, y+0.5); // final move to specified location ctx.SetColor (Colors.Blue); ctx.DrawTextLayout (layout, 0, 0); // Use Matrix transforms to reflect Y-values and skew X-values by -0.5*Y // Note that transforms are prepended, so are actioned in reverse order // This is the same order that Backend Context transforms are applied Matrix m = new Matrix (); // Identity matrix Matrix s = new Matrix (1.0, 0.0, // new skew matrix -0.5, 1.0, 0.0, 0.0); m.Translate (0, size.Height); // Shift text back to place m.Prepend (s); // Skew X-values m.Scale (1, -1); // Reflect text Y-values m.Translate (0, -size.Height); // Shift text base to (0,0) ctx.ModifyCTM (m); // NB ctx.Translate (x+0.5, y+0.5) still active ctx.SetColor (Colors.DarkGray); ctx.Rectangle (r); ctx.Fill (); ctx.SetColor (Colors.LightBlue); ctx.DrawTextLayout (layout, 0, 0); ctx.Restore (); }