Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / CommonUI / System / Drawing / Advanced / GraphicsPath.cs / 1305376 / GraphicsPath.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Drawing.Drawing2D {
using System.Runtime.InteropServices;
using System.Diagnostics;
using System;
using Microsoft.Win32;
using System.Drawing;
using System.ComponentModel;
using System.Drawing.Internal;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Runtime.Versioning;
/**
* Represent a Path object
*/
///
/// Represents a series of connected lines and
/// curves.
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public sealed class GraphicsPath : MarshalByRefObject, ICloneable, IDisposable {
/*
* handle to native path object
*/
internal IntPtr nativePath;
/**
* Create a new path object with the default fill mode
*/
///
///
/// Initializes a new instance of the
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath() : this(System.Drawing.Drawing2D.FillMode.Alternate) { }
/**
* Create a new path object with the specified fill mode
*/
///
/// Initializes a new instance of the
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(FillMode fillMode) {
IntPtr nativePath = IntPtr.Zero;
int status = SafeNativeMethods.Gdip.GdipCreatePath((int)fillMode, out nativePath);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
this.nativePath = nativePath;
}
// float version
///
///
/// Initializes a new instance of the
///
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(PointF[] pts, byte[] types) :
this(pts, types, System.Drawing.Drawing2D.FillMode.Alternate) {}
///
///
/// Initializes a new instance of the
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(PointF[] pts, byte[] types, FillMode fillMode) {
if (pts == null)
throw new ArgumentNullException("pts");
IntPtr nativePath = IntPtr.Zero;
if (pts.Length != types.Length)
throw SafeNativeMethods.Gdip.StatusException(SafeNativeMethods.Gdip.InvalidParameter);
int count = types.Length;
IntPtr ptbuf = SafeNativeMethods.Gdip.ConvertPointToMemory(pts);
IntPtr typebuf = Marshal.AllocHGlobal(count);
try {
Marshal.Copy(types, 0, typebuf, count);
int status = SafeNativeMethods.Gdip.GdipCreatePath2(new HandleRef(null, ptbuf), new HandleRef(null, typebuf), count,
(int)fillMode, out nativePath);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(ptbuf);
Marshal.FreeHGlobal(typebuf);
}
this.nativePath = nativePath;
}
// int version
///
///
/// Initializes a new instance of the
///
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(Point[] pts, byte[] types) :
this(pts, types, System.Drawing.Drawing2D.FillMode.Alternate) {}
///
///
/// Initializes a new instance of the
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(Point[] pts, byte[] types, FillMode fillMode) {
if (pts == null)
throw new ArgumentNullException("pts");
IntPtr nativePath = IntPtr.Zero;
if (pts.Length != types.Length)
throw SafeNativeMethods.Gdip.StatusException(SafeNativeMethods.Gdip.InvalidParameter);
int count = types.Length;
IntPtr ptbuf = SafeNativeMethods.Gdip.ConvertPointToMemory(pts);
IntPtr typebuf = Marshal.AllocHGlobal(count);
try {
Marshal.Copy(types, 0, typebuf, count);
int status = SafeNativeMethods.Gdip.GdipCreatePath2I(new HandleRef(null, ptbuf), new HandleRef(null, typebuf), count,
(int)fillMode, out nativePath);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(ptbuf);
Marshal.FreeHGlobal(typebuf);
}
this.nativePath = nativePath;
}
/**
* Make a copy of the current path object
*/
///
/// Creates an exact copy of this
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public object Clone() {
IntPtr clonePath = IntPtr.Zero;
int status = SafeNativeMethods.Gdip.GdipClonePath(new HandleRef(this, nativePath), out clonePath);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return new GraphicsPath(clonePath, 0);
}
/**
* 'extra' parameter is necessary to avoid conflict with
* other constructor GraphicsPath(int fillmode)
*/
private GraphicsPath(IntPtr nativePath, int extra) {
if (nativePath == IntPtr.Zero)
throw new ArgumentNullException("nativePath");
this.nativePath = nativePath;
}
/**
* Dispose of resources associated with the
*/
///
/// Eliminates resources for this
public void Dispose() {
Dispose(true);
GC.SuppressFinalize(this);
}
void Dispose(bool disposing) {
if (nativePath != IntPtr.Zero) {
try{
#if DEBUG
int status =
#endif
SafeNativeMethods.Gdip.GdipDeletePath(new HandleRef(this, nativePath));
#if DEBUG
Debug.Assert(status == SafeNativeMethods.Gdip.Ok, "GDI+ returned an error status: " + status.ToString(CultureInfo.InvariantCulture));
#endif
}
catch( Exception ex ){
if( ClientUtils.IsSecurityOrCriticalException( ex ) ) {
throw;
}
Debug.Fail( "Exception thrown during Dispose: " + ex.ToString() );
}
finally{
nativePath = IntPtr.Zero;
}
}
}
///
/// Eliminates resources for this
~GraphicsPath() {
Dispose(false);
}
/**
* Reset the path object to empty
*/
///
/// Empties the
public void Reset() {
int status = SafeNativeMethods.Gdip.GdipResetPath(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
/**
* Get path fill mode information
*/
///
/// Gets or sets a
public FillMode FillMode {
get {
int fillmode = 0;
int status = SafeNativeMethods.Gdip.GdipGetPathFillMode(new HandleRef(this, nativePath), out fillmode);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return(FillMode) fillmode;
}
set {
//validate the FillMode enum
//valid values are 0x0 to 0x1
if (!ClientUtils.IsEnumValid(value, (int)value, (int)FillMode.Alternate, (int)FillMode.Winding))
{
throw new InvalidEnumArgumentException("value", (int)value, typeof(FillMode));
}
int status = SafeNativeMethods.Gdip.GdipSetPathFillMode(new HandleRef(this, nativePath), (int) value);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
}
private PathData _GetPathData() {
int ptSize = (int) Marshal.SizeOf(typeof(GPPOINTF));
int numPts = PointCount;
PathData pathData = new PathData();
pathData.Types = new byte[numPts];
IntPtr memoryPathData = Marshal.AllocHGlobal(3*IntPtr.Size);
IntPtr memoryPoints = Marshal.AllocHGlobal(ptSize*numPts);
try {
GCHandle typesHandle = GCHandle.Alloc(pathData.Types, GCHandleType.Pinned);
try {
IntPtr typesPtr = typesHandle.AddrOfPinnedObject();
//IntPtr typesPtr = Marshal.AddrOfArrayElement(pathData.Types, IntPtr.Zero);
Marshal.StructureToPtr(numPts, memoryPathData, false);
Marshal.StructureToPtr(memoryPoints, (IntPtr)((long)memoryPathData+IntPtr.Size), false);
Marshal.StructureToPtr(typesPtr, (IntPtr)((long)memoryPathData+2*IntPtr.Size), false);
int status = SafeNativeMethods.Gdip.GdipGetPathData(new HandleRef(this, nativePath), memoryPathData);
if (status != SafeNativeMethods.Gdip.Ok) {
throw SafeNativeMethods.Gdip.StatusException(status);
}
pathData.Points = SafeNativeMethods.Gdip.ConvertGPPOINTFArrayF(memoryPoints, numPts);
} finally {
typesHandle.Free();
}
} finally {
Marshal.FreeHGlobal(memoryPathData);
Marshal.FreeHGlobal(memoryPoints);
}
return pathData;
}
///
/// Gets a
public PathData PathData {
get {
return _GetPathData();
}
}
///
///
/// Starts a new figure without closing the
/// current figure. All subsequent points added to the path are added to this new
/// figure.
///
///
public void StartFigure() {
int status = SafeNativeMethods.Gdip.GdipStartPathFigure(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Closes the current figure and starts a new
/// figure. If the current figure contains a sequence of connected lines and curves,
/// it closes the loop by connecting a line from the ending point to the starting
/// point.
///
public void CloseFigure() {
int status = SafeNativeMethods.Gdip.GdipClosePathFigure(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Closes all open figures in a path and
/// starts a new figure. It closes each open figure by connecting a line from it's
/// ending point to it's starting point.
///
public void CloseAllFigures() {
int status = SafeNativeMethods.Gdip.GdipClosePathFigures(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Sets a marker on this
///
public void SetMarkers() {
int status = SafeNativeMethods.Gdip.GdipSetPathMarker(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Clears all markers from this
public void ClearMarkers() {
int status = SafeNativeMethods.Gdip.GdipClearPathMarkers(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Reverses the order of points in the
public void Reverse() {
int status = SafeNativeMethods.Gdip.GdipReversePath(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Gets the last point in the
public PointF GetLastPoint() {
GPPOINTF gppt = new GPPOINTF();
int status = SafeNativeMethods.Gdip.GdipGetPathLastPoint(new HandleRef(this, nativePath), gppt);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return gppt.ToPoint();
}
/*
* Hit testing
*/
///
///
/// Indicates whether the specified point is contained
/// within this
///
public bool IsVisible(float x, float y) {
return IsVisible(new PointF(x,y), (Graphics)null);
}
///
///
/// Indicates whether the specified point is contained
/// within this
///
public bool IsVisible(PointF point) {
return IsVisible(point, (Graphics)null);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(float x, float y, Graphics graphics) {
return IsVisible(new PointF(x,y), graphics);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(PointF pt, Graphics graphics) {
int isVisible;
int status = SafeNativeMethods.Gdip.GdipIsVisiblePathPoint(new HandleRef(this, nativePath),
pt.X,
pt.Y,
new HandleRef(graphics, (graphics != null) ?
graphics.NativeGraphics : IntPtr.Zero),
out isVisible);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return isVisible != 0;
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(int x, int y) {
return IsVisible(new Point(x,y), (Graphics)null);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(Point point) {
return IsVisible(point, (Graphics)null);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(int x, int y, Graphics graphics) {
return IsVisible(new Point(x,y), graphics);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(Point pt, Graphics graphics) {
int isVisible;
int status = SafeNativeMethods.Gdip.GdipIsVisiblePathPointI(new HandleRef(this, nativePath),
pt.X,
pt.Y,
new HandleRef(graphics, (graphics != null) ?
graphics.NativeGraphics : IntPtr.Zero),
out isVisible);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return isVisible != 0;
}
///
/// Indicates whether an outline drawn by the
/// specified
public bool IsOutlineVisible(float x, float y, Pen pen) {
return IsOutlineVisible(new PointF(x,y), pen, (Graphics)null);
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(PointF point, Pen pen) {
return IsOutlineVisible(point, pen, (Graphics)null);
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(float x, float y, Pen pen, Graphics graphics) {
return IsOutlineVisible(new PointF(x,y), pen, graphics);
}
///
///
/// Indicates whether an outline drawn by the specified
///
///
public bool IsOutlineVisible(PointF pt, Pen pen, Graphics graphics) {
int isVisible;
if (pen == null)
throw new ArgumentNullException("pen");
int status = SafeNativeMethods.Gdip.GdipIsOutlineVisiblePathPoint(new HandleRef(this, nativePath),
pt.X,
pt.Y,
new HandleRef(pen, pen.NativePen),
new HandleRef(graphics, (graphics != null) ?
graphics.NativeGraphics : IntPtr.Zero),
out isVisible);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return isVisible != 0;
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(int x, int y, Pen pen) {
return IsOutlineVisible(new Point(x,y), pen, (Graphics)null);
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(Point point, Pen pen) {
return IsOutlineVisible(point, pen, (Graphics)null);
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(int x, int y, Pen pen, Graphics graphics) {
return IsOutlineVisible(new Point(x,y), pen, graphics);
}
///
///
/// Indicates whether an outline drawn by the specified
///
///
public bool IsOutlineVisible(Point pt, Pen pen, Graphics graphics) {
int isVisible;
if (pen == null)
throw new ArgumentNullException("pen");
int status = SafeNativeMethods.Gdip.GdipIsOutlineVisiblePathPointI(new HandleRef(this, nativePath),
pt.X,
pt.Y,
new HandleRef(pen, pen.NativePen),
new HandleRef(graphics, (graphics != null) ?
graphics.NativeGraphics : IntPtr.Zero),
out isVisible);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return isVisible != 0;
}
/*
* Add lines to the path object
*/
// float version
///
/// Appends a line segment to this
public void AddLine(PointF pt1, PointF pt2) {
AddLine(pt1.X, pt1.Y, pt2.X, pt2.Y);
}
///
/// Appends a line segment to this
public void AddLine(float x1, float y1, float x2, float y2) {
int status = SafeNativeMethods.Gdip.GdipAddPathLine(new HandleRef(this, nativePath), x1, y1, x2, y2);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Appends a series of connected line
/// segments to the end of this
public void AddLines(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathLine2(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Appends a line segment to this
///
public void AddLine(Point pt1, Point pt2) {
AddLine(pt1.X, pt1.Y, pt2.X, pt2.Y);
}
///
///
/// Appends a line segment to this
///
public void AddLine(int x1, int y1, int x2, int y2) {
int status = SafeNativeMethods.Gdip.GdipAddPathLineI(new HandleRef(this, nativePath), x1, y1, x2, y2);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Appends a series of connected line segments to the end of this
///
public void AddLines(Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathLine2I(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
/*
* Add an arc to the path object
*/
// float version
///
///
/// Appends an elliptical arc to the current
/// figure.
///
///
public void AddArc(RectangleF rect, float startAngle, float sweepAngle) {
AddArc(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
}
///
///
/// Appends an elliptical arc to the current figure.
///
///
public void AddArc(float x, float y, float width, float height,
float startAngle, float sweepAngle) {
int status = SafeNativeMethods.Gdip.GdipAddPathArc(new HandleRef(this, nativePath), x, y, width, height,
startAngle, sweepAngle);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
// int version
///
///
/// Appends an elliptical arc to the current figure.
///
///
public void AddArc(Rectangle rect, float startAngle, float sweepAngle) {
AddArc(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
}
///
///
/// Appends an elliptical arc to the current figure.
///
///
public void AddArc(int x, int y, int width, int height,
float startAngle, float sweepAngle) {
int status = SafeNativeMethods.Gdip.GdipAddPathArcI(new HandleRef(this, nativePath), x, y, width, height,
startAngle, sweepAngle);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
/*
* Add Bezier curves to the path object
*/
// float version
///
///
/// Adds a cubic Bzier curve to the current
/// figure.
///
///
public void AddBezier(PointF pt1, PointF pt2, PointF pt3, PointF pt4) {
AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
}
///
///
/// Adds a cubic Bzier curve to the current
/// figure.
///
///
public void AddBezier(float x1, float y1, float x2, float y2,
float x3, float y3, float x4, float y4) {
int status = SafeNativeMethods.Gdip.GdipAddPathBezier(new HandleRef(this, nativePath), x1, y1, x2, y2,
x3, y3, x4, y4);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a sequence of connected cubic Bzier
/// curves to the current figure.
///
///
public void AddBeziers(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathBeziers(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Adds a cubic Bzier curve to the current figure.
///
///
public void AddBezier(Point pt1, Point pt2, Point pt3, Point pt4) {
AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
}
///
///
/// Adds a cubic Bzier curve to the current
/// figure.
///
///
public void AddBezier(int x1, int y1, int x2, int y2,
int x3, int y3, int x4, int y4) {
int status = SafeNativeMethods.Gdip.GdipAddPathBezierI(new HandleRef(this, nativePath), x1, y1, x2, y2,
x3, y3, x4, y4);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a sequence of connected cubic Bzier curves to the
/// current figure.
///
///
public void AddBeziers(params Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathBeziersI(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
/*
* Add cardinal splines to the path object
*/
// float version
///
///
/// Adds a spline curve to the current figure.
/// A Cardinal spline curve is used because the curve travels through each of the
/// points in the array.
///
///
public void AddCurve(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
/// Adds a spline curve to the current figure.
///
public void AddCurve(PointF[] points, float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve2(new HandleRef(this, nativePath), new HandleRef(null, buf),
points.Length, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a spline curve to the current figure.
///
///
public void AddCurve(PointF[] points, int offset, int numberOfSegments,
float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve3(new HandleRef(this, nativePath), new HandleRef(null, buf),
points.Length, offset,
numberOfSegments, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Adds a spline curve to the current figure. A Cardinal spline curve is used
/// because the curve travels through each of the points in the array.
///
///
public void AddCurve(Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurveI(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a spline curve to the current figure.
///
///
public void AddCurve(Point[] points, float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve2I(new HandleRef(this, nativePath), new HandleRef(null, buf),
points.Length, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a spline curve to the current figure.
///
///
public void AddCurve(Point[] points, int offset, int numberOfSegments,
float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve3I(new HandleRef(this, nativePath), new HandleRef(null, buf),
points.Length, offset,
numberOfSegments, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// float version
///
///
/// Adds a closed curve to the current figure. A Cardinal spline curve is
/// used because the curve travels through each of the points in the array.
///
///
public void AddClosedCurve(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathClosedCurve(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a closed curve to the current figure. A Cardinal spline curve is
/// used because the curve travels through each of the points in the array.
///
///
public void AddClosedCurve(PointF[] points, float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathClosedCurve2(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Adds a closed curve to the current figure. A Cardinal spline curve is used
/// because the curve travels through each of the points in the array.
///
///
public void AddClosedCurve(Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathClosedCurveI(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a closed curve to the current figure. A Cardinal spline curve is used
/// because the curve travels through each of the points in the array.
///
///
public void AddClosedCurve(Point[] points, float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathClosedCurve2I(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
/// Adds a rectangle to the current figure.
///
public void AddRectangle(RectangleF rect) {
int status = SafeNativeMethods.Gdip.GdipAddPathRectangle(new HandleRef(this, nativePath), rect.X, rect.Y,
rect.Width, rect.Height);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a series of rectangles to the current
/// figure.
///
///
public void AddRectangles(RectangleF[] rects) {
if (rects == null)
throw new ArgumentNullException("rects");
IntPtr buf = SafeNativeMethods.Gdip.ConvertRectangleToMemory(rects);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathRectangles(new HandleRef(this, nativePath), new HandleRef(null, buf), rects.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Adds a rectangle to the current figure.
///
///
public void AddRectangle(Rectangle rect) {
int status = SafeNativeMethods.Gdip.GdipAddPathRectangleI(new HandleRef(this, nativePath), rect.X, rect.Y,
rect.Width, rect.Height);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a series of rectangles to the current figure.
///
///
public void AddRectangles(Rectangle[] rects) {
if (rects == null)
throw new ArgumentNullException("rects");
IntPtr buf = SafeNativeMethods.Gdip.ConvertRectangleToMemory(rects);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathRectanglesI(new HandleRef(this, nativePath), new HandleRef(null, buf), rects.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// float version
///
/// Adds an ellipse to the current figure.
///
public void AddEllipse(RectangleF rect) {
AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
}
/**
* Add an ellipse to the current path
*
* !!! Need to handle the status code returned
* by the native GDI+ APIs.
*/
///
/// Adds an ellipse to the current figure.
///
public void AddEllipse(float x, float y, float width, float height) {
int status = SafeNativeMethods.Gdip.GdipAddPathEllipse(new HandleRef(this, nativePath), x, y, width, height);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
// int version
///
///
/// Adds an ellipse to the current figure.
///
///
public void AddEllipse(Rectangle rect) {
AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
}
/**
* Add an ellipse to the current path
*
* !!! Need to handle the status code returned
* by the native GDI+ APIs.
*/
///
///
/// Adds an ellipse to the current figure.
///
///
public void AddEllipse(int x, int y, int width, int height) {
int status = SafeNativeMethods.Gdip.GdipAddPathEllipseI(new HandleRef(this, nativePath), x, y, width, height);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds the outline of a pie shape to the
/// current figure.
///
///
public void AddPie(Rectangle rect, float startAngle, float sweepAngle) {
AddPie(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
}
// float version
///
///
/// Adds the outline of a pie shape to the current
/// figure.
///
///
public void AddPie(float x, float y, float width, float height,
float startAngle, float sweepAngle) {
int status = SafeNativeMethods.Gdip.GdipAddPathPie(new HandleRef(this, nativePath), x, y, width, height,
startAngle, sweepAngle);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
// int version
///
///
/// Adds the outline of a pie shape to the current
/// figure.
///
///
public void AddPie(int x, int y, int width, int height,
float startAngle, float sweepAngle) {
int status = SafeNativeMethods.Gdip.GdipAddPathPieI(new HandleRef(this, nativePath), x, y, width, height,
startAngle, sweepAngle);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
// float version
///
/// Adds a polygon to the current figure.
///
public void AddPolygon(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathPolygon(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
/// Adds a polygon to the current figure.
///
public void AddPolygon(Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathPolygonI(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
/// Appends the specified
public void AddPath(GraphicsPath addingPath,
bool connect)
{
if (addingPath == null)
throw new ArgumentNullException("addingPath");
int status = SafeNativeMethods.Gdip.GdipAddPathPath(new HandleRef(this, nativePath), new HandleRef(addingPath, addingPath.nativePath), connect);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
/*
* Add text string to the path object
*
* @notes The final form of this API is yet to be defined.
* @notes What are the choices for the format parameter?
*/
///
///
/// Adds a text string to the current figure.
///
///
public void AddString(String s, FontFamily family, int style, float emSize,
PointF origin, StringFormat format) {
GPRECTF rectf = new GPRECTF(origin.X, origin.Y, 0, 0);
int status = SafeNativeMethods.Gdip.GdipAddPathString(new HandleRef(this, nativePath),
s,
s.Length,
new HandleRef(family, (family != null) ? family.NativeFamily : IntPtr.Zero),
style,
emSize,
ref rectf,
new HandleRef(format, (format != null) ? format.nativeFormat : IntPtr.Zero));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a text string to the current figure.
///
///
public void AddString(String s, FontFamily family, int style, float emSize,
Point origin, StringFormat format) {
GPRECT rect = new GPRECT(origin.X, origin.Y, 0, 0);
int status = SafeNativeMethods.Gdip.GdipAddPathStringI(new HandleRef(this, nativePath),
s,
s.Length,
new HandleRef(family, (family != null) ? family.NativeFamily : IntPtr.Zero),
style,
emSize,
ref rect,
new HandleRef(format, (format != null) ? format.nativeFormat : IntPtr.Zero));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a text string to the current figure.
///
///
public void AddString(String s, FontFamily family, int style, float emSize,
RectangleF layoutRect, StringFormat format) {
GPRECTF rectf = new GPRECTF(layoutRect);
int status = SafeNativeMethods.Gdip.GdipAddPathString(new HandleRef(this, nativePath),
s,
s.Length,
new HandleRef(family, (family != null) ? family.NativeFamily : IntPtr.Zero),
style,
emSize,
ref rectf,
new HandleRef(format, (format != null) ? format.nativeFormat : IntPtr.Zero));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a text string to the current figure.
///
///
public void AddString(String s, FontFamily family, int style, float emSize,
Rectangle layoutRect, StringFormat format) {
GPRECT rect = new GPRECT(layoutRect);
int status = SafeNativeMethods.Gdip.GdipAddPathStringI(new HandleRef(this, nativePath),
s,
s.Length,
new HandleRef(family, (family != null) ? family.NativeFamily : IntPtr.Zero),
style,
emSize,
ref rect,
new HandleRef(format, (format != null) ? format.nativeFormat : IntPtr.Zero));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Applies a transform matrix to this
public void Transform(Matrix matrix) {
if (matrix == null)
throw new ArgumentNullException("matrix");
// !! Is this an optimization? We should catch this in GdipTransformPath
if (matrix.nativeMatrix == IntPtr.Zero)
return;
int status = SafeNativeMethods.Gdip.GdipTransformPath(new HandleRef(this, nativePath),
new HandleRef(matrix, matrix.nativeMatrix));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Returns a rectangle that bounds this
///
public RectangleF GetBounds() {
return GetBounds(null);
}
///
///
/// Returns a rectangle that bounds this
///
public RectangleF GetBounds(Matrix matrix) {
return GetBounds(matrix, null);
}
///
///
/// Returns a rectangle that bounds this
///
public RectangleF GetBounds(Matrix matrix, Pen pen) {
GPRECTF gprectf = new GPRECTF();
IntPtr nativeMatrix = IntPtr.Zero, nativePen = IntPtr.Zero;
if (matrix != null)
nativeMatrix = matrix.nativeMatrix;
if (pen != null)
nativePen = pen.NativePen;
int status = SafeNativeMethods.Gdip.GdipGetPathWorldBounds(new HandleRef(this, nativePath),
ref gprectf,
new HandleRef(matrix, nativeMatrix),
new HandleRef(pen, nativePen));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return gprectf.ToRectangleF();
}
/*
* Flatten the path object
*/
///
/// Converts each curve in this
public void Flatten() {
Flatten(null);
}
///
/// Converts each curve in this
public void Flatten(Matrix matrix) {
Flatten(matrix, 0.25f);
}
///
/// Converts each curve in this
public void Flatten(Matrix matrix, float flatness) {
int status = SafeNativeMethods.Gdip.GdipFlattenPath(new HandleRef(this, nativePath),
new HandleRef(matrix, (matrix == null) ? IntPtr.Zero : matrix.nativeMatrix),
flatness);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
/**
* Widen the path object
*
* @notes We don't have an API yet.
* Should we just take in a GeometricPen as parameter?
*/
///
///
public void Widen(Pen pen) {
float flatness = (float) 2.0 / (float) 3.0;
Widen(pen, (Matrix)null, flatness);
}
///
/// [To be supplied.]
///
public void Widen(Pen pen, Matrix matrix) {
float flatness = (float) 2.0 / (float) 3.0;
Widen(pen, matrix, flatness);
}
///
/// [To be supplied.]
///
public void Widen(Pen pen,
Matrix matrix,
float flatness)
{
IntPtr nativeMatrix;
if (matrix == null)
nativeMatrix = IntPtr.Zero;
else
nativeMatrix = matrix.nativeMatrix;
if (pen == null)
throw new ArgumentNullException("pen");
//
int pointCount;
SafeNativeMethods.Gdip.GdipGetPointCount(new HandleRef(this, nativePath), out pointCount);
if(pointCount == 0)
return;
int status = SafeNativeMethods.Gdip.GdipWidenPath(new HandleRef(this, nativePath),
new HandleRef(pen, pen.NativePen),
new HandleRef(matrix, nativeMatrix),
flatness);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public void Warp(PointF[] destPoints, RectangleF srcRect)
{ Warp(destPoints, srcRect, null); }
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public void Warp(PointF[] destPoints, RectangleF srcRect, Matrix matrix)
{ Warp(destPoints, srcRect, matrix, WarpMode.Perspective); }
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public void Warp(PointF[] destPoints, RectangleF srcRect, Matrix matrix,
WarpMode warpMode)
{ Warp(destPoints, srcRect, matrix, warpMode, 0.25f); }
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public void Warp(PointF[] destPoints, RectangleF srcRect, Matrix matrix,
WarpMode warpMode, float flatness)
{
if (destPoints == null)
throw new ArgumentNullException("destPoints");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(destPoints);
try {
int status = SafeNativeMethods.Gdip.GdipWarpPath(new HandleRef(this, nativePath),
new HandleRef(matrix, (matrix == null) ? IntPtr.Zero : matrix.nativeMatrix),
new HandleRef(null, buf),
destPoints.Length,
srcRect.X,
srcRect.Y,
srcRect.Width,
srcRect.Height,
warpMode,
flatness);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
/**
* Return the number of points in the current path
*/
///
/// [To be supplied.]
///
public int PointCount {
get {
int count = 0;
int status = SafeNativeMethods.Gdip.GdipGetPointCount(new HandleRef(this, nativePath), out count);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return count;
}
}
/**
* Return the path point type information
*/
///
/// [To be supplied.]
///
public byte[] PathTypes {
get {
int count = PointCount;
byte[] types = new byte[count];
int status = SafeNativeMethods.Gdip.GdipGetPathTypes(new HandleRef(this, nativePath), types, count);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return types;
}
}
/*
* Return the path point coordinate information
* @notes Should there be PathData that contains types[] and points[]
* for get & set purposes.
*/
// float points
///
/// [To be supplied.]
///
public PointF[] PathPoints {
get {
int count = PointCount;
int size = (int) Marshal.SizeOf(typeof(GPPOINTF));
IntPtr buf = Marshal.AllocHGlobal(count * size);
try {
int status = SafeNativeMethods.Gdip.GdipGetPathPoints(new HandleRef(this, nativePath), new HandleRef(null, buf), count);
if (status != SafeNativeMethods.Gdip.Ok) {
throw SafeNativeMethods.Gdip.StatusException(status);
}
PointF[] points = SafeNativeMethods.Gdip.ConvertGPPOINTFArrayF(buf, count);
return points;
} finally {
Marshal.FreeHGlobal(buf);
}
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Drawing.Drawing2D {
using System.Runtime.InteropServices;
using System.Diagnostics;
using System;
using Microsoft.Win32;
using System.Drawing;
using System.ComponentModel;
using System.Drawing.Internal;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Runtime.Versioning;
/**
* Represent a Path object
*/
///
/// Represents a series of connected lines and
/// curves.
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public sealed class GraphicsPath : MarshalByRefObject, ICloneable, IDisposable {
/*
* handle to native path object
*/
internal IntPtr nativePath;
/**
* Create a new path object with the default fill mode
*/
///
///
/// Initializes a new instance of the
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath() : this(System.Drawing.Drawing2D.FillMode.Alternate) { }
/**
* Create a new path object with the specified fill mode
*/
///
/// Initializes a new instance of the
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(FillMode fillMode) {
IntPtr nativePath = IntPtr.Zero;
int status = SafeNativeMethods.Gdip.GdipCreatePath((int)fillMode, out nativePath);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
this.nativePath = nativePath;
}
// float version
///
///
/// Initializes a new instance of the
///
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(PointF[] pts, byte[] types) :
this(pts, types, System.Drawing.Drawing2D.FillMode.Alternate) {}
///
///
/// Initializes a new instance of the
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(PointF[] pts, byte[] types, FillMode fillMode) {
if (pts == null)
throw new ArgumentNullException("pts");
IntPtr nativePath = IntPtr.Zero;
if (pts.Length != types.Length)
throw SafeNativeMethods.Gdip.StatusException(SafeNativeMethods.Gdip.InvalidParameter);
int count = types.Length;
IntPtr ptbuf = SafeNativeMethods.Gdip.ConvertPointToMemory(pts);
IntPtr typebuf = Marshal.AllocHGlobal(count);
try {
Marshal.Copy(types, 0, typebuf, count);
int status = SafeNativeMethods.Gdip.GdipCreatePath2(new HandleRef(null, ptbuf), new HandleRef(null, typebuf), count,
(int)fillMode, out nativePath);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(ptbuf);
Marshal.FreeHGlobal(typebuf);
}
this.nativePath = nativePath;
}
// int version
///
///
/// Initializes a new instance of the
///
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(Point[] pts, byte[] types) :
this(pts, types, System.Drawing.Drawing2D.FillMode.Alternate) {}
///
///
/// Initializes a new instance of the
///
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public GraphicsPath(Point[] pts, byte[] types, FillMode fillMode) {
if (pts == null)
throw new ArgumentNullException("pts");
IntPtr nativePath = IntPtr.Zero;
if (pts.Length != types.Length)
throw SafeNativeMethods.Gdip.StatusException(SafeNativeMethods.Gdip.InvalidParameter);
int count = types.Length;
IntPtr ptbuf = SafeNativeMethods.Gdip.ConvertPointToMemory(pts);
IntPtr typebuf = Marshal.AllocHGlobal(count);
try {
Marshal.Copy(types, 0, typebuf, count);
int status = SafeNativeMethods.Gdip.GdipCreatePath2I(new HandleRef(null, ptbuf), new HandleRef(null, typebuf), count,
(int)fillMode, out nativePath);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(ptbuf);
Marshal.FreeHGlobal(typebuf);
}
this.nativePath = nativePath;
}
/**
* Make a copy of the current path object
*/
///
/// Creates an exact copy of this
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public object Clone() {
IntPtr clonePath = IntPtr.Zero;
int status = SafeNativeMethods.Gdip.GdipClonePath(new HandleRef(this, nativePath), out clonePath);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return new GraphicsPath(clonePath, 0);
}
/**
* 'extra' parameter is necessary to avoid conflict with
* other constructor GraphicsPath(int fillmode)
*/
private GraphicsPath(IntPtr nativePath, int extra) {
if (nativePath == IntPtr.Zero)
throw new ArgumentNullException("nativePath");
this.nativePath = nativePath;
}
/**
* Dispose of resources associated with the
*/
///
/// Eliminates resources for this
public void Dispose() {
Dispose(true);
GC.SuppressFinalize(this);
}
void Dispose(bool disposing) {
if (nativePath != IntPtr.Zero) {
try{
#if DEBUG
int status =
#endif
SafeNativeMethods.Gdip.GdipDeletePath(new HandleRef(this, nativePath));
#if DEBUG
Debug.Assert(status == SafeNativeMethods.Gdip.Ok, "GDI+ returned an error status: " + status.ToString(CultureInfo.InvariantCulture));
#endif
}
catch( Exception ex ){
if( ClientUtils.IsSecurityOrCriticalException( ex ) ) {
throw;
}
Debug.Fail( "Exception thrown during Dispose: " + ex.ToString() );
}
finally{
nativePath = IntPtr.Zero;
}
}
}
///
/// Eliminates resources for this
~GraphicsPath() {
Dispose(false);
}
/**
* Reset the path object to empty
*/
///
/// Empties the
public void Reset() {
int status = SafeNativeMethods.Gdip.GdipResetPath(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
/**
* Get path fill mode information
*/
///
/// Gets or sets a
public FillMode FillMode {
get {
int fillmode = 0;
int status = SafeNativeMethods.Gdip.GdipGetPathFillMode(new HandleRef(this, nativePath), out fillmode);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return(FillMode) fillmode;
}
set {
//validate the FillMode enum
//valid values are 0x0 to 0x1
if (!ClientUtils.IsEnumValid(value, (int)value, (int)FillMode.Alternate, (int)FillMode.Winding))
{
throw new InvalidEnumArgumentException("value", (int)value, typeof(FillMode));
}
int status = SafeNativeMethods.Gdip.GdipSetPathFillMode(new HandleRef(this, nativePath), (int) value);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
}
private PathData _GetPathData() {
int ptSize = (int) Marshal.SizeOf(typeof(GPPOINTF));
int numPts = PointCount;
PathData pathData = new PathData();
pathData.Types = new byte[numPts];
IntPtr memoryPathData = Marshal.AllocHGlobal(3*IntPtr.Size);
IntPtr memoryPoints = Marshal.AllocHGlobal(ptSize*numPts);
try {
GCHandle typesHandle = GCHandle.Alloc(pathData.Types, GCHandleType.Pinned);
try {
IntPtr typesPtr = typesHandle.AddrOfPinnedObject();
//IntPtr typesPtr = Marshal.AddrOfArrayElement(pathData.Types, IntPtr.Zero);
Marshal.StructureToPtr(numPts, memoryPathData, false);
Marshal.StructureToPtr(memoryPoints, (IntPtr)((long)memoryPathData+IntPtr.Size), false);
Marshal.StructureToPtr(typesPtr, (IntPtr)((long)memoryPathData+2*IntPtr.Size), false);
int status = SafeNativeMethods.Gdip.GdipGetPathData(new HandleRef(this, nativePath), memoryPathData);
if (status != SafeNativeMethods.Gdip.Ok) {
throw SafeNativeMethods.Gdip.StatusException(status);
}
pathData.Points = SafeNativeMethods.Gdip.ConvertGPPOINTFArrayF(memoryPoints, numPts);
} finally {
typesHandle.Free();
}
} finally {
Marshal.FreeHGlobal(memoryPathData);
Marshal.FreeHGlobal(memoryPoints);
}
return pathData;
}
///
/// Gets a
public PathData PathData {
get {
return _GetPathData();
}
}
///
///
/// Starts a new figure without closing the
/// current figure. All subsequent points added to the path are added to this new
/// figure.
///
///
public void StartFigure() {
int status = SafeNativeMethods.Gdip.GdipStartPathFigure(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Closes the current figure and starts a new
/// figure. If the current figure contains a sequence of connected lines and curves,
/// it closes the loop by connecting a line from the ending point to the starting
/// point.
///
public void CloseFigure() {
int status = SafeNativeMethods.Gdip.GdipClosePathFigure(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Closes all open figures in a path and
/// starts a new figure. It closes each open figure by connecting a line from it's
/// ending point to it's starting point.
///
public void CloseAllFigures() {
int status = SafeNativeMethods.Gdip.GdipClosePathFigures(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Sets a marker on this
///
public void SetMarkers() {
int status = SafeNativeMethods.Gdip.GdipSetPathMarker(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Clears all markers from this
public void ClearMarkers() {
int status = SafeNativeMethods.Gdip.GdipClearPathMarkers(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Reverses the order of points in the
public void Reverse() {
int status = SafeNativeMethods.Gdip.GdipReversePath(new HandleRef(this, nativePath));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Gets the last point in the
public PointF GetLastPoint() {
GPPOINTF gppt = new GPPOINTF();
int status = SafeNativeMethods.Gdip.GdipGetPathLastPoint(new HandleRef(this, nativePath), gppt);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return gppt.ToPoint();
}
/*
* Hit testing
*/
///
///
/// Indicates whether the specified point is contained
/// within this
///
public bool IsVisible(float x, float y) {
return IsVisible(new PointF(x,y), (Graphics)null);
}
///
///
/// Indicates whether the specified point is contained
/// within this
///
public bool IsVisible(PointF point) {
return IsVisible(point, (Graphics)null);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(float x, float y, Graphics graphics) {
return IsVisible(new PointF(x,y), graphics);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(PointF pt, Graphics graphics) {
int isVisible;
int status = SafeNativeMethods.Gdip.GdipIsVisiblePathPoint(new HandleRef(this, nativePath),
pt.X,
pt.Y,
new HandleRef(graphics, (graphics != null) ?
graphics.NativeGraphics : IntPtr.Zero),
out isVisible);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return isVisible != 0;
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(int x, int y) {
return IsVisible(new Point(x,y), (Graphics)null);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(Point point) {
return IsVisible(point, (Graphics)null);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(int x, int y, Graphics graphics) {
return IsVisible(new Point(x,y), graphics);
}
///
///
/// Indicates whether the specified point is contained within this
///
public bool IsVisible(Point pt, Graphics graphics) {
int isVisible;
int status = SafeNativeMethods.Gdip.GdipIsVisiblePathPointI(new HandleRef(this, nativePath),
pt.X,
pt.Y,
new HandleRef(graphics, (graphics != null) ?
graphics.NativeGraphics : IntPtr.Zero),
out isVisible);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return isVisible != 0;
}
///
/// Indicates whether an outline drawn by the
/// specified
public bool IsOutlineVisible(float x, float y, Pen pen) {
return IsOutlineVisible(new PointF(x,y), pen, (Graphics)null);
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(PointF point, Pen pen) {
return IsOutlineVisible(point, pen, (Graphics)null);
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(float x, float y, Pen pen, Graphics graphics) {
return IsOutlineVisible(new PointF(x,y), pen, graphics);
}
///
///
/// Indicates whether an outline drawn by the specified
///
///
public bool IsOutlineVisible(PointF pt, Pen pen, Graphics graphics) {
int isVisible;
if (pen == null)
throw new ArgumentNullException("pen");
int status = SafeNativeMethods.Gdip.GdipIsOutlineVisiblePathPoint(new HandleRef(this, nativePath),
pt.X,
pt.Y,
new HandleRef(pen, pen.NativePen),
new HandleRef(graphics, (graphics != null) ?
graphics.NativeGraphics : IntPtr.Zero),
out isVisible);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return isVisible != 0;
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(int x, int y, Pen pen) {
return IsOutlineVisible(new Point(x,y), pen, (Graphics)null);
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(Point point, Pen pen) {
return IsOutlineVisible(point, pen, (Graphics)null);
}
///
///
/// Indicates whether an outline drawn by the specified
///
public bool IsOutlineVisible(int x, int y, Pen pen, Graphics graphics) {
return IsOutlineVisible(new Point(x,y), pen, graphics);
}
///
///
/// Indicates whether an outline drawn by the specified
///
///
public bool IsOutlineVisible(Point pt, Pen pen, Graphics graphics) {
int isVisible;
if (pen == null)
throw new ArgumentNullException("pen");
int status = SafeNativeMethods.Gdip.GdipIsOutlineVisiblePathPointI(new HandleRef(this, nativePath),
pt.X,
pt.Y,
new HandleRef(pen, pen.NativePen),
new HandleRef(graphics, (graphics != null) ?
graphics.NativeGraphics : IntPtr.Zero),
out isVisible);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return isVisible != 0;
}
/*
* Add lines to the path object
*/
// float version
///
/// Appends a line segment to this
public void AddLine(PointF pt1, PointF pt2) {
AddLine(pt1.X, pt1.Y, pt2.X, pt2.Y);
}
///
/// Appends a line segment to this
public void AddLine(float x1, float y1, float x2, float y2) {
int status = SafeNativeMethods.Gdip.GdipAddPathLine(new HandleRef(this, nativePath), x1, y1, x2, y2);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Appends a series of connected line
/// segments to the end of this
public void AddLines(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathLine2(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Appends a line segment to this
///
public void AddLine(Point pt1, Point pt2) {
AddLine(pt1.X, pt1.Y, pt2.X, pt2.Y);
}
///
///
/// Appends a line segment to this
///
public void AddLine(int x1, int y1, int x2, int y2) {
int status = SafeNativeMethods.Gdip.GdipAddPathLineI(new HandleRef(this, nativePath), x1, y1, x2, y2);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Appends a series of connected line segments to the end of this
///
public void AddLines(Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathLine2I(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
/*
* Add an arc to the path object
*/
// float version
///
///
/// Appends an elliptical arc to the current
/// figure.
///
///
public void AddArc(RectangleF rect, float startAngle, float sweepAngle) {
AddArc(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
}
///
///
/// Appends an elliptical arc to the current figure.
///
///
public void AddArc(float x, float y, float width, float height,
float startAngle, float sweepAngle) {
int status = SafeNativeMethods.Gdip.GdipAddPathArc(new HandleRef(this, nativePath), x, y, width, height,
startAngle, sweepAngle);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
// int version
///
///
/// Appends an elliptical arc to the current figure.
///
///
public void AddArc(Rectangle rect, float startAngle, float sweepAngle) {
AddArc(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
}
///
///
/// Appends an elliptical arc to the current figure.
///
///
public void AddArc(int x, int y, int width, int height,
float startAngle, float sweepAngle) {
int status = SafeNativeMethods.Gdip.GdipAddPathArcI(new HandleRef(this, nativePath), x, y, width, height,
startAngle, sweepAngle);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
/*
* Add Bezier curves to the path object
*/
// float version
///
///
/// Adds a cubic Bzier curve to the current
/// figure.
///
///
public void AddBezier(PointF pt1, PointF pt2, PointF pt3, PointF pt4) {
AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
}
///
///
/// Adds a cubic Bzier curve to the current
/// figure.
///
///
public void AddBezier(float x1, float y1, float x2, float y2,
float x3, float y3, float x4, float y4) {
int status = SafeNativeMethods.Gdip.GdipAddPathBezier(new HandleRef(this, nativePath), x1, y1, x2, y2,
x3, y3, x4, y4);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a sequence of connected cubic Bzier
/// curves to the current figure.
///
///
public void AddBeziers(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathBeziers(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Adds a cubic Bzier curve to the current figure.
///
///
public void AddBezier(Point pt1, Point pt2, Point pt3, Point pt4) {
AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
}
///
///
/// Adds a cubic Bzier curve to the current
/// figure.
///
///
public void AddBezier(int x1, int y1, int x2, int y2,
int x3, int y3, int x4, int y4) {
int status = SafeNativeMethods.Gdip.GdipAddPathBezierI(new HandleRef(this, nativePath), x1, y1, x2, y2,
x3, y3, x4, y4);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a sequence of connected cubic Bzier curves to the
/// current figure.
///
///
public void AddBeziers(params Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathBeziersI(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
/*
* Add cardinal splines to the path object
*/
// float version
///
///
/// Adds a spline curve to the current figure.
/// A Cardinal spline curve is used because the curve travels through each of the
/// points in the array.
///
///
public void AddCurve(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
/// Adds a spline curve to the current figure.
///
public void AddCurve(PointF[] points, float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve2(new HandleRef(this, nativePath), new HandleRef(null, buf),
points.Length, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a spline curve to the current figure.
///
///
public void AddCurve(PointF[] points, int offset, int numberOfSegments,
float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve3(new HandleRef(this, nativePath), new HandleRef(null, buf),
points.Length, offset,
numberOfSegments, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Adds a spline curve to the current figure. A Cardinal spline curve is used
/// because the curve travels through each of the points in the array.
///
///
public void AddCurve(Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurveI(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a spline curve to the current figure.
///
///
public void AddCurve(Point[] points, float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve2I(new HandleRef(this, nativePath), new HandleRef(null, buf),
points.Length, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a spline curve to the current figure.
///
///
public void AddCurve(Point[] points, int offset, int numberOfSegments,
float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathCurve3I(new HandleRef(this, nativePath), new HandleRef(null, buf),
points.Length, offset,
numberOfSegments, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// float version
///
///
/// Adds a closed curve to the current figure. A Cardinal spline curve is
/// used because the curve travels through each of the points in the array.
///
///
public void AddClosedCurve(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathClosedCurve(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a closed curve to the current figure. A Cardinal spline curve is
/// used because the curve travels through each of the points in the array.
///
///
public void AddClosedCurve(PointF[] points, float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathClosedCurve2(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Adds a closed curve to the current figure. A Cardinal spline curve is used
/// because the curve travels through each of the points in the array.
///
///
public void AddClosedCurve(Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathClosedCurveI(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
///
/// Adds a closed curve to the current figure. A Cardinal spline curve is used
/// because the curve travels through each of the points in the array.
///
///
public void AddClosedCurve(Point[] points, float tension) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathClosedCurve2I(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length, tension);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
/// Adds a rectangle to the current figure.
///
public void AddRectangle(RectangleF rect) {
int status = SafeNativeMethods.Gdip.GdipAddPathRectangle(new HandleRef(this, nativePath), rect.X, rect.Y,
rect.Width, rect.Height);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a series of rectangles to the current
/// figure.
///
///
public void AddRectangles(RectangleF[] rects) {
if (rects == null)
throw new ArgumentNullException("rects");
IntPtr buf = SafeNativeMethods.Gdip.ConvertRectangleToMemory(rects);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathRectangles(new HandleRef(this, nativePath), new HandleRef(null, buf), rects.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
///
/// Adds a rectangle to the current figure.
///
///
public void AddRectangle(Rectangle rect) {
int status = SafeNativeMethods.Gdip.GdipAddPathRectangleI(new HandleRef(this, nativePath), rect.X, rect.Y,
rect.Width, rect.Height);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a series of rectangles to the current figure.
///
///
public void AddRectangles(Rectangle[] rects) {
if (rects == null)
throw new ArgumentNullException("rects");
IntPtr buf = SafeNativeMethods.Gdip.ConvertRectangleToMemory(rects);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathRectanglesI(new HandleRef(this, nativePath), new HandleRef(null, buf), rects.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// float version
///
/// Adds an ellipse to the current figure.
///
public void AddEllipse(RectangleF rect) {
AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
}
/**
* Add an ellipse to the current path
*
* !!! Need to handle the status code returned
* by the native GDI+ APIs.
*/
///
/// Adds an ellipse to the current figure.
///
public void AddEllipse(float x, float y, float width, float height) {
int status = SafeNativeMethods.Gdip.GdipAddPathEllipse(new HandleRef(this, nativePath), x, y, width, height);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
// int version
///
///
/// Adds an ellipse to the current figure.
///
///
public void AddEllipse(Rectangle rect) {
AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
}
/**
* Add an ellipse to the current path
*
* !!! Need to handle the status code returned
* by the native GDI+ APIs.
*/
///
///
/// Adds an ellipse to the current figure.
///
///
public void AddEllipse(int x, int y, int width, int height) {
int status = SafeNativeMethods.Gdip.GdipAddPathEllipseI(new HandleRef(this, nativePath), x, y, width, height);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds the outline of a pie shape to the
/// current figure.
///
///
public void AddPie(Rectangle rect, float startAngle, float sweepAngle) {
AddPie(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
}
// float version
///
///
/// Adds the outline of a pie shape to the current
/// figure.
///
///
public void AddPie(float x, float y, float width, float height,
float startAngle, float sweepAngle) {
int status = SafeNativeMethods.Gdip.GdipAddPathPie(new HandleRef(this, nativePath), x, y, width, height,
startAngle, sweepAngle);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
// int version
///
///
/// Adds the outline of a pie shape to the current
/// figure.
///
///
public void AddPie(int x, int y, int width, int height,
float startAngle, float sweepAngle) {
int status = SafeNativeMethods.Gdip.GdipAddPathPieI(new HandleRef(this, nativePath), x, y, width, height,
startAngle, sweepAngle);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
// float version
///
/// Adds a polygon to the current figure.
///
public void AddPolygon(PointF[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathPolygon(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
// int version
///
/// Adds a polygon to the current figure.
///
public void AddPolygon(Point[] points) {
if (points == null)
throw new ArgumentNullException("points");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(points);
try {
int status = SafeNativeMethods.Gdip.GdipAddPathPolygonI(new HandleRef(this, nativePath), new HandleRef(null, buf), points.Length);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
///
/// Appends the specified
public void AddPath(GraphicsPath addingPath,
bool connect)
{
if (addingPath == null)
throw new ArgumentNullException("addingPath");
int status = SafeNativeMethods.Gdip.GdipAddPathPath(new HandleRef(this, nativePath), new HandleRef(addingPath, addingPath.nativePath), connect);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
/*
* Add text string to the path object
*
* @notes The final form of this API is yet to be defined.
* @notes What are the choices for the format parameter?
*/
///
///
/// Adds a text string to the current figure.
///
///
public void AddString(String s, FontFamily family, int style, float emSize,
PointF origin, StringFormat format) {
GPRECTF rectf = new GPRECTF(origin.X, origin.Y, 0, 0);
int status = SafeNativeMethods.Gdip.GdipAddPathString(new HandleRef(this, nativePath),
s,
s.Length,
new HandleRef(family, (family != null) ? family.NativeFamily : IntPtr.Zero),
style,
emSize,
ref rectf,
new HandleRef(format, (format != null) ? format.nativeFormat : IntPtr.Zero));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a text string to the current figure.
///
///
public void AddString(String s, FontFamily family, int style, float emSize,
Point origin, StringFormat format) {
GPRECT rect = new GPRECT(origin.X, origin.Y, 0, 0);
int status = SafeNativeMethods.Gdip.GdipAddPathStringI(new HandleRef(this, nativePath),
s,
s.Length,
new HandleRef(family, (family != null) ? family.NativeFamily : IntPtr.Zero),
style,
emSize,
ref rect,
new HandleRef(format, (format != null) ? format.nativeFormat : IntPtr.Zero));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a text string to the current figure.
///
///
public void AddString(String s, FontFamily family, int style, float emSize,
RectangleF layoutRect, StringFormat format) {
GPRECTF rectf = new GPRECTF(layoutRect);
int status = SafeNativeMethods.Gdip.GdipAddPathString(new HandleRef(this, nativePath),
s,
s.Length,
new HandleRef(family, (family != null) ? family.NativeFamily : IntPtr.Zero),
style,
emSize,
ref rectf,
new HandleRef(format, (format != null) ? format.nativeFormat : IntPtr.Zero));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Adds a text string to the current figure.
///
///
public void AddString(String s, FontFamily family, int style, float emSize,
Rectangle layoutRect, StringFormat format) {
GPRECT rect = new GPRECT(layoutRect);
int status = SafeNativeMethods.Gdip.GdipAddPathStringI(new HandleRef(this, nativePath),
s,
s.Length,
new HandleRef(family, (family != null) ? family.NativeFamily : IntPtr.Zero),
style,
emSize,
ref rect,
new HandleRef(format, (format != null) ? format.nativeFormat : IntPtr.Zero));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// Applies a transform matrix to this
public void Transform(Matrix matrix) {
if (matrix == null)
throw new ArgumentNullException("matrix");
// !! Is this an optimization? We should catch this in GdipTransformPath
if (matrix.nativeMatrix == IntPtr.Zero)
return;
int status = SafeNativeMethods.Gdip.GdipTransformPath(new HandleRef(this, nativePath),
new HandleRef(matrix, matrix.nativeMatrix));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
///
/// Returns a rectangle that bounds this
///
public RectangleF GetBounds() {
return GetBounds(null);
}
///
///
/// Returns a rectangle that bounds this
///
public RectangleF GetBounds(Matrix matrix) {
return GetBounds(matrix, null);
}
///
///
/// Returns a rectangle that bounds this
///
public RectangleF GetBounds(Matrix matrix, Pen pen) {
GPRECTF gprectf = new GPRECTF();
IntPtr nativeMatrix = IntPtr.Zero, nativePen = IntPtr.Zero;
if (matrix != null)
nativeMatrix = matrix.nativeMatrix;
if (pen != null)
nativePen = pen.NativePen;
int status = SafeNativeMethods.Gdip.GdipGetPathWorldBounds(new HandleRef(this, nativePath),
ref gprectf,
new HandleRef(matrix, nativeMatrix),
new HandleRef(pen, nativePen));
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return gprectf.ToRectangleF();
}
/*
* Flatten the path object
*/
///
/// Converts each curve in this
public void Flatten() {
Flatten(null);
}
///
/// Converts each curve in this
public void Flatten(Matrix matrix) {
Flatten(matrix, 0.25f);
}
///
/// Converts each curve in this
public void Flatten(Matrix matrix, float flatness) {
int status = SafeNativeMethods.Gdip.GdipFlattenPath(new HandleRef(this, nativePath),
new HandleRef(matrix, (matrix == null) ? IntPtr.Zero : matrix.nativeMatrix),
flatness);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
/**
* Widen the path object
*
* @notes We don't have an API yet.
* Should we just take in a GeometricPen as parameter?
*/
///
///
public void Widen(Pen pen) {
float flatness = (float) 2.0 / (float) 3.0;
Widen(pen, (Matrix)null, flatness);
}
///
/// [To be supplied.]
///
public void Widen(Pen pen, Matrix matrix) {
float flatness = (float) 2.0 / (float) 3.0;
Widen(pen, matrix, flatness);
}
///
/// [To be supplied.]
///
public void Widen(Pen pen,
Matrix matrix,
float flatness)
{
IntPtr nativeMatrix;
if (matrix == null)
nativeMatrix = IntPtr.Zero;
else
nativeMatrix = matrix.nativeMatrix;
if (pen == null)
throw new ArgumentNullException("pen");
//
int pointCount;
SafeNativeMethods.Gdip.GdipGetPointCount(new HandleRef(this, nativePath), out pointCount);
if(pointCount == 0)
return;
int status = SafeNativeMethods.Gdip.GdipWidenPath(new HandleRef(this, nativePath),
new HandleRef(pen, pen.NativePen),
new HandleRef(matrix, nativeMatrix),
flatness);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
}
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public void Warp(PointF[] destPoints, RectangleF srcRect)
{ Warp(destPoints, srcRect, null); }
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public void Warp(PointF[] destPoints, RectangleF srcRect, Matrix matrix)
{ Warp(destPoints, srcRect, matrix, WarpMode.Perspective); }
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public void Warp(PointF[] destPoints, RectangleF srcRect, Matrix matrix,
WarpMode warpMode)
{ Warp(destPoints, srcRect, matrix, warpMode, 0.25f); }
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
public void Warp(PointF[] destPoints, RectangleF srcRect, Matrix matrix,
WarpMode warpMode, float flatness)
{
if (destPoints == null)
throw new ArgumentNullException("destPoints");
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(destPoints);
try {
int status = SafeNativeMethods.Gdip.GdipWarpPath(new HandleRef(this, nativePath),
new HandleRef(matrix, (matrix == null) ? IntPtr.Zero : matrix.nativeMatrix),
new HandleRef(null, buf),
destPoints.Length,
srcRect.X,
srcRect.Y,
srcRect.Width,
srcRect.Height,
warpMode,
flatness);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
} finally {
Marshal.FreeHGlobal(buf);
}
}
/**
* Return the number of points in the current path
*/
///
/// [To be supplied.]
///
public int PointCount {
get {
int count = 0;
int status = SafeNativeMethods.Gdip.GdipGetPointCount(new HandleRef(this, nativePath), out count);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return count;
}
}
/**
* Return the path point type information
*/
///
/// [To be supplied.]
///
public byte[] PathTypes {
get {
int count = PointCount;
byte[] types = new byte[count];
int status = SafeNativeMethods.Gdip.GdipGetPathTypes(new HandleRef(this, nativePath), types, count);
if (status != SafeNativeMethods.Gdip.Ok)
throw SafeNativeMethods.Gdip.StatusException(status);
return types;
}
}
/*
* Return the path point coordinate information
* @notes Should there be PathData that contains types[] and points[]
* for get & set purposes.
*/
// float points
///
/// [To be supplied.]
///
public PointF[] PathPoints {
get {
int count = PointCount;
int size = (int) Marshal.SizeOf(typeof(GPPOINTF));
IntPtr buf = Marshal.AllocHGlobal(count * size);
try {
int status = SafeNativeMethods.Gdip.GdipGetPathPoints(new HandleRef(this, nativePath), new HandleRef(null, buf), count);
if (status != SafeNativeMethods.Gdip.Ok) {
throw SafeNativeMethods.Gdip.StatusException(status);
}
PointF[] points = SafeNativeMethods.Gdip.ConvertGPPOINTFArrayF(buf, count);
return points;
} finally {
Marshal.FreeHGlobal(buf);
}
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ProjectionPath.cs
- WindowPattern.cs
- WindowsGrip.cs
- CommandConverter.cs
- counter.cs
- AppDomainUnloadedException.cs
- XmlElementAttributes.cs
- Int16Converter.cs
- NonSerializedAttribute.cs
- RuleProcessor.cs
- ConfigurationStrings.cs
- ObjectParameter.cs
- RSAOAEPKeyExchangeFormatter.cs
- ComponentChangingEvent.cs
- PageAdapter.cs
- SafeCoTaskMem.cs
- CancellationState.cs
- KerberosTicketHashIdentifierClause.cs
- DataGridTextBoxColumn.cs
- ExtentJoinTreeNode.cs
- Normalizer.cs
- FormClosingEvent.cs
- CookielessHelper.cs
- EnumBuilder.cs
- SystemIPAddressInformation.cs
- InternalResources.cs
- SqlUnionizer.cs
- HTMLTextWriter.cs
- StringUtil.cs
- CustomErrorsSection.cs
- ValueSerializerAttribute.cs
- PointLightBase.cs
- ImageMapEventArgs.cs
- EventDescriptorCollection.cs
- AsyncOperationManager.cs
- SynthesizerStateChangedEventArgs.cs
- ConfigurationException.cs
- ExecutionContext.cs
- Int32AnimationBase.cs
- ObjectDataSource.cs
- BinaryCommonClasses.cs
- ModelServiceImpl.cs
- Properties.cs
- List.cs
- Stack.cs
- LinqToSqlWrapper.cs
- CodeValidator.cs
- SqlDataSourceCache.cs
- XPathCompileException.cs
- PropertyEmitterBase.cs
- RawAppCommandInputReport.cs
- ellipse.cs
- Send.cs
- ScriptBehaviorDescriptor.cs
- DBParameter.cs
- NonClientArea.cs
- RetrieveVirtualItemEventArgs.cs
- ObjectDataSourceDisposingEventArgs.cs
- IChannel.cs
- BrushConverter.cs
- CollectionsUtil.cs
- UrlMapping.cs
- XComponentModel.cs
- Polygon.cs
- DropSourceBehavior.cs
- SizeValueSerializer.cs
- EntityDataSourceViewSchema.cs
- ArithmeticException.cs
- Track.cs
- ConfigXmlCDataSection.cs
- XPathAxisIterator.cs
- VisualTransition.cs
- Enum.cs
- SettingsProviderCollection.cs
- SqlWriter.cs
- MetadataArtifactLoaderFile.cs
- BitmapScalingModeValidation.cs
- Knowncolors.cs
- VideoDrawing.cs
- StatusBarPanel.cs
- SecureConversationServiceElement.cs
- ValueExpressions.cs
- TextBoxBase.cs
- SrgsDocumentParser.cs
- SqlBulkCopyColumnMappingCollection.cs
- MergeFailedEvent.cs
- GridViewPageEventArgs.cs
- SchemaImporterExtension.cs
- EventWaitHandleSecurity.cs
- ListViewUpdateEventArgs.cs
- SecurityContextTokenValidationException.cs
- References.cs
- HwndSubclass.cs
- HttpHeaderCollection.cs
- Guid.cs
- PromptStyle.cs
- BitmapEffectrendercontext.cs
- MemberAccessException.cs
- Memoizer.cs
- OperatingSystem.cs