protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); drawingContext.PushTransform(new TranslateTransform(AdornedElement.RenderSize.Width - 14, (AdornedElement.RenderSize.Height - 18) / 2.0)); drawingContext.DrawGeometry(ArrowBrush, null, sda_render_geometry); drawingContext.Pop(); }
protected override void DrawPointElement(DrawingContext dc, int Zoom) { dc.DrawLine(new Pen(Brushes.Black, 2), new Point(), new Point(0, -BodyOffset)); dc.PushTransform(new TranslateTransform(0, - 0.5 * BodyHeight - BodyOffset)); dc.DrawRectangle(Brushes.Black, null, new Rect(-0.5 * BodyWidth, -0.5 * BodyHeight, BodyWidth, BodyHeight)); for (int i = 0; i < Lights.Length; i++) dc.DrawEllipse(Lights[i], null, new Point(0, (2 + LightRadius + 1) * (i - 1)), LightRadius, LightRadius); dc.PushTransform(new TranslateTransform(0.5 * BodyWidth + 2, -0.5 * BodyHeight)); if (Zoom > 11) { PrintStack(dc, new FormattedText(Target.Name, CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Verdana"), 10, Brushes.Black), new FormattedText(OrdinateString, CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Verdana"), 8, Brushes.Blue)); } dc.Pop(); dc.Pop(); }
public void drawLimb(DrawingContext dc, Point p1, Point p2, int margin) { dc.PushTransform(new TranslateTransform(p1.X, p1.Y)); Vector diff = p2 - p1; diff.Normalize(); double angle = Math.Acos(diff.Y) * (180.0 / Math.PI); if (Double.IsNaN(angle)) angle = 0; if (Double.IsNaN(diff.X)) diff.X = 0; dc.PushTransform(new RotateTransform(Math.Sign(diff.X) * (-1) * angle)); Vector diff2 = p2 - p1; double scale = diff2.Length / (this.Height - 2 * margin); dc.PushTransform(new ScaleTransform(1, scale)); dc.PushTransform(new TranslateTransform(-this.Width / 2.0, -margin)); dc.DrawImage(this.Image, new Rect(0, 0, this.Width, this.Height)); dc.Pop(); dc.Pop(); dc.Pop(); dc.Pop(); }
protected override void InnerDraw(DrawingContext drawingContext) { drawingContext.PushTransform(_translateTransform); drawingContext.PushTransform(_rotateTransform); base.InnerDraw(drawingContext); drawingContext.Pop(); drawingContext.Pop(); }
private void DrawTriangle(DrawingContext drawingContext, Point origin, double rotation) { drawingContext.PushTransform(new TranslateTransform(origin.X, origin.Y)); drawingContext.PushTransform(new RotateTransform(rotation)); drawingContext.DrawGeometry(m_Pen.Brush, null, m_Triangle); drawingContext.Pop(); drawingContext.Pop(); }
/// <summary>This method performs the actual render operation to show a text label</summary> /// <param name="dc">Drawing context</param> /// <param name="info">Render info</param> /// <param name="scale">The scale.</param> /// <param name="offset">The offset.</param> public virtual void RenderHeader(DrawingContext dc, AutoHeaderTextRenderInfo info, double scale, Point offset) { dc.PushTransform(new TranslateTransform(offset.X, offset.Y)); dc.PushTransform(new ScaleTransform(scale, scale)); dc.PushClip(new RectangleGeometry(info.RenderRect)); info.FormattedText.SetMaxTextWidths(new[] { info.RenderRect.Width }); info.FormattedText.MaxLineCount = 1; info.FormattedText.Trimming = TextTrimming.CharacterEllipsis; dc.DrawText(info.FormattedText, info.RenderRect.TopLeft); dc.Pop(); dc.Pop(); dc.Pop(); }
//private const int Margin = 3; protected override void InnerDraw(DrawingContext drawingContext) { base.InnerDraw(drawingContext); if (_scaleTransform != null) drawingContext.PushTransform(_scaleTransform); if (_clipGeometry != null) drawingContext.PushClip(_clipGeometry); drawingContext.DrawDrawing(_textDrawing); if (_clipGeometry != null) drawingContext.Pop(); if (_scaleTransform != null) drawingContext.Pop(); }
protected override void OnRender(DrawingContext drawingContext) { AnimationControl(); var width = Width < 1 ? 1 : Width; drawingContext.PushTransform(new TranslateTransform(RenderSize.Width / 2, RenderSize.Height / 2)); for (int i = 0; i < c_Blobs; i++) { drawingContext.PushTransform(new RotateTransform((360 / c_Blobs) * i)); drawingContext.DrawRectangle(m_Brushes[i], null, new Rect(0, width / 4.25, width / 16.0, width / 4.0)); drawingContext.Pop(); } drawingContext.Pop(); }
protected override void InnerDraw(DrawingContext drawingContext) { base.InnerDraw(drawingContext); drawingContext.PushTransform(_scaleTransform); drawingContext.DrawDrawing(_textDrawing); drawingContext.Pop(); }
/// <summary>This method draws a rectangular background around a group of elements</summary> /// <param name="dc">The drawing context.</param> /// <param name="info">Render info</param> /// <param name="scale">The scale.</param> /// <param name="offset">The offset.</param> public virtual void RenderBackground(DrawingContext dc, GroupBackgroundRenderInfo info, double scale, Point offset) { dc.PushTransform(new TranslateTransform(offset.X, offset.Y)); dc.PushTransform(new ScaleTransform(scale, scale)); dc.DrawRectangle(info.Background, null, info.RenderRect); if (info.Border != null && info.BorderWidth > 0) { var rect2 = new Rect(info.RenderRect.X + (info.BorderWidth/2), info.RenderRect.Y + (info.BorderWidth/2), info.RenderRect.Width + info.BorderWidth, info.RenderRect.Height + info.BorderWidth); dc.DrawRectangle(null, new Pen(info.Border, info.BorderWidth), rect2); } dc.Pop(); dc.Pop(); }
protected override void OnRender(DrawingContext drawingContext) { // draw everything except the reflection base.OnRender(drawingContext); // set opacity drawingContext.PushOpacityMask(opacityMask); reflection.Visual = Child; var group = new TransformGroup(); if (Child.RenderTransform is TransformGroup) { foreach (var child in ((TransformGroup)Child.RenderTransform).Children) { group.Children.Add(child); } } else { group.Children.Add(Child.RenderTransform); } scaleTransform.CenterY = (ActualHeight / 1.5) + ((ActualHeight / 1.5) / 4); scaleTransform.CenterX = ActualWidth / 2; group.Children.Add(scaleTransform); reflection.Transform = group; // draw the reflection drawingContext.DrawRectangle( reflection, null, new Rect(0, ActualHeight / 1.5, ActualWidth, ActualHeight / 3)); // cleanup drawingContext.Pop(); }
protected override void ApplyFilter(FastBitmap source, DrawingContext dc, int width, int height) { Vector offsetSize = GetOffsetSize() + new Vector(Size, Size); dc.PushTransform(new TranslateTransform(offsetSize.X, offsetSize.Y)); base.ApplyFilter(source, dc, width, height); dc.Pop(); }
public void Draw(LayerPropertiesModel props, LayerPropertiesModel applied, DrawingContext c) { if (applied?.Brush == null) return; const int scale = 4; // Set up variables for this frame var rect = props.Contain ? new Rect(applied.X*scale, applied.Y*scale, applied.Width*scale, applied.Height*scale) : new Rect(props.X*scale, props.Y*scale, props.Width*scale, props.Height*scale); var clip = new Rect(applied.X*scale, applied.Y*scale, applied.Width*scale, applied.Height*scale); // Take an offset of 4 to allow layers to slightly leave their bounds var progress = (6.0 - props.AnimationProgress)*10.0; if (progress < 0) { // Can't meddle with the original brush because it's frozen. var brush = applied.Brush.Clone(); brush.Opacity = 1 + 0.025*progress; if (brush.Opacity < 0) brush.Opacity = 0; if (brush.Opacity > 1) brush.Opacity = 1; applied.Brush = brush; } rect.Inflate(-rect.Width/100.0*progress, -rect.Height/100.0*progress); clip.Inflate(-clip.Width/100.0*progress, -clip.Height/100.0*progress); c.PushClip(new RectangleGeometry(clip)); c.DrawRectangle(applied.Brush, null, rect); c.Pop(); }
protected override void OnRender(DrawingContext dc) { Point pos, tangent; double angleInRadians; double angleInDegrees; TransformGroup tg; Pen pen = new Pen(Stroke, StrokeThickness); //dc.DrawGeometry(null, pen, LinePath); if (BeginCap != null) { LinePath.GetPointAtFractionLength(0.01d, out pos, out tangent); angleInRadians = Math.Atan2(tangent.Y, tangent.X) + Math.PI; angleInDegrees = angleInRadians * 180 / Math.PI + 180; tg = new TransformGroup(); tg.Children.Add(new RotateTransform(angleInDegrees)); LinePath.GetPointAtFractionLength(0.0d, out pos, out tangent); tg.Children.Add(new TranslateTransform(pos.X, pos.Y)); dc.PushTransform(tg); dc.DrawGeometry(Brushes.DeepPink, pen, BeginCap); dc.Pop(); } if (EndCap != null) { LinePath.GetPointAtFractionLength(0.99, out pos, out tangent); angleInRadians = Math.Atan2(tangent.Y, tangent.X) + Math.PI; angleInDegrees = angleInRadians * 180 / Math.PI; tg = new TransformGroup(); tg.Children.Add(new RotateTransform(angleInDegrees)); LinePath.GetPointAtFractionLength(1, out pos, out tangent); tg.Children.Add(new TranslateTransform(pos.X, pos.Y)); dc.PushTransform(tg); dc.DrawGeometry(Brushes.DeepPink, pen, EndCap); } }
protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); if (AdornedElement.RenderSize.Width < 20) return; TranslateTransform transform = new TranslateTransform ( AdornedElement.RenderSize.Width - 15, (AdornedElement.RenderSize.Height - 5) / 2 ); transform = new TranslateTransform ( AdornedElement.RenderSize.Width / 2 - 3.5, AdornedElement.RenderSize.Height / 2 - 10 ); drawingContext.PushTransform(transform); Geometry geometry = ascGeometry; if (this.Direction == ListSortDirection.Descending) geometry = descGeometry; drawingContext.DrawGeometry(Brushes.LightGray, null, geometry); drawingContext.Pop(); }
private void RenderImportanceArrow(DrawingContext dc, FrameworkElement mostImportant, FrameworkElement leastImportant) { var startPoint = FindPoint(mostImportant, new Point(mostImportant.ActualWidth/2, mostImportant.ActualHeight)); var endPoint = FindPoint(leastImportant, new Point(leastImportant.ActualWidth/2, 0)); var vector = Point.Subtract(endPoint, startPoint); var midPoint = Point.Add(startPoint, Vector.Multiply(vector, 0.66)); Transform arrowTransform = Transform.Identity; double angle; if (Math.Abs((angle = Vector.AngleBetween(vector, new Vector(0, -1))) - 0) > double.Epsilon) { arrowTransform = new RotateTransform(angle, midPoint.X, midPoint.Y); } var line = BuildPath.From(startPoint).LineTo(endPoint.X, endPoint.Y).Build(); var arrow = BuildPath.From(midPoint.X - 3, midPoint.Y - 3).LineTo(midPoint.X, midPoint.Y) .LineTo(midPoint.X + 3, midPoint.Y - 3).Build(); dc.DrawGeometry(null, _pen, line); dc.PushTransform(arrowTransform); dc.DrawGeometry(null, _pen, arrow); dc.Pop(); }
protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); if (AdornedElement.RenderSize.Width < 20) return; drawingContext.PushTransform( new TranslateTransform( AdornedElement.RenderSize.Width - 15, (AdornedElement.RenderSize.Height - 5) / 2)); if (IsSecondaryAdorner) { drawingContext.DrawGeometry(null, new Pen(Brushes.Black, 0.5), Direction == ListSortDirection.Ascending ? _AscGeometry : _DescGeometry); } else { drawingContext.DrawGeometry(Brushes.Black, null, Direction == ListSortDirection.Ascending ? _AscGeometry : _DescGeometry); } drawingContext.Pop(); }
protected override void OnRender(DrawingContext drawingContext) { PushButton pushButton = Visual as PushButton; if (pushButton.Pushed && _pushedImage != null) { drawingContext.DrawImage(_pushedImage, _imageRect); } else if (_image != null) { drawingContext.DrawImage(_image, _imageRect); } if (pushButton.Pushed) { drawingContext.PushTransform(new TranslateTransform(pushButton.TextPushOffset.X, pushButton.TextPushOffset.Y)); } if (pushButton.Glyph != PushButtonGlyph.None) { drawingContext.DrawGeometry(_glyphBrush, _glyphPen, _glyphPath); } pushButton.TextFormat.RenderText(drawingContext, _textBrush, pushButton.Text, _imageRect); if (pushButton.Pushed) { drawingContext.Pop(); } }
protected override void Draw(DrawingContext dc, int Zoom) { Point elementPoint = Projector.Project(Position, Zoom); dc.PushTransform(new TranslateTransform(elementPoint.X, elementPoint.Y)); DrawPointElement(dc, Zoom); dc.Pop(); }
public void Draw(LayerModel layer, DrawingContext c) { // If an animation is present, let it handle the drawing if (layer.LayerAnimation != null && !(layer.LayerAnimation is NoneAnimation)) { layer.LayerAnimation.Draw(layer.Properties, layer.AppliedProperties, c); return; } // Otherwise draw the rectangle with its layer.AppliedProperties dimensions and brush var rect = layer.Properties.Contain ? new Rect(layer.AppliedProperties.X*4, layer.AppliedProperties.Y*4, layer.AppliedProperties.Width*4, layer.AppliedProperties.Height*4) : new Rect(layer.Properties.X*4, layer.Properties.Y*4, layer.Properties.Width*4, layer.Properties.Height*4); var clip = new Rect(layer.AppliedProperties.X*4, layer.AppliedProperties.Y*4, layer.AppliedProperties.Width*4, layer.AppliedProperties.Height*4); c.PushClip(new RectangleGeometry(clip)); c.DrawRectangle(layer.AppliedProperties.Brush, null, rect); c.Pop(); }
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 ApplyFilter(FastBitmap source, DrawingContext dc, int width, int height) { // Clip to rounded rectangle shape. dc.PushClip(new RectangleGeometry(new Rect(new Size(width, height)), Roundness, Roundness)); // Draw image. dc.PushTransform(new TranslateTransform(BorderWidth, BorderWidth)); dc.DrawImage(source.InnerBitmap, new Rect(0, 0, source.Width, source.Height)); dc.Pop(); dc.Pop(); // Draw border. dc.DrawRoundedRectangle(null, new Pen(new SolidColorBrush(BorderColor.ToWpfColor()), BorderWidth), new Rect(BorderWidth / 2.0, BorderWidth / 2.0, width - BorderWidth, height - BorderWidth), Roundness, Roundness); }
protected override void OnRender(DrawingContext drawingContext) { if (this.textBoxHasSelection) { // up button drawingContext.PushTransform(new TranslateTransform(this.x, this.top)); drawingContext.PushTransform(new ScaleTransform(1, -1)); drawingContext.DrawGeometry(TextBoxUpDownAdorner.Fill, TextBoxUpDownAdorner.Outline, this.triangle); drawingContext.Pop(); drawingContext.Pop(); // down button drawingContext.PushTransform(new TranslateTransform(this.x, this.bottom)); drawingContext.DrawGeometry(TextBoxUpDownAdorner.Fill, TextBoxUpDownAdorner.Outline, this.triangle); drawingContext.Pop(); } }
public void Render(DrawingContext dc, Point location, Brush tint, int tileIndex) { var dstRect = new Rect(location, new Size(TileWidth, TileHeight)); dc.PushOpacityMask(new ImageBrush(_tiles[tileIndex])); dc.DrawRectangle(tint, null, dstRect); dc.Pop(); }
public void Render(DrawingContext drawingContext) { if (IsVisible) { drawingContext.PushClip(_clipGeometry); drawingContext.DrawGeometry(null, PainterCache.GridLinePen, _geometry); drawingContext.Pop(); } }
protected override void OnRender(DrawingContext drawingContext) { // draw everything except the reflection base.OnRender(drawingContext); // set opacity drawingContext.PushOpacityMask(_opacityMask); drawingContext.PushOpacity(0.4); // set reflection parameters based on content size _reflection.Visual = Child; // draw the reflection drawingContext.DrawRectangle(_reflection, null, new Rect(0, ActualHeight + _gap, ActualWidth, ActualHeight)); // cleanup drawingContext.Pop(); drawingContext.Pop(); }
protected override void ApplyFilter(FastBitmap source, DrawingContext dc, int width, int height) { // Draw border. dc.DrawRectangle(Fill.GetBrush(), null, new Rect(0, 0, width, height)); // Draw image. dc.PushTransform(new TranslateTransform(Width, Width)); dc.DrawImage(source.InnerBitmap, new Rect(0, 0, source.Width, source.Height)); dc.Pop(); }
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, _pixelsPerDip) { 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) { if (AdornedElement.RenderSize.Width < 20) return; var transform = new TranslateTransform(AdornedElement.RenderSize.Width - 15, (AdornedElement.RenderSize.Height - 5) / 2); drawingContext.PushTransform(transform); Geometry geometry = (this.Direction == ListSortDirection.Descending ? descGeometry : ascGeometry); drawingContext.DrawGeometry(Brushes.Black, null, geometry); drawingContext.Pop(); }
public void Render(DrawingContext dc, Size renderSize, TileRenderContext ctx) { dc.DrawRectangle(Brushes.Black, null, new Rect(0, 0, renderSize.Width, renderSize.Height)); dc.PushTransform(new TranslateTransform(ctx.RenderOffset.X, ctx.RenderOffset.Y)); dc.PushTransform(new ScaleTransform(ctx.TileSize, ctx.TileSize)); for (int y = 0; y < ctx.RenderGridSize.Height && y < m_renderData.Height; ++y) { for (int x = 0; x < ctx.RenderGridSize.Width && x < m_renderData.Width; ++x) { dc.PushTransform(new TranslateTransform(x, y)); RenderTile(dc, x, y); dc.Pop(); } } dc.Pop(); dc.Pop(); }
protected override void OnRender(DrawingContext drawingContext) { Point povCenter = new Point(ActualHeight / 2d, ActualWidth / 2d); drawingContext.DrawEllipse(null, _linePen, povCenter, povCenter.X - 5d, povCenter.Y - 5d); drawingContext.DrawEllipse(_lineBrush, null, povCenter, 5, 5); if (Direction == POVDirection.Center) { drawingContext.DrawEllipse(_activePositionBrush, null, povCenter, 4, 4); } else { drawingContext.PushTransform(new RotateTransform((double)Direction, povCenter.X, povCenter.Y)); drawingContext.PushTransform(new TranslateTransform(povCenter.X - 5, 0)); drawingContext.DrawGeometry(_activePositionBrush, null, _arrowPath); drawingContext.Pop(); drawingContext.Pop(); } }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { Rotary rotary = Visual as Rotary; if (rotary != null) { drawingContext.PushTransform(new RotateTransform(rotary.KnobRotation, _center.X, _center.Y)); drawingContext.DrawImage(_image, _imageRect); drawingContext.Pop(); } }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { TransformGroup transform = new TransformGroup(); transform.Children.Add(new TranslateTransform((-_center.X + HorizontalOffset) * _xScale, (-_center.Y + VerticalOffset) * _yScale)); transform.Children.Add(new RotateTransform(_rotation + _baseRotation)); transform.Children.Add(new TranslateTransform(_location.X * _xScale, _location.Y * _yScale)); drawingContext.PushTransform(transform); drawingContext.DrawImage(_image, _rectangle); drawingContext.Pop(); }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { Metric metric = Visual as Metric; if (metric != null) { drawingContext.PushTransform(new TranslateTransform(metric.MetricTranslationX, metric.MetricTranslationY)); drawingContext.PushTransform(new RotateTransform(metric.MetricRotation, _center.X, _center.Y - metric.MetricTranslationY)); drawingContext.DrawImage(_image, _imageRect); drawingContext.Pop( ); } }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { double x = AdornedElement.RenderSize.Width - 20; double y = (AdornedElement.RenderSize.Height - 5) / 2; if (x >= 20) { // Right order of the statements is important drawingContext.PushTransform(new TranslateTransform(x, y)); drawingContext.DrawGeometry(Brushes.Black, null, _sortDirection); drawingContext.Pop(); } }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { double x = AdornedElement.RenderSize.Width - 12; double y = (AdornedElement.RenderSize.Height - 8) / 2; if (x >= 10) { // Right order of the statements is important drawingContext.PushTransform(new TranslateTransform(x, y)); drawingContext.DrawGeometry(brush, pen, direction); drawingContext.Pop(); } }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { if (_bitmap != null) { var bitmapSize = new Vector(_bitmap.Width, _bitmap.Height); var dpiScaleToWpfScale = CurrentHwndSource.CompositionTarget.TransformFromDevice; var adjustedBitmapSize = dpiScaleToWpfScale.Transform(bitmapSize); drawingContext.PushClip(new RectangleGeometry(new Rect(RenderSize))); drawingContext.DrawImage(_bitmap, new Rect(new Size(adjustedBitmapSize.X, adjustedBitmapSize.Y))); drawingContext.Pop(); } }
private void DrawText(System.Windows.Media.DrawingContext dc) { dc.PushClip(new RectangleGeometry(new Rect(10, 0, Width - 20, Height))); for (int lineNumber = StartLine; lineNumber < Lines.Count && lineNumber <= StartLine + Height / LineHeight; lineNumber++) { double Y = (lineNumber - StartLine) * LineHeight + 2; if (lineNumber == CursorLine) { dc.DrawRectangle(BackCursorBrush, null, new Rect(0, Y, Width, LineHeight)); } DrawTextUsingString(dc, lineNumber, Y); } dc.Pop(); }
protected void RenderTiles(System.Windows.Media.DrawingContext dc) { double opacityIncrement = 1.0f / Layers.Count; double opacity = opacityIncrement; foreach (Layer layer in Layers) { dc.PushOpacity(opacity); foreach (Sprite sprite in layer.Tiles) { dc.DrawImage(sprite.ImageSource, sprite.Rect); } dc.Pop(); opacity += opacityIncrement; } }
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); }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { _scopeBrush = new SolidColorBrush(Color.FromRgb(255, 0, 0)); Pen _scopePen = new Pen(_scopeBrush, 1d); CustomNeedle customNeedle = Visual as CustomNeedle; if (customNeedle != null) { drawingContext.DrawImage(_bgplate_image, _bgplate_imageRect); drawingContext.PushTransform(new RotateTransform(customNeedle.KnobRotation, _center.X, _center.Y)); drawingContext.DrawImage(_image, _imageRect); drawingContext.DrawLine(_scopePen, _center, _punto); //draw rotation point for reference drawingContext.Pop(); } }
protected override void DrawCore(System.Windows.Media.DrawingContext context, DrawingAttributes overrides) { // create a drop shadow // if (this.Shadowed) { Geometry pathGeometry = this.GetGeometry(overrides).Clone(); pathGeometry.Transform = new TranslateTransform(5, 0); try { context.PushOpacity(0.5); context.DrawGeometry(Brushes.DarkGray, null, pathGeometry); } finally { context.Pop(); } } base.DrawCore(context, overrides); }
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 }
ImageSource RenderFrame(ApplicationContext actx, double scaleFactor, ImageDescription idesc) { SWM.DrawingVisual visual = new SWM.DrawingVisual(); using (SWM.DrawingContext ctx = visual.RenderOpen()) { ctx.PushTransform(new ScaleTransform(scaleFactor, scaleFactor)); Draw(actx, ctx, scaleFactor, 0, 0, idesc); ctx.Pop(); } SWMI.RenderTargetBitmap bmp = new SWMI.RenderTargetBitmap((int)(idesc.Size.Width * scaleFactor), (int)(idesc.Size.Height * scaleFactor), 96, 96, PixelFormats.Pbgra32); bmp.Render(visual); var f = new ImageFrame(bmp, idesc.Size.Width, idesc.Size.Height); if (drawCallback == null) { AddFrame(f); } return(bmp); }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { RotaryKnob rotary = Visual as RotaryKnob; if (rotary != null) { drawingContext.PushTransform(new RotateTransform(rotary.KnobRotation, _center.X, _center.Y)); drawingContext.DrawImage(_image, _imageRect); if (rotary.VisualizeDragging) { double length = (rotary.DragPoint - _center).Length; drawingContext.DrawLine(HeadingPen, _center, _center + new Vector(0d, -length)); } drawingContext.Pop(); if (rotary.VisualizeDragging) { drawingContext.DrawLine(DragPen, _center, rotary.DragPoint); } } }
ImageSource RenderFrame(ApplicationContext actx, double scaleFactor, double width, double height) { ImageDescription idesc = new ImageDescription() { Alpha = 1, Size = new Size(width, height) }; SWM.DrawingVisual visual = new SWM.DrawingVisual(); using (SWM.DrawingContext ctx = visual.RenderOpen()) { ctx.PushTransform(new ScaleTransform(scaleFactor, scaleFactor)); Draw(actx, ctx, scaleFactor, 0, 0, idesc); ctx.Pop(); } SWMI.RenderTargetBitmap bmp = new SWMI.RenderTargetBitmap((int)(width * scaleFactor), (int)(height * scaleFactor), 96, 96, PixelFormats.Pbgra32); bmp.Render(visual); var f = new ImageFrame(bmp, width, height); AddFrame(f); return(bmp); }
public void Draw(ApplicationContext actx, SWM.DrawingContext dc, double scaleFactor, double x, double y, ImageDescription idesc) { if (drawCallback != null) { DrawingContext c = new DrawingContext(dc, scaleFactor); actx.InvokeUserCode(delegate { drawCallback(c, new Rectangle(x, y, idesc.Size.Width, idesc.Size.Height), idesc, actx.Toolkit); }); } else { if (idesc.Alpha < 1) { dc.PushOpacity(idesc.Alpha); } var f = GetBestFrame(actx, scaleFactor, idesc.Size.Width, idesc.Size.Height, false); var bmpImage = f as BitmapSource; // When an image is a single bitmap that doesn't have the same intrinsic size as the drawing size, dc.DrawImage makes a very poor job of down/up scaling it. // Thus we handle this manually by using a TransformedBitmap to handle the conversion in a better way when it's needed. var scaledWidth = idesc.Size.Width * scaleFactor; var scaledHeight = idesc.Size.Height * scaleFactor; if (bmpImage != null && (Math.Abs(bmpImage.PixelHeight - scaledHeight) > 0.001 || Math.Abs(bmpImage.PixelWidth - scaledWidth) > 0.001)) { f = new TransformedBitmap(bmpImage, new ScaleTransform(scaledWidth / bmpImage.PixelWidth, scaledHeight / bmpImage.PixelHeight)); } dc.DrawImage(f, new Rect(x, y, idesc.Size.Width, idesc.Size.Height)); if (idesc.Alpha < 1) { dc.Pop(); } } }
public void Restore() { if (pushes.Count == 0) { return; } for (int n = 0; n < pushCount; n++) { Context.Pop(); } var cd = pushes.Pop(); pushCount = cd.PushCount; while (transforms.Children.Count > cd.TransformCount) { transforms.Children.RemoveAt(transforms.Children.Count - 1); } AllocatePen(cd.CurrentColor, cd.Thickness, cd.DashStyle); patternBrush = cd.Pattern; }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { drawingContext.PushTransform(new ScaleTransform(_scaleX, _scaleY)); drawingContext.DrawEllipse(Brushes.Black, null, _center, 187d, 187d); if (_rwr != null && _rwr.IsOn) { bool primary = DateTime.Now.Millisecond < 500; // Draw heart beat lines drawingContext.DrawLine(_scopePen, new Point(160d, 193.5), new Point(180d, 193.5d)); drawingContext.DrawLine(_scopePen, new Point(220d, 193.5), new Point(240d, 193.5d)); drawingContext.DrawLine(_scopePen, new Point(200d, 153.5), new Point(200d, 173.5)); drawingContext.DrawLine(_scopePen, new Point(200d, 213.5), new Point(200d, 233.5)); if (primary) { drawingContext.DrawLine(_scopePen, new Point(220d, 193.5d), new Point(220d, 203.5d)); } else { drawingContext.DrawLine(_scopePen, new Point(220d, 183.5d), new Point(220d, 193.5d)); } if (_rwr.Contacts != null) { foreach (RadarContact contact in _rwr.Contacts) { if (contact.Visible) { double y = 0.0f; if (contact.Lethality > 1f) { y = -((2.0f - contact.Lethality) * 178.0d); } else { //lethality values range in 1 = lowest priority to .01 = highest priority //substract -(1.0f - contact.Lethality) * 178.0d) from the elipse radious (187d) to get the inverse value //so that the symbol maps into the correct threat ring y = -(187d - ((1.0f - contact.Lethality) * 178.0d)); } drawingContext.PushTransform(new RotateTransform(contact.RelativeBearing)); drawingContext.PushTransform(new TranslateTransform(0d, y)); drawingContext.PushTransform(new RotateTransform(-contact.RelativeBearing)); if (contact.NewDetection && !primary) { _format.FontSize = 24; } else { _format.FontSize = 22; } DrawContactSymbol(drawingContext, contact, primary); if (contact.Selected) { drawingContext.DrawLine(_scopePen, new Point(200d, 168.5d), new Point(225d, 193.5d)); drawingContext.DrawLine(_scopePen, new Point(225d, 193.5d), new Point(200d, 218.5d)); drawingContext.DrawLine(_scopePen, new Point(200d, 218.5d), new Point(175d, 193.5d)); drawingContext.DrawLine(_scopePen, new Point(175d, 193.5d), new Point(200d, 168.5d)); } if ((contact.MissileActivity && !contact.MissileLaunch) || (contact.MissileActivity && contact.MissileLaunch && _rwr.Flash4Hz)) { drawingContext.DrawEllipse(null, _scopePen, _center, 25, 25); } drawingContext.Pop(); drawingContext.Pop(); drawingContext.Pop(); } } } } if (_bezelBrush != null) { drawingContext.DrawRectangle(_bezelBrush, null, _bezelRect); } drawingContext.Pop(); }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { if (model == null) { return; } renderStopwatch.Restart(); Pen forwardPen = new Pen(Brushes.Silver, 1); Pen backwardPen = new Pen(Brushes.Pink, 1); Pen fixedPen = new Pen(Brushes.Black, 1); foreach (var link in model.Links) { drawingContext.DrawLine(link.A.Position[0] < link.B.Position[0] ? forwardPen : backwardPen, transform.ToScreen(link.A.Position), transform.ToScreen(link.B.Position)); } foreach (var particle in model.Particles) { DrawData drawData = particle.Tag as DrawData; if (drawData == null) { drawData = new DrawData(); if (particle.FillColor.A != 0) { drawData.Brush = new SolidColorBrush(particle.FillColor); } if (particle.StrokeColor.A != 0) { drawData.Pen = new Pen(new SolidColorBrush(particle.StrokeColor), 1); } drawData.Pinned = particle.Fixed; if (particle.Name != null) { drawData.Text = new FormattedText(particle.Name, CultureInfo.CurrentCulture, FlowDirection.LeftToRight, textTypeface, textSize, Brushes.Black); } particle.Tag = drawData; } Point p = transform.ToScreen(particle.Position); drawingContext.DrawEllipse(drawData.Brush, drawData.Pen, p, ParticleSize, ParticleSize); if (drawData.Selected) { drawingContext.DrawEllipse(null, fixedPen, p, ParticleSize * 1.3, ParticleSize * 1.3); } if (drawData.Text != null) { drawingContext.DrawText(drawData.Text, p); } if (drawData.Pinned) { // drawingContext.DrawRectangle(Brushes.Black, fixedPen, new Rect(0, 0, 8, 8)); drawingContext.PushTransform(new TranslateTransform(p.X, p.Y)); drawingContext.PushTransform(new ScaleTransform(ParticleSize / 8, ParticleSize / 8)); drawingContext.DrawGeometry(Brushes.LightCoral, fixedPen, pinImage); drawingContext.Pop(); drawingContext.Pop(); } } RenderElapsedTime = renderStopwatch.Elapsed.TotalSeconds; renderStopwatch.Restart(); }
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(System.Windows.Media.DrawingContext drawingContext) { if (_editor.SelectedItems.Count > 0) { Pen rectPen = _drawFocus ? SelectionRectPen : SelectionRectPenNoFocus; Brush circleBrush = _drawFocus ? SelectionResizeBrush : SelectionResizeBrushNoFocus; if (_isline) { Point start; Point end; drawingContext.PushTransform(new ScaleTransform(_editor.ZoomFactor, _editor.ZoomFactor)); if (_editor.SnapManager.Action == SnapAction.LineStart || _editor.SnapManager.Action == SnapAction.LineEnd) { drawingContext.PushTransform(new TranslateTransform(_tempLine.Left, _tempLine.Top)); _tempLine.Renderer.Render(drawingContext); drawingContext.Pop(); start = _tempLine.Start; end = _tempLine.End; } else { Helios.Controls.LineDecoration line = _editor.SelectedItems[0] as Helios.Controls.LineDecoration; start = line.Start; end = line.End; if (_editor.SnapManager.Action == SnapAction.Move) { start += _editor.SnapManager.LocationOffset; end += _editor.SnapManager.LocationOffset; _tempLine.Clone(line); drawingContext.PushTransform(new TranslateTransform(_tempLine.Left + _editor.SnapManager.LocationOffset.X, _tempLine.Top + _editor.SnapManager.LocationOffset.Y)); _tempLine.Renderer.Render(drawingContext); drawingContext.Pop(); } } drawingContext.Pop(); start.X *= _editor.ZoomFactor; start.Y *= _editor.ZoomFactor; end.X *= _editor.ZoomFactor; end.Y *= _editor.ZoomFactor; drawingContext.DrawEllipse(circleBrush, rectPen, start, ResizeRadius, ResizeRadius); drawingContext.DrawEllipse(circleBrush, rectPen, end, ResizeRadius, ResizeRadius); } else { foreach (HeliosVisual visual in _editor.SelectedItems) { Rect visualRect = visual.DisplayRectangle; visualRect.Scale(_editor.ZoomFactor, _editor.ZoomFactor); drawingContext.DrawRectangle(null, SelectionBorderPen, visualRect); } Rect selectionRect = (_editor.SnapManager.Action != SnapAction.None && _editor.SnapManager.Action != SnapAction.Drop && _editor.SnapManager.IsValidDrag) ? _editor.SnapManager.NewRectangle : _editor.SelectedItems.Rectangle; selectionRect.Scale(_editor.ZoomFactor, _editor.ZoomFactor); drawingContext.DrawRectangle(null, rectPen, selectionRect); drawingContext.DrawEllipse(circleBrush, rectPen, selectionRect.TopLeft, ResizeRadius, ResizeRadius); drawingContext.DrawEllipse(circleBrush, rectPen, selectionRect.TopRight, ResizeRadius, ResizeRadius); drawingContext.DrawEllipse(circleBrush, rectPen, selectionRect.BottomLeft, ResizeRadius, ResizeRadius); drawingContext.DrawEllipse(circleBrush, rectPen, selectionRect.BottomRight, ResizeRadius, ResizeRadius); } } }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { if (group == null) { return; } Rect area = new Rect(0, 0, AdornedElement.RenderSize.Width, AdornedElement.RenderSize.Height); drawingContext.PushClip(new RectangleGeometry(area)); drawingContext.DrawRectangle(Brushes.White, null, area); var threads = group.Threads; int rowIndex = 0; KeyValuePair <int, int> mainThreadInterval = new KeyValuePair <int, int>(); for (int threadIndex = 0; threadIndex < threads.Count; ++threadIndex) { List <EventFrame> frames = threads[threadIndex].Events; RowRange rowRange = rows[threadIndex]; if (rowRange.MaxDepth > 0 && frames.Count > 0) { KeyValuePair <int, int> interval = CalculateEventRange(frames, Position, Position + Range); if (threadIndex == group.Board.MainThreadIndex) { mainThreadInterval = interval; } Brush backgroundBrush = Brushes.White; if (rowIndex++ % 2 == 0) { backgroundBrush = AlternativeBackgroundColor; drawingContext.DrawRectangle(AlternativeBackgroundColor, null, new Rect(0, rowRange.Offset, AdornedElement.RenderSize.Width, rowRange.Height)); } for (int i = interval.Key; i <= interval.Value; ++i) { OnRenderFrame(drawingContext, frames[i], rowRange.Offset, rowRange.MaxDepth, backgroundBrush); } } } int mainThreadIndex = group.Board.MainThreadIndex; RenderFPSLines(drawingContext, group.Threads[mainThreadIndex].Events, mainThreadInterval); if (FocusedFrame != null) { RowRange rowRange = rows[FocusedFrame.Header.ThreadIndex]; Durable interval = FocusedNode != null ? FocusedNode.Entry as Durable : FocusedFrame.Header as Durable; Rect focusedRectangle = CalculateRect(interval, rowRange.Offset, rowRange.Height); drawingContext.DrawRectangle(null, selectedPen, focusedRectangle); } RenderSelectedScopes(drawingContext); drawingContext.Pop(); base.OnRender(drawingContext); }
/// <summary> /// Draws the contours against a horizontal and vertical axis. /// </summary> /// <param name="dc">The drawing context on which to draw.</param> /// <param name="hAxis">The horizontal physical axis to draw against.</param> /// <param name="vAxis">The vertical physical axis to draw against.</param> public void Draw(System.Windows.Media.DrawingContext dc, HorizontalPhysicalAxis hAxis, VerticalPhysicalAxis vAxis) { double worldHorizontalRange = hAxis.Axis.WorldMax - hAxis.Axis.WorldMin; double worldVerticalRange = vAxis.Axis.WorldMax - vAxis.Axis.WorldMin; for (int i = 0; i < _internalGridSize.Rows; ++i) { for (int j = 0; j < _internalGridSize.Columns; ++j) { double worldY = (double)i / (double)(_internalGridSize.Rows - 1) * worldVerticalRange + vAxis.Axis.WorldMin; double worldX = (double)j / (double)(_internalGridSize.Columns - 1) * worldHorizontalRange + hAxis.Axis.WorldMin; _grid[i, j] = _fieldMethod(worldX, worldY); } } Pair <List <double>, List <List <LineSegment> > > contourGroups = ContourUtils.ContourGenCore.Generate(_grid, _levels); double physicalHorizontalRange = hAxis.PhysicalMaxX - hAxis.PhysicalMinX; double physicalVerticalRange = vAxis.PhysicalMaxY - vAxis.PhysicalMinY; Pen p = new Pen(_stroke, _strokeThickness); for (int i = 0; i < contourGroups.First.Count; ++i) { List <LineSegment> lineSegments = contourGroups.Second[i]; // find best index to put label. int bestJ = DetermineBestLabelPosition(lineSegments, 0, _internalGridSize.Columns - 1, 0, _internalGridSize.Rows - 1); // see if line segment sequence is reasonably long. If so, put a contour label on it. bool drawingLabel = false; if (_showContourLabels) { double sum = 0.0; for (int k = 0; k < lineSegments.Count; ++k) { sum += Math.Abs(lineSegments[k].X1 - lineSegments[k].X2) + Math.Abs(lineSegments[k].Y1 - lineSegments[k].Y2); if (sum > _internalGridSize.Rows / 6.0) { drawingLabel = true; break; } } } if (drawingLabel) { LineSegment ls = lineSegments[bestJ]; double x1 = ls.X1 / (double)(_internalGridSize.Columns - 1) * physicalHorizontalRange + hAxis.PhysicalMinX; double x2 = ls.X2 / (double)(_internalGridSize.Columns - 1) * physicalHorizontalRange + hAxis.PhysicalMinX; double y1 = ls.Y1 / (double)(_internalGridSize.Rows - 1) * physicalVerticalRange + vAxis.PhysicalMinY; double y2 = ls.Y2 / (double)(_internalGridSize.Rows - 1) * physicalVerticalRange + vAxis.PhysicalMinY; FormattedText ft = new FormattedText(contourGroups.First[i].ToString(_contourLabelFormat), System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Arial"), 11, _stroke); double angle = Math.Atan2( contourGroups.Second[i][bestJ].Y1 - contourGroups.Second[i][bestJ].Y2, contourGroups.Second[i][bestJ].X2 - contourGroups.Second[i][bestJ].X1) / Math.PI * 180.0; if (angle > 90) { angle -= 180; } if (angle < -90) { angle += 180; } RotateTransform rt = new RotateTransform(angle); dc.PushTransform(new TranslateTransform((x1 + x2) / 2.0, (y1 + y2) / 2.0)); dc.PushTransform(rt); dc.DrawText(ft, new Point(-ft.Width / 2.0, -ft.Height / 2.0)); dc.Pop(); dc.Pop(); Rect r1 = new Rect(hAxis.PhysicalMinX, vAxis.PhysicalMaxY, hAxis.PhysicalMaxX - hAxis.PhysicalMinX, vAxis.PhysicalMinY - vAxis.PhysicalMaxY); Rect r2 = new Rect((x1 + x2) / 2.0 - ft.Width * 1.6 / 2.0, (y1 + y2) / 2.0 - ft.Height * 1.6 / 2.0, ft.Width * 1.6, ft.Height * 1.6); DrawingBrush db = new DrawingBrush(); db.ViewboxUnits = BrushMappingMode.Absolute; db.ViewportUnits = BrushMappingMode.Absolute; db.Viewport = r1; db.Viewbox = r1; GeometryGroup gg = new GeometryGroup(); gg.FillRule = FillRule.Nonzero; if (r2.Left - r1.Left > 0) { RectangleGeometry rg = new RectangleGeometry(new Rect(r1.Left, r1.Top, r2.Left - r1.Left, r1.Height)); gg.Children.Add(rg); } if (r1.Right - r2.Right > 0) { RectangleGeometry rg = new RectangleGeometry(new Rect(r2.Right, r1.Top, r1.Right - r2.Right, r1.Height)); gg.Children.Add(rg); } if (r2.Top - r1.Top > 0) { RectangleGeometry rg = new RectangleGeometry(new Rect(r1.Left, r1.Top, r1.Width, r2.Top - r1.Top)); gg.Children.Add(rg); } if (r1.Bottom - r2.Bottom > 0) { RectangleGeometry rg = new RectangleGeometry(new Rect(r1.Left, r2.Bottom, r1.Width, r1.Bottom - r2.Bottom)); gg.Children.Add(rg); } SolidColorBrush scb = new SolidColorBrush(Color.FromArgb(255, 0, 0, 0)); GeometryDrawing gd = new GeometryDrawing(scb, null, gg); db.Drawing = gd; dc.PushOpacityMask(db); } for (int j = 0; j < lineSegments.Count; ++j) { LineSegment ls = lineSegments[j]; double x1 = ls.X1 / (double)(_internalGridSize.Columns - 1) * physicalHorizontalRange + hAxis.PhysicalMinX; double x2 = ls.X2 / (double)(_internalGridSize.Columns - 1) * physicalHorizontalRange + hAxis.PhysicalMinX; double y1 = ls.Y1 / (double)(_internalGridSize.Rows - 1) * physicalVerticalRange + vAxis.PhysicalMinY; double y2 = ls.Y2 / (double)(_internalGridSize.Rows - 1) * physicalVerticalRange + vAxis.PhysicalMinY; dc.DrawLine(p, new Point(x1, y1), new Point(x2, y2)); } if (drawingLabel) { // pop opacity mask. dc.Pop(); } } }