public override void UpdateGeometry() { ScaleThickness = Image.State.Flags.HasFlag(ShapeStateFlags.Thickness); ScaleSize = Image.State.Flags.HasFlag(ShapeStateFlags.Size); if (!string.IsNullOrEmpty(Image.Key)) { ImageCached = BitmapCache.Get(Image.Key) as AMI.Bitmap; if (ImageCached == null && ImageCache != null) { try { var bytes = ImageCache.GetImage(Image.Key); if (bytes != null) { using var ms = new System.IO.MemoryStream(bytes); ImageCached = new AMI.Bitmap(ms); BitmapCache.Set(Image.Key, ImageCached); } } catch (Exception ex) { Debug.WriteLine($"{ex.Message}"); Debug.WriteLine($"{ex.StackTrace}"); } } if (ImageCached != null) { SourceRect = new A.Rect(0, 0, ImageCached.PixelSize.Width, ImageCached.PixelSize.Height); } } else { ImageCached = null; } var rect2 = Rect2.FromPoints(Image.TopLeft.X, Image.TopLeft.Y, Image.BottomRight.X, Image.BottomRight.Y, 0, 0); DestRect = new A.Rect(rect2.X, rect2.Y, rect2.Width, rect2.Height); Center = DestRect.Center; base.UpdateTextGeometry(); }
public ImageDrawCommand(AM.IImage?source, A.Rect sourceRect, A.Rect destRect, AVMI.BitmapInterpolationMode bitmapInterpolationMode) { Source = source; SourceRect = sourceRect; DestRect = destRect; BitmapInterpolationMode = bitmapInterpolationMode; }
public override void UpdateGeometry() { ScaleThickness = false; ScaleSize = false; Rect = new A.Rect(X, Y, Width, Height); Center = Rect.Center; }
public RectangleDrawCommand(AM.IBrush?brush, AM.IPen?pen, A.Rect rect, double radiusX, double radiusY) { Brush = brush; Pen = pen; Rect = rect; RadiusX = radiusX; RadiusY = radiusY; }
public static AM.Geometry ToGeometry(EllipseShapeViewModel ellipse) { var rect2 = Rect2.FromPoints(ellipse.TopLeft.X, ellipse.TopLeft.Y, ellipse.BottomRight.X, ellipse.BottomRight.Y); var rect = new A.Rect(rect2.X, rect2.Y, rect2.Width, rect2.Height); var g = new AM.EllipseGeometry(rect); return(g); }
/// <inheritdoc/> public override void Fill(object dc, double x, double y, double width, double height, ArgbColor color) { var _dc = dc as AM.DrawingContext; var brush = ToBrush(color); var rect = new A.Rect(x, y, width, height); _dc.FillRectangle(brush, rect); }
public override void UpdateGeometry() { ScaleThickness = true; // Point.State.HasFlag(ShapeStateFlags.Thickness); ScaleSize = true; // Point.State.HasFlag(ShapeStateFlags.Size); var rect2 = Rect2.FromPoints(Point.X - PointSize, Point.Y - PointSize, Point.X + PointSize, Point.Y + PointSize, 0, 0); Rect = new A.Rect(rect2.X, rect2.Y, rect2.Width, rect2.Height); Center = Rect.Center; }
public override void UpdateGeometry() { ScaleThickness = Rectangle.State.HasFlag(ShapeStateFlags.Thickness); ScaleSize = Rectangle.State.HasFlag(ShapeStateFlags.Size); var rect2 = Rect2.FromPoints(Rectangle.TopLeft.X, Rectangle.TopLeft.Y, Rectangle.BottomRight.X, Rectangle.BottomRight.Y, 0, 0); Rect = new A.Rect(rect2.X, rect2.Y, rect2.Width, rect2.Height); Center = Rect.Center; }
public sealed override void UpdateGeometry() { ScaleThickness = Text.State.HasFlag(ShapeStateFlags.Thickness); ScaleSize = Text.State.HasFlag(ShapeStateFlags.Size); var rect2 = Rect2.FromPoints(Text.TopLeft.X, Text.TopLeft.Y, Text.BottomRight.X, Text.BottomRight.Y, 0, 0); Rect = new A.Rect(rect2.X, rect2.Y, rect2.Width, rect2.Height); Center = Rect.Center; UpdateTextGeometry(); }
public override void UpdateGeometry() { ScaleThickness = true; ScaleSize = false; Rect = new A.Rect( X + Grid.GridOffsetLeft, Y + Grid.GridOffsetTop, Width - Grid.GridOffsetLeft + Grid.GridOffsetRight, Height - Grid.GridOffsetTop + Grid.GridOffsetBottom); Center = Rect.Center; }
public void Draw(TextView textView, DrawingContext drawingContext) { if (line > 0 && line < textView.TextDocument.LineCount) { var currentLine = textView.TextDocument.GetLineByNumber(line); var rects = VisualLineGeometryBuilder.GetRectsForSegment(textView, currentLine); foreach (var rect in rects) { var drawRect = new Rect(rect.TopLeft.X, rect.TopLeft.Y, textView.Bounds.Width, rect.Height); drawingContext.FillRectangle(selectedLineBg, drawRect); } } }
private static void DrawEllipseInternal(AM.DrawingContext dc, AM.IBrush brush, AM.Pen pen, bool isStroked, bool isFilled, ref Rect2 rect) { if (!isFilled && !isStroked) { return; } var r = new A.Rect(rect.X, rect.Y, rect.Width, rect.Height); var g = new AM.EllipseGeometry(r); dc.DrawGeometry( isFilled ? brush : null, isStroked ? pen : null, g); }
public void Draw(TextView textView, DrawingContext drawingContext) { if (textView.SelectionStart == textView.SelectionEnd && textView.CaretIndex != -1 && textView.CaretIndex <= textView.TextDocument.TextLength) { var currentLine = textView.TextDocument.GetLineByOffset(textView.CaretIndex); var rects = VisualLineGeometryBuilder.GetRectsForSegment(textView, currentLine); foreach (var rect in rects) { var drawRect = new Rect(rect.TopLeft.X, rect.TopLeft.Y, textView.Bounds.Width, rect.Height); drawingContext.FillRectangle(selectedLineBg, drawRect); } } }
public void DrawPoint(Point point, PointStyle style, bool fast) { Point viewPoint = (Point)Viewport.GetViewGeometry(point); A.Rect rect = GetPointRect(viewPoint.Coordinate, style.Size); Brush brush = GetBrush(style.FillStyle); Pen pen = GetPen(style.LineStyle); AM.Geometry geometry; if (style.Shape == PointShape.Circle) { geometry = new EllipseGeometry(rect); } else { geometry = new RectangleGeometry(rect); } m_Context.DrawGeometry(brush, pen, geometry); }
private static void DrawRectangleInternal(AM.DrawingContext dc, AM.IBrush brush, AM.Pen pen, bool isStroked, bool isFilled, ref Rect2 rect) { if (!isStroked && !isFilled) { return; } var r = new A.Rect(rect.X, rect.Y, rect.Width, rect.Height); if (isFilled) { dc.FillRectangle(brush, r); } if (isStroked) { dc.DrawRectangle(pen, r); } }
private void DrawCoordinates(Coordinate[] coords, PointStyle style, bool fast, bool skipLast = false) { Brush brush = GetBrush(style.FillStyle); Pen pen = GetPen(style.LineStyle); int max = (skipLast ? coords.Length - 1 : coords.Length); for (int i = 0; i < max; i++) { A.Rect rect = GetPointRect(coords[i], style.Size); AM.Geometry geometry; if (style.Shape == PointShape.Circle) { geometry = new EllipseGeometry(rect); } else { geometry = new RectangleGeometry(rect); } m_Context.DrawGeometry(brush, pen, geometry); } }
protected override void OnRender(DrawingContext ctx) { ctx.FillRectangle(Brushes.Green, new Rect(0, 0, Width, Height)); var rc = new Rect(0, 0, Width/3, Height/3); using (ctx.PushPostTransform( Avalonia.Matrix.CreateTranslation(-Width/6, -Width/6)* Avalonia.Matrix.CreateRotation(_radians)* Avalonia.Matrix.CreateTranslation(Width/2, Height/2))) { ctx.FillRectangle(new LinearGradientBrush() { GradientStops = { new GradientStop() {Color = Colors.Blue}, new GradientStop(Colors.Red, 1) } }, rc, 5); } }
public static Rect Inflate(Rect rect, double width, double height) { if (width < rect.Width * -2) { return Rect.Empty; } if (height < rect.Height * -2) { return Rect.Empty; } Rect result = rect; result.Inflate(width, height); return result; }
private static void Record(CanvasCommand canvasCommand, AvaloniaPicture avaloniaPicture) { if (avaloniaPicture == null || avaloniaPicture._commands == null) { return; } switch (canvasCommand) { case ClipPathCanvasCommand clipPathCanvasCommand: { var path = clipPathCanvasCommand.ClipPath.ToGeometry(false); if (path != null) { // TODO: clipPathCanvasCommand.Operation; // TODO: clipPathCanvasCommand.Antialias; avaloniaPicture._commands.Add(new GeometryClipDrawCommand(path)); } } break; case ClipRectCanvasCommand clipRectCanvasCommand: { var rect = clipRectCanvasCommand.Rect.ToSKRect(); // TODO: clipRectCanvasCommand.Operation; // TODO: clipRectCanvasCommand.Antialias; avaloniaPicture._commands.Add(new ClipDrawCommand(rect)); } break; case SaveCanvasCommand _: { // TODO: avaloniaPicture._commands.Add(new SaveDrawCommand()); } break; case RestoreCanvasCommand _: { // TODO: avaloniaPicture._commands.Add(new RestoreDrawCommand()); } break; case SetMatrixCanvasCommand setMatrixCanvasCommand: { var matrix = setMatrixCanvasCommand.Matrix.ToMatrix(); avaloniaPicture._commands.Add(new SetTransformDrawCommand(matrix)); } break; case SaveLayerCanvasCommand saveLayerCanvasCommand: { // TODO: avaloniaPicture._commands.Add(new SaveLayerDrawCommand()); } break; case DrawImageCanvasCommand drawImageCanvasCommand: { if (drawImageCanvasCommand.Image != null) { var image = drawImageCanvasCommand.Image.ToBitmap(); if (image != null) { var source = drawImageCanvasCommand.Source.ToSKRect(); var dest = drawImageCanvasCommand.Dest.ToSKRect(); var bitmapInterpolationMode = drawImageCanvasCommand.Paint?.FilterQuality.ToBitmapInterpolationMode() ?? AVMI.BitmapInterpolationMode.Default; avaloniaPicture._commands.Add(new ImageDrawCommand(image, source, dest, bitmapInterpolationMode)); } } } break; case DrawPathCanvasCommand drawPathCanvasCommand: { if (drawPathCanvasCommand.Path != null && drawPathCanvasCommand.Paint != null) { (var brush, var pen) = drawPathCanvasCommand.Paint.ToBrushAndPen(); if (drawPathCanvasCommand.Path.Commands?.Count == 1) { var pathCommand = drawPathCanvasCommand.Path.Commands[0]; var success = false; switch (pathCommand) { case AddRectPathCommand addRectPathCommand: { var rect = addRectPathCommand.Rect.ToSKRect(); avaloniaPicture._commands.Add(new RectangleDrawCommand(brush, pen, rect, 0, 0)); success = true; } break; case AddRoundRectPathCommand addRoundRectPathCommand: { var rect = addRoundRectPathCommand.Rect.ToSKRect(); var rx = addRoundRectPathCommand.Rx; var ry = addRoundRectPathCommand.Ry; avaloniaPicture._commands.Add(new RectangleDrawCommand(brush, pen, rect, rx, ry)); success = true; } break; case AddOvalPathCommand addOvalPathCommand: { var rect = addOvalPathCommand.Rect.ToSKRect(); var ellipseGeometry = new AM.EllipseGeometry(rect); avaloniaPicture._commands.Add(new GeometryDrawCommand(brush, pen, ellipseGeometry)); success = true; } break; case AddCirclePathCommand addCirclePathCommand: { var x = addCirclePathCommand.X; var y = addCirclePathCommand.Y; var radius = addCirclePathCommand.Radius; var rect = new A.Rect(x - radius, y - radius, radius + radius, radius + radius); var ellipseGeometry = new AM.EllipseGeometry(rect); avaloniaPicture._commands.Add(new GeometryDrawCommand(brush, pen, ellipseGeometry)); success = true; } break; case AddPolyPathCommand addPolyPathCommand: { if (addPolyPathCommand.Points != null) { var points = addPolyPathCommand.Points.ToPoints(); var close = addPolyPathCommand.Close; var polylineGeometry = new AM.PolylineGeometry(points, close); avaloniaPicture._commands.Add(new GeometryDrawCommand(brush, pen, polylineGeometry)); success = true; } } break; } if (success) { break; } } if (drawPathCanvasCommand.Path.Commands?.Count == 2) { var pathCommand1 = drawPathCanvasCommand.Path.Commands[0]; var pathCommand2 = drawPathCanvasCommand.Path.Commands[1]; if (pathCommand1 is MoveToPathCommand moveTo && pathCommand2 is LineToPathCommand lineTo) { var p1 = new A.Point(moveTo.X, moveTo.Y); var p2 = new A.Point(lineTo.X, lineTo.Y); avaloniaPicture._commands.Add(new LineDrawCommand(pen, p1, p2)); break; } } var geometry = drawPathCanvasCommand.Path.ToGeometry(brush != null); if (geometry != null) { avaloniaPicture._commands.Add(new GeometryDrawCommand(brush, pen, geometry)); } } } break; case DrawTextBlobCanvasCommand drawPositionedTextCanvasCommand: { // TODO: } break; case DrawTextCanvasCommand drawTextCanvasCommand: { if (drawTextCanvasCommand.Paint != null) { (var brush, _) = drawTextCanvasCommand.Paint.ToBrushAndPen(); var text = drawTextCanvasCommand.Paint.ToFormattedText(drawTextCanvasCommand.Text); var x = drawTextCanvasCommand.X; var y = drawTextCanvasCommand.Y; var origin = new A.Point(x, y - drawTextCanvasCommand.Paint.TextSize); avaloniaPicture._commands.Add(new TextDrawCommand(brush, origin, text)); } } break; case DrawTextOnPathCanvasCommand drawTextOnPathCanvasCommand: { // TODO: } break; default: break; } }
public static bool Equals(Rect rect1, Rect rect2) { return rect1.Equals(rect2); }
/// <summary> /// Determines whether a rectangle intersects with this rectangle. /// </summary> /// <param name="rect">The other rectangle.</param> /// <returns> /// True if the specified rectangle intersects with this one; otherwise false. /// </returns> public bool Intersects(Rect rect) { return (rect.X < Right) && (X < rect.Right) && (rect.Y < Bottom) && (Y < rect.Bottom); }
/// <summary> /// Determines whether the rectangle fully contains another rectangle. /// </summary> /// <param name="r">The rectangle.</param> /// <returns>true if the rectangle is fully contained; otherwise false.</returns> public bool Contains(Rect r) { return Contains(r.TopLeft) && Contains(r.BottomRight); }
public static Rect Offset(Rect rect, double offsetX, double offsetY) { Rect result = rect; result.Offset(offsetX, offsetY); return result; }
public static Rect Transform(Rect rect, Matrix matrix) { Rect result = rect; result.Transform(matrix); return result; }
/// <summary> /// Centers another rectangle in this rectangle. /// </summary> /// <param name="rect">The rectangle to center.</param> /// <returns>The centered rectangle.</returns> public Rect CenterIn(Rect rect) { return new Rect( _x + ((_width - rect._width) / 2), _y + ((_height - rect._height) / 2), rect._width, rect._height); }
private static void DrawRectangleInternal(AM.DrawingContext dc, AM.IBrush brush, AM.Pen pen, bool isStroked, bool isFilled, ref Rect2 rect) { if (!isStroked && !isFilled) return; var r = new A.Rect(rect.X, rect.Y, rect.Width, rect.Height); if (isFilled) { dc.FillRectangle(brush, r); } if (isStroked) { dc.DrawRectangle(pen, r); } }
protected sealed override void ArrangeCore(Rect finalRect) { Point origin = new Point( finalRect.Left + this.Margin.Left, finalRect.Top + this.Margin.Top); Size size = new Size( Math.Max(0, finalRect.Width - this.Margin.Left - this.Margin.Right), Math.Max(0, finalRect.Height - this.Margin.Top - this.Margin.Bottom)); if (this.HorizontalAlignment != HorizontalAlignment.Stretch) { size = new Size(Math.Min(size.Width, this.DesiredSize.Width), size.Height); } if (this.VerticalAlignment != VerticalAlignment.Stretch) { size = new Size(size.Width, Math.Min(size.Height, this.DesiredSize.Height)); } Size taken = this.ArrangeOverride(size); size = new Size( Math.Min(taken.Width, size.Width), Math.Min(taken.Height, size.Height)); switch (this.HorizontalAlignment) { case HorizontalAlignment.Center: origin.X += (finalRect.Width - size.Width) / 2; break; case HorizontalAlignment.Right: origin.X += finalRect.Width - size.Width; break; } switch (this.VerticalAlignment) { case VerticalAlignment.Center: origin.Y += (finalRect.Height - size.Height) / 2; break; case VerticalAlignment.Bottom: origin.Y += finalRect.Height - size.Height; break; } base.ArrangeCore(new Rect(origin, size)); }
protected virtual void ArrangeCore(Rect finalRect) { this.VisualOffset = (Vector)finalRect.TopLeft; this.RenderSize = finalRect.Size; }
private static void DrawEllipseInternal(AM.DrawingContext dc, AM.IBrush brush, AM.Pen pen, bool isStroked, bool isFilled, ref Rect2 rect) { if (!isFilled && !isStroked) return; var r = new A.Rect(rect.X, rect.Y, rect.Width, rect.Height); var g = new AM.EllipseGeometry(r); dc.DrawGeometry( isFilled ? brush : null, isStroked ? pen : null, g); }
public ClipDrawCommand(A.Rect clip) { Clip = clip; }
private MarkerBase CreateArrowMarker(double x, double y, double angle, ShapeStyleViewModel shapeStyleViewModel, ArrowStyleViewModel style) { switch (style.ArrowType) { default: { var marker = new NoneMarker(); marker.ShapeViewModel = Line; marker.ShapeStyleViewModel = shapeStyleViewModel; marker.Style = style; marker.Point = new A.Point(x, y); return(marker); } case ArrowType.Rectangle: { double rx = style.RadiusX; double ry = style.RadiusY; double sx = 2.0 * rx; double sy = 2.0 * ry; var marker = new RectangleMarker(); marker.ShapeViewModel = Line; marker.ShapeStyleViewModel = shapeStyleViewModel; marker.Style = style; marker.Rotation = ACP.MatrixHelper.Rotation(angle, new A.Vector(x, y)); marker.Point = ACP.MatrixHelper.TransformPoint(marker.Rotation, new A.Point(x - sx, y)); var rect2 = new Rect2(x - sx, y - ry, sx, sy); marker.Rect = new A.Rect(rect2.X, rect2.Y, rect2.Width, rect2.Height); return(marker); } case ArrowType.Ellipse: { double rx = style.RadiusX; double ry = style.RadiusY; double sx = 2.0 * rx; double sy = 2.0 * ry; var marker = new EllipseMarker(); marker.ShapeViewModel = Line; marker.ShapeStyleViewModel = shapeStyleViewModel; marker.Style = style; marker.Rotation = ACP.MatrixHelper.Rotation(angle, new A.Vector(x, y)); marker.Point = ACP.MatrixHelper.TransformPoint(marker.Rotation, new A.Point(x - sx, y)); var rect2 = new Rect2(x - sx, y - ry, sx, sy); var rect = new A.Rect(rect2.X, rect2.Y, rect2.Width, rect2.Height); marker.EllipseGeometry = new AM.EllipseGeometry(rect); return(marker); } case ArrowType.Arrow: { double rx = style.RadiusX; double ry = style.RadiusY; double sx = 2.0 * rx; double sy = 2.0 * ry; var marker = new ArrowMarker(); marker.ShapeViewModel = Line; marker.ShapeStyleViewModel = shapeStyleViewModel; marker.Style = style; marker.Rotation = ACP.MatrixHelper.Rotation(angle, new A.Vector(x, y)); marker.Point = ACP.MatrixHelper.TransformPoint(marker.Rotation, new A.Point(x, y)); marker.P11 = ACP.MatrixHelper.TransformPoint(marker.Rotation, new A.Point(x - sx, y + sy)); marker.P21 = ACP.MatrixHelper.TransformPoint(marker.Rotation, new A.Point(x, y)); marker.P12 = ACP.MatrixHelper.TransformPoint(marker.Rotation, new A.Point(x - sx, y - sy)); marker.P22 = ACP.MatrixHelper.TransformPoint(marker.Rotation, new A.Point(x, y)); return(marker); } } }
public static Rect Inflate(Rect rect, Size size) { return Rect.Inflate(rect, size.Width, size.Height); }
public static Rect Union(Rect rect, Point point) { Rect result = rect; result.Union(point); return result; }
public static Rect Intersect(Rect rect1, Rect rect2) { Rect result = rect1; result.Intersect(rect2); return result; }
public bool Contains(Rect rect) { if (rect.Left < this.Left || rect.Right > this.Right) { return false; } if (rect.Top < this.Top || rect.Bottom > this.Bottom) { return false; } return true; }
public static Rect Offset(Rect rect, Vector offsetVector) { Rect result = rect; result.Offset(offsetVector); return result; }
public bool IntersectsWith(Rect rect) { return !((this.Left >= rect.Right) || (this.Right <= rect.Left) || (this.Top >= rect.Bottom) || (this.Bottom <= rect.Top)); }
public static Rect Union(Rect rect1, Rect rect2) { Rect result = rect1; result.Union(rect2); return result; }
/// <summary> /// Gets the intersection of two rectangles. /// </summary> /// <param name="rect">The other rectangle.</param> /// <returns>The intersection.</returns> public Rect Intersect(Rect rect) { var newLeft = (rect.X > X) ? rect.X : X; var newTop = (rect.Y > Y) ? rect.Y : Y; var newRight = (rect.Right < Right) ? rect.Right : Right; var newBottom = (rect.Bottom < Bottom) ? rect.Bottom : Bottom; if ((newRight > newLeft) && (newBottom > newTop)) { return new Rect(newLeft, newTop, newRight - newLeft, newBottom - newTop); } else { return Empty; } }
public bool Equals(Rect value) { return this.x == value.X && this.y == value.Y && this.width == value.Width && this.height == value.Height; }
public bool BringIntoView(IControl target, Rect targetRect) { throw new NotImplementedException(); }
public void Intersect(Rect rect) { double x = Math.Max(this.x, rect.x); double y = Math.Max(this.y, rect.y); double width = Math.Min(this.Right, rect.Right) - x; double height = Math.Min(this.Bottom, rect.Bottom) - y; if (width < 0 || height < 0) { this.x = this.y = double.PositiveInfinity; this.width = this.height = double.NegativeInfinity; } else { this.x = x; this.y = y; this.width = width; this.height = height; } }
/// <summary> /// Render the html using the given device. /// </summary> /// <param name="g">the device to use to render</param> /// <param name="clip">the clip rectangle of the html container</param> public void PerformPaint(DrawingContext g, Rect clip) { ArgChecker.AssertArgNotNull(g, "g"); using (var ig = new GraphicsAdapter(g, Util.Convert(clip))) { _htmlContainerInt.PerformPaint(ig); } }
public void Union(Rect rect) { var left = Math.Min(this.Left, rect.Left); var top = Math.Min(this.Top, rect.Top); var right = Math.Max(this.Right, rect.Right); var bottom = Math.Max(this.Bottom, rect.Bottom); this.x = left; this.y = top; this.width = right - left; this.height = bottom - top; }
public IInputElement InputHitTest(Point point) { Rect bounds = new Rect(this.RenderSize); if (bounds.Contains(point)) { foreach (UIElement child in VisualTreeHelper.GetChildren(this).OfType<UIElement>()) { Point offsetPoint = point - child.VisualOffset; IInputElement hit = child.InputHitTest(offsetPoint); if (hit != null) { return hit; } } return this; } else { return null; } }
/// <summary> /// Convert from WPF rectangle to core rectangle. /// </summary> public static RRect Convert(Rect r) { return new RRect(r.X, r.Y, r.Width, r.Height); }