|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.ComponentModel;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
#if NET9_0_OR_GREATER
using System.Drawing.Imaging.Effects;
#endif
using System.Numerics;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
namespace System.Drawing;
/// <summary>
/// Encapsulates a GDI+ drawing surface.
/// </summary>
public sealed unsafe partial class Graphics : MarshalByRefObject, IDisposable, IDeviceContext, IGraphics
{
/// <summary>
/// The context state previous to the current Graphics context (the head of the stack).
/// We don't keep a GraphicsContext for the current context since it is available at any time from GDI+ and
/// we don't want to keep track of changes in it.
/// </summary>
private GraphicsContext? _previousContext;
private static readonly Lock s_syncObject = new();
// Object reference used for printing; it could point to a PrintPreviewGraphics to obtain the VisibleClipBounds, or
// a DeviceContext holding a printer DC.
private object? _printingHelper;
// GDI+'s preferred HPALETTE.
private static HPALETTE s_halftonePalette;
// pointer back to the Image backing a specific graphic object
private Image? _backingImage;
/// <summary>
/// Handle to native DC - obtained from the GDI+ graphics object. We need to cache it to implement
/// IDeviceContext interface.
/// </summary>
private HDC _nativeHdc;
public delegate bool DrawImageAbort(IntPtr callbackdata);
/// <summary>
/// Callback for EnumerateMetafile methods.
/// This method can then call Metafile.PlayRecord to play the record that was just enumerated.
/// </summary>
/// <param name="recordType">if >= MinRecordType, it's an EMF+ record</param>
/// <param name="flags">always 0 for EMF records</param>
/// <param name="dataSize">size of the data, or 0 if no data</param>
/// <param name="data">pointer to the data, or NULL if no data (UINT32 aligned)</param>
/// <param name="callbackData">pointer to callbackData, if any</param>
/// <returns>False to abort enumerating, true to continue.</returns>
public delegate bool EnumerateMetafileProc(
EmfPlusRecordType recordType,
int flags,
int dataSize,
IntPtr data,
PlayRecordCallback? callbackData);
/// <summary>
/// Constructor to initialize this object from a native GDI+ Graphics pointer.
/// </summary>
private Graphics(GpGraphics* gdipNativeGraphics)
{
if (gdipNativeGraphics is null)
throw new ArgumentNullException(nameof(gdipNativeGraphics));
NativeGraphics = gdipNativeGraphics;
}
/// <summary>
/// Creates a new instance of the <see cref='Graphics'/> class from the specified handle to a device context.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Advanced)]
public static Graphics FromHdc(IntPtr hdc)
{
if (hdc == IntPtr.Zero)
throw new ArgumentNullException(nameof(hdc));
return FromHdcInternal(hdc);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
public static Graphics FromHdcInternal(IntPtr hdc)
{
GpGraphics* nativeGraphics;
Gdip.CheckStatus(PInvoke.GdipCreateFromHDC((HDC)hdc, &nativeGraphics));
return new Graphics(nativeGraphics);
}
/// <summary>
/// Creates a new instance of the Graphics class from the specified handle to a device context and handle to a device.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Advanced)]
public static Graphics FromHdc(IntPtr hdc, IntPtr hdevice)
{
GpGraphics* nativeGraphics;
Gdip.CheckStatus(PInvoke.GdipCreateFromHDC2((HDC)hdc, (HANDLE)hdevice, &nativeGraphics));
return new Graphics(nativeGraphics);
}
/// <summary>
/// Creates a new instance of the <see cref='Graphics'/> class from a window handle.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Advanced)]
public static Graphics FromHwnd(IntPtr hwnd) => FromHwndInternal(hwnd);
[EditorBrowsable(EditorBrowsableState.Advanced)]
public static Graphics FromHwndInternal(IntPtr hwnd)
{
GpGraphics* nativeGraphics;
// This is one of the few places we need to manually ensure GDI+ is initialized. Other calls to PInvoke will do
// this automatically, PInvokeCore cannot and as such needs to be manually initialized if we've never called
// another PInvoke method.
GdiPlusInitialization.EnsureInitialized();
Gdip.CheckStatus(PInvokeCore.GdipCreateFromHWND((HWND)hwnd, &nativeGraphics));
return new Graphics(nativeGraphics);
}
/// <summary>
/// Creates an instance of the <see cref='Graphics'/> class from an existing <see cref='Image'/>.
/// </summary>
public static Graphics FromImage(Image image)
{
ArgumentNullException.ThrowIfNull(image);
if ((image.PixelFormat & PixelFormat.Indexed) != 0)
throw new ArgumentException(SR.GdiplusCannotCreateGraphicsFromIndexedPixelFormat, nameof(image));
GpGraphics* nativeGraphics;
Gdip.CheckStatus(PInvoke.GdipGetImageGraphicsContext(image.Pointer(), &nativeGraphics));
GC.KeepAlive(image);
return new Graphics(nativeGraphics) { _backingImage = image };
}
[EditorBrowsable(EditorBrowsableState.Never)]
public void ReleaseHdcInternal(IntPtr hdc)
{
CheckStatus(!Gdip.Initialized ? Status.Ok : PInvoke.GdipReleaseDC(NativeGraphics, (HDC)hdc));
_nativeHdc = HDC.Null;
}
/// <summary>
/// Deletes this <see cref='Graphics'/>, and frees the memory allocated for it.
/// </summary>
public void Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
private void Dispose(bool disposing)
{
if (disposing)
{
while (_previousContext is not null)
{
// Dispose entire stack.
GraphicsContext? context = _previousContext.Previous;
_previousContext.Dispose();
_previousContext = context;
}
if (PrintingHelper is HdcHandle printerDC)
{
printerDC.Dispose();
_printingHelper = null;
}
}
if (!_nativeHdc.IsNull)
{
ReleaseHdc();
}
if (NativeGraphics is not null)
{
Status status = !Gdip.Initialized ? Status.Ok : PInvokeCore.GdipDeleteGraphics(NativeGraphics);
NativeGraphics = null;
Debug.Assert(status == Status.Ok, $"GDI+ returned an error status: {status}");
}
}
~Graphics() => Dispose(disposing: false);
/// <summary>
/// Handle to native GDI+ graphics object. This object is created on demand.
/// </summary>
internal GpGraphics* NativeGraphics { get; private set; }
nint IPointer<GpGraphics>.Pointer => (nint)NativeGraphics;
public Region Clip
{
get
{
Region region = new();
CheckStatus(PInvoke.GdipGetClip(NativeGraphics, region.NativeRegion));
return region;
}
set => SetClip(value, Drawing2D.CombineMode.Replace);
}
public RectangleF ClipBounds
{
get
{
RectF rect;
CheckStatus(PInvoke.GdipGetClipBounds(NativeGraphics, &rect));
return rect;
}
}
/// <summary>
/// Gets or sets the <see cref='Drawing2D.CompositingMode'/> associated with this <see cref='Graphics'/>.
/// </summary>
public Drawing2D.CompositingMode CompositingMode
{
get
{
GdiPlus.CompositingMode mode;
CheckStatus(PInvoke.GdipGetCompositingMode(NativeGraphics, &mode));
return (Drawing2D.CompositingMode)mode;
}
set
{
if (value is < Drawing2D.CompositingMode.SourceOver or > Drawing2D.CompositingMode.SourceCopy)
throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(Drawing2D.CompositingMode));
CheckStatus(PInvoke.GdipSetCompositingMode(NativeGraphics, (GdiPlus.CompositingMode)value));
}
}
public Drawing2D.CompositingQuality CompositingQuality
{
get
{
GdiPlus.CompositingQuality quality;
CheckStatus(PInvoke.GdipGetCompositingQuality(NativeGraphics, &quality));
return (Drawing2D.CompositingQuality)quality;
}
set
{
if (value is < Drawing2D.CompositingQuality.Invalid or > Drawing2D.CompositingQuality.AssumeLinear)
throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(Drawing2D.CompositingQuality));
CheckStatus(PInvoke.GdipSetCompositingQuality(NativeGraphics, (GdiPlus.CompositingQuality)value));
}
}
public float DpiX
{
get
{
float dpi;
CheckStatus(PInvoke.GdipGetDpiX(NativeGraphics, &dpi));
return dpi;
}
}
public float DpiY
{
get
{
float dpi;
CheckStatus(PInvoke.GdipGetDpiY(NativeGraphics, &dpi));
return dpi;
}
}
/// <summary>
/// Gets or sets the interpolation mode associated with this Graphics.
/// </summary>
public Drawing2D.InterpolationMode InterpolationMode
{
get
{
GdiPlus.InterpolationMode mode;
CheckStatus(PInvoke.GdipGetInterpolationMode(NativeGraphics, &mode));
return (Drawing2D.InterpolationMode)mode;
}
set
{
if (value is < Drawing2D.InterpolationMode.Invalid or > Drawing2D.InterpolationMode.HighQualityBicubic)
throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(Drawing2D.InterpolationMode));
CheckStatus(PInvoke.GdipSetInterpolationMode(NativeGraphics, (GdiPlus.InterpolationMode)value));
}
}
public bool IsClipEmpty
{
get
{
BOOL isEmpty;
CheckStatus(PInvoke.GdipIsClipEmpty(NativeGraphics, &isEmpty));
return isEmpty;
}
}
public bool IsVisibleClipEmpty
{
get
{
BOOL isEmpty;
CheckStatus(PInvoke.GdipIsVisibleClipEmpty(NativeGraphics, &isEmpty));
return isEmpty;
}
}
public float PageScale
{
get
{
float scale;
CheckStatus(PInvoke.GdipGetPageScale(NativeGraphics, &scale));
return scale;
}
set => CheckStatus(PInvoke.GdipSetPageScale(NativeGraphics, value));
}
public GraphicsUnit PageUnit
{
get
{
Unit unit;
CheckStatus(PInvoke.GdipGetPageUnit(NativeGraphics, &unit));
return (GraphicsUnit)unit;
}
set
{
if (value is < GraphicsUnit.World or > GraphicsUnit.Millimeter)
throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(GraphicsUnit));
CheckStatus(PInvoke.GdipSetPageUnit(NativeGraphics, (Unit)value));
}
}
public PixelOffsetMode PixelOffsetMode
{
get
{
GdiPlus.PixelOffsetMode mode;
CheckStatus(PInvoke.GdipGetPixelOffsetMode(NativeGraphics, &mode));
return (PixelOffsetMode)mode;
}
set
{
if (value is < PixelOffsetMode.Invalid or > PixelOffsetMode.Half)
throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(PixelOffsetMode));
CheckStatus(PInvoke.GdipSetPixelOffsetMode(NativeGraphics, (GdiPlus.PixelOffsetMode)value));
}
}
public Point RenderingOrigin
{
get
{
int x, y;
CheckStatus(PInvoke.GdipGetRenderingOrigin(NativeGraphics, &x, &y));
return new Point(x, y);
}
set => CheckStatus(PInvoke.GdipSetRenderingOrigin(NativeGraphics, value.X, value.Y));
}
public Drawing2D.SmoothingMode SmoothingMode
{
get
{
GdiPlus.SmoothingMode mode;
CheckStatus(PInvoke.GdipGetSmoothingMode(NativeGraphics, &mode));
return (Drawing2D.SmoothingMode)mode;
}
set
{
if (value is < Drawing2D.SmoothingMode.Invalid or > Drawing2D.SmoothingMode.AntiAlias)
throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(Drawing2D.SmoothingMode));
CheckStatus(PInvoke.GdipSetSmoothingMode(NativeGraphics, (GdiPlus.SmoothingMode)value));
}
}
public int TextContrast
{
get
{
uint textContrast;
CheckStatus(PInvoke.GdipGetTextContrast(NativeGraphics, &textContrast));
return (int)textContrast;
}
set => CheckStatus(PInvoke.GdipSetTextContrast(NativeGraphics, (uint)value));
}
/// <summary>
/// Gets or sets the rendering mode for text associated with this <see cref='Graphics'/>.
/// </summary>
public TextRenderingHint TextRenderingHint
{
get
{
GdiPlus.TextRenderingHint hint;
CheckStatus(PInvoke.GdipGetTextRenderingHint(NativeGraphics, &hint));
return (TextRenderingHint)hint;
}
set
{
if (value is < TextRenderingHint.SystemDefault or > TextRenderingHint.ClearTypeGridFit)
throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(TextRenderingHint));
CheckStatus(PInvoke.GdipSetTextRenderingHint(NativeGraphics, (GdiPlus.TextRenderingHint)value));
}
}
/// <summary>
/// Gets or sets the world transform for this <see cref='Graphics'/>.
/// </summary>
public Matrix Transform
{
get
{
Matrix matrix = new();
CheckStatus(PInvoke.GdipGetWorldTransform(NativeGraphics, matrix.NativeMatrix));
return matrix;
}
set
{
CheckStatus(PInvoke.GdipSetWorldTransform(NativeGraphics, value.NativeMatrix));
GC.KeepAlive(value);
}
}
/// <summary>
/// Gets or sets the world transform elements for this <see cref="Graphics"/>.
/// </summary>
/// <remarks>
/// <para>
/// This is a more performant alternative to <see cref="Transform"/> that does not need disposal.
/// </para>
/// </remarks>
public Matrix3x2 TransformElements
{
get
{
GdiPlus.Matrix* nativeMatrix;
CheckStatus(PInvoke.GdipCreateMatrix(&nativeMatrix));
try
{
CheckStatus(PInvoke.GdipGetWorldTransform(NativeGraphics, nativeMatrix));
Matrix3x2 matrix = default;
CheckStatus(PInvoke.GdipGetMatrixElements(nativeMatrix, (float*)&matrix));
return matrix;
}
finally
{
if (nativeMatrix is not null)
{
PInvoke.GdipDeleteMatrix(nativeMatrix);
}
}
}
set
{
GdiPlus.Matrix* nativeMatrix = Matrix.CreateNativeHandle(value);
try
{
CheckStatus(PInvoke.GdipSetWorldTransform(NativeGraphics, nativeMatrix));
}
finally
{
if (nativeMatrix is not null)
{
PInvoke.GdipDeleteMatrix(nativeMatrix);
}
}
}
}
HDC IHdcContext.GetHdc() => (HDC)GetHdc();
public IntPtr GetHdc()
{
HDC hdc;
CheckStatus(PInvoke.GdipGetDC(NativeGraphics, &hdc));
// Need to cache the hdc to be able to release with a call to IDeviceContext.ReleaseHdc().
_nativeHdc = hdc;
return _nativeHdc;
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void ReleaseHdc(IntPtr hdc) => ReleaseHdcInternal(hdc);
public void ReleaseHdc() => ReleaseHdcInternal(_nativeHdc);
/// <summary>
/// Forces immediate execution of all operations currently on the stack.
/// </summary>
public void Flush() => Flush(Drawing2D.FlushIntention.Flush);
/// <summary>
/// Forces execution of all operations currently on the stack.
/// </summary>
public void Flush(Drawing2D.FlushIntention intention) =>
CheckStatus(PInvoke.GdipFlush(NativeGraphics, (GdiPlus.FlushIntention)intention));
public void SetClip(Graphics g) => SetClip(g, Drawing2D.CombineMode.Replace);
public void SetClip(Graphics g, Drawing2D.CombineMode combineMode)
{
ArgumentNullException.ThrowIfNull(g);
CheckStatus(PInvoke.GdipSetClipGraphics(NativeGraphics, g.NativeGraphics, (GdiPlus.CombineMode)combineMode));
GC.KeepAlive(g);
}
public void SetClip(Rectangle rect) => SetClip(rect, Drawing2D.CombineMode.Replace);
public void SetClip(Rectangle rect, Drawing2D.CombineMode combineMode) => SetClip((RectangleF)rect, combineMode);
public void SetClip(RectangleF rect) => SetClip(rect, Drawing2D.CombineMode.Replace);
public void SetClip(RectangleF rect, Drawing2D.CombineMode combineMode) =>
CheckStatus(PInvoke.GdipSetClipRect(NativeGraphics, rect.X, rect.Y, rect.Width, rect.Height, (GdiPlus.CombineMode)combineMode));
public void SetClip(GraphicsPath path) => SetClip(path, Drawing2D.CombineMode.Replace);
public void SetClip(GraphicsPath path, Drawing2D.CombineMode combineMode)
{
ArgumentNullException.ThrowIfNull(path);
CheckStatus(PInvoke.GdipSetClipPath(NativeGraphics, path._nativePath, (GdiPlus.CombineMode)combineMode));
GC.KeepAlive(path);
}
public void SetClip(Region region, Drawing2D.CombineMode combineMode)
{
ArgumentNullException.ThrowIfNull(region);
CheckStatus(PInvoke.GdipSetClipRegion(NativeGraphics, region.NativeRegion, (GdiPlus.CombineMode)combineMode));
GC.KeepAlive(region);
}
public void IntersectClip(Rectangle rect) => IntersectClip((RectangleF)rect);
public void IntersectClip(RectangleF rect) =>
CheckStatus(PInvoke.GdipSetClipRect(
NativeGraphics,
rect.X, rect.Y, rect.Width, rect.Height,
GdiPlus.CombineMode.CombineModeIntersect));
public void IntersectClip(Region region)
{
ArgumentNullException.ThrowIfNull(region);
CheckStatus(PInvoke.GdipSetClipRegion(NativeGraphics, region.NativeRegion, GdiPlus.CombineMode.CombineModeIntersect));
GC.KeepAlive(region);
}
public void ExcludeClip(Rectangle rect) =>
CheckStatus(PInvoke.GdipSetClipRect(
NativeGraphics,
rect.X, rect.Y, rect.Width, rect.Height,
GdiPlus.CombineMode.CombineModeExclude));
public void ExcludeClip(Region region)
{
ArgumentNullException.ThrowIfNull(region);
CheckStatus(PInvoke.GdipSetClipRegion(NativeGraphics, region.NativeRegion, GdiPlus.CombineMode.CombineModeExclude));
GC.KeepAlive(region);
}
public void ResetClip() => CheckStatus(PInvoke.GdipResetClip(NativeGraphics));
public void TranslateClip(float dx, float dy) => CheckStatus(PInvoke.GdipTranslateClip(NativeGraphics, dx, dy));
public void TranslateClip(int dx, int dy) => CheckStatus(PInvoke.GdipTranslateClip(NativeGraphics, dx, dy));
public bool IsVisible(int x, int y) => IsVisible(new Point(x, y));
public bool IsVisible(Point point) => IsVisible(point.X, point.Y);
public bool IsVisible(float x, float y)
{
BOOL isVisible;
CheckStatus(PInvoke.GdipIsVisiblePoint(NativeGraphics, x, y, &isVisible));
return isVisible;
}
public bool IsVisible(PointF point) => IsVisible(point.X, point.Y);
public bool IsVisible(int x, int y, int width, int height) => IsVisible((float)x, y, width, height);
public bool IsVisible(Rectangle rect) => IsVisible((float)rect.X, rect.Y, rect.Width, rect.Height);
public bool IsVisible(float x, float y, float width, float height)
{
BOOL isVisible;
CheckStatus(PInvoke.GdipIsVisibleRect(NativeGraphics, x, y, width, height, &isVisible));
return isVisible;
}
public bool IsVisible(RectangleF rect) => IsVisible(rect.X, rect.Y, rect.Width, rect.Height);
/// <summary>
/// Resets the world transform to identity.
/// </summary>
public void ResetTransform() => CheckStatus(PInvoke.GdipResetWorldTransform(NativeGraphics));
/// <summary>
/// Multiplies the <see cref='Matrix'/> that represents the world transform and <paramref name="matrix"/>.
/// </summary>
public void MultiplyTransform(Matrix matrix) => MultiplyTransform(matrix, MatrixOrder.Prepend);
/// <summary>
/// Multiplies the <see cref='Matrix'/> that represents the world transform and <paramref name="matrix"/>.
/// </summary>
public void MultiplyTransform(Matrix matrix, MatrixOrder order)
{
ArgumentNullException.ThrowIfNull(matrix);
CheckStatus(PInvoke.GdipMultiplyWorldTransform(NativeGraphics, matrix.NativeMatrix, (GdiPlus.MatrixOrder)order));
GC.KeepAlive(matrix);
}
public void TranslateTransform(float dx, float dy) => TranslateTransform(dx, dy, MatrixOrder.Prepend);
public void TranslateTransform(float dx, float dy, MatrixOrder order) =>
CheckStatus(PInvoke.GdipTranslateWorldTransform(NativeGraphics, dx, dy, (GdiPlus.MatrixOrder)order));
public void ScaleTransform(float sx, float sy) => ScaleTransform(sx, sy, MatrixOrder.Prepend);
public void ScaleTransform(float sx, float sy, MatrixOrder order) =>
CheckStatus(PInvoke.GdipScaleWorldTransform(NativeGraphics, sx, sy, (GdiPlus.MatrixOrder)order));
public void RotateTransform(float angle) => RotateTransform(angle, MatrixOrder.Prepend);
public void RotateTransform(float angle, MatrixOrder order) =>
CheckStatus(PInvoke.GdipRotateWorldTransform(NativeGraphics, angle, (GdiPlus.MatrixOrder)order));
/// <summary>
/// Draws an arc from the specified ellipse.
/// </summary>
public void DrawArc(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
{
ArgumentNullException.ThrowIfNull(pen);
CheckErrorStatus(PInvoke.GdipDrawArc(
NativeGraphics,
pen.NativePen,
x, y, width, height,
startAngle,
sweepAngle));
GC.KeepAlive(pen);
}
/// <summary>
/// Draws an arc from the specified ellipse.
/// </summary>
public void DrawArc(Pen pen, RectangleF rect, float startAngle, float sweepAngle) =>
DrawArc(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
/// <summary>
/// Draws an arc from the specified ellipse.
/// </summary>
public void DrawArc(Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle)
=> DrawArc(pen, (float)x, y, width, height, startAngle, sweepAngle);
/// <summary>
/// Draws an arc from the specified ellipse.
/// </summary>
public void DrawArc(Pen pen, Rectangle rect, float startAngle, float sweepAngle) =>
DrawArc(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
/// <summary>
/// Draws a cubic Bezier curve defined by four ordered pairs that represent points.
/// </summary>
public void DrawBezier(Pen pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
{
ArgumentNullException.ThrowIfNull(pen);
CheckErrorStatus(PInvoke.GdipDrawBezier(
NativeGraphics,
pen.NativePen,
x1, y1, x2, y2, x3, y3, x4, y4));
GC.KeepAlive(pen);
}
/// <summary>
/// Draws a cubic Bezier curve defined by four points.
/// </summary>
public void DrawBezier(Pen pen, PointF pt1, PointF pt2, PointF pt3, PointF pt4) =>
DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
/// <summary>
/// Draws a cubic Bezier curve defined by four points.
/// </summary>
public void DrawBezier(Pen pen, Point pt1, Point pt2, Point pt3, Point pt4) =>
DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
/// <summary>
/// Draws the outline of a rectangle specified by <paramref name="rect"/>.
/// </summary>
/// <param name="pen">A Pen that determines the color, width, and style of the rectangle.</param>
/// <param name="rect">A Rectangle structure that represents the rectangle to draw.</param>
public void DrawRectangle(Pen pen, RectangleF rect) => DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height);
/// <summary>
/// Draws the outline of a rectangle specified by <paramref name="rect"/>.
/// </summary>
public void DrawRectangle(Pen pen, Rectangle rect) => DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height);
#if NET9_0_OR_GREATER
/// <inheritdoc cref="DrawRoundedRectangle(Pen, RectangleF, SizeF)"/>
public void DrawRoundedRectangle(Pen pen, Rectangle rect, Size radius) =>
DrawRoundedRectangle(pen, (RectangleF)rect, radius);
/// <summary>
/// Draws the outline of the specified rounded rectangle.
/// </summary>
/// <param name="pen">The <see cref="Pen"/> to draw the outline with.</param>
/// <param name="rect">The bounds of the rounded rectangle.</param>
/// <param name="radius">The radius width and height used to round the corners of the rectangle.</param>
public void DrawRoundedRectangle(Pen pen, RectangleF rect, SizeF radius)
{
using GraphicsPath path = new();
path.AddRoundedRectangle(rect, radius);
DrawPath(pen, path);
}
#endif
/// <summary>
/// Draws the outline of the specified rectangle.
/// </summary>
public void DrawRectangle(Pen pen, float x, float y, float width, float height)
{
ArgumentNullException.ThrowIfNull(pen);
CheckErrorStatus(PInvoke.GdipDrawRectangle(NativeGraphics, pen.NativePen, x, y, width, height));
GC.KeepAlive(pen);
}
/// <summary>
/// Draws the outline of the specified rectangle.
/// </summary>
public void DrawRectangle(Pen pen, int x, int y, int width, int height)
=> DrawRectangle(pen, (float)x, y, width, height);
/// <inheritdoc cref="DrawRectangles(Pen, Rectangle[])"/>
public void DrawRectangles(Pen pen, params RectangleF[] rects) => DrawRectangles(pen, rects.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawRectangles(Pen, Rectangle[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawRectangles(Pen pen, params ReadOnlySpan<RectangleF> rects)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (RectangleF* r = rects)
{
CheckErrorStatus(PInvoke.GdipDrawRectangles(NativeGraphics, pen.NativePen, (RectF*)r, rects.Length));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Draws the outlines of a series of rectangles.
/// </summary>
/// <param name="pen"><see cref="Pen"/> that determines the color, width, and style of the outlines of the rectangles.</param>
/// <param name="rects">An array of <see cref="Rectangle"/> structures that represents the rectangles to draw.</param>
public void DrawRectangles(Pen pen, params Rectangle[] rects) => DrawRectangles(pen, rects.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawRectangles(Pen, Rectangle[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawRectangles(Pen pen, params ReadOnlySpan<Rectangle> rects)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (Rectangle* r = rects)
{
CheckErrorStatus(PInvoke.GdipDrawRectanglesI(NativeGraphics, pen.NativePen, (Rect*)r, rects.Length));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Draws the outline of an ellipse defined by a bounding rectangle.
/// </summary>
public void DrawEllipse(Pen pen, RectangleF rect) => DrawEllipse(pen, rect.X, rect.Y, rect.Width, rect.Height);
/// <summary>
/// Draws the outline of an ellipse defined by a bounding rectangle.
/// </summary>
public void DrawEllipse(Pen pen, float x, float y, float width, float height)
{
ArgumentNullException.ThrowIfNull(pen);
CheckErrorStatus(PInvoke.GdipDrawEllipse(NativeGraphics, pen.NativePen, x, y, width, height));
GC.KeepAlive(pen);
}
/// <summary>
/// Draws the outline of an ellipse specified by a bounding rectangle.
/// </summary>
public void DrawEllipse(Pen pen, Rectangle rect) => DrawEllipse(pen, (float)rect.X, rect.Y, rect.Width, rect.Height);
/// <summary>
/// Draws the outline of an ellipse defined by a bounding rectangle.
/// </summary>
public void DrawEllipse(Pen pen, int x, int y, int width, int height) => DrawEllipse(pen, (float)x, y, width, height);
/// <summary>
/// Draws the outline of a pie section defined by an ellipse and two radial lines.
/// </summary>
public void DrawPie(Pen pen, RectangleF rect, float startAngle, float sweepAngle) =>
DrawPie(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
/// <summary>
/// Draws the outline of a pie section defined by an ellipse and two radial lines.
/// </summary>
public void DrawPie(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
{
ArgumentNullException.ThrowIfNull(pen);
CheckErrorStatus(PInvoke.GdipDrawPie(NativeGraphics, pen.NativePen, x, y, width, height, startAngle, sweepAngle));
GC.KeepAlive(pen);
}
/// <summary>
/// Draws the outline of a pie section defined by an ellipse and two radial lines.
/// </summary>
public void DrawPie(Pen pen, Rectangle rect, float startAngle, float sweepAngle) =>
DrawPie(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
/// <summary>
/// Draws the outline of a pie section defined by an ellipse and two radial lines.
/// </summary>
public void DrawPie(Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle) =>
DrawPie(pen, (float)x, y, width, height, startAngle, sweepAngle);
/// <inheritdoc cref="DrawPolygon(Pen, Point[])"/>
public void DrawPolygon(Pen pen, params PointF[] points) => DrawPolygon(pen, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawPolygon(Pen, Point[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawPolygon(Pen pen, params ReadOnlySpan<PointF> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawPolygon(NativeGraphics, pen.NativePen, (GdiPlus.PointF*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Draws the outline of a polygon defined by an array of points.
/// </summary>
/// <param name="pen">The <see cref="Pen"/> to draw the outline with.</param>
/// <param name="points">An array of <see cref="Point"/> structures that represent the vertices of the polygon.</param>
public void DrawPolygon(Pen pen, params Point[] points) => DrawPolygon(pen, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawPolygon(Pen, Point[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawPolygon(Pen pen, params ReadOnlySpan<Point> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawPolygonI(NativeGraphics, pen.NativePen, (GdiPlus.Point*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Draws the lines and curves defined by a <see cref='GraphicsPath'/>.
/// </summary>
public void DrawPath(Pen pen, GraphicsPath path)
{
ArgumentNullException.ThrowIfNull(pen);
ArgumentNullException.ThrowIfNull(path);
CheckErrorStatus(PInvoke.GdipDrawPath(NativeGraphics, pen.NativePen, path._nativePath));
GC.KeepAlive(pen);
GC.KeepAlive(path);
}
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
public void DrawCurve(Pen pen, params PointF[] points) => DrawCurve(pen, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawCurve(Pen pen, params ReadOnlySpan<PointF> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawCurve(NativeGraphics, pen.NativePen, (GdiPlus.PointF*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
public void DrawCurve(Pen pen, PointF[] points, float tension) =>
DrawCurve(pen, points.OrThrowIfNull().AsSpan(), tension);
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawCurve(Pen pen, ReadOnlySpan<PointF> points, float tension)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawCurve2(
NativeGraphics,
pen.NativePen,
(GdiPlus.PointF*)p, points.Length,
tension));
}
GC.KeepAlive(pen);
}
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
public void DrawCurve(Pen pen, PointF[] points, int offset, int numberOfSegments) =>
DrawCurve(pen, points, offset, numberOfSegments, 0.5f);
#if NET9_0_OR_GREATER
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
public void DrawCurve(Pen pen, ReadOnlySpan<PointF> points, int offset, int numberOfSegments) =>
DrawCurve(pen, points, offset, numberOfSegments, 0.5f);
#endif
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
public void DrawCurve(Pen pen, PointF[] points, int offset, int numberOfSegments, float tension) =>
DrawCurve(pen, points.OrThrowIfNull().AsSpan(), offset, numberOfSegments, tension);
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawCurve(Pen pen, ReadOnlySpan<PointF> points, int offset, int numberOfSegments, float tension)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawCurve3(
NativeGraphics,
pen.NativePen,
(GdiPlus.PointF*)p, points.Length,
offset,
numberOfSegments,
tension));
}
GC.KeepAlive(pen);
}
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
public void DrawCurve(Pen pen, params Point[] points) => DrawCurve(pen, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawCurve(Pen pen, params ReadOnlySpan<Point> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawCurveI(NativeGraphics, pen.NativePen, (GdiPlus.Point*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
public void DrawCurve(Pen pen, Point[] points, float tension) =>
DrawCurve(pen, points.OrThrowIfNull().AsSpan(), tension);
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawCurve(Pen pen, ReadOnlySpan<Point> points, float tension)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawCurve2I(
NativeGraphics,
pen.NativePen,
(GdiPlus.Point*)p, points.Length,
tension));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Draws a curve defined by an array of points.
/// </summary>
/// <param name="pen">The <see cref="Pen"/> to draw the curve with.</param>
/// <param name="points">An array of points that define the curve.</param>
/// <param name="offset">The index of the first point in the array to draw.</param>
/// <param name="numberOfSegments">The number of segments to draw.</param>
/// <param name="tension">A value greater than, or equal to zero that specifies the tension of the curve.</param>
public void DrawCurve(Pen pen, Point[] points, int offset, int numberOfSegments, float tension) =>
DrawCurve(pen, points.OrThrowIfNull().AsSpan(), offset, numberOfSegments, tension);
/// <inheritdoc cref="DrawCurve(Pen, Point[], int, int, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawCurve(Pen pen, ReadOnlySpan<Point> points, int offset, int numberOfSegments, float tension)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawCurve3I(
NativeGraphics,
pen.NativePen,
(GdiPlus.Point*)p, points.Length,
offset,
numberOfSegments,
tension));
}
GC.KeepAlive(pen);
}
/// <inheritdoc cref="DrawClosedCurve(Pen, PointF[], float, FillMode)"/>
public void DrawClosedCurve(Pen pen, params PointF[] points) =>
DrawClosedCurve(pen, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawClosedCurve(Pen, PointF[], float, FillMode)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawClosedCurve(Pen pen, params ReadOnlySpan<PointF> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawClosedCurve(
NativeGraphics,
pen.NativePen,
(GdiPlus.PointF*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Draws a closed curve defined by an array of points.
/// </summary>
/// <param name="pen">The <see cref="Pen"/> to draw the closed curve with.</param>
/// <param name="points">An array of points that define the closed curve.</param>
/// <param name="tension">A value greater than, or equal to zero that specifies the tension of the curve.</param>
/// <param name="fillmode">A <see cref="FillMode"/> enumeration that specifies the fill mode of the curve.</param>
public void DrawClosedCurve(Pen pen, PointF[] points, float tension, FillMode fillmode) =>
DrawClosedCurve(pen, points.OrThrowIfNull().AsSpan(), tension, fillmode);
/// <inheritdoc cref="DrawClosedCurve(Pen, PointF[], float, FillMode)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawClosedCurve(Pen pen, ReadOnlySpan<PointF> points, float tension, FillMode fillmode)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawClosedCurve2(
NativeGraphics,
pen.NativePen,
(GdiPlus.PointF*)p, points.Length,
tension));
}
GC.KeepAlive(pen);
}
/// <inheritdoc cref="DrawClosedCurve(Pen, PointF[], float, FillMode)"/>
public void DrawClosedCurve(Pen pen, params Point[] points) => DrawClosedCurve(pen, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawClosedCurve(Pen, PointF[], float, FillMode)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawClosedCurve(Pen pen, params ReadOnlySpan<Point> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawClosedCurveI(
NativeGraphics,
pen.NativePen,
(GdiPlus.Point*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <inheritdoc cref="DrawClosedCurve(Pen, PointF[], float, FillMode)"/>
public void DrawClosedCurve(Pen pen, Point[] points, float tension, FillMode fillmode) =>
DrawClosedCurve(pen, points.OrThrowIfNull().AsSpan(), tension, fillmode);
/// <inheritdoc cref="DrawClosedCurve(Pen, PointF[], float, FillMode)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawClosedCurve(Pen pen, ReadOnlySpan<Point> points, float tension, FillMode fillmode)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawClosedCurve2I(
NativeGraphics,
pen.NativePen,
(GdiPlus.Point*)p, points.Length,
tension));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Fills the entire drawing surface with the specified color.
/// </summary>
public void Clear(Color color) => CheckStatus(PInvoke.GdipGraphicsClear(NativeGraphics, (uint)color.ToArgb()));
#if NET9_0_OR_GREATER
/// <inheritdoc cref="FillRoundedRectangle(Brush, RectangleF, SizeF)"/>/>
public void FillRoundedRectangle(Brush brush, Rectangle rect, Size radius) =>
FillRoundedRectangle(brush, (RectangleF)rect, radius);
/// <summary>
/// Fills the interior of a rounded rectangle with a <see cref='Brush'/>.
/// </summary>
/// <param name="brush">The <see cref="Brush"/> to fill the rounded rectangle with.</param>
/// <param name="rect">The bounds of the rounded rectangle.</param>
/// <param name="radius">The radius width and height used to round the corners of the rectangle.</param>
public void FillRoundedRectangle(Brush brush, RectangleF rect, SizeF radius)
{
using GraphicsPath path = new();
path.AddRoundedRectangle(rect, radius);
FillPath(brush, path);
}
#endif
/// <summary>
/// Fills the interior of a rectangle with a <see cref='Brush'/>.
/// </summary>
public void FillRectangle(Brush brush, RectangleF rect) => FillRectangle(brush, rect.X, rect.Y, rect.Width, rect.Height);
/// <summary>
/// Fills the interior of a rectangle with a <see cref='Brush'/>.
/// </summary>
public void FillRectangle(Brush brush, float x, float y, float width, float height)
{
ArgumentNullException.ThrowIfNull(brush);
CheckErrorStatus(PInvoke.GdipFillRectangle(
NativeGraphics,
brush.NativeBrush,
x, y, width, height));
GC.KeepAlive(brush);
}
/// <summary>
/// Fills the interior of a rectangle with a <see cref='Brush'/>.
/// </summary>
public void FillRectangle(Brush brush, Rectangle rect) => FillRectangle(brush, (float)rect.X, rect.Y, rect.Width, rect.Height);
/// <summary>
/// Fills the interior of a rectangle with a <see cref='Brush'/>.
/// </summary>
public void FillRectangle(Brush brush, int x, int y, int width, int height) => FillRectangle(brush, (float)x, y, width, height);
/// <summary>
/// Fills the interiors of a series of rectangles with a <see cref='Brush'/>.
/// </summary>
/// <param name="brush">The <see cref="Brush"/> to fill the rectangles with.</param>
/// <param name="rects">An array of rectangles to fill.</param>
public void FillRectangles(Brush brush, params RectangleF[] rects)
{
ArgumentNullException.ThrowIfNull(rects);
FillRectangles(brush, rects.AsSpan());
}
/// <inheritdoc cref="FillRectangles(Brush, RectangleF[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void FillRectangles(Brush brush, params ReadOnlySpan<RectangleF> rects)
{
ArgumentNullException.ThrowIfNull(brush);
fixed (RectangleF* r = rects)
{
CheckErrorStatus(PInvoke.GdipFillRectangles(NativeGraphics, brush.NativeBrush, (RectF*)r, rects.Length));
}
GC.KeepAlive(brush);
}
/// <inheritdoc cref="FillRectangles(Brush, RectangleF[])"/>
public void FillRectangles(Brush brush, params Rectangle[] rects) =>
FillRectangles(brush, rects.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="FillRectangles(Brush, RectangleF[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void FillRectangles(Brush brush, params ReadOnlySpan<Rectangle> rects)
{
ArgumentNullException.ThrowIfNull(brush);
fixed (Rectangle* r = rects)
{
CheckErrorStatus(PInvoke.GdipFillRectanglesI(NativeGraphics, brush.NativeBrush, (Rect*)r, rects.Length));
}
GC.KeepAlive(brush);
}
/// <inheritdoc cref="FillPolygon(Brush, Point[], FillMode)"/>
public void FillPolygon(Brush brush, params PointF[] points) => FillPolygon(brush, points, FillMode.Alternate);
#if NET9_0_OR_GREATER
/// <inheritdoc cref="FillPolygon(Brush, Point[], FillMode)"/>
public void FillPolygon(Brush brush, params ReadOnlySpan<PointF> points) => FillPolygon(brush, points, FillMode.Alternate);
#endif
/// <inheritdoc cref="FillPolygon(Brush, Point[], FillMode)"/>
public void FillPolygon(Brush brush, PointF[] points, FillMode fillMode) =>
FillPolygon(brush, points.OrThrowIfNull().AsSpan(), fillMode);
/// <inheritdoc cref="FillPolygon(Brush, Point[], FillMode)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void FillPolygon(Brush brush, ReadOnlySpan<PointF> points, FillMode fillMode)
{
ArgumentNullException.ThrowIfNull(brush);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipFillPolygon(
NativeGraphics,
brush.NativeBrush,
(GdiPlus.PointF*)p, points.Length,
(GdiPlus.FillMode)fillMode));
}
GC.KeepAlive(brush);
}
/// <inheritdoc cref="FillPolygon(Brush, Point[], FillMode)"/>
public void FillPolygon(Brush brush, Point[] points) => FillPolygon(brush, points, FillMode.Alternate);
#if NET9_0_OR_GREATER
/// <inheritdoc cref="FillPolygon(Brush, Point[], FillMode)"/>
public void FillPolygon(Brush brush, params ReadOnlySpan<Point> points) => FillPolygon(brush, points, FillMode.Alternate);
#endif
/// <summary>
/// Fills the interior of a polygon defined by an array of points.
/// </summary>
/// <param name="brush">The <see cref="Brush"/> to fill the polygon with.</param>
/// <param name="points">An array points that represent the vertices of the polygon.</param>
/// <param name="fillMode">A <see cref="FillMode"/> enumeration that specifies the fill mode of the polygon.</param>
public void FillPolygon(Brush brush, Point[] points, FillMode fillMode) =>
FillPolygon(brush, points.OrThrowIfNull().AsSpan(), fillMode);
/// <inheritdoc cref="FillPolygon(Brush, Point[], FillMode)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void FillPolygon(Brush brush, ReadOnlySpan<Point> points, FillMode fillMode)
{
ArgumentNullException.ThrowIfNull(brush);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipFillPolygonI(
NativeGraphics,
brush.NativeBrush,
(GdiPlus.Point*)p, points.Length,
(GdiPlus.FillMode)fillMode));
}
GC.KeepAlive(brush);
}
/// <summary>
/// Fills the interior of an ellipse defined by a bounding rectangle.
/// </summary>
public void FillEllipse(Brush brush, RectangleF rect) => FillEllipse(brush, rect.X, rect.Y, rect.Width, rect.Height);
/// <summary>
/// Fills the interior of an ellipse defined by a bounding rectangle.
/// </summary>
public void FillEllipse(Brush brush, float x, float y, float width, float height)
{
ArgumentNullException.ThrowIfNull(brush);
CheckErrorStatus(PInvoke.GdipFillEllipse(
NativeGraphics,
brush.NativeBrush,
x, y, width, height));
GC.KeepAlive(brush);
}
/// <summary>
/// Fills the interior of an ellipse defined by a bounding rectangle.
/// </summary>
public void FillEllipse(Brush brush, Rectangle rect) => FillEllipse(brush, (float)rect.X, rect.Y, rect.Width, rect.Height);
/// <summary>
/// Fills the interior of an ellipse defined by a bounding rectangle.
/// </summary>
public void FillEllipse(Brush brush, int x, int y, int width, int height) => FillEllipse(brush, (float)x, y, width, height);
/// <summary>
/// Fills the interior of a pie section defined by an ellipse and two radial lines.
/// </summary>
public void FillPie(Brush brush, Rectangle rect, float startAngle, float sweepAngle) =>
FillPie(brush, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
/// <summary>
/// Fills the interior of a pie section defined by an ellipse and two radial lines.
/// </summary>
/// <param name="brush">A Brush that determines the characteristics of the fill.</param>
/// <param name="rect">
/// A Rectangle structure that represents the bounding rectangle that defines the ellipse from which
/// the pie section comes.
/// </param>
/// <param name="startAngle">
/// Angle in degrees measured clockwise from the x-axis to the first side of the pie section.
/// </param>
/// <param name="sweepAngle">
/// Angle in degrees measured clockwise from the <paramref name="startAngle"/> parameter
/// to the second side of the pie section.
/// </param>
public void FillPie(Brush brush, RectangleF rect, float startAngle, float sweepAngle) =>
FillPie(brush, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
/// <summary>
/// Fills the interior of a pie section defined by an ellipse and two radial lines.
/// </summary>
public void FillPie(Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle)
{
ArgumentNullException.ThrowIfNull(brush);
CheckErrorStatus(PInvoke.GdipFillPie(
NativeGraphics,
brush.NativeBrush,
x, y, width, height,
startAngle,
sweepAngle));
GC.KeepAlive(brush);
}
/// <summary>
/// Fills the interior of a pie section defined by an ellipse and two radial lines.
/// </summary>
public void FillPie(Brush brush, int x, int y, int width, int height, int startAngle, int sweepAngle)
=> FillPie(brush, (float)x, y, width, height, startAngle, sweepAngle);
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
public void FillClosedCurve(Brush brush, params PointF[] points) =>
FillClosedCurve(brush, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void FillClosedCurve(Brush brush, params ReadOnlySpan<PointF> points)
{
ArgumentNullException.ThrowIfNull(brush);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipFillClosedCurve(
NativeGraphics,
brush.NativeBrush,
(GdiPlus.PointF*)p, points.Length));
}
GC.KeepAlive(brush);
}
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
public void FillClosedCurve(Brush brush, PointF[] points, FillMode fillmode) =>
FillClosedCurve(brush, points, fillmode, 0.5f);
#if NET9_0_OR_GREATER
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
public void FillClosedCurve(Brush brush, ReadOnlySpan<PointF> points, FillMode fillmode) =>
FillClosedCurve(brush, points, fillmode, 0.5f);
#endif
/// <summary>
/// Fills the interior of a closed curve defined by an array of points.
/// </summary>
/// <param name="brush">The <see cref="Brush"/> to fill the closed curve with.</param>
/// <param name="points">An array of points that make up the closed curve.</param>
/// <param name="fillmode">A <see cref="FillMode"/> enumeration that specifies the fill mode of the closed curve.</param>
/// <param name="tension">A value greater than, or equal to zero that specifies the tension of the curve.</param>
public void FillClosedCurve(Brush brush, PointF[] points, FillMode fillmode, float tension) =>
FillClosedCurve(brush, points.OrThrowIfNull().AsSpan(), fillmode, tension);
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void FillClosedCurve(Brush brush, ReadOnlySpan<PointF> points, FillMode fillmode, float tension)
{
ArgumentNullException.ThrowIfNull(brush);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipFillClosedCurve2(
NativeGraphics,
brush.NativeBrush,
(GdiPlus.PointF*)p, points.Length,
tension,
(GdiPlus.FillMode)fillmode));
}
GC.KeepAlive(brush);
}
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
public void FillClosedCurve(Brush brush, params Point[] points) =>
FillClosedCurve(brush, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void FillClosedCurve(Brush brush, params ReadOnlySpan<Point> points)
{
ArgumentNullException.ThrowIfNull(brush);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipFillClosedCurveI(
NativeGraphics,
brush.NativeBrush,
(GdiPlus.Point*)p, points.Length));
}
GC.KeepAlive(brush);
}
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
public void FillClosedCurve(Brush brush, Point[] points, FillMode fillmode) =>
FillClosedCurve(brush, points, fillmode, 0.5f);
#if NET9_0_OR_GREATER
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
public void FillClosedCurve(Brush brush, ReadOnlySpan<Point> points, FillMode fillmode) =>
FillClosedCurve(brush, points, fillmode, 0.5f);
#endif
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
public void FillClosedCurve(Brush brush, Point[] points, FillMode fillmode, float tension) =>
FillClosedCurve(brush, points.OrThrowIfNull().AsSpan(), fillmode, tension);
/// <inheritdoc cref="FillClosedCurve(Brush, PointF[], FillMode, float)"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void FillClosedCurve(Brush brush, ReadOnlySpan<Point> points, FillMode fillmode, float tension)
{
ArgumentNullException.ThrowIfNull(brush);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipFillClosedCurve2I(
NativeGraphics,
brush.NativeBrush,
(GdiPlus.Point*)p, points.Length,
tension,
(GdiPlus.FillMode)fillmode));
}
GC.KeepAlive(brush);
}
/// <summary>
/// Draws the specified text at the specified location with the specified <see cref="Brush"/> and
/// <see cref="Font"/> objects.
/// </summary>
/// <param name="s">The text to draw.</param>
/// <param name="font"><see cref="Font"/> that defines the text format.</param>
/// <param name="brush"><see cref="Brush"/> that determines the color and texture of the drawn text.</param>
/// <param name="x">The x-coordinate of the upper-left corner of the drawn text.</param>
/// <param name="y">The y-coordinate of the upper-left corner of the drawn text.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="brush"/> is <see langword="null"/>. -or- <paramref name="font"/> is <see langword="null"/>.
/// </exception>
public void DrawString(string? s, Font font, Brush brush, float x, float y) =>
DrawString(s, font, brush, new RectangleF(x, y, 0, 0), null);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="DrawString(string?, Font, Brush, float, float)"/>
public void DrawString(ReadOnlySpan<char> s, Font font, Brush brush, float x, float y) =>
DrawString(s, font, brush, new RectangleF(x, y, 0, 0), null);
#endif
/// <summary>
/// Draws the specified text at the specified location with the specified <see cref="Brush"/> and
/// <see cref="Font"/> objects.
/// </summary>
/// <param name="s">The text to draw.</param>
/// <param name="font"><see cref="Font"/> that defines the text format.</param>
/// <param name="brush"><see cref="Brush"/> that determines the color and texture of the drawn text.</param>
/// <param name="point"><see cref="PointF"/>structure that specifies the upper-left corner of the drawn text.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="brush"/> is <see langword="null"/>. -or- <paramref name="font"/> is <see langword="null"/>.
/// </exception>
public void DrawString(string? s, Font font, Brush brush, PointF point) =>
DrawString(s, font, brush, new RectangleF(point.X, point.Y, 0, 0), null);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="DrawString(string?, Font, Brush, PointF)"/>
public void DrawString(ReadOnlySpan<char> s, Font font, Brush brush, PointF point) =>
DrawString(s, font, brush, new RectangleF(point.X, point.Y, 0, 0), null);
#endif
/// <summary>
/// Draws the specified text at the specified location with the specified <see cref="Brush"/> and
/// <see cref="Font"/> objects using the formatting attributes of the specified <see cref="StringFormat"/>.
/// </summary>
/// <param name="s">The text to draw.</param>
/// <param name="font"><see cref="Font"/> that defines the text format.</param>
/// <param name="brush"><see cref="Brush"/> that determines the color and texture of the drawn text.</param>
/// <param name="x">The x-coordinate of the upper-left corner of the drawn text.</param>
/// <param name="y">The y-coordinate of the upper-left corner of the drawn text.</param>
/// <param name="format">
/// <see cref="StringFormat"/> that specifies formatting attributes, such as line spacing and alignment,
/// that are applied to the drawn text.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="brush"/> is <see langword="null"/>. -or- <paramref name="font"/> is <see langword="null"/>.
/// </exception>
public void DrawString(string? s, Font font, Brush brush, float x, float y, StringFormat? format) =>
DrawString(s, font, brush, new RectangleF(x, y, 0, 0), format);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="DrawString(string?, Font, Brush, float, float, StringFormat?)"/>
public void DrawString(ReadOnlySpan<char> s, Font font, Brush brush, float x, float y, StringFormat? format) =>
DrawString(s, font, brush, new RectangleF(x, y, 0, 0), format);
#endif
/// <summary>
/// Draws the specified text at the specified location with the specified <see cref="Brush"/> and
/// <see cref="Font"/> objects using the formatting attributes of the specified <see cref="StringFormat"/>.
/// </summary>
/// <param name="s">The text to draw.</param>
/// <param name="font"><see cref="Font"/> that defines the text format.</param>
/// <param name="brush"><see cref="Brush"/> that determines the color and texture of the drawn text.</param>
/// <param name="point"><see cref="PointF"/>structure that specifies the upper-left corner of the drawn text.</param>
/// <param name="format">
/// <see cref="StringFormat"/> that specifies formatting attributes, such as line spacing and alignment,
/// that are applied to the drawn text.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="brush"/> is <see langword="null"/>. -or- <paramref name="font"/> is <see langword="null"/>.
/// </exception>
public void DrawString(string? s, Font font, Brush brush, PointF point, StringFormat? format) =>
DrawString(s, font, brush, new RectangleF(point.X, point.Y, 0, 0), format);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="DrawString(string?, Font, Brush, PointF, StringFormat?)"/>
public void DrawString(ReadOnlySpan<char> s, Font font, Brush brush, PointF point, StringFormat? format) =>
DrawString(s, font, brush, new RectangleF(point.X, point.Y, 0, 0), format);
#endif
/// <summary>
/// Draws the specified text in the specified rectangle with the specified <see cref="Brush"/> and
/// <see cref="Font"/> objects.
/// </summary>
/// <param name="s">The text to draw.</param>
/// <param name="font"><see cref="Font"/> that defines the text format.</param>
/// <param name="brush"><see cref="Brush"/> that determines the color and texture of the drawn text.</param>
/// <param name="layoutRectangle"><see cref="RectangleF"/>structure that specifies the location of the drawn text.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="brush"/> is <see langword="null"/>. -or- <paramref name="font"/> is <see langword="null"/>.
/// </exception>
/// <remarks>
/// <para>
/// The text represented by the <paramref name="s"/> parameter is drawn inside the rectangle represented by
/// the <paramref name="layoutRectangle"/> parameter. If the text does not fit inside the rectangle, it is
/// truncated at the nearest word. To further manipulate how the string is drawn inside the rectangle use the
/// <see cref="DrawString(string?, Font, Brush, RectangleF, StringFormat?)"/> overload that takes
/// a <see cref="StringFormat"/>.
/// </para>
/// </remarks>
public void DrawString(string? s, Font font, Brush brush, RectangleF layoutRectangle) =>
DrawString(s, font, brush, layoutRectangle, null);
#if NET8_0_OR_GREATER
/// <remarks>
/// <para>
/// The text represented by the <paramref name="s"/> parameter is drawn inside the rectangle represented by
/// the <paramref name="layoutRectangle"/> parameter. If the text does not fit inside the rectangle, it is
/// truncated at the nearest word. To further manipulate how the string is drawn inside the rectangle use the
/// <see cref="DrawString(ReadOnlySpan{char}, Font, Brush, RectangleF, StringFormat?)"/> overload that takes
/// a <see cref="StringFormat"/>.
/// </para>
/// </remarks>
/// <inheritdoc cref="DrawString(string?, Font, Brush, RectangleF)"/>
public void DrawString(ReadOnlySpan<char> s, Font font, Brush brush, RectangleF layoutRectangle) =>
DrawString(s, font, brush, layoutRectangle, null);
#endif
/// <summary>
/// Draws the specified text in the specified rectangle with the specified <see cref="Brush"/> and
/// <see cref="Font"/> objects using the formatting attributes of the specified <see cref="StringFormat"/>.
/// </summary>
/// <param name="s">The text to draw.</param>
/// <param name="font"><see cref="Font"/> that defines the text format.</param>
/// <param name="brush"><see cref="Brush"/> that determines the color and texture of the drawn text.</param>
/// <param name="layoutRectangle"><see cref="RectangleF"/>structure that specifies the location of the drawn text.</param>
/// <param name="format">
/// <see cref="StringFormat"/> that specifies formatting attributes, such as line spacing and alignment,
/// that are applied to the drawn text.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="brush"/> is <see langword="null"/>. -or- <paramref name="font"/> is <see langword="null"/>.
/// </exception>
/// <remarks>
/// <para>
/// The text represented by the <paramref name="s"/> parameter is drawn inside the rectangle represented by
/// the <paramref name="layoutRectangle"/> parameter. If the text does not fit inside the rectangle, it is
/// truncated at the nearest word, unless otherwise specified with the <paramref name="format"/> parameter.
/// </para>
/// </remarks>
public void DrawString(string? s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat? format) =>
DrawStringInternal(s, font, brush, layoutRectangle, format);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="DrawString(string?, Font, Brush, RectangleF, StringFormat?)"/>
public void DrawString(ReadOnlySpan<char> s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat? format) =>
DrawStringInternal(s, font, brush, layoutRectangle, format);
#endif
private void DrawStringInternal(ReadOnlySpan<char> s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat? format)
{
ArgumentNullException.ThrowIfNull(brush);
if (s.IsEmpty)
{
return;
}
ArgumentNullException.ThrowIfNull(font);
fixed (char* c = s)
{
CheckErrorStatus(PInvoke.GdipDrawString(
NativeGraphics,
c, s.Length,
font.NativeFont,
(RectF*)&layoutRectangle,
format.Pointer(),
brush.NativeBrush));
}
GC.KeepAlive(font);
GC.KeepAlive(brush);
GC.KeepAlive(format);
}
/// <param name="charactersFitted">Number of characters in the text.</param>
/// <param name="linesFilled">Number of lines in the text.</param>
/// <inheritdoc cref="MeasureString(string?, Font, SizeF, StringFormat?)"/>
public SizeF MeasureString(
string? text,
Font font,
SizeF layoutArea,
StringFormat? stringFormat,
out int charactersFitted,
out int linesFilled) =>
MeasureStringInternal(text, font, new(default, layoutArea), stringFormat, out charactersFitted, out linesFilled);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="MeasureString(string?, Font, SizeF, StringFormat?, out int, out int)"/>
public SizeF MeasureString(
ReadOnlySpan<char> text,
Font font,
SizeF layoutArea,
StringFormat? stringFormat,
out int charactersFitted,
out int linesFilled) =>
MeasureStringInternal(text, font, new(default, layoutArea), stringFormat, out charactersFitted, out linesFilled);
#endif
public SizeF MeasureStringInternal(
ReadOnlySpan<char> text,
Font font,
RectangleF layoutArea,
StringFormat? stringFormat,
out int charactersFitted,
out int linesFilled)
{
if (text.IsEmpty)
{
charactersFitted = 0;
linesFilled = 0;
return SizeF.Empty;
}
ArgumentNullException.ThrowIfNull(font);
RectF boundingBox = default;
fixed (char* c = text)
fixed (int* fitted = &charactersFitted)
fixed (int* filled = &linesFilled)
{
CheckStatus(PInvoke.GdipMeasureString(
NativeGraphics,
c,
text.Length,
font.NativeFont,
(RectF*)&layoutArea,
stringFormat.Pointer(),
&boundingBox,
fitted,
filled));
}
GC.KeepAlive(font);
GC.KeepAlive(stringFormat);
return new SizeF(boundingBox.Width, boundingBox.Height);
}
/// <param name="origin"><see cref="PointF"/> structure that represents the upper-left corner of the text.</param>
/// <inheritdoc cref="MeasureString(string?, Font, SizeF, StringFormat?)"/>
public SizeF MeasureString(string? text, Font font, PointF origin, StringFormat? stringFormat)
=> MeasureStringInternal(text, font, new(origin, default), stringFormat, out _, out _);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="MeasureString(string?, Font, PointF, StringFormat?)"/>
public SizeF MeasureString(ReadOnlySpan<char> text, Font font, PointF origin, StringFormat? stringFormat)
=> MeasureStringInternal(text, font, new(origin, default), stringFormat, out _, out _);
#endif
/// <inheritdoc cref="MeasureString(string?, Font, SizeF, StringFormat?)"/>
public SizeF MeasureString(string? text, Font font, SizeF layoutArea) => MeasureString(text, font, layoutArea, null);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="MeasureString(string?, Font, SizeF)"/>
public SizeF MeasureString(ReadOnlySpan<char> text, Font font, SizeF layoutArea) => MeasureString(text, font, layoutArea, null);
#endif
/// <param name="stringFormat">
/// <see cref="StringFormat"/> that represents formatting information, such as line spacing, for the text.
/// </param>
/// <param name="layoutArea">
/// <see cref="SizeF"/> structure that specifies the maximum layout area for the text.
/// </param>
/// <inheritdoc cref="MeasureString(string?, Font, int, StringFormat?)"/>
public SizeF MeasureString(string? text, Font font, SizeF layoutArea, StringFormat? stringFormat) =>
MeasureStringInternal(text, font, new(default, layoutArea), stringFormat, out _, out _);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="MeasureString(string?, Font, SizeF, StringFormat?)"/>
public SizeF MeasureString(ReadOnlySpan<char> text, Font font, SizeF layoutArea, StringFormat? stringFormat) =>
MeasureStringInternal(text, font, new(default, layoutArea), stringFormat, out _, out _);
#endif
/// <summary>
/// Measures the specified text when drawn with the specified <see cref="Font"/>.
/// </summary>
/// <param name="text">Text to measure.</param>
/// <param name="font"><see cref="Font"/> that defines the text format.</param>
/// <returns>
/// This method returns a <see cref="SizeF"/> structure that represents the size, in the units specified by the
/// <see cref="PageUnit"/> property, of the text specified by the <paramref name="text"/> parameter as drawn
/// with the <paramref name="font"/> parameter.
/// </returns>
/// <remarks>
/// <para>
/// The <see cref="MeasureString(string?, Font)"/> method is designed for use with individual strings and
/// includes a small amount of extra space before and after the string to allow for overhanging glyphs. Also,
/// the <see cref="DrawString(string?, Font, Brush, PointF)"/> method adjusts glyph points to optimize display
/// quality and might display a string narrower than reported by <see cref="MeasureString(string?, Font)"/>.
/// To obtain metrics suitable for adjacent strings in layout (for example, when implementing formatted text),
/// use the <see cref="MeasureCharacterRanges(string?, Font, RectangleF, StringFormat?)"/> method or one of
/// the <see cref="MeasureString(string?, Font, int, StringFormat?)"/> methods that takes a StringFormat, and
/// pass <see cref="StringFormat.GenericTypographic"/>. Also, ensure the <see cref="TextRenderingHint"/> for
/// the <see cref="Graphics"/> is <see cref="TextRenderingHint.AntiAlias"/>.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException"><paramref name="font"/> is null.</exception>
public SizeF MeasureString(string? text, Font font) => MeasureString(text, font, new SizeF(0, 0));
#if NET8_0_OR_GREATER
/// <inheritdoc cref="MeasureString(string?, Font)"/>
public SizeF MeasureString(ReadOnlySpan<char> text, Font font) => MeasureString(text, font, new SizeF(0, 0));
#endif
/// <param name="width">Maximum width of the string in pixels.</param>
/// <inheritdoc cref="MeasureString(string?, Font)"/>
public SizeF MeasureString(string? text, Font font, int width) => MeasureString(text, font, new SizeF(width, 999999));
#if NET8_0_OR_GREATER
/// <inheritdoc cref="MeasureString(string?, Font, int)"/>
public SizeF MeasureString(ReadOnlySpan<char> text, Font font, int width) =>
MeasureString(text, font, new SizeF(width, 999999));
#endif
/// <param name="format">
/// <see cref="StringFormat"/> that represents formatting information, such as line spacing, for the text.
/// </param>
/// <inheritdoc cref="MeasureString(string?, Font, int)"/>
public SizeF MeasureString(string? text, Font font, int width, StringFormat? format) =>
MeasureString(text, font, new SizeF(width, 999999), format);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="MeasureString(string?, Font, int, StringFormat?)"/>
public SizeF MeasureString(ReadOnlySpan<char> text, Font font, int width, StringFormat? format) =>
MeasureString(text, font, new SizeF(width, 999999), format);
#endif
/// <summary>
/// Gets an array of <see cref="Region"/> objects, each of which bounds a range of character positions within
/// the specified text.
/// </summary>
/// <param name="text">Text to measure.</param>
/// <param name="font"><see cref="Font"/> that defines the text format.</param>
/// <param name="layoutRect"><see cref="RectangleF"/> structure that specifies the layout rectangle for the text.</param>
/// <param name="stringFormat">
/// <see cref="StringFormat"/> that represents formatting information, such as line spacing, for the text.
/// </param>
/// <returns>
/// This method returns an array of <see cref="Region"/> objects, each of which bounds a range of character
/// positions within the specified text.
/// </returns>
/// <remarks>
/// <para>
/// The regions returned by this method are resolution-dependent, so there might be a slight loss of accuracy
/// if text is recorded in a metafile at one resolution and later played back at a different resolution.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException"><paramref name="font"/> is <see langword="null"/>.</exception>
public Region[] MeasureCharacterRanges(string? text, Font font, RectangleF layoutRect, StringFormat? stringFormat) =>
MeasureCharacterRangesInternal(text, font, layoutRect, stringFormat);
#if NET8_0_OR_GREATER
/// <inheritdoc cref="MeasureCharacterRanges(string?, Font, RectangleF, StringFormat?)"/>
public Region[] MeasureCharacterRanges(ReadOnlySpan<char> text, Font font, RectangleF layoutRect, StringFormat? stringFormat) =>
MeasureCharacterRangesInternal(text, font, layoutRect, stringFormat);
#endif
private Region[] MeasureCharacterRangesInternal(
ReadOnlySpan<char> text,
Font font,
RectF layoutRect,
StringFormat? stringFormat)
{
if (text.IsEmpty)
return [];
ArgumentNullException.ThrowIfNull(font);
int count;
CheckStatus(PInvoke.GdipGetStringFormatMeasurableCharacterRangeCount(stringFormat.Pointer(), &count));
if (count == 0)
{
return [];
}
GpRegion*[] gpRegions = new GpRegion*[count];
Region[] regions = new Region[count];
for (int f = 0; f < count; f++)
{
regions[f] = new Region();
gpRegions[f] = regions[f].NativeRegion;
}
fixed (char* c = text)
fixed (GpRegion** r = gpRegions)
{
CheckStatus(PInvoke.GdipMeasureCharacterRanges(
NativeGraphics,
c,
text.Length,
font.NativeFont,
&layoutRect,
stringFormat.Pointer(),
count,
r));
}
GC.KeepAlive(stringFormat);
GC.KeepAlive(font);
return regions;
}
/// <summary>
/// Draws the specified image at the specified location.
/// </summary>
public void DrawImage(Image image, PointF point) => DrawImage(image, point.X, point.Y);
public void DrawImage(Image image, float x, float y)
{
ArgumentNullException.ThrowIfNull(image);
Status status = PInvoke.GdipDrawImage(NativeGraphics, image.Pointer(), x, y);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
public void DrawImage(Image image, RectangleF rect) => DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height);
public void DrawImage(Image image, float x, float y, float width, float height)
{
ArgumentNullException.ThrowIfNull(image);
Status status = PInvoke.GdipDrawImageRect(NativeGraphics, image.Pointer(), x, y, width, height);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
public void DrawImage(Image image, Point point) => DrawImage(image, (float)point.X, point.Y);
public void DrawImage(Image image, int x, int y) => DrawImage(image, (float)x, y);
public void DrawImage(Image image, Rectangle rect) => DrawImage(image, (float)rect.X, rect.Y, rect.Width, rect.Height);
public void DrawImage(Image image, int x, int y, int width, int height) => DrawImage(image, (float)x, y, width, height);
public void DrawImageUnscaled(Image image, Point point) => DrawImage(image, point.X, point.Y);
public void DrawImageUnscaled(Image image, int x, int y) => DrawImage(image, x, y);
public void DrawImageUnscaled(Image image, Rectangle rect) => DrawImage(image, rect.X, rect.Y);
public void DrawImageUnscaled(Image image, int x, int y, int width, int height) => DrawImage(image, x, y);
public void DrawImageUnscaledAndClipped(Image image, Rectangle rect)
{
ArgumentNullException.ThrowIfNull(image);
int width = Math.Min(rect.Width, image.Width);
int height = Math.Min(rect.Height, image.Height);
// We could put centering logic here too for the case when the image
// is smaller than the rect.
DrawImage(image, rect, 0, 0, width, height, GraphicsUnit.Pixel);
}
public void DrawImage(Image image, PointF[] destPoints)
{
// Affine or perspective blt
//
// destPoints.Length = 3: rect => parallelogram
// destPoints[0] <=> top-left corner of the source rectangle
// destPoints[1] <=> top-right corner
// destPoints[2] <=> bottom-left corner
// destPoints.Length = 4: rect => quad
// destPoints[3] <=> bottom-right corner
//
// @notes Perspective blt only works for bitmap images.
ArgumentNullException.ThrowIfNull(image);
ArgumentNullException.ThrowIfNull(destPoints);
int count = destPoints.Length;
if (count is not 3 and not 4)
throw new ArgumentException(SR.GdiplusDestPointsInvalidLength);
fixed (PointF* p = destPoints)
{
Status status = PInvoke.GdipDrawImagePoints(NativeGraphics, image.Pointer(), (GdiPlus.PointF*)p, count);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
}
public void DrawImage(Image image, Point[] destPoints)
{
ArgumentNullException.ThrowIfNull(image);
ArgumentNullException.ThrowIfNull(destPoints);
int count = destPoints.Length;
if (count is not 3 and not 4)
throw new ArgumentException(SR.GdiplusDestPointsInvalidLength);
fixed (Point* p = destPoints)
{
Status status = PInvoke.GdipDrawImagePointsI(NativeGraphics, image.Pointer(), (GdiPlus.Point*)p, count);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
}
public void DrawImage(Image image, float x, float y, RectangleF srcRect, GraphicsUnit srcUnit)
{
ArgumentNullException.ThrowIfNull(image);
Status status = PInvoke.GdipDrawImagePointRect(
NativeGraphics,
image.Pointer(),
x, y,
srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height,
(Unit)srcUnit);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
public void DrawImage(Image image, int x, int y, Rectangle srcRect, GraphicsUnit srcUnit)
=> DrawImage(image, x, y, (RectangleF)srcRect, srcUnit);
public void DrawImage(Image image, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit)
{
ArgumentNullException.ThrowIfNull(image);
Status status = PInvoke.GdipDrawImageRectRect(
NativeGraphics,
image.Pointer(),
destRect.X, destRect.Y, destRect.Width, destRect.Height,
srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height,
(Unit)srcUnit,
imageAttributes: null,
callback: 0,
callbackData: null);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
public void DrawImage(Image image, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit)
=> DrawImage(image, destRect, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit);
public void DrawImage(Image image, PointF[] destPoints, RectangleF srcRect, GraphicsUnit srcUnit)
{
ArgumentNullException.ThrowIfNull(image);
ArgumentNullException.ThrowIfNull(destPoints);
int count = destPoints.Length;
if (count is not 3 and not 4)
throw new ArgumentException(SR.GdiplusDestPointsInvalidLength);
fixed (PointF* p = destPoints)
{
Status status = PInvoke.GdipDrawImagePointsRect(
NativeGraphics,
image.Pointer(),
(GdiPlus.PointF*)p, destPoints.Length,
srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height,
(Unit)srcUnit,
imageAttributes: null,
callback: 0,
callbackData: null);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
}
public void DrawImage(Image image, PointF[] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes? imageAttr) =>
DrawImage(image, destPoints, srcRect, srcUnit, imageAttr, null, 0);
public void DrawImage(
Image image,
PointF[] destPoints,
RectangleF srcRect,
GraphicsUnit srcUnit,
ImageAttributes? imageAttr,
DrawImageAbort? callback) =>
DrawImage(image, destPoints, srcRect, srcUnit, imageAttr, callback, 0);
public void DrawImage(
Image image,
PointF[] destPoints,
RectangleF srcRect,
GraphicsUnit srcUnit,
ImageAttributes? imageAttr,
DrawImageAbort? callback,
int callbackData)
{
ArgumentNullException.ThrowIfNull(image);
ArgumentNullException.ThrowIfNull(destPoints);
int count = destPoints.Length;
if (count is not 3 and not 4)
throw new ArgumentException(SR.GdiplusDestPointsInvalidLength);
fixed (PointF* p = destPoints)
{
Status status = PInvoke.GdipDrawImagePointsRect(
NativeGraphics,
image.Pointer(),
(GdiPlus.PointF*)p, destPoints.Length,
srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height,
(Unit)srcUnit,
imageAttr.Pointer(),
callback is null ? 0 : Marshal.GetFunctionPointerForDelegate(callback),
(void*)(nint)callbackData);
GC.KeepAlive(imageAttr);
GC.KeepAlive(callback);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
}
public void DrawImage(Image image, Point[] destPoints, Rectangle srcRect, GraphicsUnit srcUnit) =>
DrawImage(image, destPoints, srcRect, srcUnit, null, null, 0);
public void DrawImage(
Image image,
Point[] destPoints,
Rectangle srcRect,
GraphicsUnit srcUnit,
ImageAttributes? imageAttr) => DrawImage(image, destPoints, srcRect, srcUnit, imageAttr, null, 0);
public void DrawImage(
Image image,
Point[] destPoints,
Rectangle srcRect,
GraphicsUnit srcUnit,
ImageAttributes? imageAttr,
DrawImageAbort? callback) => DrawImage(image, destPoints, srcRect, srcUnit, imageAttr, callback, 0);
public void DrawImage(
Image image,
Point[] destPoints,
Rectangle srcRect,
GraphicsUnit srcUnit,
ImageAttributes? imageAttr,
DrawImageAbort? callback,
int callbackData)
{
ArgumentNullException.ThrowIfNull(image);
ArgumentNullException.ThrowIfNull(destPoints);
int count = destPoints.Length;
if (count is not 3 and not 4)
throw new ArgumentException(SR.GdiplusDestPointsInvalidLength);
fixed (Point* p = destPoints)
{
Status status = PInvoke.GdipDrawImagePointsRectI(
NativeGraphics,
image.Pointer(),
(GdiPlus.Point*)p, destPoints.Length,
srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height,
(Unit)srcUnit,
imageAttr.Pointer(),
callback is null ? 0 : Marshal.GetFunctionPointerForDelegate(callback),
(void*)(nint)callbackData);
GC.KeepAlive(imageAttr);
GC.KeepAlive(callback);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
}
public void DrawImage(
Image image,
Rectangle destRect,
float srcX,
float srcY,
float srcWidth,
float srcHeight,
GraphicsUnit srcUnit) => DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, null);
public void DrawImage(
Image image,
Rectangle destRect,
float srcX,
float srcY,
float srcWidth,
float srcHeight,
GraphicsUnit srcUnit,
ImageAttributes? imageAttrs) => DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, imageAttrs, null);
public void DrawImage(
Image image,
Rectangle destRect,
float srcX,
float srcY,
float srcWidth,
float srcHeight,
GraphicsUnit srcUnit,
ImageAttributes? imageAttrs,
DrawImageAbort? callback) => DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, imageAttrs, callback, IntPtr.Zero);
public void DrawImage(
Image image,
Rectangle destRect,
float srcX,
float srcY,
float srcWidth,
float srcHeight,
GraphicsUnit srcUnit,
ImageAttributes? imageAttrs,
DrawImageAbort? callback,
IntPtr callbackData)
{
ArgumentNullException.ThrowIfNull(image);
Status status = PInvoke.GdipDrawImageRectRect(
NativeGraphics,
image.Pointer(),
destRect.X, destRect.Y, destRect.Width, destRect.Height,
srcX, srcY, srcWidth, srcHeight,
(Unit)srcUnit,
imageAttrs.Pointer(),
callback is null ? 0 : Marshal.GetFunctionPointerForDelegate(callback),
(void*)callbackData);
GC.KeepAlive(imageAttrs);
GC.KeepAlive(callback);
IgnoreMetafileErrors(image, ref status);
CheckErrorStatus(status);
}
public void DrawImage(
Image image,
Rectangle destRect,
int srcX,
int srcY,
int srcWidth,
int srcHeight,
GraphicsUnit srcUnit) => DrawImage(image, destRect, (float)srcX, srcY, srcWidth, srcHeight, srcUnit, null);
public void DrawImage(
Image image,
Rectangle destRect,
int srcX,
int srcY,
int srcWidth,
int srcHeight,
GraphicsUnit srcUnit,
ImageAttributes? imageAttr) => DrawImage(image, destRect, (float)srcX, srcY, srcWidth, srcHeight, srcUnit, imageAttr, null);
public void DrawImage(
Image image,
Rectangle destRect,
int srcX,
int srcY,
int srcWidth,
int srcHeight,
GraphicsUnit srcUnit,
ImageAttributes? imageAttr,
DrawImageAbort? callback) => DrawImage(image, destRect, (float)srcX, srcY, srcWidth, srcHeight, srcUnit, imageAttr, callback, IntPtr.Zero);
public void DrawImage(
Image image,
Rectangle destRect,
int srcX,
int srcY,
int srcWidth,
int srcHeight,
GraphicsUnit srcUnit,
ImageAttributes? imageAttrs,
DrawImageAbort? callback,
IntPtr callbackData) => DrawImage(image, destRect, (float)srcX, srcY, srcWidth, srcHeight, srcUnit, imageAttrs, callback, callbackData);
/// <summary>
/// Draws a line connecting the two specified points.
/// </summary>
public void DrawLine(Pen pen, PointF pt1, PointF pt2) => DrawLine(pen, pt1.X, pt1.Y, pt2.X, pt2.Y);
/// <inheritdoc cref="DrawLines(Pen, Point[])"/>
public void DrawLines(Pen pen, params PointF[] points) => DrawLines(pen, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawLines(Pen, Point[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawLines(Pen pen, params ReadOnlySpan<PointF> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawLines(NativeGraphics, pen.NativePen, (GdiPlus.PointF*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Draws a line connecting the two specified points.
/// </summary>
public void DrawLine(Pen pen, int x1, int y1, int x2, int y2) =>
DrawLine(pen, (float)x1, y1, x2, y2);
/// <summary>
/// Draws a line connecting the two specified points.
/// </summary>
public void DrawLine(Pen pen, Point pt1, Point pt2) => DrawLine(pen, (float)pt1.X, pt1.Y, pt2.X, pt2.Y);
/// <summary>
/// Draws a series of line segments that connect an array of points.
/// </summary>
/// <param name="pen">The <see cref="Pen"/> that determines the color, width, and style of the line segments.</param>
/// <param name="points">An array of points to connect.</param>
public void DrawLines(Pen pen, params Point[] points)
{
ArgumentNullException.ThrowIfNull(pen);
ArgumentNullException.ThrowIfNull(points);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawLinesI(NativeGraphics, pen.NativePen, (GdiPlus.Point*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <inheritdoc cref="DrawLines(Pen, Point[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawLines(Pen pen, params ReadOnlySpan<Point> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawLinesI(NativeGraphics, pen.NativePen, (GdiPlus.Point*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <summary>
/// CopyPixels will perform a gdi "bitblt" operation to the source from the destination with the given size.
/// </summary>
public void CopyFromScreen(Point upperLeftSource, Point upperLeftDestination, Size blockRegionSize) =>
CopyFromScreen(upperLeftSource.X, upperLeftSource.Y, upperLeftDestination.X, upperLeftDestination.Y, blockRegionSize);
/// <summary>
/// CopyPixels will perform a gdi "bitblt" operation to the source from the destination with the given size.
/// </summary>
public void CopyFromScreen(int sourceX, int sourceY, int destinationX, int destinationY, Size blockRegionSize) =>
CopyFromScreen(sourceX, sourceY, destinationX, destinationY, blockRegionSize, CopyPixelOperation.SourceCopy);
/// <summary>
/// CopyPixels will perform a gdi "bitblt" operation to the source from the destination with the given size
/// and specified raster operation.
/// </summary>
public void CopyFromScreen(Point upperLeftSource, Point upperLeftDestination, Size blockRegionSize, CopyPixelOperation copyPixelOperation) =>
CopyFromScreen(upperLeftSource.X, upperLeftSource.Y, upperLeftDestination.X, upperLeftDestination.Y, blockRegionSize, copyPixelOperation);
public void EnumerateMetafile(Metafile metafile, PointF destPoint, EnumerateMetafileProc callback) =>
EnumerateMetafile(metafile, destPoint, callback, IntPtr.Zero);
public void EnumerateMetafile(Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData) =>
EnumerateMetafile(metafile, destPoint, callback, callbackData, null);
public void EnumerateMetafile(Metafile metafile, Point destPoint, EnumerateMetafileProc callback) =>
EnumerateMetafile(metafile, destPoint, callback, IntPtr.Zero);
public void EnumerateMetafile(Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData) =>
EnumerateMetafile(metafile, destPoint, callback, callbackData, null);
public void EnumerateMetafile(Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback) =>
EnumerateMetafile(metafile, destRect, callback, IntPtr.Zero);
public void EnumerateMetafile(Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData) =>
EnumerateMetafile(metafile, destRect, callback, callbackData, null);
public void EnumerateMetafile(Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback) =>
EnumerateMetafile(metafile, destRect, callback, IntPtr.Zero);
public void EnumerateMetafile(Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData) =>
EnumerateMetafile(metafile, destRect, callback, callbackData, null);
public void EnumerateMetafile(Metafile metafile, PointF[] destPoints, EnumerateMetafileProc callback) =>
EnumerateMetafile(metafile, destPoints, callback, IntPtr.Zero);
public void EnumerateMetafile(
Metafile metafile,
PointF[] destPoints,
EnumerateMetafileProc callback,
IntPtr callbackData) => EnumerateMetafile(metafile, destPoints, callback, IntPtr.Zero, null);
public void EnumerateMetafile(Metafile metafile, Point[] destPoints, EnumerateMetafileProc callback) =>
EnumerateMetafile(metafile, destPoints, callback, IntPtr.Zero);
public void EnumerateMetafile(Metafile metafile, Point[] destPoints, EnumerateMetafileProc callback, IntPtr callbackData) =>
EnumerateMetafile(metafile, destPoints, callback, callbackData, null);
public void EnumerateMetafile(
Metafile metafile,
PointF destPoint,
RectangleF srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback) => EnumerateMetafile(metafile, destPoint, srcRect, srcUnit, callback, IntPtr.Zero);
public void EnumerateMetafile(
Metafile metafile,
PointF destPoint,
RectangleF srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback,
IntPtr callbackData) => EnumerateMetafile(metafile, destPoint, srcRect, srcUnit, callback, callbackData, null);
public void EnumerateMetafile(
Metafile metafile,
Point destPoint,
Rectangle srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback) => EnumerateMetafile(metafile, destPoint, srcRect, srcUnit, callback, IntPtr.Zero);
public void EnumerateMetafile(
Metafile metafile,
Point destPoint,
Rectangle srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback,
IntPtr callbackData) => EnumerateMetafile(metafile, destPoint, srcRect, srcUnit, callback, callbackData, null);
public void EnumerateMetafile(
Metafile metafile,
RectangleF destRect,
RectangleF srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback) => EnumerateMetafile(metafile, destRect, srcRect, srcUnit, callback, IntPtr.Zero);
public void EnumerateMetafile(
Metafile metafile,
RectangleF destRect,
RectangleF srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback,
IntPtr callbackData) => EnumerateMetafile(metafile, destRect, srcRect, srcUnit, callback, callbackData, null);
public void EnumerateMetafile(
Metafile metafile,
Rectangle destRect,
Rectangle srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback) => EnumerateMetafile(metafile, destRect, srcRect, srcUnit, callback, IntPtr.Zero);
public void EnumerateMetafile(
Metafile metafile,
Rectangle destRect,
Rectangle srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback,
IntPtr callbackData) => EnumerateMetafile(metafile, destRect, srcRect, srcUnit, callback, callbackData, null);
public void EnumerateMetafile(
Metafile metafile,
PointF[] destPoints,
RectangleF srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback) => EnumerateMetafile(metafile, destPoints, srcRect, srcUnit, callback, IntPtr.Zero);
public void EnumerateMetafile(
Metafile metafile,
PointF[] destPoints,
RectangleF srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback,
IntPtr callbackData) => EnumerateMetafile(metafile, destPoints, srcRect, srcUnit, callback, callbackData, null);
public void EnumerateMetafile(
Metafile metafile,
Point[] destPoints,
Rectangle srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback) => EnumerateMetafile(metafile, destPoints, srcRect, srcUnit, callback, IntPtr.Zero);
public void EnumerateMetafile(
Metafile metafile,
Point[] destPoints,
Rectangle srcRect,
GraphicsUnit srcUnit,
EnumerateMetafileProc callback,
IntPtr callbackData) => EnumerateMetafile(metafile, destPoints, srcRect, srcUnit, callback, callbackData, null);
/// <summary>
/// Transforms an array of points from one coordinate space to another using the current world and page
/// transformations of this <see cref="Graphics"/>.
/// </summary>
/// <param name="destSpace">The destination coordinate space.</param>
/// <param name="srcSpace">The source coordinate space.</param>
/// <param name="pts">The points to transform.</param>
public void TransformPoints(Drawing2D.CoordinateSpace destSpace, Drawing2D.CoordinateSpace srcSpace, params PointF[] pts)
{
ArgumentNullException.ThrowIfNull(pts);
TransformPoints(destSpace, srcSpace, pts.AsSpan());
}
/// <inheritdoc cref="TransformPoints(Drawing2D.CoordinateSpace, Drawing2D.CoordinateSpace, PointF[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void TransformPoints(Drawing2D.CoordinateSpace destSpace, Drawing2D.CoordinateSpace srcSpace, params ReadOnlySpan<PointF> pts)
{
fixed (PointF* p = pts)
{
CheckStatus(PInvoke.GdipTransformPoints(
NativeGraphics,
(GdiPlus.CoordinateSpace)destSpace,
(GdiPlus.CoordinateSpace)srcSpace,
(GdiPlus.PointF*)p,
pts.Length));
}
}
/// <inheritdoc cref="TransformPoints(Drawing2D.CoordinateSpace, Drawing2D.CoordinateSpace, PointF[])"/>
public void TransformPoints(Drawing2D.CoordinateSpace destSpace, Drawing2D.CoordinateSpace srcSpace, params Point[] pts)
{
ArgumentNullException.ThrowIfNull(pts);
TransformPoints(destSpace, srcSpace, pts.AsSpan());
}
/// <inheritdoc cref="TransformPoints(Drawing2D.CoordinateSpace, Drawing2D.CoordinateSpace, PointF[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void TransformPoints(Drawing2D.CoordinateSpace destSpace, Drawing2D.CoordinateSpace srcSpace, params ReadOnlySpan<Point> pts)
{
fixed (Point* p = pts)
{
CheckStatus(PInvoke.GdipTransformPointsI(
NativeGraphics,
(GdiPlus.CoordinateSpace)destSpace,
(GdiPlus.CoordinateSpace)srcSpace,
(GdiPlus.Point*)p,
pts.Length));
}
}
/// <summary>
/// GDI+ will return a 'generic error' when we attempt to draw an Emf
/// image with width/height == 1. Here, we will hack around this by
/// resetting the Status. Note that we don't do simple arg checking
/// for height || width == 1 here because transforms can be applied to
/// the Graphics object making it difficult to identify this scenario.
/// </summary>
private static void IgnoreMetafileErrors(Image image, ref Status errorStatus)
{
if (errorStatus != Status.Ok && image.RawFormat.Equals(ImageFormat.Emf))
errorStatus = Status.Ok;
GC.KeepAlive(image);
}
/// <summary>
/// Creates a Region class only if the native region is not infinite.
/// </summary>
internal Region? GetRegionIfNotInfinite()
{
GpRegion* regionHandle;
CheckStatus(PInvoke.GdipCreateRegion(®ionHandle));
try
{
BOOL isInfinite;
PInvoke.GdipGetClip(NativeGraphics, regionHandle);
CheckStatus(PInvokeCore.GdipIsInfiniteRegion(
regionHandle,
NativeGraphics,
&isInfinite));
if (isInfinite)
{
// Infinite
return null;
}
Region region = new(regionHandle);
regionHandle = null;
return region;
}
finally
{
if (regionHandle is not null)
{
PInvoke.GdipDeleteRegion(regionHandle);
}
}
}
/// <summary>
/// Represents an object used in connection with the printing API, it is used to hold a reference to a
/// PrintPreviewGraphics (fake graphics) or a printer DeviceContext (and maybe more in the future).
/// </summary>
internal object? PrintingHelper
{
get => _printingHelper;
set
{
Debug.Assert(_printingHelper is null, "WARNING: Overwriting the printing helper reference!");
_printingHelper = value;
}
}
/// <summary>
/// CopyPixels will perform a gdi "bitblt" operation to the source from the destination with the given size
/// and specified raster operation.
/// </summary>
public void CopyFromScreen(int sourceX, int sourceY, int destinationX, int destinationY, Size blockRegionSize, CopyPixelOperation copyPixelOperation)
{
switch (copyPixelOperation)
{
case CopyPixelOperation.Blackness:
case CopyPixelOperation.NotSourceErase:
case CopyPixelOperation.NotSourceCopy:
case CopyPixelOperation.SourceErase:
case CopyPixelOperation.DestinationInvert:
case CopyPixelOperation.PatInvert:
case CopyPixelOperation.SourceInvert:
case CopyPixelOperation.SourceAnd:
case CopyPixelOperation.MergePaint:
case CopyPixelOperation.MergeCopy:
case CopyPixelOperation.SourceCopy:
case CopyPixelOperation.SourcePaint:
case CopyPixelOperation.PatCopy:
case CopyPixelOperation.PatPaint:
case CopyPixelOperation.Whiteness:
case CopyPixelOperation.CaptureBlt:
case CopyPixelOperation.NoMirrorBitmap:
break;
default:
throw new InvalidEnumArgumentException(nameof(copyPixelOperation), (int)copyPixelOperation, typeof(CopyPixelOperation));
}
int destWidth = blockRegionSize.Width;
int destHeight = blockRegionSize.Height;
using var screenDC = GetDcScope.ScreenDC;
if (screenDC == 0)
{
// ERROR_INVALID_HANDLE - if you pass an empty handle to BitBlt you'll get this error.
// Checking here to better describe test failures (and avoids taking the Graphics HDC lock).
throw new Win32Exception(6);
}
HDC targetDC = (HDC)GetHdc();
try
{
BOOL result = PInvokeCore.BitBlt(
targetDC,
destinationX,
destinationY,
destWidth,
destHeight,
screenDC,
sourceX,
sourceY,
(ROP_CODE)copyPixelOperation);
if (!result)
{
throw new Win32Exception();
}
}
finally
{
if (!targetDC.IsNull)
{
ReleaseHdc();
}
}
}
public Color GetNearestColor(Color color)
{
uint nearest = (uint)color.ToArgb();
CheckStatus(PInvoke.GdipGetNearestColor(NativeGraphics, &nearest));
return Color.FromArgb((int)nearest);
}
/// <summary>
/// Draws a line connecting the two specified points.
/// </summary>
public void DrawLine(Pen pen, float x1, float y1, float x2, float y2)
{
ArgumentNullException.ThrowIfNull(pen);
CheckErrorStatus(PInvoke.GdipDrawLine(NativeGraphics, pen.NativePen, x1, y1, x2, y2));
GC.KeepAlive(pen);
}
/// <inheritdoc cref="DrawBeziers(Pen, Point[])"/>
public void DrawBeziers(Pen pen, params PointF[] points) =>
DrawBeziers(pen, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawBeziers(Pen, Point[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawBeziers(Pen pen, params ReadOnlySpan<PointF> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (PointF* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawBeziers(
NativeGraphics,
pen.NativePen,
(GdiPlus.PointF*)p, points.Length));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Draws a series of cubic Bézier curves from an array of points.
/// </summary>
/// <param name="pen">The <paramref name="pen"/> to draw the Bézier with.</param>
/// <param name="points">
/// Points that represent the points that determine the curve. The number of points in the array
/// should be a multiple of 3 plus 1, such as 4, 7, or 10.
/// </param>
public void DrawBeziers(Pen pen, params Point[] points) => DrawBeziers(pen, points.OrThrowIfNull().AsSpan());
/// <inheritdoc cref="DrawBeziers(Pen, Point[])"/>
#if NET9_0_OR_GREATER
public
#else
private
#endif
void DrawBeziers(Pen pen, params ReadOnlySpan<Point> points)
{
ArgumentNullException.ThrowIfNull(pen);
fixed (Point* p = points)
{
CheckErrorStatus(PInvoke.GdipDrawBeziersI(
NativeGraphics,
pen.NativePen,
(GdiPlus.Point*)p,
points.Length));
}
GC.KeepAlive(pen);
}
/// <summary>
/// Fills the interior of a path.
/// </summary>
public void FillPath(Brush brush, GraphicsPath path)
{
ArgumentNullException.ThrowIfNull(brush);
ArgumentNullException.ThrowIfNull(path);
CheckErrorStatus(PInvoke.GdipFillPath(
NativeGraphics,
brush.NativeBrush,
path._nativePath));
GC.KeepAlive(brush);
GC.KeepAlive(path);
}
/// <summary>
/// Fills the interior of a <see cref='Region'/>.
/// </summary>
public void FillRegion(Brush brush, Region region)
{
ArgumentNullException.ThrowIfNull(brush);
ArgumentNullException.ThrowIfNull(region);
CheckErrorStatus(PInvoke.GdipFillRegion(
NativeGraphics,
brush.NativeBrush,
region.NativeRegion));
GC.KeepAlive(brush);
GC.KeepAlive(region);
}
public void DrawIcon(Icon icon, int x, int y)
{
ArgumentNullException.ThrowIfNull(icon);
if (_backingImage is not null)
{
// We don't call the icon directly because we want to stay in GDI+ all the time
// to avoid alpha channel interop issues between gdi and gdi+
// so we do icon.ToBitmap() and then we call DrawImage. This is probably slower.
DrawImage(icon.ToBitmap(), x, y);
}
else
{
icon.Draw(this, x, y);
}
}
/// <summary>
/// Draws this image to a graphics object. The drawing command originates on the graphics
/// object, but a graphics object generally has no idea how to render a given image. So,
/// it passes the call to the actual image. This version crops the image to the given
/// dimensions and allows the user to specify a rectangle within the image to draw.
/// </summary>
public void DrawIcon(Icon icon, Rectangle targetRect)
{
ArgumentNullException.ThrowIfNull(icon);
if (_backingImage is not null)
{
// We don't call the icon directly because we want to stay in GDI+ all the time
// to avoid alpha channel interop issues between gdi and gdi+
// so we do icon.ToBitmap() and then we call DrawImage. This is probably slower.
DrawImage(icon.ToBitmap(), targetRect);
}
else
{
icon.Draw(this, targetRect);
}
}
/// <summary>
/// Draws this image to a graphics object. The drawing command originates on the graphics
/// object, but a graphics object generally has no idea how to render a given image. So,
/// it passes the call to the actual image. This version stretches the image to the given
/// dimensions and allows the user to specify a rectangle within the image to draw.
/// </summary>
public void DrawIconUnstretched(Icon icon, Rectangle targetRect)
{
ArgumentNullException.ThrowIfNull(icon);
if (_backingImage is not null)
{
DrawImageUnscaled(icon.ToBitmap(), targetRect);
}
else
{
icon.DrawUnstretched(this, targetRect);
}
}
public void EnumerateMetafile(
Metafile metafile,
PointF destPoint,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr)
{
using EnumerateMetafileDataAdapter adapter = new(callback);
PInvoke.GdipEnumerateMetafileDestPoint(
NativeGraphics,
metafile.Pointer(),
(GdiPlus.PointF*)&destPoint,
adapter.NativeCallback,
(void*)callbackData,
imageAttr.Pointer()).ThrowIfFailed();
GC.KeepAlive(imageAttr);
GC.KeepAlive(metafile);
GC.KeepAlive(this);
}
public void EnumerateMetafile(
Metafile metafile,
Point destPoint,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr)
=> EnumerateMetafile(metafile, (PointF)destPoint, callback, callbackData, imageAttr);
public void EnumerateMetafile(
Metafile metafile,
RectangleF destRect,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr)
{
using EnumerateMetafileDataAdapter adapter = new(callback);
PInvoke.GdipEnumerateMetafileDestRect(
NativeGraphics,
metafile.Pointer(),
(RectF*)&destRect,
adapter.NativeCallback,
(void*)callbackData,
imageAttr.Pointer()).ThrowIfFailed();
GC.KeepAlive(imageAttr);
GC.KeepAlive(metafile);
GC.KeepAlive(this);
}
public void EnumerateMetafile(
Metafile metafile,
Rectangle destRect,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr) => EnumerateMetafile(metafile, (RectangleF)destRect, callback, callbackData, imageAttr);
public void EnumerateMetafile(
Metafile metafile,
PointF[] destPoints,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr)
{
ArgumentNullException.ThrowIfNull(destPoints);
if (destPoints.Length != 3)
throw new ArgumentException(SR.GdiplusDestPointsInvalidParallelogram);
fixed (PointF* p = destPoints)
{
using EnumerateMetafileDataAdapter adapter = new(callback);
PInvoke.GdipEnumerateMetafileDestPoints(
NativeGraphics,
metafile.Pointer(),
(GdiPlus.PointF*)p, destPoints.Length,
adapter.NativeCallback,
(void*)callbackData,
imageAttr.Pointer()).ThrowIfFailed();
GC.KeepAlive(imageAttr);
GC.KeepAlive(metafile);
GC.KeepAlive(this);
}
}
public void EnumerateMetafile(
Metafile metafile,
Point[] destPoints,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr)
{
ArgumentNullException.ThrowIfNull(destPoints);
if (destPoints.Length != 3)
throw new ArgumentException(SR.GdiplusDestPointsInvalidParallelogram);
fixed (Point* p = destPoints)
{
using EnumerateMetafileDataAdapter adapter = new(callback);
PInvoke.GdipEnumerateMetafileDestPointsI(
NativeGraphics,
metafile.Pointer(),
(GdiPlus.Point*)p, destPoints.Length,
adapter.NativeCallback,
(void*)callbackData,
imageAttr.Pointer()).ThrowIfFailed();
GC.KeepAlive(imageAttr);
GC.KeepAlive(metafile);
GC.KeepAlive(this);
}
}
public void EnumerateMetafile(
Metafile metafile,
PointF destPoint,
RectangleF srcRect,
GraphicsUnit unit,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr)
{
using EnumerateMetafileDataAdapter adapter = new(callback);
PInvoke.GdipEnumerateMetafileSrcRectDestPoint(
NativeGraphics,
metafile.Pointer(),
(GdiPlus.PointF*)&destPoint,
(RectF*)&srcRect,
(Unit)unit,
adapter.NativeCallback,
(void*)callbackData,
imageAttr.Pointer()).ThrowIfFailed();
GC.KeepAlive(imageAttr);
GC.KeepAlive(metafile);
GC.KeepAlive(this);
}
public void EnumerateMetafile(
Metafile metafile,
Point destPoint,
Rectangle srcRect,
GraphicsUnit unit,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr) => EnumerateMetafile(
metafile,
(PointF)destPoint,
(RectangleF)srcRect,
unit,
callback,
callbackData,
imageAttr);
public void EnumerateMetafile(
Metafile metafile,
RectangleF destRect,
RectangleF srcRect,
GraphicsUnit unit,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr)
{
using EnumerateMetafileDataAdapter adapter = new(callback);
PInvoke.GdipEnumerateMetafileSrcRectDestRect(
NativeGraphics,
metafile.Pointer(),
(RectF*)&destRect,
(RectF*)&srcRect,
(Unit)unit,
adapter.NativeCallback,
(void*)callbackData,
imageAttr.Pointer()).ThrowIfFailed();
GC.KeepAlive(imageAttr);
GC.KeepAlive(metafile);
GC.KeepAlive(this);
}
public void EnumerateMetafile(
Metafile metafile,
Rectangle destRect,
Rectangle srcRect,
GraphicsUnit unit,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr) => EnumerateMetafile(metafile, (RectangleF)destRect, srcRect, unit, callback, callbackData, imageAttr);
public void EnumerateMetafile(
Metafile metafile,
PointF[] destPoints,
RectangleF srcRect,
GraphicsUnit unit,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr)
{
ArgumentNullException.ThrowIfNull(destPoints);
if (destPoints.Length != 3)
throw new ArgumentException(SR.GdiplusDestPointsInvalidParallelogram);
fixed (PointF* p = destPoints)
{
using EnumerateMetafileDataAdapter adapter = new(callback);
PInvoke.GdipEnumerateMetafileSrcRectDestPoints(
NativeGraphics,
metafile.Pointer(),
(GdiPlus.PointF*)p, destPoints.Length,
(RectF*)&srcRect,
(Unit)unit,
adapter.NativeCallback,
(void*)callbackData,
imageAttr.Pointer()).ThrowIfFailed();
GC.KeepAlive(imageAttr);
GC.KeepAlive(metafile);
GC.KeepAlive(this);
}
}
public void EnumerateMetafile(
Metafile metafile,
Point[] destPoints,
Rectangle srcRect,
GraphicsUnit unit,
EnumerateMetafileProc callback,
IntPtr callbackData,
ImageAttributes? imageAttr)
{
ArgumentNullException.ThrowIfNull(destPoints);
if (destPoints.Length != 3)
throw new ArgumentException(SR.GdiplusDestPointsInvalidParallelogram);
fixed (Point* p = destPoints)
{
using EnumerateMetafileDataAdapter adapter = new(callback);
PInvoke.GdipEnumerateMetafileSrcRectDestPointsI(
NativeGraphics,
metafile.Pointer(),
(GdiPlus.Point*)p, destPoints.Length,
(Rect*)&srcRect,
(Unit)unit,
adapter.NativeCallback,
(void*)callbackData,
imageAttr.Pointer()).ThrowIfFailed();
GC.KeepAlive(imageAttr);
GC.KeepAlive(metafile);
GC.KeepAlive(this);
}
}
/// <summary>
/// Combines current Graphics context with all previous contexts.
/// When BeginContainer() is called, a copy of the current context is pushed into the GDI+ context stack, it keeps track of the
/// absolute clipping and transform but reset the public properties so it looks like a brand new context.
/// When Save() is called, a copy of the current context is also pushed in the GDI+ stack but the public clipping and transform
/// properties are not reset (cumulative). Consecutive Save context are ignored with the exception of the top one which contains
/// all previous information.
/// The return value is an object array where the first element contains the cumulative clip region and the second the cumulative
/// translate transform matrix.
/// WARNING: This method is for internal FX support only.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
[Obsolete("Use the Graphics.GetContextInfo overloads that accept arguments for better performance and fewer allocations.", DiagnosticId = "SYSLIB0016", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
[SupportedOSPlatform("windows")]
public object GetContextInfo()
{
GetContextInfo(out Matrix3x2 cumulativeTransform, calculateClip: true, out Region? cumulativeClip);
return new object[] { cumulativeClip ?? new Region(), new Matrix(cumulativeTransform) };
}
private void GetContextInfo(out Matrix3x2 cumulativeTransform, bool calculateClip, out Region? cumulativeClip)
{
cumulativeClip = calculateClip ? GetRegionIfNotInfinite() : null; // Current context clip.
cumulativeTransform = TransformElements; // Current context transform.
Vector2 currentOffset = default; // Offset of current context.
Vector2 totalOffset = default; // Absolute coordinate offset of top context.
GraphicsContext? context = _previousContext;
if (!cumulativeTransform.IsIdentity)
{
currentOffset = cumulativeTransform.Translation;
}
while (context is not null)
{
if (!context.TransformOffset.IsEmpty())
{
cumulativeTransform.Translate(context.TransformOffset);
}
if (!currentOffset.IsEmpty())
{
// The location of the GDI+ clip region is relative to the coordinate origin after any translate transform
// has been applied. We need to intersect regions using the same coordinate origin relative to the previous
// context.
// If we don't have a cumulative clip, we're infinite, and translation on infinite regions is a no-op.
cumulativeClip?.Translate(currentOffset.X, currentOffset.Y);
totalOffset.X += currentOffset.X;
totalOffset.Y += currentOffset.Y;
}
// Context only stores clips if they are not infinite. Intersecting a clip with an infinite clip is a no-op.
if (calculateClip && context.Clip is not null)
{
// Intersecting an infinite clip with another is just a copy of the second clip.
if (cumulativeClip is null)
{
cumulativeClip = context.Clip;
}
else
{
cumulativeClip.Intersect(context.Clip);
}
}
currentOffset = context.TransformOffset;
// Ignore subsequent cumulative contexts.
do
{
context = context.Previous;
if (context is null || !context.Next!.IsCumulative)
{
break;
}
}
while (context.IsCumulative);
}
if (!totalOffset.IsEmpty())
{
// We need now to reset the total transform in the region so when calling Region.GetHRgn(Graphics)
// the HRegion is properly offset by GDI+ based on the total offset of the graphics object.
// If we don't have a cumulative clip, we're infinite, and translation on infinite regions is a no-op.
cumulativeClip?.Translate(-totalOffset.X, -totalOffset.Y);
}
}
(HDC hdc, int saveState) IGraphicsContextInfo.GetHdc(ApplyGraphicsProperties apply, bool alwaysSaveState)
{
bool applyTransform = apply.HasFlag(ApplyGraphicsProperties.TranslateTransform);
bool applyClipping = apply.HasFlag(ApplyGraphicsProperties.Clipping);
int saveState = 0;
HDC hdc = HDC.Null;
Region? clipRegion = null;
PointF offset = default;
if (applyClipping)
{
GetContextInfo(out offset, out clipRegion);
}
else if (applyTransform)
{
GetContextInfo(out offset);
}
using (clipRegion)
{
applyTransform = applyTransform && !offset.IsEmpty;
applyClipping = clipRegion is not null;
using var graphicsRegion = applyClipping ? new RegionScope(clipRegion!, this) : default;
applyClipping = applyClipping && !graphicsRegion!.Region.IsNull;
hdc = (HDC)GetHdc();
if (alwaysSaveState || applyClipping || applyTransform)
{
saveState = PInvokeCore.SaveDC(hdc);
}
if (applyClipping)
{
// If the Graphics object was created from a native DC the actual clipping region is the intersection
// between the original DC clip region and the GDI+ one - for display Graphics it is the same as
// Graphics.VisibleClipBounds.
GDI_REGION_TYPE type;
using RegionScope dcRegion = new(hdc);
if (!dcRegion.IsNull)
{
type = PInvokeCore.CombineRgn(graphicsRegion!, dcRegion, graphicsRegion!, RGN_COMBINE_MODE.RGN_AND);
if (type == GDI_REGION_TYPE.RGN_ERROR)
{
throw new Win32Exception();
}
}
type = PInvokeCore.SelectClipRgn(hdc, graphicsRegion!);
if (type == GDI_REGION_TYPE.RGN_ERROR)
{
throw new Win32Exception();
}
}
if (applyTransform)
{
PInvokeCore.OffsetViewportOrgEx(hdc, (int)offset.X, (int)offset.Y, lppt: null);
}
}
return (hdc, saveState);
}
/// <summary>
/// Gets the cumulative offset.
/// </summary>
/// <param name="offset">The cumulative offset.</param>
[EditorBrowsable(EditorBrowsableState.Never)]
[SupportedOSPlatform("windows")]
public void GetContextInfo(out PointF offset)
{
GetContextInfo(out Matrix3x2 cumulativeTransform, calculateClip: false, out _);
Vector2 translation = cumulativeTransform.Translation;
offset = new PointF(translation.X, translation.Y);
}
/// <summary>
/// Gets the cumulative offset and clip region.
/// </summary>
/// <param name="offset">The cumulative offset.</param>
/// <param name="clip">The cumulative clip region or null if the clip region is infinite.</param>
[EditorBrowsable(EditorBrowsableState.Never)]
[SupportedOSPlatform("windows")]
public void GetContextInfo(out PointF offset, out Region? clip)
{
GetContextInfo(out Matrix3x2 cumulativeTransform, calculateClip: true, out clip);
Vector2 translation = cumulativeTransform.Translation;
offset = new PointF(translation.X, translation.Y);
}
public RectangleF VisibleClipBounds
{
get
{
if (PrintingHelper is PrintPreviewGraphics ppGraphics)
return ppGraphics.VisibleClipBounds;
RectF rect;
CheckStatus(PInvoke.GdipGetVisibleClipBounds(NativeGraphics, &rect));
return rect;
}
}
/// <summary>
/// Saves the current context into the context stack.
/// </summary>
private void PushContext(GraphicsContext context)
{
Debug.Assert(context is not null && context.State != 0, "GraphicsContext object is null or not valid.");
if (_previousContext is not null)
{
// Push context.
context.Previous = _previousContext;
_previousContext.Next = context;
}
_previousContext = context;
}
/// <summary>
/// Pops all contexts from the specified one included. The specified context is becoming the current context.
/// </summary>
private void PopContext(int currentContextState)
{
Debug.Assert(_previousContext is not null, "Trying to restore a context when the stack is empty");
GraphicsContext? context = _previousContext;
// Pop all contexts up the stack.
while (context is not null)
{
if (context.State == currentContextState)
{
_previousContext = context.Previous;
// This will dispose all context object up the stack.
context.Dispose();
return;
}
context = context.Previous;
}
Debug.Fail("Warning: context state not found!");
}
public GraphicsState Save()
{
GraphicsContext context = new(this);
uint state;
Status status = PInvoke.GdipSaveGraphics(NativeGraphics, &state);
GC.KeepAlive(this);
if (status != Status.Ok)
{
context.Dispose();
throw Gdip.StatusException(status);
}
context.State = (int)state;
context.IsCumulative = true;
PushContext(context);
return new GraphicsState((int)state);
}
public void Restore(GraphicsState gstate)
{
CheckStatus(PInvoke.GdipRestoreGraphics(NativeGraphics, (uint)gstate._nativeState));
PopContext(gstate._nativeState);
}
public GraphicsContainer BeginContainer(RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit)
{
GraphicsContext context = new(this);
uint state;
Status status = PInvoke.GdipBeginContainer(NativeGraphics, (RectF*)&dstrect, (RectF*)&srcrect, (Unit)unit, &state);
GC.KeepAlive(this);
if (status != Status.Ok)
{
context.Dispose();
throw Gdip.StatusException(status);
}
context.State = (int)state;
PushContext(context);
return new GraphicsContainer((int)state);
}
public GraphicsContainer BeginContainer()
{
GraphicsContext context = new(this);
uint state;
Status status = PInvoke.GdipBeginContainer2(NativeGraphics, &state);
GC.KeepAlive(this);
if (status != Status.Ok)
{
context.Dispose();
throw Gdip.StatusException(status);
}
context.State = (int)state;
PushContext(context);
return new GraphicsContainer((int)state);
}
public void EndContainer(GraphicsContainer container)
{
ArgumentNullException.ThrowIfNull(container);
CheckStatus(PInvoke.GdipEndContainer(NativeGraphics, (uint)container._nativeGraphicsContainer));
PopContext(container._nativeGraphicsContainer);
}
public GraphicsContainer BeginContainer(Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit)
=> BeginContainer((RectangleF)dstrect, (RectangleF)srcrect, unit);
public void AddMetafileComment(byte[] data)
{
ArgumentNullException.ThrowIfNull(data);
fixed (byte* b = data)
{
CheckStatus(PInvoke.GdipComment(NativeGraphics, (uint)data.Length, b));
}
}
public static IntPtr GetHalftonePalette()
{
if (s_halftonePalette == IntPtr.Zero)
{
lock (s_syncObject)
{
if (s_halftonePalette == IntPtr.Zero)
{
AppDomain.CurrentDomain.DomainUnload += OnDomainUnload;
AppDomain.CurrentDomain.ProcessExit += OnDomainUnload;
s_halftonePalette = PInvoke.GdipCreateHalftonePalette();
}
}
}
return s_halftonePalette;
}
// This is called from AppDomain.ProcessExit and AppDomain.DomainUnload.
private static void OnDomainUnload(object? sender, EventArgs e)
{
if (!s_halftonePalette.IsNull)
{
PInvokeCore.DeleteObject(s_halftonePalette);
s_halftonePalette = HPALETTE.Null;
}
}
/// <summary>
/// GDI+ will return a 'generic error' with specific win32 last error codes when
/// a terminal server session has been closed, minimized, etc... We don't want
/// to throw when this happens, so we'll guard against this by looking at the
/// 'last win32 error code' and checking to see if it is either 1) access denied
/// or 2) proc not found and then ignore it.
///
/// The problem is that when you lock the machine, the secure desktop is enabled and
/// rendering fails which is expected (since the app doesn't have permission to draw
/// on the secure desktop). Not sure if there's anything you can do, short of catching
/// the desktop switch message and absorbing all the exceptions that get thrown while
/// it's the secure desktop.
/// </summary>
private void CheckErrorStatus(Status status)
{
if (status == Status.Ok)
{
return;
}
// Generic error from GDI+ can be GenericError or Win32Error.
if (status is Status.GenericError or Status.Win32Error)
{
WIN32_ERROR error = (WIN32_ERROR)Marshal.GetLastWin32Error();
if (error == WIN32_ERROR.ERROR_ACCESS_DENIED || error == WIN32_ERROR.ERROR_PROC_NOT_FOUND ||
// Here, we'll check to see if we are in a terminal services session.
(((PInvokeCore.GetSystemMetrics(SYSTEM_METRICS_INDEX.SM_REMOTESESSION) & 0x00000001) != 0) && (error == 0)))
{
return;
}
}
GC.KeepAlive(this);
// Legitimate error, throw our status exception.
throw Gdip.StatusException(status);
}
#if NET8_0_OR_GREATER
/// <summary>
/// Draws the given <paramref name="cachedBitmap"/>.
/// </summary>
/// <param name="cachedBitmap">The <see cref="CachedBitmap"/> that contains the image to be drawn.</param>
/// <param name="x">The x-coordinate of the upper-left corner of the drawn image.</param>
/// <param name="y">The y-coordinate of the upper-left corner of the drawn image.</param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="cachedBitmap"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="InvalidOperationException">
/// <para>
/// The <paramref name="cachedBitmap"/> is not compatible with the <see cref="Graphics"/> device state.
/// </para>
/// <para>
/// - or -
/// </para>
/// <para>
/// The <see cref="Graphics"/> object has a transform applied other than a translation.
/// </para>
/// </exception>
public void DrawCachedBitmap(CachedBitmap cachedBitmap, int x, int y)
{
ArgumentNullException.ThrowIfNull(cachedBitmap);
CheckStatus(PInvoke.GdipDrawCachedBitmap(
NativeGraphics,
(GpCachedBitmap*)cachedBitmap.Handle,
x, y));
GC.KeepAlive(cachedBitmap);
}
#endif
#if NET9_0_OR_GREATER
/// <inheritdoc cref="DrawImage(Image, Effect, RectangleF, Matrix?, GraphicsUnit, ImageAttributes?)"/>
public void DrawImage(
Image image,
Effect effect) => DrawImage(image, effect, srcRect: default, transform: default, GraphicsUnit.Pixel, imageAttr: null);
/// <summary>
/// Draws a portion of an image after applying a specified effect.
/// </summary>
/// <param name="image"><see cref="Image"/> to be drawn.</param>
/// <param name="effect">The effect to be applied when drawing.</param>
/// <param name="srcRect">The portion of the image to be drawn. <see cref="RectangleF.Empty"/> draws the full image.</param>
/// <param name="transform">The transform to apply to the <paramref name="srcRect"/> to determine the destination.</param>
/// <param name="srcUnit">Unit of measure of the <paramref name="srcRect"/>.</param>
/// <param name="imageAttr">Additional adjustments to be applied, if any.</param>
public void DrawImage(
Image image,
Effect effect,
RectangleF srcRect = default,
Matrix? transform = default,
GraphicsUnit srcUnit = GraphicsUnit.Pixel,
ImageAttributes? imageAttr = default)
{
PInvoke.GdipDrawImageFX(
NativeGraphics,
image.Pointer(),
srcRect.IsEmpty ? null : (RectF*)&srcRect,
transform.Pointer(),
effect.Pointer(),
imageAttr.Pointer(),
(Unit)srcUnit).ThrowIfFailed();
GC.KeepAlive(effect);
GC.KeepAlive(imageAttr);
GC.KeepAlive(image);
GC.KeepAlive(this);
}
#endif
private void CheckStatus(Status status)
{
status.ThrowIfFailed();
GC.KeepAlive(this);
}
}
|