protected override void OnRender(DrawingContext drawingContext) { var fe = AdornedElement as FrameworkElement; if (fe == null) { return; } var rect = new Rect(1, 1, Math.Max(0, fe.ActualWidth - 2), Math.Max(0, fe.ActualHeight - 2)); var color = Colors.Red; var brush = new SolidColorBrush(color); var pen = new Pen(brush, 1); pen.Freeze(); var dashPen = new Pen(brush, 1) { DashStyle = new DashStyle(new double[] { 1, 6 }, 0) }; dashPen.Freeze(); var guidelineSet = new GuidelineSet(); guidelineSet.GuidelinesX.Add(0.5); guidelineSet.GuidelinesY.Add(0.5); //var outlinePen = new Pen(new SolidColorBrush(Color.FromArgb(0x70, 0xFF, 0xFF, 0xFF)), 5); //outlinePen.Freeze(); drawingContext.PushGuidelineSet(guidelineSet); //drawingContext.DrawRectangle(null, outlinePen, rect); drawingContext.DrawRectangle(null, pen, rect); //var parent = VisualTreeHelper.GetParent(fe) as FrameworkElement; //if (parent != null) //{ // var thisLeft = new Point(0, fe.ActualHeight / 2); // var thisRight = new Point(fe.ActualWidth, fe.ActualHeight / 2); // var thisTop = new Point(fe.ActualWidth / 2, 0); // var thisBottom = new Point(fe.ActualWidth / 2, fe.ActualHeight); // var ancestorLeft = new Point(parent.TranslatePoint(thisLeft, fe).X, thisLeft.Y); // var ancestorRight = ancestorLeft + new Vector(parent.ActualWidth, 0); // var ancestorTop = new Point(thisTop.X, parent.TranslatePoint(new Point(), fe).Y); // var ancestorBottom = new Point(thisBottom.X, parent.TranslatePoint(new Point(), fe).Y + parent.ActualHeight); // var leftPen = fe.HorizontalAlignment == HorizontalAlignment.Left || fe.HorizontalAlignment == HorizontalAlignment.Stretch ? pen : dashPen; // var rightPen = fe.HorizontalAlignment == HorizontalAlignment.Right || fe.HorizontalAlignment == HorizontalAlignment.Stretch ? pen : dashPen; // var topPen = fe.VerticalAlignment == VerticalAlignment.Top || fe.VerticalAlignment == VerticalAlignment.Stretch ? pen : dashPen; // var bottomPen = fe.VerticalAlignment == VerticalAlignment.Bottom || fe.VerticalAlignment == VerticalAlignment.Stretch ? pen : dashPen; // drawingContext.DrawLine(leftPen, thisLeft, ancestorLeft); // drawingContext.DrawLine(rightPen, thisRight, ancestorRight); // drawingContext.DrawLine(topPen, thisTop, ancestorTop); // drawingContext.DrawLine(bottomPen, thisBottom, ancestorBottom); //} var formattedHeight = new FormattedText(string.Format("{0:0}", fe.ActualHeight), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, TypeFace, 10, brush); var formattedWidth = new FormattedText(string.Format("{0:0}", fe.ActualWidth), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, TypeFace, 10, brush); drawingContext.DrawText(formattedHeight, new Point(rect.Width + 5, (rect.Height / 2) - (formattedHeight.Height / 2))); drawingContext.DrawText(formattedWidth, new Point(rect.Width / 2 - formattedWidth.Width / 2, rect.Height + 5)); drawingContext.Pop(); }
protected override void OnRender(swm.DrawingContext dc) { var rect = new sw.Rect(Child.Bounds.X, Child.Bounds.Y, Child.Bounds.Width + 0.5, Child.Bounds.Height + 0.5); var graphics = new Graphics(Handler.Widget.Generator, new GraphicsHandler(this, dc, rect)); dc.PushGuidelineSet(new swm.GuidelineSet(new double[] { Child.Bounds.Left, Child.Bounds.Right }, new double[] { Child.Bounds.Top, Child.Bounds.Bottom })); Handler.Widget.OnPaint(new PaintEventArgs(graphics, Generator.Convert(Child.Bounds))); }
protected override void Draw(DrawingContext dc, int RenderZoom) { EarthPoint topLeftPoint = OsmIndexes.GetTopLeftPoint(HorizontalIndex, VerticalIndex, RenderZoom); Point topLeftPointScreenProjection = Projector.Project(topLeftPoint, RenderZoom); dc.PushGuidelineSet(ScreenGuidelineSet); var tileRect = new Rect(topLeftPointScreenProjection, new Size(256, 256)); DrawTile(dc, tileRect); //dc.DrawRectangle(null, new Pen(Brushes.Gray, 2), tileRect); }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { double textMaxWidth = 0; double textX = ActualWidth; switch (TextAlignment) { case TextAlignment.Left: textX = 0; break; case TextAlignment.Center: textX = ActualWidth / 2; break; case TextAlignment.Right: textX = ActualWidth; break; } if (TickRenderMode == TickRenderMode.Text || TickRenderMode == TickRenderMode.Both) { foreach (double value in Ticks) { double y = CalculateY(value); FormattedText text = new FormattedText(value.ToString(), CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, new Typeface("Tahoma"), 8.0d, Fill) { TextAlignment = TextAlignment }; drawingContext.DrawText(text, new Point(textX, y - text.Height / 2)); textMaxWidth = Math.Max(textMaxWidth, text.Width); } textMaxWidth += 3; } if (TickRenderMode == TickRenderMode.Tick || TickRenderMode == TickRenderMode.Both) { Pen pen = new Pen(Fill, 1.0d); GuidelineSet guidelineSet = new GuidelineSet(); drawingContext.PushGuidelineSet(guidelineSet); foreach (double value in Ticks) { double y = CalculateY(value) + 1; drawingContext.DrawLine(pen, new Point(0, y), new Point(ActualWidth - textMaxWidth, y)); guidelineSet.GuidelinesY.Add(y - 0.5); } drawingContext.Pop(); } }
protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); Pen pen = new Pen(LineBrush, 1); GuidelineSet gs = new GuidelineSet(); gs.GuidelinesX.Clear(); gs.GuidelinesY.Clear(); gs.GuidelinesY.Add(_lastPoint.Y - 0.5); gs.GuidelinesY.Add(_lastPoint.Y + 0.5); drawingContext.PushGuidelineSet(gs.Clone()); drawingContext.DrawLine(pen, new Point(0, _lastPoint.Y), new Point(ActualWidth, _lastPoint.Y)); drawingContext.PushGuidelineSet(gs.Clone()); gs.GuidelinesX.Clear(); gs.GuidelinesY.Clear(); gs.GuidelinesX.Add(_lastPoint.X - 0.5); gs.GuidelinesX.Add(_lastPoint.X + 0.5); drawingContext.PushGuidelineSet(gs.Clone()); drawingContext.DrawLine(pen, new Point(_lastPoint.X, 0), new Point(_lastPoint.X, ActualHeight)); drawingContext.PushGuidelineSet(gs.Clone()); }
protected override void OnRender(DrawingContext drawingContext) { var rect = new Rect(startPoint, currentPoint); if (SurpassesThreshold(rect) && isDragging) { const double thickness = 1.0; const double thicknessOffset = thickness / 2; drawingContext.PushGuidelineSet(new GuidelineSet(new[] { startPoint.X - thicknessOffset, currentPoint.X - thicknessOffset }, new[] { startPoint.Y - thicknessOffset, currentPoint.Y - thicknessOffset })); drawingContext.DrawGeometry(brush, new Pen(SystemColors.HighlightBrush, thickness), new RectangleGeometry(rect)); } base.OnRender(drawingContext); }
protected override void OnRender(DrawingContext drawingContext) { Pen pen = new Pen(Brushes.Gray, 1); Pen penDash = new Pen(Brushes.Silver, 1) { DashStyle = DashStyles.Dash }; Rect rect = new Rect(20, 20, 50, 60); double halfPenWidth = pen.Thickness / 2; TimeSpan StartTime = TimeSpan.FromHours(6); TimeSpan EndTime = TimeSpan.FromHours(24); GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rect.Left + halfPenWidth); guidelines.GuidelinesX.Add(rect.Right + halfPenWidth); guidelines.GuidelinesY.Add(rect.Top + halfPenWidth); guidelines.GuidelinesY.Add(rect.Bottom + halfPenWidth); drawingContext.PushGuidelineSet(guidelines); TimeSpan tmpTime = StartTime; int drawHours = (int)EndTime.Subtract(StartTime).TotalHours; double segmentHeight = this.ActualHeight / drawHours; for (int i = 0; i < drawHours; i++) { int y = (int)(segmentHeight * i); drawingContext.DrawLine(pen, new Point(0, y), new Point(this.ActualWidth, y)); int y2 = (int)(y + segmentHeight / 2); drawingContext.DrawLine(penDash, new Point(0, y2), new Point(this.ActualWidth, y2)); drawingContext.DrawText(new FormattedText( tmpTime.ToString(@"h\:mm"), System.Globalization.CultureInfo.CurrentCulture, FlowDirection.RightToLeft, new Typeface("Segoe UI"), 12, Brushes.Black, null, TextFormattingMode.Display),new Point(this.ActualWidth, y)); tmpTime = tmpTime.Add(TimeSpan.FromHours(1)); } TimeSpan timeNow = new TimeSpan(DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second).Subtract(StartTime); double h = segmentHeight * (timeNow.TotalHours); drawingContext.DrawLine(new Pen(Brushes.Red, 1), new Point(0, h), new Point(this.ActualWidth, h)); drawingContext.Pop(); }
public GuidelineSetBlock( DrawingContext target, IEnumerable<double> xGuides = null, IEnumerable<double> yGuides = null) { Debug.Assert(target != null); _target = target; var guidelines = new GuidelineSet(); { xGuides?.ForEach(g => guidelines.GuidelinesX.Add(g)); yGuides?.ForEach(g => guidelines.GuidelinesY.Add(g)); } target.PushGuidelineSet(guidelines); }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { if (this.pen == null) { pen = new Pen(Foreground, Thickness) { StartLineCap = PenLineCap.Round, EndLineCap = PenLineCap.Round }; previousForeground = Foreground; previousThickness = Thickness; penHalfThickness = pen.Thickness / 2.0; } else { if (Foreground != previousForeground || Thickness != previousThickness) { previousForeground = Foreground; previousThickness = Thickness; pen.Brush = Foreground; pen.Thickness = Thickness; penHalfThickness = pen.Thickness / 2.0; } } rect.X = 0.0; rect.Y = 0.0; rect.Width = this.ActualWidth; rect.Height = this.ActualHeight; GuidelineSet g = new GuidelineSet(); g.GuidelinesX.Add(rect.Left + penHalfThickness); g.GuidelinesX.Add(rect.Right + penHalfThickness); g.GuidelinesY.Add(rect.Top + penHalfThickness); g.GuidelinesY.Add(rect.Bottom + penHalfThickness); drawingContext.PushGuidelineSet(g); drawingContext.DrawRectangle(Background, pen, rect); drawingContext.Pop(); //drawingContext.DrawRectangle(Background, pen, rect); }
public void DrawLine(Pen p, Point startPoint, Point endPoint) { #if !GRID_GUIDELINE double halfPenWidth = p.Thickness / 2; // Create a guidelines set System.Windows.Media.GuidelineSet guidelines = new System.Windows.Media.GuidelineSet(); guidelines.GuidelinesX.Add(startPoint.X + halfPenWidth); guidelines.GuidelinesY.Add(startPoint.Y + halfPenWidth); g.PushGuidelineSet(guidelines); #endif // GRID_GUIDELINE g.DrawLine(p, (System.Windows.Point)startPoint, (System.Windows.Point)endPoint); #if !GRID_GUIDELINE g.Pop(); #endif // GRID_GUIDELINE }
//for linescontrol public static void DrawColumnLines(this FrameworkElement element, DrawingContext drawingContext, double RowWidth, double xOffset,double offset,Pen pen) { double halfPenHeight = pen.Thickness / 2; Point start = new Point(0, 0); Point end = new Point(0, element.RenderSize.Height); GuidelineSet guidelines = new GuidelineSet(); //draw column var count = Convert.ToInt32(element.RenderSize.Width / RowWidth); for (int i = 1; i <= count; i++) { start.X = xOffset - offset; end.X = xOffset - offset; guidelines.GuidelinesX = new DoubleCollection(new[] { xOffset - halfPenHeight, xOffset + halfPenHeight }); drawingContext.PushGuidelineSet(guidelines); drawingContext.DrawLine(pen, start, end); drawingContext.Pop(); xOffset += RowWidth; } }
public static void DrawPoint(DrawingContext dc, Point? point,string fromColor, string toColor, double duration, bool isAutoReverse) { SolidColorBrush scbW = new SolidColorBrush(Colors.Black); ColorAnimation myAnimation = new ColorAnimation((Color)ColorConverter.ConvertFromString(fromColor), (Color)ColorConverter.ConvertFromString(toColor), new Duration(TimeSpan.FromSeconds(duration))); myAnimation.AutoReverse = isAutoReverse; myAnimation.RepeatBehavior = RepeatBehavior.Forever; scbW.BeginAnimation(SolidColorBrush.ColorProperty, myAnimation); Pen wpen = new Pen(scbW, 1); Rect rectW = new Rect(point.Value.X, point.Value.Y, 0.1, 0.1); double halfPenWidth = wpen.Thickness / 2; GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rectW.Left + halfPenWidth); guidelines.GuidelinesX.Add(rectW.Right + halfPenWidth); guidelines.GuidelinesY.Add(rectW.Top + halfPenWidth); guidelines.GuidelinesY.Add(rectW.Bottom + halfPenWidth); dc.PushGuidelineSet(guidelines); dc.DrawRectangle(null, wpen, rectW); dc.Pop(); }
public GuidelineSetBlock( DrawingContext target, Rect rect, double rectPenWidth = 0, IEnumerable<double> xGuides = null, IEnumerable<double> yGuides = null) { Debug.Assert(target != null); _target = target; var guidelines = new GuidelineSet(); { guidelines.GuidelinesX.Add(rect.Left + rectPenWidth*0.5); guidelines.GuidelinesX.Add(rect.Right + rectPenWidth*0.5); guidelines.GuidelinesY.Add(rect.Top + rectPenWidth*0.5); guidelines.GuidelinesY.Add(rect.Bottom + rectPenWidth*0.5); xGuides?.ForEach(g => guidelines.GuidelinesX.Add(g)); yGuides?.ForEach(g => guidelines.GuidelinesY.Add(g)); } target.PushGuidelineSet(guidelines); }
private static void DrawLineInternal(DrawingContext dc, double half, Pen pen, bool isStroked, ref Point p0, ref Point p1) { if (!isStroked) return; var gs = new GuidelineSet( new double[] { p0.X + half, p1.X + half }, new double[] { p0.Y + half, p1.Y + half }); dc.PushGuidelineSet(gs); dc.DrawLine(isStroked ? pen : null, p0, p1); dc.Pop(); }
/// <summary> /// Performs the actual rendering of the caret on the given context. Called by /// CaretSubElement. /// </summary> /// <param name="context">Drawing context</param> /// <remarks>This method is on CaretElement instead of CaretSubElement because CaretElement /// knows all of the necessary data, and conceptually CaretSubElement only exists to provide /// a rendering surface.</remarks> internal void OnRenderCaretSubElement(DrawingContext context) { // [....] up Win32 caret position with Avalon caret position. Win32SetCaretPos(); if (_showCaret) { TextEditorThreadLocalStore threadLocalStore = TextEditor._ThreadLocalStore; Invariant.Assert(!(_italic && this.IsInInterimState), "Assert !(_italic && IsInInterimState)"); // Drawing context's pushed count to pop it up int contextPushedCount = 0; // Apply internally requested opacity. context.PushOpacity(_opacity); contextPushedCount++; // Apply italic transformation if (_italic && !(threadLocalStore.Bidi)) { // Rotate transform 20 degree for italic that is the based on 'H' italic degree. // NOTE: The angle of italic caret is constant. This is Word behavior // established after usability studies with conditional angle dependent // on font properties - they discovered that variations look annoying. // NOTE: We ignore _italic setting in _bidi case. This is Word behavior. // When flow direction is Right to Left, we need to reverse the caret transform. // // Get the flow direction which is the flow direction of AdornedElement. // CaretElement is rendering the caret that based on AdornedElement, so we can // render the right italic caret whatever the text content set the flow direction. FlowDirection flowDirection = (FlowDirection)AdornedElement.GetValue(FlowDirectionProperty); context.PushTransform(new RotateTransform( flowDirection == FlowDirection.RightToLeft ? -20 : 20, 0, _height)); contextPushedCount++; } if (this.IsInInterimState || _systemCaretWidth > DefaultNarrowCaretWidth) { // Make the block caret partially transparent to avoid obstructing text. context.PushOpacity(CaretOpacity); contextPushedCount++; } if (this.IsInInterimState) { // Render the interim block caret as the specified interim block caret width. context.DrawRectangle(_caretBrush, null, new Rect(0, 0, _interimWidth, _height)); } else { // Snap the caret to device pixels. if (!_italic || threadLocalStore.Bidi) { GuidelineSet guidelineSet = new GuidelineSet(new double[] { -(_systemCaretWidth / 2), _systemCaretWidth / 2 }, null); context.PushGuidelineSet(guidelineSet); contextPushedCount++; } // If we don't snap, the caret will render as a 2 pixel wide rect, one pixel in each bordering char bounding box. context.DrawRectangle(_caretBrush, null, new Rect(-(_systemCaretWidth / 2), 0, _systemCaretWidth, _height)); } if (threadLocalStore.Bidi) { // Set the Bidi caret indicator width. TextBox/RichTextBox control must have // the enough margin to display BiDi indicator. double bidiCaretIndicatorWidth = BidiCaretIndicatorWidth; // Get the flow direction which is the flow direction of AdornedElement. // Because CaretElement is rendering the caret that based on AdornedElement. // With getting the flow direction, we can render the BiDi caret indicator correctly // whatever AdornedElement's flow direction is set. FlowDirection flowDirection = (FlowDirection)AdornedElement.GetValue(FlowDirectionProperty); if (flowDirection == FlowDirection.RightToLeft) { // BiDi caret indicator should always direct by the right to left bidiCaretIndicatorWidth = bidiCaretIndicatorWidth * (-1); } // Draw BIDI caret to indicate the coming input is BIDI characters. // Shape is a little flag oriented to the left - as in Word. // Orientation does not depend on anything (which seems to be Word behavior). // PathGeometry pathGeometry; PathFigure pathFigure; pathGeometry = new PathGeometry(); pathFigure = new PathFigure(); pathFigure.StartPoint = new Point(0, 0); pathFigure.Segments.Add(new LineSegment(new Point(-bidiCaretIndicatorWidth, 0), true)); pathFigure.Segments.Add(new LineSegment(new Point(0, _height / BidiIndicatorHeightRatio), true)); pathFigure.IsClosed = true; pathGeometry.Figures.Add(pathFigure); context.DrawGeometry(_caretBrush, null, pathGeometry); } // Pop the drawing context if pushed for italic or opacity setting for (int i = 0; i < contextPushedCount; i++) { context.Pop(); } } else { // Destroy Win32 caret. Win32DestroyCaret(); } }
private void DrawImage(DrawingContext dc, Rect rect) { ImageSource source = Image; if (source != null) { double opacity = ImageOpacity; if (IsNineGrid) { // make sure we don't step out of borders Thickness margin = Clamp(ImageMargin, new Size(source.Width, source.Height), rect.Size); double[] xGuidelines = { 0, margin.Left, rect.Width - margin.Right, rect.Width }; double[] yGuidelines = { 0, margin.Top, rect.Height - margin.Bottom, rect.Height }; GuidelineSet guidelineSet = new GuidelineSet(xGuidelines, yGuidelines); guidelineSet.Freeze(); dc.PushGuidelineSet(guidelineSet); double[] vx = { 0D, margin.Left / source.Width, (source.Width - margin.Right) / source.Width, 1D }; double[] vy = { 0D, margin.Top / source.Height, (source.Height - margin.Bottom) / source.Height, 1D }; double[] x = { rect.Left, rect.Left + margin.Left, rect.Right - margin.Right, rect.Right }; double[] y = { rect.Top, rect.Top + margin.Top, rect.Bottom - margin.Bottom, rect.Bottom }; for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { var brush = new ImageBrush(source) { Opacity = opacity, Viewbox = new Rect(vx[j], vy[i], Math.Max(0D, (vx[j + 1] - vx[j])), Math.Max(0D, (vy[i + 1] - vy[i]))) }; dc.DrawRectangle(brush, null, new Rect(x[j], y[i], Math.Max(0D, (x[j + 1] - x[j])), Math.Max(0D, (y[i + 1] - y[i])))); } } dc.Pop(); } else { var brush = new ImageBrush(source) { Opacity = opacity }; dc.DrawRectangle(brush, null, rect); } } }
public void Draw(TextView textView, DrawingContext drawingContext) { try { textView.EnsureVisualLines(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////// bool odd = true; if (!G.AppSettings.isFixedBackgroundLines) if (textView.VisualLines.Count>0) if (textView.VisualLines[0].FirstDocumentLine.LineNumber % 2 == 0) odd = false; for (int i = 0; i < textView.VisualLines.Count; i++) { var segment2 = new TextSegment { StartOffset = textView.VisualLines[i].FirstDocumentLine.Offset, EndOffset = textView.VisualLines[i].LastDocumentLine.EndOffset }; foreach (Rect r in BackgroundGeometryBuilder.GetRectsForSegment(textView, segment2)) { if (!odd) drawingContext.DrawRectangle(scbEven, border, new Rect(r.Location, new Size(textView.ActualWidth, r.Height)));//draw even line else drawingContext.DrawRectangle(scbOdd, border, new Rect(r.Location, new Size(textView.ActualWidth, r.Height)));//draw odd line if (G.AppSettings.isShowUnderline) { string str = editor.Document.GetText(textView.VisualLines[i].FirstDocumentLine.Offset, textView.VisualLines[i].FirstDocumentLine.Length); //if (str.Contains("<frame_end>") || str.Contains("<bmp_end>")) if (Contains(str, G.AppSettings.underlineThisWords)) { double halfPenWidth = lpen.Thickness / 2; GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(r.Left + halfPenWidth); guidelines.GuidelinesX.Add(r.Right + halfPenWidth); guidelines.GuidelinesY.Add(r.Top + halfPenWidth); guidelines.GuidelinesY.Add(r.Bottom + halfPenWidth); drawingContext.PushGuidelineSet(guidelines); drawingContext.DrawLine(lpen, new Point(r.Left, r.Bottom), new Point(textView.ActualWidth, r.Bottom)); //draw underline } } if (odd) odd = false; else odd = true; } //foreach } //for //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// var line = editor.Document.GetLineByOffset(editor.CaretOffset); var segment = new TextSegment { StartOffset = line.Offset, EndOffset = line.EndOffset }; foreach (Rect r in BackgroundGeometryBuilder.GetRectsForSegment(textView, segment)) { drawingContext.DrawRectangle(lgbLine, border, new Rect(r.Location, new Size(textView.ActualWidth, r.Height))); //Draw current cursor line if (G.AppSettings.isShowUnderline) { string str2 = editor.Document.GetText(segment); if (Contains(str2, G.AppSettings.underlineThisWords)) { double halfPenWidth = lpen.Thickness / 2; GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(r.Left + halfPenWidth); guidelines.GuidelinesX.Add(r.Right + halfPenWidth); guidelines.GuidelinesY.Add(r.Top + halfPenWidth); guidelines.GuidelinesY.Add(r.Bottom + halfPenWidth); drawingContext.PushGuidelineSet(guidelines); drawingContext.DrawLine(lpen, new Point(r.Left, r.Bottom), new Point(textView.ActualWidth, r.Bottom)); //correct underline } } } } catch (Exception ex) { new wException(ex).ShowDialog(); } }//Draw end
protected override void OnRender(DrawingContext ctx) { base.OnRender(ctx); if (ctx != null) { // only solid brush is supported now var brush = (IsContentActive ? ActiveBorderBrush : InactiveBorderBrush) as SolidColorBrush; if (brush != null) { Rect rClient = new Rect(0, 0, this.ActualWidth, this.ActualHeight); var thick = BorderThickness; var clientW = rClient.Width - thick.Right - thick.Left;// -1; var clientH = rClient.Height - thick.Top - thick.Bottom;// -1; if (clientW > 1 && clientH > 1) { rClient.X += thick.Left; rClient.Y += thick.Top; rClient.Width = clientW; rClient.Height = clientH; var rTop = new Rect(rClient.Left, 0, rClient.Width, thick.Top); var rTopLeft = new Rect(0, 0, thick.Left, thick.Top); var rTopRight = new Rect(rClient.Right, 0, thick.Right, thick.Top); var rBottom = new Rect(rClient.Left, rClient.Bottom, rClient.Width, thick.Bottom); var rBottomLeft = new Rect(0, rClient.Bottom, thick.Left, thick.Bottom); var rBottomRight = new Rect(rClient.Right, rClient.Bottom, thick.Right, thick.Bottom); var rLeft = new Rect(0, rClient.Top, thick.Left, rClient.Height); var rRight = new Rect(rClient.Right, rClient.Top, thick.Right, rClient.Height); var brushes = GetShadowBrushes(brush.Color);//, (thick.Top + thick.Bottom + thick.Right + thick.Left) / 4); ctx.DrawRectangle(brushes[(int)BorderSide.TopLeft], null, rTopLeft); ctx.DrawRectangle(brushes[(int)BorderSide.TopRight], null, rTopRight); ctx.DrawRectangle(brushes[(int)BorderSide.Top], null, rTop); ctx.DrawRectangle(brushes[(int)BorderSide.BottomLeft], null, rBottomLeft); ctx.DrawRectangle(brushes[(int)BorderSide.BottomRight], null, rBottomRight); ctx.DrawRectangle(brushes[(int)BorderSide.Bottom], null, rBottom); ctx.DrawRectangle(brushes[(int)BorderSide.Left], null, rLeft); ctx.DrawRectangle(brushes[(int)BorderSide.Right], null, rRight); Pen borderPen = new Pen(brush, 1); // from http://wpftutorial.net/DrawOnPhysicalDevicePixels.html double halfPenWidth = borderPen.Thickness / 2; // Create a guidelines set GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rClient.Left + halfPenWidth); guidelines.GuidelinesX.Add(rClient.Right + halfPenWidth); guidelines.GuidelinesY.Add(rClient.Top + halfPenWidth); guidelines.GuidelinesY.Add(rClient.Bottom + halfPenWidth); ctx.PushGuidelineSet(guidelines); rClient.X -= 1; rClient.Y -= 1; rClient.Width += 1; rClient.Height += 1; ctx.DrawRectangle(null, borderPen, rClient); //ctx.DrawRectangle(null, new Pen(Brushes.Red, 1), rect); } } } }
private static void DrawPathGeometryInternal(DrawingContext dc, double half, Brush brush, Pen pen, bool isStroked, bool isFilled, PathGeometry pg) { if (!isStroked && !isFilled) return; var gs = new GuidelineSet( new double[] { pg.Bounds.TopLeft.X + half, pg.Bounds.BottomRight.X + half }, new double[] { pg.Bounds.TopLeft.Y + half, pg.Bounds.BottomRight.Y + half }); dc.PushGuidelineSet(gs); dc.DrawGeometry(isFilled ? brush : null, isStroked ? pen : null, pg); dc.Pop(); }
/// <summary> /// OnRender method. /// </summary> /// <param name="drawingContext">Drawing context.</param> protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); if (TimeAxis.ZoomMode == ZoomMode.FrameLevel) { GuidelineSet gs = new GuidelineSet(); Pen pen = new Pen(Brushes.LightGray, 1); double halfPen = pen.Thickness / 2; // draw time line for each frame for (int i = 0; i <= ActualWidth / ViewHelper.TimespanToPixel(TimeAxis.SampleInterval, TimeAxis.ZoomScale); ++i) { double x = ViewHelper.TimespanToPixel(TimeAxis.SampleInterval * (double)i, TimeAxis.ZoomScale); gs.GuidelinesX.Clear(); gs.GuidelinesX.Add(x - halfPen); gs.GuidelinesX.Add(x + halfPen); drawingContext.PushGuidelineSet(gs.Clone()); drawingContext.DrawLine(pen, new Point(x, 0), new Point(x, Height)); drawingContext.Pop(); } } }
private void RenderMarker(DrawingContext dc) { dc.PushGuidelineSet(new GuidelineSet(new double[] { 0 }, new double[] { 0.5 })); foreach(var m in _Markers) { dc.DrawLine(new Pen(Brushes.White, 1), m.StartPoint, m.EndPoint); dc.DrawText(m.Value, m.TextPoint); } dc.Pop(); }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { base.OnRender(drawingContext); double actualWidth = ActualWidth; double actualHeight = ActualHeight; // draw background drawingContext.DrawRectangle(Background, null, new Rect(0, 0, actualWidth, actualHeight)); Interval viewportInterval = VirtualViewportInterval; double scale = actualWidth / viewportInterval.Length; long ticks = FindTicks(viewportInterval.Length, (int)(Math.Round(actualWidth / 20))); Interval viewportIntervalAligned = new Interval( viewportInterval.From - (viewportInterval.From % ticks), viewportInterval.To + (viewportInterval.To % ticks)); double drawingOffset = (viewportIntervalAligned.From - viewportInterval.From) * scale; GuidelineSet guidelineSet = new GuidelineSet(); drawingContext.PushGuidelineSet(guidelineSet); // draw interval start, length & end time FormattedText formattedStartText = new FormattedText( new TimeSpan(viewportInterval.From).ToString(SCALE_TEXT_FORMAT), CultureInfo.CurrentUICulture, System.Windows.FlowDirection.LeftToRight, new Typeface("Tahoma"), SCALE_FONT_SIZE, IntervalTextColor) { TextAlignment = TextAlignment.Left }; drawingContext.DrawText(formattedStartText, new Point(1, 0)); FormattedText formattedLengthText = new FormattedText( new TimeSpan(viewportInterval.Length).ToString(SCALE_TEXT_FORMAT), CultureInfo.CurrentUICulture, System.Windows.FlowDirection.LeftToRight, new Typeface("Tahoma"), SCALE_FONT_SIZE, IntervalTextColor) { TextAlignment = TextAlignment.Center }; drawingContext.DrawText(formattedLengthText, new Point(actualWidth / 2, 0)); FormattedText formattedEndText = new FormattedText( new TimeSpan(viewportInterval.To).ToString(SCALE_TEXT_FORMAT), CultureInfo.CurrentUICulture, System.Windows.FlowDirection.LeftToRight, new Typeface("Tahoma"), SCALE_FONT_SIZE, IntervalTextColor) { TextAlignment = TextAlignment.Right }; drawingContext.DrawText(formattedEndText, new Point(actualWidth - 1, 0)); // draw markers and time int timeDrawingRate = 5; long markerCount = (viewportIntervalAligned.From / ticks) % timeDrawingRate; for (long i = 0; i < viewportIntervalAligned.Length; i += ticks) { double markerHeight = actualHeight - (SCALE_HEIGHT / 2 * 1.5); double x = i * scale + drawingOffset; // draw time if (markerCount++ % timeDrawingRate == 0) { markerHeight = actualHeight - SCALE_HEIGHT; FormattedText formattedText = new FormattedText( new TimeSpan(viewportIntervalAligned.From + i).ToString(SCALE_TEXT_FORMAT), CultureInfo.CurrentUICulture, System.Windows.FlowDirection.LeftToRight, new Typeface("Tahoma"), SCALE_FONT_SIZE, Foreground) { TextAlignment = TextAlignment.Center }; drawingContext.DrawText(formattedText, new Point(x, actualHeight - SCALE_HEIGHT - SCALE_FONT_SIZE * 1.2)); } // draw marker guidelineSet.GuidelinesX.Add(x + 0.5); drawingContext.DrawLine(new Pen(Foreground, 1), new Point(x, markerHeight), new Point(x, actualHeight)); } // draw markers' bottom line //guidelineSet.GuidelinesY.Add(actualHeight - 0.5); //drawingContext.DrawLine(new Pen(Foreground, 1), // new Point(0, actualHeight - 1), new Point(actualWidth, actualHeight - 1)); drawingContext.Pop(); }
protected override void OnRender( DrawingContext ctx ) { base.OnRender( ctx ); var thinPen = new Pen( this.Foreground, 1 ); var thickPen = new Pen( this.Foreground, 3 ); var halfPenWidth = thinPen.Thickness / 2; var guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add( 0 + halfPenWidth ); guidelines.GuidelinesY.Add( 0 + halfPenWidth ); ctx.PushGuidelineSet( guidelines ); Point pt1, pt2, pt3; if( Orientation == Orientation.Horizontal ) { pt1 = new Point( MousePosition, RenderSize.Height ); pt2 = new Point( MousePosition, RenderSize.Height - ToothSize ); pt3 = new Point( MousePosition, RenderSize.Height - ToothSize - NeedleSize ); } else { pt1 = new Point( 0, MousePosition ); pt2 = new Point( ToothSize, MousePosition ); pt3 = new Point( ToothSize + NeedleSize, MousePosition ); } ctx.DrawLine( new Pen( Brushes.White, 3 ), pt1, pt2 ); ctx.DrawLine( thinPen, pt1, pt2 ); ctx.DrawLine( thickPen, pt2, pt3 ); // var axisLabel = new FormattedText( MousePosition.ToString(), CultureInfo.CurrentCulture, FlowDirection.LeftToRight, // tooltipTypeface, FontSize, Foreground ); //ctx.DrawText( axisLabel, new Point( ToothSize + MinorTickSize + 3, y - 2 ) );; }
DrawPixelAlignedRectangle ( DrawingContext drawingContext, Brush brush, Pen pen, Rect rect ) { Debug.Assert(drawingContext != null); Debug.Assert(pen != null); // This technique was described at "Draw lines excactly on physical // device pixels," by Christian Mosers, at // http://wpftutorial.net/DrawOnPhysicalDevicePixels.html. Double dHalfPenWidth = pen.Thickness / 2.0; GuidelineSet oGuidelineSet = new GuidelineSet(); DoubleCollection oGuidelinesX = oGuidelineSet.GuidelinesX; DoubleCollection oGuidelinesY = oGuidelineSet.GuidelinesY; oGuidelinesX.Add(rect.Left + dHalfPenWidth); oGuidelinesX.Add(rect.Right + dHalfPenWidth); oGuidelinesY.Add(rect.Top + dHalfPenWidth); oGuidelinesY.Add(rect.Bottom + dHalfPenWidth); drawingContext.PushGuidelineSet(oGuidelineSet); drawingContext.DrawRectangle(brush, pen, rect); drawingContext.Pop(); }
protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); double dpiFactor = 1; // If there's no LabelTemplate, there's no label to place. // If there's no label to place, there's no connecting lines that need to be drawn. // Additionally, if there is no brush or if the line is too small to render // we can't draw the connectors if (LabelTemplate == null || (LeaderThickness) < 0.25) { return; } // If possible, find the factor to adjust the pen width to device pixels PresentationSource source = PresentationSource.FromVisual(this); if (source != null && source.CompositionTarget != null) { // PresentationSource and CompositionTarget should never be null at this point, // but we still need to check to see if they are since the API doesn't guarantee // the return value is not null. Matrix matrix = source.CompositionTarget.TransformToDevice; dpiFactor = 1 / matrix.M11; } foreach ( FrameworkElement element in InternalChildren.OfType<FrameworkElement>().Where(child => !GetIsLabel(child))) { FrameworkElement label = GetLabelPresenter(element); if (label == null || !label.IsVisible || !element.IsVisible) { // Don't draw any lines when there are no labels for an element, or if either the label // or the element are not visible continue; } Brush leaderBrush = GetLabelBrush(element); if (leaderBrush == null || Equals(leaderBrush, Brushes.Transparent)) { // If the color is transparent, don't waste processing time drawing a leader // that won't be seen anyway. continue; } leaderBrush.Freeze(); Pen linePen = new Pen(leaderBrush, LeaderThickness * dpiFactor); linePen.Freeze(); Rect objectRect = new Rect(element.TranslatePoint(new Point(), this), element.RenderSize); Rect labelRect = new Rect(label.TranslatePoint(new Point(), this), label.RenderSize); double halfPenWidth = linePen.Thickness / 2; // Set up snap to pixels GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(objectRect.Right + halfPenWidth); guidelines.GuidelinesX.Add(labelRect.Left + halfPenWidth); guidelines.GuidelinesY.Add(objectRect.Top + halfPenWidth); guidelines.GuidelinesY.Add(labelRect.Top + halfPenWidth); // Do snap to pixels work. drawingContext.PushGuidelineSet(guidelines); if (objectRect.Width > 0 && labelRect.Width > 0) { Point startPoint = new Point(objectRect.Right + linePen.Thickness, objectRect.Top + (objectRect.Height / 2)); Point endPoint = new Point(labelRect.Left, labelRect.Top + (labelRect.Height / 2)); drawingContext.DrawLine(linePen, startPoint, endPoint); drawingContext.DrawLine(linePen, labelRect.TopLeft, labelRect.BottomLeft); } drawingContext.Pop(); } }
private static void DrawRectangleInternal(DrawingContext dc, double half, Brush brush, Pen pen, bool isStroked, bool isFilled, ref Rect rect) { if (!isStroked && !isFilled) return; var gs = new GuidelineSet( new double[] { rect.TopLeft.X + half, rect.BottomRight.X + half }, new double[] { rect.TopLeft.Y + half, rect.BottomRight.Y + half }); dc.PushGuidelineSet(gs); dc.DrawRectangle(isFilled ? brush : null, isStroked ? pen : null, rect); dc.Pop(); }
public static void DrawLayout( Circuit.SymbolLayout Layout, DrawingContext Context, Matrix Tx, Pen Pen, FontFamily FontFamily, FontWeight FontWeight, double FontSize) { Context.PushGuidelineSet(Guidelines); foreach (Circuit.SymbolLayout.Shape i in Layout.Lines) Context.DrawLine( Pen != null ? Pen : MapToPen(i.Edge), T(Tx, i.x1), T(Tx, i.x2)); foreach (Circuit.SymbolLayout.Shape i in Layout.Rectangles) Context.DrawRectangle( (i.Fill && Pen == null) ? MapToBrush(i.Edge) : null, Pen != null ? Pen : MapToPen(i.Edge), new Rect(T(Tx, i.x1), T(Tx, i.x2))); foreach (Circuit.SymbolLayout.Shape i in Layout.Ellipses) { Brush brush = (i.Fill && Pen == null) ? MapToBrush(i.Edge) : null; Pen pen = Pen != null ? Pen : MapToPen(i.Edge); Point p1 = T(Tx, i.x1); Point p2 = T(Tx, i.x2); Context.DrawEllipse( brush, pen, new Point((p1.X + p2.X) / 2, (p1.Y + p2.Y) / 2), (p2.X - p1.X) / 2, (p2.Y - p1.Y) / 2); } foreach (Circuit.SymbolLayout.Curve i in Layout.Curves) { IEnumerator<Circuit.Point> e = i.x.AsEnumerable().GetEnumerator(); if (!e.MoveNext()) return; Pen pen = Pen != null ? Pen : MapToPen(i.Edge); Point x1 = T(Tx, e.Current); while (e.MoveNext()) { Point x2 = T(Tx, e.Current); Context.DrawLine(pen, x1, x2); x1 = x2; } } if (FontFamily != null) { // Not sure if this matrix has row or column vectors... want the y axis scaling here. double scale = Math.Sqrt(Tx.M11 * Tx.M11 + Tx.M21 * Tx.M21); foreach (Circuit.SymbolLayout.Text i in Layout.Texts) { double size; switch (i.Size) { case Circuit.Size.Small: size = 0.5; break; case Circuit.Size.Large: size = 1.5; break; default: size = 1.0; break; } FormattedText text = new FormattedText( i.String, CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, new Typeface(FontFamily, FontStyles.Normal, FontWeight, FontStretches.Normal), FontSize * scale * size, Brushes.Black); Point p = T(Tx, i.x); Vector p1 = T(Tx, new Circuit.Point(i.x.x - MapAlignment(i.HorizontalAlign), i.x.y + (1 - MapAlignment(i.VerticalAlign)))) - p; Vector p2 = T(Tx, new Circuit.Point(i.x.x - (1 - MapAlignment(i.HorizontalAlign)), i.x.y + MapAlignment(i.VerticalAlign))) - p; p1.X *= text.Width; p2.X *= text.Width; p1.Y *= text.Height; p2.Y *= text.Height; Rect rc = new Rect( Math.Min(p.X + p1.X, p.X - p2.X), Math.Min(p.Y + p1.Y, p.Y - p2.Y), text.Width, text.Height); if (TextOutline != null) Context.DrawRectangle(null, TextOutline, rc); Context.DrawText(text, rc.TopLeft); } } foreach (Circuit.Terminal i in Layout.Terminals) DrawTerminal(Context, T(Tx, Layout.MapTerminal(i)), i.ConnectedTo != null); Context.Pop(); }
private static void DrawEllipseInternal(DrawingContext dc, double half, Brush brush, Pen pen, bool isStroked, bool isFilled, ref Point center, double rx, double ry) { if (!isStroked && !isFilled) return; var gs = new GuidelineSet( new double[] { center.X - rx + half, center.X + rx + half }, new double[] { center.Y - ry + half, center.Y + ry + half }); dc.PushGuidelineSet(gs); dc.DrawEllipse(isFilled ? brush : null, isStroked ? pen : null, center, rx, ry); dc.Pop(); }
protected override void OnRender(DrawingContext drawingContext) { Matrix transform = Transform; dc = drawingContext; dc.PushGuidelineSet(SymbolControl.Guidelines); DrawLayout(layout, dc, transform, Pen, ShowText ? FontFamily : null, FontWeight, FontSize); Rect bounds = new Rect(T(transform, layout.LowerBound), T(transform, layout.UpperBound)); if (Selected) dc.DrawRectangle(null, SelectedPen, bounds); else if (Highlighted) dc.DrawRectangle(null, HighlightPen, bounds); dc.Pop(); dc = null; }
protected override void OnRender( DrawingContext drawingContext ) { if( this.ConnectionLinePen != null ) { bool left = false; bool top = false; bool middle = false; switch( this.ConnectionLineAlignment ) { case ConnectionLineAlignment.LeftToBottom: left = true; break; case ConnectionLineAlignment.RightToTop: top = true; break; case ConnectionLineAlignment.LeftToTop: left = true; top = true; break; case ConnectionLineAlignment.CenterToCenter: middle = true; break; case ConnectionLineAlignment.RightToBottom: default: break; } //cycling with count -1 because we don't want to draw a ligne after last item for( int i = 0; i < this.InternalChildren.Count - 1; i++ ) { UIElement startItem = this.InternalChildren[ i ]; UIElement endItem = this.InternalChildren[ i + 1 ]; Vector startOffset = VisualTreeHelper.GetOffset( startItem ); Vector endOffset = VisualTreeHelper.GetOffset( endItem ); Size startSize = startItem.RenderSize; Size endSize = endItem.RenderSize; double startPointX = 0.0d; double startPointY = 0.0d; double endPointX = 0.0d; double endPointY = 0.0d; List<PathSegment> myPathSegments = null; GuidelineSet guidelineSet = new GuidelineSet(); drawingContext.PushGuidelineSet( guidelineSet ); if( middle == true ) { startPointX = startOffset.X + startSize.Width + this.ConnectionLineOffset; startPointY = startOffset.Y + ( startSize.Height / 2 ); endPointY = endOffset.Y + ( endSize.Height / 2 ); endPointX = endOffset.X - this.ConnectionLineOffset; double deltaX = ( endPointX - startPointX ); guidelineSet.GuidelinesX.Add( startPointX ); guidelineSet.GuidelinesX.Add( startPointX + ( deltaX / 2 ) + 0.5d ); guidelineSet.GuidelinesX.Add( startPointX + deltaX ); guidelineSet.GuidelinesY.Add( startPointY ); guidelineSet.GuidelinesY.Add( endPointY ); myPathSegments = new List<PathSegment>( 4 ); //we know there are going be only 4 segments myPathSegments.Add( new LineSegment( new Point( startPointX, startPointY ), true ) ); myPathSegments.Add( new LineSegment( new Point( startPointX + ( deltaX / 2 ), startPointY ), true ) ); myPathSegments.Add( new LineSegment( new Point( startPointX + ( deltaX / 2 ), endPointY ), true ) ); myPathSegments.Add( new LineSegment( new Point( startPointX + deltaX, endPointY ), true ) ); } else { if( left == true ) { startPointX = startOffset.X + this.ConnectionLineOffset; } else { startPointX = startOffset.X + startSize.Width - this.ConnectionLineOffset; } startPointY = startOffset.Y + startSize.Height; if( top == true ) { endPointY = endOffset.Y + this.ConnectionLineOffset; } else { endPointY = endOffset.Y + endSize.Height - this.ConnectionLineOffset; } endPointX = endOffset.X; guidelineSet.GuidelinesX.Add( startPointX ); guidelineSet.GuidelinesX.Add( endPointX ); guidelineSet.GuidelinesY.Add( startPointY ); guidelineSet.GuidelinesY.Add( endPointY ); myPathSegments = new List<PathSegment>( 2 ); //we know there are going be only 2 segments myPathSegments.Add( new LineSegment( new Point( startPointX, endPointY ), true ) ); myPathSegments.Add( new LineSegment( new Point( endPointX, endPointY ), true ) ); } PathFigure myPathFigure = new PathFigure( new Point( startPointX, startPointY ), myPathSegments, false ); PathGeometry myPathGeometry = new PathGeometry(); myPathGeometry.Figures.Add( myPathFigure ); drawingContext.DrawGeometry( null, this.ConnectionLinePen, myPathGeometry ); // pop the context to remove the GuidelineSet drawingContext.Pop(); } } base.OnRender( drawingContext ); }
/// <summary> /// Render callback. /// </summary> protected override void OnRender(DrawingContext drawingContext) { CornerRadius cornerRadius = CornerRadius; Rect shadowBounds = new Rect(new Point(ShadowDepth, ShadowDepth), new Size(RenderSize.Width, RenderSize.Height)); Color color = Color; if (shadowBounds.Width > 0 && shadowBounds.Height > 0 && color.A > 0) { // The shadow is drawn with a dark center the size of the shadow bounds // deflated by shadow depth on each side. double centerWidth = shadowBounds.Right - shadowBounds.Left - 2 * ShadowDepth; double centerHeight = shadowBounds.Bottom - shadowBounds.Top - 2 * ShadowDepth; // Clamp corner radii to be less than 1/2 the side of the inner shadow bounds double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius); // Get the brushes for the 9 regions Brush[] brushes = GetBrushes(color, cornerRadius); // Snap grid to device pixels double centerTop = shadowBounds.Top + ShadowDepth; double centerLeft = shadowBounds.Left + ShadowDepth; double centerRight = shadowBounds.Right - ShadowDepth; double centerBottom = shadowBounds.Bottom - ShadowDepth; // Because of different corner radii there are 6 potential x (or y) lines to snap to double[] guidelineSetX = new double[] { centerLeft, centerLeft + cornerRadius.TopLeft, centerRight - cornerRadius.TopRight, centerLeft + cornerRadius.BottomLeft, centerRight - cornerRadius.BottomRight, centerRight}; double[] guidelineSetY = new double[] { centerTop, centerTop + cornerRadius.TopLeft, centerTop + cornerRadius.TopRight, centerBottom - cornerRadius.BottomLeft, centerBottom - cornerRadius.BottomRight, centerBottom}; drawingContext.PushGuidelineSet(new GuidelineSet(guidelineSetX, guidelineSetY)); // The corner rectangles are drawn drawn ShadowDepth pixels bigger to // account for the blur cornerRadius.TopLeft = cornerRadius.TopLeft + ShadowDepth; cornerRadius.TopRight = cornerRadius.TopRight + ShadowDepth; cornerRadius.BottomLeft = cornerRadius.BottomLeft + ShadowDepth; cornerRadius.BottomRight = cornerRadius.BottomRight + ShadowDepth; // Draw Top row Rect topLeft = new Rect(shadowBounds.Left, shadowBounds.Top, cornerRadius.TopLeft, cornerRadius.TopLeft); drawingContext.DrawRectangle(brushes[TopLeft], null, topLeft); double topWidth = guidelineSetX[2] - guidelineSetX[1]; if (topWidth > 0) { Rect top = new Rect(guidelineSetX[1], shadowBounds.Top, topWidth, ShadowDepth); drawingContext.DrawRectangle(brushes[Top], null, top); } Rect topRight = new Rect(guidelineSetX[2], shadowBounds.Top, cornerRadius.TopRight, cornerRadius.TopRight); drawingContext.DrawRectangle(brushes[TopRight], null, topRight); // Middle row double leftHeight = guidelineSetY[3] - guidelineSetY[1]; if (leftHeight > 0) { Rect left = new Rect(shadowBounds.Left, guidelineSetY[1], ShadowDepth, leftHeight); drawingContext.DrawRectangle(brushes[Left], null, left); } double rightHeight = guidelineSetY[4] - guidelineSetY[2]; if (rightHeight > 0) { Rect right = new Rect(guidelineSetX[5], guidelineSetY[2], ShadowDepth, rightHeight); drawingContext.DrawRectangle(brushes[Right], null, right); } // Bottom row Rect bottomLeft = new Rect(shadowBounds.Left, guidelineSetY[3], cornerRadius.BottomLeft, cornerRadius.BottomLeft); drawingContext.DrawRectangle(brushes[BottomLeft], null, bottomLeft); double bottomWidth = guidelineSetX[4] - guidelineSetX[3]; if (bottomWidth > 0) { Rect bottom = new Rect(guidelineSetX[3], guidelineSetY[5], bottomWidth, ShadowDepth); drawingContext.DrawRectangle(brushes[Bottom], null, bottom); } Rect bottomRight = new Rect(guidelineSetX[4], guidelineSetY[4], cornerRadius.BottomRight, cornerRadius.BottomRight); drawingContext.DrawRectangle(brushes[BottomRight], null, bottomRight); // Fill Center // Because the heights of the top/bottom rects and widths of the left/right rects are fixed // and the corner rects are drawn with the size of the corner, the center // may not be a square. In this case, create a path to fill the area // When the target object's corner radius is 0, only need to draw one rect if (cornerRadius.TopLeft == ShadowDepth && cornerRadius.TopLeft == cornerRadius.TopRight && cornerRadius.TopLeft == cornerRadius.BottomLeft && cornerRadius.TopLeft == cornerRadius.BottomRight) { // All corners of target are 0, render one large rectangle Rect center = new Rect(guidelineSetX[0], guidelineSetY[0], centerWidth, centerHeight); drawingContext.DrawRectangle(brushes[Center], null, center); } else { // If the corner radius is TL=2, TR=1, BL=0, BR=2 the following shows the shape that needs to be created. // _________________ // | |_ // _ _| | // | | // | _ _| // | | // |___________________| // The missing corners of the shape are filled with the radial gradients drawn above // Define shape counter clockwise PathFigure figure = new PathFigure(); if (cornerRadius.TopLeft > ShadowDepth) { figure.StartPoint = new Point(guidelineSetX[1], guidelineSetY[0]); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[1], guidelineSetY[1]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[0], guidelineSetY[1]), true)); } else { figure.StartPoint = new Point(guidelineSetX[0], guidelineSetY[0]); } if (cornerRadius.BottomLeft > ShadowDepth) { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[0], guidelineSetY[3]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[3], guidelineSetY[3]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[3], guidelineSetY[5]), true)); } else { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[0], guidelineSetY[5]), true)); } if (cornerRadius.BottomRight > ShadowDepth) { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[4], guidelineSetY[5]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[4], guidelineSetY[4]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[4]), true)); } else { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[5]), true)); } if (cornerRadius.TopRight > ShadowDepth) { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[2]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[2], guidelineSetY[2]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[2], guidelineSetY[0]), true)); } else { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[0]), true)); } figure.IsClosed = true; figure.Freeze(); PathGeometry geometry = new PathGeometry(); geometry.Figures.Add(figure); geometry.Freeze(); drawingContext.DrawGeometry(brushes[Center], null, geometry); } drawingContext.Pop(); } }
private void RenderGridLine(DrawingContext dc) { SolidColorBrush solidbrush = new SolidColorBrush(Color.FromArgb(0xff, 0xb0, 0xb0, 0xb0)); //#FFB0B0B0 Pen p = new Pen(solidbrush, 1); p.DashStyle = DashStyles.Dash; dc.PushGuidelineSet(new GuidelineSet(new double[] {0.5 },new double[] { 0.5})); foreach (var m in _Markers) { dc.DrawLine(p,m.GridStartPoint, m.GridEndPoint); } dc.Pop(); }
protected override void OnRender( DrawingContext drawingContext ) { base.OnRender( drawingContext ); Brush contentBrush = this.ContentBorderBrush; Thickness contentThickness = this.ContentBorderThickness; Rect usedSurface = this.UsedSurface; if( ( contentBrush != null ) && ( usedSurface != Rect.Empty ) ) { Pen myPen = new Pen( contentBrush, contentThickness.Left ); GuidelineSet gls = new GuidelineSet(); gls.GuidelinesX.Add( 0 ); gls.GuidelinesX.Add( usedSurface.Right ); gls.GuidelinesY.Add( 0 ); gls.GuidelinesY.Add( usedSurface.Bottom ); drawingContext.PushGuidelineSet( gls ); if( contentThickness.Left > 0 ) { drawingContext.DrawLine( myPen, new Point( 0 + ( contentThickness.Left / 2 ), 0 ), new Point( 0 + ( contentThickness.Left / 2 ), usedSurface.Bottom + contentThickness.Top ) ); } if( contentThickness.Top > 0 ) { if( myPen.Thickness != contentThickness.Top ) { myPen = new Pen( contentBrush, contentThickness.Top ); } drawingContext.DrawLine( myPen, new Point( 0, 0 + ( contentThickness.Top / 2 ) ), new Point( usedSurface.Right + contentThickness.Left, 0 + ( contentThickness.Top / 2 ) ) ); } if( contentThickness.Right > 0 ) { if( myPen.Thickness != contentThickness.Right ) { myPen = new Pen( contentBrush, contentThickness.Right ); } drawingContext.DrawLine( myPen, new Point( usedSurface.Right + ( contentThickness.Right / 2 ), 0 ), new Point( usedSurface.Right + ( contentThickness.Right / 2 ), usedSurface.Bottom + contentThickness.Top ) ); } if( contentThickness.Bottom > 0 ) { if( myPen.Thickness != contentThickness.Bottom ) { myPen = new Pen( contentBrush, contentThickness.Bottom ); } drawingContext.DrawLine( myPen, new Point( 0, usedSurface.Bottom + ( contentThickness.Bottom / 2 ) ), new Point( usedSurface.Right + contentThickness.Left, usedSurface.Bottom + ( contentThickness.Bottom / 2 ) ) ); } drawingContext.Pop(); } }
protected override void OnRender(DrawingContext dc) { if (!guidelinesFixed) { System.Windows.Media.Matrix m = PresentationSource.FromVisual(this).CompositionTarget.TransformToDevice; halfDpiX = m.M11 * 0.5; halfDpiY = m.M22 * 0.5; guidelinesFixed = true; } // Create a guidelines set GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(halfDpiX); guidelines.GuidelinesY.Add(halfDpiY); dc.PushGuidelineSet(guidelines); dc.DrawRectangle(backgroundBrush, null, new Rect(0, 0, ActualWidth, ActualHeight)); double range; double pos = 0; double orderOfMag; double stepSize = 0.1; switch (Orientation) { case RulerOrientation.Vertical: //// Thin horizontal lines //range = MaxY - MinY; //orderOfMag = Math.Pow(10, Math.Truncate(Math.Log10(range))); //stepSize = 0.1 * orderOfMag; pos = (Math.Truncate(MinY / stepSize) - 0) * stepSize; //DrawGridHorizonalLines(dc, pos, stepSize, gridLinePen); break; case RulerOrientation.Horizontal: // Thin vertical lines. //range = MaxX - MinX; //orderOfMag = Math.Pow(10, Math.Truncate(Math.Log10(range))); //stepSize = 0.1 * orderOfMag; pos = Math.Truncate(MinX / stepSize) * stepSize; //DrawGridVerticalLines(dc, pos, stepSize, gridLinePen); // Draw the seek needle var needlePos = new System.Windows.Point(NeedlePosition, 0); needlePos = CurveCoordsToScreen(ref needlePos); dc.PushTransform(new TranslateTransform(needlePos.X, needlePos.Y)); dc.DrawDrawing(SeekNeedle); dc.Pop(); break; } dc.Pop(); switch (Orientation) { case RulerOrientation.Vertical: DrawHorizontalLinesText(dc, pos, stepSize); break; case RulerOrientation.Horizontal: DrawVerticalLinesText(dc, pos, stepSize); break; } base.OnRender(dc); }
private void RenderLine(DrawingContext dc) { dc.PushGuidelineSet(new GuidelineSet(new double[] { 0.5 }, new double[] { 0 })); dc.DrawLine(new Pen(Brushes.White, 1), StartPoint, EndPoint); dc.Pop(); }