Merge branch 'feature-patheffect' into update-skia-m52

# Conflicts:
#	binding/Binding/SkiaApi.cs
#	skia

README.md

@@ -25,6 +25,10 @@ to create your native libraries.
 
 Check our getting [started guide](https://developer.xamarin.com/guides/cross-platform/drawing/)
 
+# Extensions for SkiaSharp
+
+Windows/WPF users might find the [SkiaSharpWPFExtensions](https://github.com/impsnldavid/skiasharpwpfextensions) useful.
+
 ## Building SkiaSharp
 
 First clone the repository:
@@ -44,15 +48,20 @@ Run from Bash
 
     $ ./bootstrapper.sh -t libs
 
+This runs the build process by using the `libs` build target.
+
 ### Windows
 
 You need Python 2.7 in `PATH` environment variable. Then you can build it:
 
     > .\bootstrapper.ps1 -Target libs
 
+This runs the build process by using the `libs` build target.
+
 ### Build Targets
 
-There are several targets available:
+There are several targets available, you can specify the target as the argument to the `-t` command line
+option in the bootstrapper script.
 
  - `Everything` - builds everything for the current platform
  - `externals` - builds all the native libraries

binding/Binding/Binding.projitems

@@ -16,6 +16,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)SKColorFilter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SKPaint.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SKDocument.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)SKPathEffect.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SKSurface.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SKCanvas.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SKShader.cs" />

binding/Binding/Definitions.cs

@@ -96,7 +96,7 @@ namespace SkiaSharp
 
 		public SKColor (byte red, byte green, byte blue)
 		{
-			color = (uint)(0xff000000 | (red << 16) | (green << 8) | blue);
+			color = (uint)(0xff000000u | (red << 16) | (green << 8) | blue);
 		}
 
 		public SKColor WithAlpha (byte alpha)
@@ -1141,12 +1141,49 @@ namespace SkiaSharp
 		public float SkewY, ScaleY, TransY;
 		public float Persp0, Persp1, Persp2;
 
+#if OPTIMIZED_SKMATRIX
+
+		//
+		// If we manage to get an sk_matrix_t that contains the extra
+		// the fTypeMask flag, we could accelerate various operations
+		// as well, as this caches state of what is needed to be done.
+		//
+	
+		[Flags]
+		enum Mask : uint {
+			Identity = 0,
+			Translate = 1,
+			Scale = 2,
+			Affine = 4,
+			Perspective = 8,
+			RectStaysRect = 0x10,
+			OnlyPerspectiveValid = 0x40,
+			Unknown = 0x80,
+			OrableMasks = Translate | Scale | Affine | Perspective,
+			AllMasks = OrableMasks | RectStaysRect
+		}
+		Mask typeMask;
+
+		Mask GetMask ()
+		{
+			if (typeMask.HasFlag (Mask.Unknown))
+				typeMask = (Mask) SkiaApi.sk_matrix_get_type (ref this);
+
+		        // only return the public masks
+			return (Mask) ((uint)typeMask & 0xf);
+		}
+#endif
+
 		static float sdot (float a, float b, float c, float d) => a * b + c * d;
 		static float scross(float a, float b, float c, float d) => a * b - c * d;
 
 		public static SKMatrix MakeIdentity ()
 		{
-			return new SKMatrix () { ScaleX = 1, ScaleY = 1, Persp2 = 1 };
+			return new SKMatrix () { ScaleX = 1, ScaleY = 1, Persp2 = 1
+#if OPTIMIZED_SKMATRIX
+					, typeMask = Mask.Identity | Mask.RectStaysRect
+#endif
+                        };
 		}
 
 		public void SetScaleTranslate (float sx, float sy, float tx, float ty)
@@ -1162,13 +1199,23 @@ namespace SkiaSharp
 			Persp0 = 0;
 			Persp1 = 0;
 			Persp2 = 1;
+
+#if OPTIMIZED_SKMATRIX
+			typeMask = Mask.RectStaysRect | 
+				((sx != 1 || sy != 1) ? Mask.Scale : 0) |
+				((tx != 0 || ty != 0) ? Mask.Translate : 0);
+#endif
 		}
 
 		public static SKMatrix MakeScale (float sx, float sy)
 		{
 			if (sx == 1 && sy == 1)
 				return MakeIdentity ();
-			return new SKMatrix () { ScaleX = sx, ScaleY = sy, Persp2 = 1 };
+			return new SKMatrix () { ScaleX = sx, ScaleY = sy, Persp2 = 1, 
+#if OPTIMIZED_SKMATRIX
+typeMask = Mask.Scale | Mask.RectStaysRect
+#endif
+			};
 				
 		}
 
@@ -1180,22 +1227,37 @@ namespace SkiaSharp
 		{
 			if (sx == 1 && sy == 1)
 				return MakeIdentity ();
-			//this->setScaleTranslate(sx, sy, px - sx * px, py - sy * py);
+			float tx = pivotX - sx * pivotX;
+			float ty = pivotY - sy * pivotY;
 
+#if OPTIMIZED_SKMATRIX
+			Mask mask = Mask.RectStaysRect | 
+				((sx != 1 || sy != 1) ? Mask.Scale : 0) |
+				((tx != 0 || ty != 0) ? Mask.Translate : 0);
+#endif
 			return new SKMatrix () { 
 				ScaleX = sx, ScaleY = sy, 
-				TransX = pivotX - sx * pivotX,
-				TransY = pivotY - sy * pivotY,
-				Persp2 = 1 
+				TransX = tx,
+				TransY = ty,
+				Persp2 = 1,
+#if OPTIMIZED_SKMATRIX
+				typeMask = mask
+#endif
 			};
 		}
 
 		public static SKMatrix MakeTranslation (float dx, float dy)
 		{
+			if (dx == 0 && dy == 0)
+				return MakeIdentity ();
+			
 			return new SKMatrix () { 
 				ScaleX = 1, ScaleY = 1,
 				TransX = dx, TransY = dy,
-				Persp2 = 1
+				Persp2 = 1,
+#if OPTIMIZED_SKMATRIX
+				typeMask = Mask.Translate | Mask.RectStaysRect
+#endif
 			};
 		}
 
@@ -1204,17 +1266,93 @@ namespace SkiaSharp
 			var sin = (float) Math.Sin (radians);
 			var cos = (float) Math.Cos (radians);
 
-			return new SKMatrix () {
-				ScaleX = cos,
-				SkewX = -sin,
-				TransX = 0,
-				SkewY = sin,
-				ScaleY = cos,
-				TransY = 0,
-				Persp0 = 0,
-				Persp1 = 0,
-				Persp2 = 1
-			};
+			var matrix = new SKMatrix ();
+			SetSinCos (ref matrix, sin, cos);
+			return matrix;
+		}
+
+		public static SKMatrix MakeRotation (float radians, float pivotx, float pivoty)
+		{
+			var sin = (float) Math.Sin (radians);
+			var cos = (float) Math.Cos (radians);
+
+			var matrix = new SKMatrix ();
+			SetSinCos (ref matrix, sin, cos, pivotx, pivoty);
+			return matrix;
+		}
+
+		const float degToRad = (float)System.Math.PI / 180.0f;
+		
+		public static SKMatrix MakeRotationDegrees (float degrees)
+		{
+			return MakeRotation (degrees * degToRad);
+		}
+
+		public static SKMatrix MakeRotationDegrees (float degrees, float pivotx, float pivoty)
+		{
+			return MakeRotation (degrees * degToRad, pivotx, pivoty);
+		}
+
+		static void SetSinCos (ref SKMatrix matrix, float sin, float cos)
+		{
+			matrix.ScaleX = cos;
+			matrix.SkewX = -sin;
+			matrix.TransX = 0;
+			matrix.SkewY = sin;
+			matrix.ScaleY = cos;
+			matrix.TransY = 0;
+			matrix.Persp0 = 0;
+			matrix.Persp1 = 0;
+			matrix.Persp2 = 1;
+#if OPTIMIZED_SKMATRIX
+			matrix.typeMask = Mask.Unknown | Mask.OnlyPerspectiveValid;
+#endif
+		}
+
+		static void SetSinCos (ref SKMatrix matrix, float sin, float cos, float pivotx, float pivoty)
+		{
+			float oneMinusCos = 1-cos;
+			
+			matrix.ScaleX = cos;
+			matrix.SkewX = -sin;
+			matrix.TransX = sdot(sin, pivoty, oneMinusCos, pivotx);
+			matrix.SkewY = sin;
+			matrix.ScaleY = cos;
+			matrix.TransY = sdot(-sin, pivotx, oneMinusCos, pivoty);
+			matrix.Persp0 = 0;
+			matrix.Persp1 = 0;
+			matrix.Persp2 = 1;
+#if OPTIMIZED_SKMATRIX
+			matrix.typeMask = Mask.Unknown | Mask.OnlyPerspectiveValid;
+#endif
+		}
+		
+		public static void Rotate (ref SKMatrix matrix, float radians, float pivotx, float pivoty)
+		{
+			var sin = (float) Math.Sin (radians);
+			var cos = (float) Math.Cos (radians);
+			SetSinCos (ref matrix, sin, cos, pivotx, pivoty);
+		}
+
+		public static void RotateDegrees (ref SKMatrix matrix, float degrees, float pivotx, float pivoty)
+		{
+			var sin = (float) Math.Sin (degrees * degToRad);
+			var cos = (float) Math.Cos (degrees * degToRad);
+			SetSinCos (ref matrix, sin, cos, pivotx, pivoty);
+		}
+
+		public static void Rotate (ref SKMatrix matrix, float radians)
+		{
+			var sin = (float) Math.Sin (radians);
+			var cos = (float) Math.Cos (radians);
+			SetSinCos (ref matrix, sin, cos);
+		}
+
+		public static void RotateDegrees (ref SKMatrix matrix, float degrees)
+		{
+			var sin = (float) Math.Sin (degrees * degToRad);
+			var cos = (float) Math.Cos (degrees * degToRad);
+			SetSinCos (ref matrix, sin, cos);
 		}
 
 		public static SKMatrix MakeSkew (float sx, float sy)
@@ -1228,9 +1366,120 @@ namespace SkiaSharp
 				TransY = 0,
 				Persp0 = 0,
 				Persp1 = 0,
-				Persp2 = 1
+				Persp2 = 1,
+#if OPTIMIZED_SKMATRIX
+				typeMask = Mask.Unknown | Mask.OnlyPerspectiveValid
+#endif
 			};
 		}
+
+		public bool TryInvert (out SKMatrix inverse)
+		{
+			return SkiaApi.sk_matrix_try_invert (ref this, out inverse) != 0;
+		}
+
+		[DllImport(SkiaApi.SKIA, CallingConvention = CallingConvention.Cdecl, EntryPoint="sk_matrix_concat")]
+		public extern static void Concat (ref SKMatrix target, ref SKMatrix first, ref SKMatrix second);
+
+		[DllImport(SkiaApi.SKIA, CallingConvention = CallingConvention.Cdecl, EntryPoint="sk_matrix_pre_concat")]
+		public extern static void PreConcat (ref SKMatrix target, ref SKMatrix matrix);
+
+		[DllImport(SkiaApi.SKIA, CallingConvention = CallingConvention.Cdecl, EntryPoint="sk_matrix_post_concat")]
+		public extern static void PostConcat (ref SKMatrix target, ref SKMatrix matrix);
+
+		[DllImport(SkiaApi.SKIA, CallingConvention = CallingConvention.Cdecl, EntryPoint="sk_matrix_map_rect")]
+		extern static void MapRect (ref SKMatrix matrix, out SKRect dest, ref SKRect source);
+
+		public SKRect MapRect (SKRect source)
+		{
+			SKRect result;
+			MapRect (ref this, out result, ref source);
+			return result;
+		}
+
+		[DllImport(SkiaApi.SKIA, CallingConvention = CallingConvention.Cdecl)]
+		extern static void sk_matrix_map_points (ref SKMatrix matrix, IntPtr dst, IntPtr src, int count);
+
+		public void MapPoints (SKPoint [] result, SKPoint [] points)
+		{
+			if (result == null)
+				throw new ArgumentNullException ("result");
+			if (points == null)
+				throw new ArgumentNullException ("points");
+			int dl = result.Length;
+			if (dl != points.Length)
+				throw new ArgumentException ("buffers must be the same size");
+			unsafe {
+				fixed (SKPoint *rp = &result[0]){
+					fixed (SKPoint *pp = &points[0]){
+						sk_matrix_map_points (ref this, (IntPtr) rp, (IntPtr) pp, dl);
+					}
+				}
+			}
+		}
+
+		public SKPoint [] MapPoints (SKPoint [] points)
+		{
+			if (points == null)
+				throw new ArgumentNullException ("points");
+			var res = new SKPoint [points.Length];
+			MapPoints (res, points);
+			return res;
+		}
+
+		[DllImport(SkiaApi.SKIA, CallingConvention = CallingConvention.Cdecl)]
+		extern static void sk_matrix_map_vectors (ref SKMatrix matrix, IntPtr dst, IntPtr src, int count);
+
+		public void MapVectors (SKPoint [] result, SKPoint [] vectors)
+		{
+			if (result == null)
+				throw new ArgumentNullException ("result");
+			if (vectors == null)
+				throw new ArgumentNullException ("vectors");
+			int dl = result.Length;
+			if (dl != vectors.Length)
+				throw new ArgumentException ("buffers must be the same size");
+			unsafe {
+				fixed (SKPoint *rp = &result[0]){
+					fixed (SKPoint *pp = &vectors[0]){
+						sk_matrix_map_vectors (ref this, (IntPtr) rp, (IntPtr) pp, dl);
+					}
+				}
+			}
+		}
+
+		public SKPoint [] MapVectors (SKPoint [] vectors)
+		{
+			if (vectors == null)
+				throw new ArgumentNullException ("vectors");
+			var res = new SKPoint [vectors.Length];
+			MapVectors (res, vectors);
+			return res;
+		}
+
+		[DllImport(SkiaApi.SKIA, CallingConvention = CallingConvention.Cdecl)]
+		extern static SKPoint sk_matrix_map_xy (ref SKMatrix matrix, float x, float y);
+
+		public SKPoint MapXY (float x, float y)
+		{
+			return sk_matrix_map_xy (ref this, x, y);
+		}
+
+		[DllImport(SkiaApi.SKIA, CallingConvention = CallingConvention.Cdecl)]
+		extern static SKPoint sk_matrix_map_vector (ref SKMatrix matrix, float x, float y);
+
+		public SKPoint MapVector (float x, float y)
+		{
+			return sk_matrix_map_vector (ref this, x, y);
+		}
+
+		[DllImport(SkiaApi.SKIA, CallingConvention = CallingConvention.Cdecl)]
+		extern static float sk_matrix_map_radius (ref SKMatrix matrix, float radius);
+
+		public float MapRadius (float radius)
+		{
+			return sk_matrix_map_radius (ref this, radius);
+		}
 	}
 
 	[StructLayout(LayoutKind.Sequential)]

binding/Binding/SKCanvas.cs

@@ -164,6 +164,13 @@ namespace SkiaSharp
 			SkiaApi.sk_canvas_draw_oval (Handle, ref rect, paint.Handle);
 		}
 
+		public void DrawCircle (float cx, float cy, float radius, SKPaint paint)
+		{
+			if (paint == null)
+				throw new ArgumentNullException ("paint");
+			SkiaApi.sk_canvas_draw_circle (Handle, cx, cy, radius, paint.Handle);
+		}
+		
 		public void DrawPath (SKPath path, SKPaint paint)
 		{
 			if (paint == null)

binding/Binding/SKPaint.cs

@@ -227,6 +227,15 @@ namespace SkiaSharp
 			}
 		}
 
+		public SKPathEffect PathEffect {
+			get {
+				return GetObject<SKPathEffect> (SkiaApi.sk_paint_get_path_effect(Handle));
+			}
+			set {
+				SkiaApi.sk_paint_set_path_effect (Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
 		public float MeasureText (string text)
 		{
 			if (text == null)

binding/Binding/SKPath.cs

@@ -12,6 +12,16 @@ namespace SkiaSharp
 {
 	public class SKPath : SKObject
 	{
+		public enum Verb {
+			Move, Line, Quad, Conic, Cubic, Close, Done
+		}
+
+		public enum AddMode {
+			Append,
+			Extend
+		}
+
+		
 		[Preserve]
 		internal SKPath (IntPtr handle, bool owns)
 			: base (handle, owns)
@@ -107,6 +117,16 @@ namespace SkiaSharp
 			SkiaApi.sk_path_close (Handle);
 		}
 
+		public void Rewind()
+		{
+			SkiaApi.sk_path_rewind(Handle);
+		}
+
+		public void Reset()
+		{
+			SkiaApi.sk_path_reset(Handle);
+		}
+
 		public void AddRect (SKRect rect, SKPathDirection direction)
 		{
 			SkiaApi.sk_path_add_rect (Handle, ref rect, direction);
@@ -139,6 +159,137 @@ namespace SkiaSharp
 		{
 			SkiaApi.sk_path_transform (Handle, ref matrix);
 		}
+
+		public void AddPath (SKPath other, float dx, float dy, AddMode mode = AddMode.Append)
+		{
+			if (other == null)
+				throw new ArgumentNullException (nameof (other));
+			
+			SkiaApi.sk_path_add_path_offset (Handle, other.Handle, dx, dy, mode);
+		}
+
+		public void AddPath (SKPath other, ref SKMatrix matrix, AddMode mode = AddMode.Append)
+		{
+			if (other == null)
+				throw new ArgumentNullException (nameof (other));
+			
+			SkiaApi.sk_path_add_path_matrix (Handle, other.Handle, ref matrix, mode);
+		}
+
+		public void AddPath (SKPath other, AddMode mode = AddMode.Append)
+		{
+			if (other == null)
+				throw new ArgumentNullException (nameof (other));
+			
+			SkiaApi.sk_path_add_path (Handle, other.Handle, mode);
+		}
+
+		public void AddPathReverse (SKPath other)
+		{
+			if (other == null)
+				throw new ArgumentNullException (nameof (other));
+			
+			SkiaApi.sk_path_add_path_reverse (Handle, other.Handle);
+		}
+
+		public Iterator CreateIterator (bool forceClose)
+		{
+			return new Iterator (this, SkiaApi.sk_path_create_iter (Handle, forceClose ? 1 : 0));
+		}
+
+		public RawIterator CreateRawIterator ()
+		{
+			return new RawIterator (this, SkiaApi.sk_path_create_rawiter (Handle));
+		}
+		
+		public class Iterator : IDisposable {
+			SKPath Path => path;
+			SKPath path;
+			IntPtr handle;
+
+			internal Iterator (SKPath path, IntPtr handle)
+			{
+				this.path = path;
+				this.handle = handle;
+			}
+
+			~Iterator ()
+			{
+				Dispose (false);
+			}
+
+			void Dispose (bool disposing)
+			{
+				if (handle != IntPtr.Zero){
+					// safe to call from a background thread to release resources.
+					SkiaApi.sk_path_iter_destroy (handle);
+					handle = IntPtr.Zero;
+				}
+			}
+			
+			public void Dispose ()
+			{
+				Dispose (true);
+				GC.SuppressFinalize (this);
+			}
+
+			public Verb Next (SKPoint [] points, bool doConsumeDegenerates = true, bool exact = false)
+			{
+				if (points == null)
+					throw new ArgumentNullException (nameof (points));
+				if (points.Length != 4)
+					throw new ArgumentException ("Must be an array of four elements", nameof (points));
+				return SkiaApi.sk_path_iter_next (handle, points, doConsumeDegenerates ? 1 : 0, exact ? 1 : 0);
+			}
+
+			public float ConicWeight () => SkiaApi.sk_path_iter_conic_weight (handle);
+			public bool IsCloseLine () => SkiaApi.sk_path_iter_is_close_line (handle) != 0;
+			public bool IsCloseContour () => SkiaApi.sk_path_iter_is_close_countour (handle) != 0;
+		}
+
+		public class RawIterator : IDisposable {
+			SKPath Path => path;
+			SKPath path;
+			IntPtr handle;
+
+			internal RawIterator (SKPath path, IntPtr handle)
+			{
+				this.path = path;
+				this.handle = handle;
+			}
+
+			~RawIterator ()
+			{
+				Dispose (false);
+			}
+
+			void Dispose (bool disposing)
+			{
+				if (handle != IntPtr.Zero){
+					// safe to call from a background thread to release resources.
+					SkiaApi.sk_path_rawiter_destroy (handle);
+					handle = IntPtr.Zero;
+				}
+			}
+			
+			public void Dispose ()
+			{
+				Dispose (true);
+				GC.SuppressFinalize (this);
+			}
+
+			public Verb Next (SKPoint [] points)
+			{
+				if (points == null)
+					throw new ArgumentNullException (nameof (points));
+				if (points.Length != 4)
+					throw new ArgumentException ("Must be an array of four elements", nameof (points));
+				return SkiaApi.sk_path_rawiter_next (handle, points);
+			}
+
+			public float ConicWeight () => SkiaApi.sk_path_rawiter_conic_weight (handle);
+			public Verb Peek () => SkiaApi.sk_path_rawiter_peek (handle);
+		}
 	}
 }
 

binding/Binding/SKPathEffect.cs

@@ -0,0 +1,84 @@
+//
+// Bindings for SKPath
+//
+// Author:
+//   Matthew Leibowitz
+//
+// Copyright 2016 Xamarin Inc
+//
+using System;
+
+namespace SkiaSharp
+{
+	public enum SkPath1DPathEffectStyle
+	{
+		Translate,
+		Rotate,
+		Morph,
+	}
+
+	public class SKPathEffect : SKObject
+	{
+		[Preserve]
+		internal SKPathEffect (IntPtr handle)
+			: base (handle)
+		{
+		}
+
+		public static SKPathEffect CreateCompose(SKPathEffect outer, SKPathEffect inner)
+		{
+			if (outer == null)
+				throw new ArgumentNullException(nameof(outer));
+			if (inner == null)
+				throw new ArgumentNullException(nameof(inner));
+			return GetObject<SKPathEffect>(SkiaApi.sk_path_effect_create_compose(outer.Handle, inner.Handle));
+		}
+
+		public static SKPathEffect CreateSum(SKPathEffect first, SKPathEffect second)
+		{
+			if (first == null)
+				throw new ArgumentNullException(nameof(first));
+			if (second == null)
+				throw new ArgumentNullException(nameof(second));
+			return GetObject<SKPathEffect>(SkiaApi.sk_path_effect_create_sum(first.Handle, second.Handle));
+		}
+
+		public static SKPathEffect CreateDiscrete(float segLength, float deviation, UInt32 seedAssist = 0)
+		{
+			return GetObject<SKPathEffect>(SkiaApi.sk_path_effect_create_discrete(segLength, deviation, seedAssist));
+		}
+
+		public static SKPathEffect CreateCorner(float radius)
+		{
+			return GetObject<SKPathEffect>(SkiaApi.sk_path_effect_create_corner(radius));
+		}
+
+		public static SKPathEffect Create1DPath(SKPath path, float advance, float phase, SkPath1DPathEffectStyle style)
+		{
+			if (path == null)
+				throw new ArgumentNullException(nameof(path));
+			return GetObject<SKPathEffect>(SkiaApi.sk_path_effect_create_1d_path(path.Handle, advance, phase, style));
+		}
+
+		public static SKPathEffect Create2DLine(float width, SKMatrix matrix)
+		{
+			return GetObject<SKPathEffect>(SkiaApi.sk_path_effect_create_2d_line(width, matrix));
+		}
+
+		public static SKPathEffect Create2DPath(SKMatrix matrix, SKPath path)
+		{
+			if (path == null)
+				throw new ArgumentNullException(nameof(path));
+			return GetObject<SKPathEffect>(SkiaApi.sk_path_effect_create_2d_path(matrix, path.Handle));
+		}
+
+		public static SKPathEffect CreateDash(float[] intervals, float phase)
+		{
+			if (intervals == null)
+				throw new ArgumentNullException(nameof(intervals));
+			return GetObject<SKPathEffect>(SkiaApi.sk_path_effect_create_dash(intervals, intervals.Length, phase));
+		}
+
+	}
+}
+

binding/Binding/SKTypeface.cs

@@ -107,7 +107,7 @@ namespace SkiaSharp
 				glyphs = new ushort[n];
 
 				fixed (ushort *gp = &glyphs [0]){
-					return SkiaApi.sk_typeface_chars_to_glyphs (Handle, str, SKEncoding.Utf16, (IntPtr) gp, n);
+					return SkiaApi.sk_typeface_chars_to_glyphs (Handle, str, encoding, (IntPtr) gp, n);
 				}
 			}
 		}

binding/Binding/SkiaApi.cs

@@ -38,25 +38,27 @@ using sk_imagefilter_t = System.IntPtr;
 using sk_colorfilter_t = System.IntPtr;
 using sk_document_t = System.IntPtr;
 using sk_colorspace_t = System.IntPtr;
+using sk_path_iterator_t = System.IntPtr;
+using sk_path_effect_t = System.IntPtr;
 
 namespace SkiaSharp
 {
 	internal static class SkiaApi
 	{
 #if __TVOS__ && __UNIFIED__
-		const string SKIA = "@rpath/libSkiaSharp.framework/libSkiaSharp";
+		public const string SKIA = "@rpath/libSkiaSharp.framework/libSkiaSharp";
 #elif __IOS__ && __UNIFIED__
-		const string SKIA = "@rpath/libSkiaSharp.framework/libSkiaSharp";
+		public const string SKIA = "@rpath/libSkiaSharp.framework/libSkiaSharp";
 #elif __ANDROID__
-		const string SKIA = "libSkiaSharp.so";
+		public const string SKIA = "libSkiaSharp.so";
 #elif XAMARIN_MAC
-		const string SKIA = "libSkiaSharp.dylib";
+		public const string SKIA = "libSkiaSharp.dylib";
 #elif DESKTOP
-		const string SKIA = "libSkiaSharp.dll"; // redirected using .dll.config to 'libSkiaSharp.dylib' on OS X
+		public const string SKIA = "libSkiaSharp.dll"; // redirected using .dll.config to 'libSkiaSharp.dylib' on OS X
 #elif WINDOWS_UWP
-		const string SKIA = "libSkiaSharp.dll";
+		public const string SKIA = "libSkiaSharp.dll";
 #else
-		const string SKIA = "libSkiaSharp";
+		public const string SKIA = "libSkiaSharp";
 #endif
 
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
@@ -111,6 +113,8 @@ namespace SkiaSharp
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static void sk_canvas_draw_oval(sk_canvas_t t, ref SKRect rect, sk_paint_t paint);
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_canvas_draw_circle(sk_canvas_t t, float cx, float cy, float radius, sk_paint_t paint);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static void sk_canvas_draw_path(sk_canvas_t t, sk_path_t path, sk_paint_t paint);
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static void sk_canvas_draw_image(sk_canvas_t t, sk_image_t image, float x, float y, sk_paint_t paint);
@@ -284,6 +288,11 @@ namespace SkiaSharp
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static float sk_paint_get_fontmetrics(sk_paint_t t, out SKFontMetrics fontMetrics, float scale);
 
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_effect_t sk_paint_get_path_effect(sk_paint_t cpaint);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_paint_set_path_effect(sk_paint_t cpaint, sk_path_effect_t effect);
+
 
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static sk_image_t sk_image_new_raster_copy(ref SKImageInfo info, IntPtr pixels, IntPtr rowBytes);
@@ -332,6 +341,10 @@ namespace SkiaSharp
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static void sk_path_close(sk_path_t t);
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_path_rewind(sk_path_t t);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_path_reset(sk_path_t t);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static void sk_path_add_rect(sk_path_t t, ref SKRect rect, SKPathDirection direction);
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static void sk_path_add_rect_start(sk_path_t t, ref SKRect rect, SKPathDirection direction, uint startIndex);
@@ -340,6 +353,14 @@ namespace SkiaSharp
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static void sk_path_add_arc(sk_path_t t, ref SKRect rect, float startAngle, float sweepAngle);
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_path_add_path_offset (sk_path_t t, sk_path_t other, float dx, float dy, SKPath.AddMode mode);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_path_add_path_matrix (sk_path_t t, sk_path_t other, ref SKMatrix matrix, SKPath.AddMode mode);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_path_add_path (sk_path_t t, sk_path_t other, SKPath.AddMode mode);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_path_add_path_reverse (sk_path_t t, sk_path_t other);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static bool sk_path_get_bounds(sk_path_t t, out SKRect rect);
 		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static SKPathFillType sk_path_get_filltype (sk_path_t t);
@@ -350,6 +371,32 @@ namespace SkiaSharp
 		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static sk_path_t sk_path_transform (sk_path_t t, ref SKMatrix matrix);
 
+		// iterator
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_iterator_t sk_path_create_iter (sk_path_t path, int forceClose);
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static SKPath.Verb sk_path_iter_next (sk_path_iterator_t iterator, [Out] SKPoint [] points, int doConsumeDegenerates, int exact);
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static float sk_path_iter_conic_weight (sk_path_iterator_t iterator);
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static int sk_path_iter_is_close_line (sk_path_iterator_t iterator);
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static int sk_path_iter_is_close_countour (sk_path_iterator_t iterator);
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_path_iter_destroy (sk_path_t path);
+
+		// Raw iterator
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_iterator_t sk_path_create_rawiter (sk_path_t path);
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static SKPath.Verb sk_path_rawiter_next (sk_path_iterator_t iterator, [Out] SKPoint [] points);
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static SKPath.Verb sk_path_rawiter_peek (sk_path_iterator_t iterator);
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static float sk_path_rawiter_conic_weight (sk_path_iterator_t iterator);
+		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static void sk_path_rawiter_destroy (sk_path_t path);
+							       
 		// SkMaskFilter
 		[DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static void sk_maskfilter_unref(sk_maskfilter_t t);
@@ -788,6 +835,26 @@ namespace SkiaSharp
 		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
 		public extern static bool sk_bitmap_try_alloc_pixels(sk_bitmap_t cbitmap, ref SKImageInfo requestedInfo, IntPtr rowBytes);
 
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static int sk_matrix_try_invert(ref SKMatrix matrix, out SKMatrix result);
+
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_effect_t sk_path_effect_create_compose(sk_path_effect_t outer, sk_path_effect_t inner);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_effect_t sk_path_effect_create_sum(sk_path_effect_t first, sk_path_effect_t second);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_effect_t sk_path_effect_create_discrete(float segLength, float deviation, UInt32 seedAssist /*0*/);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_effect_t sk_path_effect_create_corner(float radius);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_effect_t sk_path_effect_create_1d_path(sk_path_t path, float advance, float phase, SkPath1DPathEffectStyle style);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_effect_t sk_path_effect_create_2d_line(float width, SKMatrix matrix);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_effect_t sk_path_effect_create_2d_path(SKMatrix matrix, sk_path_t path);
+		[DllImport(SKIA, CallingConvention = CallingConvention.Cdecl)]
+		public extern static sk_path_effect_t sk_path_effect_create_dash(float[] intervals, int count, float phase);
+
 	}
 }
 

docs/en/SkiaSharp/SKBitmap.xml

@@ -135,7 +135,8 @@
       <Docs>
         <summary>Returns the configured alpha type for the bitmap.</summary>
         <value>
-          <para />
+          <para>
+          </para>
         </value>
         <remarks>This determines the kind of encoding used for the alpha channel, opaque, premultiplied or unpremultiplied.</remarks>
       </Docs>

docs/en/SkiaSharp/SKCanvas.xml

@@ -306,6 +306,31 @@
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
+    <Member MemberName="DrawCircle">
+      <MemberSignature Language="C#" Value="public void DrawCircle (float cx, float cy, float radius, SkiaSharp.SKPaint paint);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void DrawCircle(float32 cx, float32 cy, float32 radius, class SkiaSharp.SKPaint paint) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="cx" Type="System.Single" />
+        <Parameter Name="cy" Type="System.Single" />
+        <Parameter Name="radius" Type="System.Single" />
+        <Parameter Name="paint" Type="SkiaSharp.SKPaint" />
+      </Parameters>
+      <Docs>
+        <param name="cx">Center X coordinate.</param>
+        <param name="cy">Center Y coordinate.</param>
+        <param name="radius">Radius for the circle.</param>
+        <param name="paint">The paint used to draw the bitmap.</param>
+        <summary>Draws a circle on the canvas.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="DrawColor">
       <MemberSignature Language="C#" Value="public void DrawColor (SkiaSharp.SKColor color, SkiaSharp.SKXferMode mode = SkiaSharp.SKXferMode.Src);" />
       <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void DrawColor(valuetype SkiaSharp.SKColor color, valuetype SkiaSharp.SKXferMode mode) cil managed" />

docs/en/SkiaSharp/SKImage.xml

@@ -85,7 +85,8 @@
         <summary>Encodes an image, multiple file formats supported</summary>
         <returns>SKData wrapping the encoded image as a PNG.</returns>
         <remarks>
-          <para />
+          <para>
+          </para>
         </remarks>
       </Docs>
     </Member>

docs/en/SkiaSharp/SKMatrix.xml

@@ -14,11 +14,35 @@
     <summary>2D Transformation matrix with perspective.</summary>
     <remarks>
       <para>The SKMatrix is a full 3x3 matrix.</para>
-      <para />
+      <para>
+      </para>
       <para>It extends the traditional 2D affine transformation matrix with three perspective components that allow simple 3D effects to be created with it.   Those components must be manually set by using the <see cref="P:SkiaSharp.SKMatrix.Persp0" />, <see cref="P:SkiaSharp.SKMatrix.Persp1" />, <see cref="P:SkiaSharp.SKMatrix.Persp2" /> fields of the matrix.</para>
     </remarks>
   </Docs>
   <Members>
+    <Member MemberName="Concat">
+      <MemberSignature Language="C#" Value="public static void Concat (ref SkiaSharp.SKMatrix target, ref SkiaSharp.SKMatrix first, ref SkiaSharp.SKMatrix second);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig pinvokeimpl (&quot;libSkiaSharp&quot; as &quot;sk_matrix_concat&quot; cdecl)void Concat(valuetype SkiaSharp.SKMatrix target, valuetype SkiaSharp.SKMatrix first, valuetype SkiaSharp.SKMatrix second) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="target" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+        <Parameter Name="first" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+        <Parameter Name="second" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+      </Parameters>
+      <Docs>
+        <param name="target">The result matrix value.</param>
+        <param name="first">The first matrix to concatenate.</param>
+        <param name="second">The second matrix to concatenate.</param>
+        <summary>Concatenates the specified matrices into the resulting target matrix.   </summary>
+        <remarks>Either source matrices can also be the target matrix.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="MakeIdentity">
       <MemberSignature Language="C#" Value="public static SkiaSharp.SKMatrix MakeIdentity ();" />
       <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype SkiaSharp.SKMatrix MakeIdentity() cil managed" />
@@ -52,12 +76,87 @@
         <Parameter Name="radians" Type="System.Single" />
       </Parameters>
       <Docs>
-        <param name="radians">To be added.</param>
+        <param name="radians">The angle for the rotation, in radians.</param>
         <summary>Creates a rotation matrix</summary>
         <returns>To be added.</returns>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
+    <Member MemberName="MakeRotation">
+      <MemberSignature Language="C#" Value="public static SkiaSharp.SKMatrix MakeRotation (float radians, float pivotx, float pivoty);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype SkiaSharp.SKMatrix MakeRotation(float32 radians, float32 pivotx, float32 pivoty) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKMatrix</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="radians" Type="System.Single" />
+        <Parameter Name="pivotx" Type="System.Single" />
+        <Parameter Name="pivoty" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="radians">The angle for the rotation, in radians.</param>
+        <param name="pivotx">The X coordiate for the rotation pivot.</param>
+        <param name="pivoty">The Y coordiate for the rotation pivot.</param>
+        <summary>Creates an <see cref="T:SkiaSharp.SKMatrix" /> that represents a specific rotation in radians with a specific pivot point.</summary>
+        <returns>Returns a new matrix with the specific rotation at the pivot point.</returns>
+        <remarks>
+          <para>
+          </para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MakeRotationDegrees">
+      <MemberSignature Language="C#" Value="public static SkiaSharp.SKMatrix MakeRotationDegrees (float degrees);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype SkiaSharp.SKMatrix MakeRotationDegrees(float32 degrees) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKMatrix</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="degrees" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="degrees">
+          <para>The angle for the rotation, in degrees.</para>
+          <para>
+          </para>
+        </param>
+        <summary>Creates an <see cref="T:SkiaSharp.SKMatrix" /> that represents a specific rotation in degrees.</summary>
+        <returns>Returns a new matrix with the specific rotation in degrees.</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MakeRotationDegrees">
+      <MemberSignature Language="C#" Value="public static SkiaSharp.SKMatrix MakeRotationDegrees (float degrees, float pivotx, float pivoty);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype SkiaSharp.SKMatrix MakeRotationDegrees(float32 degrees, float32 pivotx, float32 pivoty) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKMatrix</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="degrees" Type="System.Single" />
+        <Parameter Name="pivotx" Type="System.Single" />
+        <Parameter Name="pivoty" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="degrees">The angle for the rotation, in degrees.</param>
+        <param name="pivotx">The X coordiate for the rotation pivot.</param>
+        <param name="pivoty">The Y coordiate for the rotation pivot.</param>
+        <summary>Creates an <see cref="T:SkiaSharp.SKMatrix" /> that represents a specific rotation in degrees.</summary>
+        <returns>To be added.</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="MakeScale">
       <MemberSignature Language="C#" Value="public static SkiaSharp.SKMatrix MakeScale (float sx, float sy);" />
       <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype SkiaSharp.SKMatrix MakeScale(float32 sx, float32 sy) cil managed" />
@@ -74,10 +173,10 @@
         <Parameter Name="sy" Type="System.Single" />
       </Parameters>
       <Docs>
-        <param name="sx">To be added.</param>
-        <param name="sy">To be added.</param>
+        <param name="sx">Scale X component.</param>
+        <param name="sy">Scale Y component.</param>
         <summary>Creates a scaling matrix.</summary>
-        <returns>To be added.</returns>
+        <returns>Returns a new matrix with the specific scale factor.</returns>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
@@ -99,12 +198,12 @@
         <Parameter Name="pivotY" Type="System.Single" />
       </Parameters>
       <Docs>
-        <param name="sx">To be added.</param>
-        <param name="sy">To be added.</param>
-        <param name="pivotX">To be added.</param>
-        <param name="pivotY">To be added.</param>
+        <param name="sx">Scale X component.</param>
+        <param name="sy">Scale Y component.</param>
+        <param name="pivotX">The X coordiate for the rotation pivot.</param>
+        <param name="pivotY">The Y coordiate for the rotation pivot.</param>
         <summary>Creates a scaling matrix with a pivot point.</summary>
-        <returns>To be added.</returns>
+        <returns>Returns a new matrix with the specific scale factor at the pivot point.</returns>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
@@ -124,10 +223,10 @@
         <Parameter Name="sy" Type="System.Single" />
       </Parameters>
       <Docs>
-        <param name="sx">To be added.</param>
-        <param name="sy">To be added.</param>
+        <param name="sx">Skew X component.</param>
+        <param name="sy">Skew Y component.</param>
         <summary>Creates a skewing matrix.</summary>
-        <returns>To be added.</returns>
+        <returns>Returns a new matrix with the specific skewing factor.</returns>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
@@ -147,10 +246,189 @@
         <Parameter Name="dy" Type="System.Single" />
       </Parameters>
       <Docs>
-        <param name="dx">To be added.</param>
-        <param name="dy">To be added.</param>
+        <param name="dx">The X offset for the translation.</param>
+        <param name="dy">The Y offset for the translation.</param>
         <summary>Creates a translation matrix.</summary>
-        <returns>To be added.</returns>
+        <returns>Returns a new matrix with the specific translation factor.</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MapPoints">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKPoint[] MapPoints (SkiaSharp.SKPoint[] points);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance valuetype SkiaSharp.SKPoint[] MapPoints(valuetype SkiaSharp.SKPoint[] points) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPoint[]</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="points" Type="SkiaSharp.SKPoint[]" />
+      </Parameters>
+      <Docs>
+        <param name="points">An array of points that you want to map.</param>
+        <summary>
+          <para>Apply the to the array of points and return the mapped results.</para>
+        </summary>
+        <returns>New array allocated with the mapped results.</returns>
+        <remarks>
+          <para>Mapping points uses all components of the matrix.   If you want to ignore the translation, use MapVectors.</para>
+          <para>
+          </para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MapPoints">
+      <MemberSignature Language="C#" Value="public void MapPoints (SkiaSharp.SKPoint[] result, SkiaSharp.SKPoint[] points);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void MapPoints(valuetype SkiaSharp.SKPoint[] result, valuetype SkiaSharp.SKPoint[] points) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="result" Type="SkiaSharp.SKPoint[]" />
+        <Parameter Name="points" Type="SkiaSharp.SKPoint[]" />
+      </Parameters>
+      <Docs>
+        <param name="result">Array where the mapped results will be stored, the array needs to have the same number of elements of the <paramref name="points" /> array.</param>
+        <param name="points">Source array with the points to convert.</param>
+        <summary>Apply the to the array of points and return the mapped results.</summary>
+        <remarks>
+          <para>Mapping points uses all components of the matrix.   If you want to ignore the translation, use MapVectors.</para>
+          <para>
+          </para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MapRadius">
+      <MemberSignature Language="C#" Value="public float MapRadius (float radius);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance float32 MapRadius(float32 radius) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Single</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="radius" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="radius">Radius to map.</param>
+        <summary>
+          <para>Return the mean radius of a circle after it has been mapped by this matrix</para>
+        </summary>
+        <returns>Return the mean radius of a circle after it has been mapped by this matrix</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MapRect">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKRect MapRect (SkiaSharp.SKRect source);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance valuetype SkiaSharp.SKRect MapRect(valuetype SkiaSharp.SKRect source) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKRect</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="source" Type="SkiaSharp.SKRect" />
+      </Parameters>
+      <Docs>
+        <param name="source">Source recatngle to map.</param>
+        <summary>Apply the matrix to the source rectangle and return the mapped rectangle.</summary>
+        <returns>The rectangle with the matrix.</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MapVector">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKPoint MapVector (float x, float y);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance valuetype SkiaSharp.SKPoint MapVector(float32 x, float32 y) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPoint</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="x" Type="System.Single" />
+        <Parameter Name="y" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="x">X component of the vector.</param>
+        <param name="y">Y component of the vector.</param>
+        <summary>Applies the matrix to a vector.</summary>
+        <returns>Returns the mapped point.</returns>
+        <remarks>Mapping vectors ignores the translation component in the matrix.   If you want to take the translation into consideration, use MapXY.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MapVectors">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKPoint[] MapVectors (SkiaSharp.SKPoint[] vectors);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance valuetype SkiaSharp.SKPoint[] MapVectors(valuetype SkiaSharp.SKPoint[] vectors) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPoint[]</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="points" Type="SkiaSharp.SKPoint[]" />
+      </Parameters>
+      <Docs>
+        <param name="vectors">An array of vectors that you want to map.</param>
+        <summary>Apply the to the array of vectors and return the mapped results..</summary>
+        <returns>New array allocated with the mapped results.</returns>
+        <remarks>Mapping vectors ignores the translation component in the matrix.   If you want to take the translation into consideration, use MapPoints.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MapVectors">
+      <MemberSignature Language="C#" Value="public void MapVectors (SkiaSharp.SKPoint[] result, SkiaSharp.SKPoint[] vectors);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void MapVectors(valuetype SkiaSharp.SKPoint[] result, valuetype SkiaSharp.SKPoint[] vectors) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="result" Type="SkiaSharp.SKPoint[]" />
+        <Parameter Name="points" Type="SkiaSharp.SKPoint[]" />
+      </Parameters>
+      <Docs>
+        <param name="result">Array where the mapped results will be stored, the array needs to have the same number of elements of the <paramref name="vectors" /> array.</param>
+        <param name="vectors">To be added.</param>
+        <param name="points">An array of vectors that you want to map.</param>
+        <summary>Apply the to the array of vectors and return the mapped results..</summary>
+        <remarks>Mapping vectors ignores the translation component in the matrix.   If you want to take the translation into consideration, use MapPoints.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="MapXY">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKPoint MapXY (float x, float y);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance valuetype SkiaSharp.SKPoint MapXY(float32 x, float32 y) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPoint</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="x" Type="System.Single" />
+        <Parameter Name="y" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="x">X coordinate.</param>
+        <param name="y">Y coordinate.</param>
+        <summary>Applies the matrix to a point.</summary>
+        <returns>Returns the mapped point.</returns>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
@@ -202,6 +480,140 @@
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
+    <Member MemberName="PostConcat">
+      <MemberSignature Language="C#" Value="public static void PostConcat (ref SkiaSharp.SKMatrix target, ref SkiaSharp.SKMatrix matrix);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig pinvokeimpl (&quot;libSkiaSharp&quot; as &quot;sk_matrix_post_concat&quot; cdecl)void PostConcat(valuetype SkiaSharp.SKMatrix target, valuetype SkiaSharp.SKMatrix matrix) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="target" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+        <Parameter Name="matrix" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+      </Parameters>
+      <Docs>
+        <param name="target">Target matrix.</param>
+        <param name="matrix">The matrix to be post-concatenated.</param>
+        <summary>Post-concatenates the matrix to the target matrix</summary>
+        <remarks>This represents newTarget = matrix * target</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="PreConcat">
+      <MemberSignature Language="C#" Value="public static void PreConcat (ref SkiaSharp.SKMatrix target, ref SkiaSharp.SKMatrix matrix);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig pinvokeimpl (&quot;libSkiaSharp&quot; as &quot;sk_matrix_pre_concat&quot; cdecl)void PreConcat(valuetype SkiaSharp.SKMatrix target, valuetype SkiaSharp.SKMatrix matrix) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="target" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+        <Parameter Name="matrix" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+      </Parameters>
+      <Docs>
+        <param name="target">Target matrix.</param>
+        <param name="matrix">The matrix to be post-concatenated.</param>
+        <summary>Pre-concatenates the matrix to the target matrix</summary>
+        <remarks>This represents newTarget = target * matrix</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Rotate">
+      <MemberSignature Language="C#" Value="public static void Rotate (ref SkiaSharp.SKMatrix matrix, float radians);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void Rotate(valuetype SkiaSharp.SKMatrix matrix, float32 radians) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="matrix" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+        <Parameter Name="radians" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="matrix">Target matrix.</param>
+        <param name="radians">The angle for the rotation, in radians.</param>
+        <summary>Rotates the spefixied matrix by the specified radians.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Rotate">
+      <MemberSignature Language="C#" Value="public static void Rotate (ref SkiaSharp.SKMatrix matrix, float radians, float pivotx, float pivoty);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void Rotate(valuetype SkiaSharp.SKMatrix matrix, float32 radians, float32 pivotx, float32 pivoty) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="matrix" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+        <Parameter Name="radians" Type="System.Single" />
+        <Parameter Name="pivotx" Type="System.Single" />
+        <Parameter Name="pivoty" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="matrix">Target matrix.</param>
+        <param name="radians">The angle for the rotation, in radians.</param>
+        <param name="pivotx">The X coordiate for the rotation pivot.</param>
+        <param name="pivoty">The Y coordiate for the rotation pivot.</param>
+        <summary>Rotates the spefixied matrix by the specified radians.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="RotateDegrees">
+      <MemberSignature Language="C#" Value="public static void RotateDegrees (ref SkiaSharp.SKMatrix matrix, float degrees);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void RotateDegrees(valuetype SkiaSharp.SKMatrix matrix, float32 degrees) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="matrix" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+        <Parameter Name="degrees" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="matrix">Target matrix.</param>
+        <param name="degrees">The angle for the rotation, in degrees.</param>
+        <summary>Rotates the spefixied matrix by the specified degrees.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="RotateDegrees">
+      <MemberSignature Language="C#" Value="public static void RotateDegrees (ref SkiaSharp.SKMatrix matrix, float degrees, float pivotx, float pivoty);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void RotateDegrees(valuetype SkiaSharp.SKMatrix matrix, float32 degrees, float32 pivotx, float32 pivoty) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="matrix" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+        <Parameter Name="degrees" Type="System.Single" />
+        <Parameter Name="pivotx" Type="System.Single" />
+        <Parameter Name="pivoty" Type="System.Single" />
+      </Parameters>
+      <Docs>
+        <param name="matrix">Target matrix.</param>
+        <param name="degrees">The angle for the rotation, in degrees.</param>
+        <param name="pivotx">The X coordiate for the rotation pivot.</param>
+        <param name="pivoty">The Y coordiate for the rotation pivot.</param>
+        <summary>Rotates the spefixied matrix by the specified degrees.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="ScaleX">
       <MemberSignature Language="C#" Value="public float ScaleX;" />
       <MemberSignature Language="ILAsm" Value=".field public float32 ScaleX" />
@@ -214,7 +626,7 @@
         <ReturnType>System.Single</ReturnType>
       </ReturnValue>
       <Docs>
-        <summary>To be added.</summary>
+        <summary>The ScaleX component of the SKMatrix.</summary>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
@@ -230,7 +642,7 @@
         <ReturnType>System.Single</ReturnType>
       </ReturnValue>
       <Docs>
-        <summary>To be added.</summary>
+        <summary>The ScaleY component of the SKMatrix.</summary>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
@@ -272,7 +684,7 @@
         <ReturnType>System.Single</ReturnType>
       </ReturnValue>
       <Docs>
-        <summary>To be added.</summary>
+        <summary>The SkewX component of the SKMatrix.</summary>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
@@ -288,7 +700,7 @@
         <ReturnType>System.Single</ReturnType>
       </ReturnValue>
       <Docs>
-        <summary>To be added.</summary>
+        <summary>The SkewY component of the SKMatrix.</summary>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
@@ -304,7 +716,7 @@
         <ReturnType>System.Single</ReturnType>
       </ReturnValue>
       <Docs>
-        <summary>To be added.</summary>
+        <summary>The TransX component of the SKMatrix.</summary>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
@@ -320,7 +732,27 @@
         <ReturnType>System.Single</ReturnType>
       </ReturnValue>
       <Docs>
-        <summary>To be added.</summary>
+        <summary>The TransY component of the SKMatrix.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="TryInvert">
+      <MemberSignature Language="C#" Value="public bool TryInvert (out SkiaSharp.SKMatrix inverse);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance bool TryInvert(valuetype SkiaSharp.SKMatrix inverse) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Boolean</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="inverse" Type="SkiaSharp.SKMatrix&amp;" RefType="out" />
+      </Parameters>
+      <Docs>
+        <param name="inverse">The destination value to store the inverted matrix if the matrix can be inverted.</param>
+        <summary>Attempts to invert the matrix, if possible the inverse matrix contains the result.</summary>
+        <returns>True if the matrix can be inverted, and the inverse parameter is initialized with the inverted matrix, false otherwise.</returns>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>

docs/en/SkiaSharp/SKPath+AddMode.xml

@@ -0,0 +1,51 @@
+<Type Name="SKPath+AddMode" FullName="SkiaSharp.SKPath+AddMode">
+  <TypeSignature Language="C#" Value="public enum SKPath.AddMode" />
+  <TypeSignature Language="ILAsm" Value=".class nested public auto ansi sealed SKPath/AddMode extends System.Enum" />
+  <AssemblyInfo>
+    <AssemblyName>SkiaSharp</AssemblyName>
+    <AssemblyVersion>1.49.0.0</AssemblyVersion>
+  </AssemblyInfo>
+  <Base>
+    <BaseTypeName>System.Enum</BaseTypeName>
+  </Base>
+  <Docs>
+    <summary>Controls how a path is added to another path.</summary>
+    <remarks>
+      <para />
+    </remarks>
+  </Docs>
+  <Members>
+    <Member MemberName="Append">
+      <MemberSignature Language="C#" Value="Append" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype SkiaSharp.SKPath/AddMode Append = int32(0)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+AddMode</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>Source path contours are added as new contours.</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="Extend">
+      <MemberSignature Language="C#" Value="Extend" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype SkiaSharp.SKPath/AddMode Extend = int32(1)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+AddMode</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>
+          <para>Path is added by extending the last contour of the destination path with the first contour of the source path. If the last contour of the destination path is closed, then it will not be extended.</para>
+          <para />
+          <para>Instead, the start of source path will be extended by a straight line to the end point of the destination path.</para>
+        </summary>
+      </Docs>
+    </Member>
+  </Members>
+</Type>

docs/en/SkiaSharp/SKPath+Iterator.xml

@@ -0,0 +1,147 @@
+<Type Name="SKPath+Iterator" FullName="SkiaSharp.SKPath+Iterator">
+  <TypeSignature Language="C#" Value="public class SKPath.Iterator : IDisposable" />
+  <TypeSignature Language="ILAsm" Value=".class nested public auto ansi beforefieldinit SKPath/Iterator extends System.Object implements class System.IDisposable" />
+  <AssemblyInfo>
+    <AssemblyName>SkiaSharp</AssemblyName>
+    <AssemblyVersion>1.49.0.0</AssemblyVersion>
+  </AssemblyInfo>
+  <Base>
+    <BaseTypeName>System.Object</BaseTypeName>
+  </Base>
+  <Interfaces>
+    <Interface>
+      <InterfaceName>System.IDisposable</InterfaceName>
+    </Interface>
+  </Interfaces>
+  <Docs>
+    <summary>Iterator object to scan the all of the segments (lines, quadratics, cubics) of each contours in a path.   </summary>
+    <remarks>Iterators are created by calling the <see cref="M:SkiaSharp.SKPath.CreateIterator" /> method.</remarks>
+  </Docs>
+  <Members>
+    <Member MemberName="ConicWeight">
+      <MemberSignature Language="C#" Value="public float ConicWeight ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance float32 ConicWeight() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Single</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>
+          <para>Return the weight for the current conic. Only valid if the current segment return by <see cref="M:SkiaSharp.SKPath+Iterator.Next" /> was a conic.</para>
+        </summary>
+        <returns>
+          <para></para>
+        </returns>
+        <remarks>
+          <para></para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Dispose">
+      <MemberSignature Language="C#" Value="public void Dispose ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void Dispose() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>Releases the iterator.</summary>
+        <remarks>
+          <para />
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Finalize">
+      <MemberSignature Language="C#" Value="~Iterator ();" />
+      <MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance void Finalize() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>To be added.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="IsCloseContour">
+      <MemberSignature Language="C#" Value="public bool IsCloseContour ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance bool IsCloseContour() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Boolean</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>Returns true if the current contour is closed (has a <see cref="E:SkiaSharp.SKPath+Verb.Close" />).</summary>
+        <returns>
+          <para />
+        </returns>
+        <remarks>
+          <para />
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="IsCloseLine">
+      <MemberSignature Language="C#" Value="public bool IsCloseLine ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance bool IsCloseLine() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Boolean</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>If the last call to <see cref="M:SkiaSharp.SKPath+Iterator.Next" /> returns a line, returns true if the line was the result of a <see cref="M:SkiaSharp.SKPath.Close()" /> command.</summary>
+        <returns>If the last call to <see cref="M:SkiaSharp.SKPath+Iterator.Next" /> returns a line, returns true if the line was the result of a <see cref="M:SkiaSharp.SKPath.Close()" /> command.</returns>
+        <remarks>If the call to Next returned a different value than Line, the result is undefined.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Next">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKPath.Verb Next (SkiaSharp.SKPoint[] points, bool doConsumeDegenerates = true, bool exact = false);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance valuetype SkiaSharp.SKPath/Verb Next(valuetype SkiaSharp.SKPoint[] points, bool doConsumeDegenerates, bool exact) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="points" Type="SkiaSharp.SKPoint[]" />
+        <Parameter Name="doConsumeDegenerates" Type="System.Boolean" />
+        <Parameter Name="exact" Type="System.Boolean" />
+      </Parameters>
+      <Docs>
+        <param name="points">Outgoing parameter, should be an array of four points, on return this contains points representing the current verb and/or segment.</param>
+        <param name="doConsumeDegenerates">
+          <para>If <see langword="true" />, first scan for segments that are deemed degenerate (too short) and skip those.</para>
+        </param>
+        <param name="exact">
+          <para>if <paramref name="doConsumeDegenerates" /> is <see langword="true" /> and exact is true, skip only degenerate elements with lengths exactly equal to zero. If exact is <see langword="false" />, skip degenerate elements with lengths close to zero. If <paramref name="doConsumeDegenerates" /> is <see langword="false" />, exact has no effect.</para>
+        </param>
+        <summary>Return the next verb in this iteration of the path.</summary>
+        <returns>The verb of the current segment.</returns>
+        <remarks>
+          <para>When all segments have been visited, returns Verb.Done</para>
+        </remarks>
+      </Docs>
+    </Member>
+  </Members>
+</Type>

docs/en/SkiaSharp/SKPath+RawIterator.xml

@@ -0,0 +1,116 @@
+<Type Name="SKPath+RawIterator" FullName="SkiaSharp.SKPath+RawIterator">
+  <TypeSignature Language="C#" Value="public class SKPath.RawIterator : IDisposable" />
+  <TypeSignature Language="ILAsm" Value=".class nested public auto ansi beforefieldinit SKPath/RawIterator extends System.Object implements class System.IDisposable" />
+  <AssemblyInfo>
+    <AssemblyName>SkiaSharp</AssemblyName>
+    <AssemblyVersion>1.49.0.0</AssemblyVersion>
+  </AssemblyInfo>
+  <Base>
+    <BaseTypeName>System.Object</BaseTypeName>
+  </Base>
+  <Interfaces>
+    <Interface>
+      <InterfaceName>System.IDisposable</InterfaceName>
+    </Interface>
+  </Interfaces>
+  <Docs>
+    <summary>To be added.</summary>
+    <remarks>To be added.</remarks>
+  </Docs>
+  <Members>
+    <Member MemberName="ConicWeight">
+      <MemberSignature Language="C#" Value="public float ConicWeight ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance float32 ConicWeight() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Single</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>Return the weight for the current conic. Only valid if the current segment return by <see cref="M:SkiaSharp.SKPath+Iterator.Next" /> was a conic.</summary>
+        <returns>
+          <para />
+        </returns>
+        <remarks>
+          <para />
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Dispose">
+      <MemberSignature Language="C#" Value="public void Dispose ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void Dispose() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>Releases the iterator.</summary>
+        <remarks>
+          <para />
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Finalize">
+      <MemberSignature Language="C#" Value="~RawIterator ();" />
+      <MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance void Finalize() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>To be added.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Next">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKPath.Verb Next (SkiaSharp.SKPoint[] points);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance valuetype SkiaSharp.SKPath/Verb Next(valuetype SkiaSharp.SKPoint[] points) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="points" Type="SkiaSharp.SKPoint[]" />
+      </Parameters>
+      <Docs>
+        <param name="points">Outgoing parameter, should be an array of four points, on return this contains points representing the current verb and/or segment.</param>
+        <summary>Return the next verb in this iteration of the path.</summary>
+        <returns>The verb of the current segment.</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Peek">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKPath.Verb Peek ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance valuetype SkiaSharp.SKPath/Verb Peek() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>Return what the next verb will be, but do not visit the next segment.</summary>
+        <returns>The verb for the next segment</returns>
+        <remarks>
+          <para />
+        </remarks>
+      </Docs>
+    </Member>
+  </Members>
+</Type>

docs/en/SkiaSharp/SKPath+Verb.xml

@@ -0,0 +1,115 @@
+<Type Name="SKPath+Verb" FullName="SkiaSharp.SKPath+Verb">
+  <TypeSignature Language="C#" Value="public enum SKPath.Verb" />
+  <TypeSignature Language="ILAsm" Value=".class nested public auto ansi sealed SKPath/Verb extends System.Enum" />
+  <AssemblyInfo>
+    <AssemblyName>SkiaSharp</AssemblyName>
+    <AssemblyVersion>1.49.0.0</AssemblyVersion>
+  </AssemblyInfo>
+  <Base>
+    <BaseTypeName>System.Enum</BaseTypeName>
+  </Base>
+  <Docs>
+    <summary>Verbs contained in an <see cref="T:SkiaSharp.SKPath" />.</summary>
+    <remarks>In the description below, the number of points returned represents the number of valid entries on the return array of SKPoints that is passed to the Next method on the iterator.</remarks>
+  </Docs>
+  <Members>
+    <Member MemberName="Close">
+      <MemberSignature Language="C#" Value="Close" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype SkiaSharp.SKPath/Verb Close = int32(5)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>Close path, a call to the iterator’s Next() method will return one point (countour’s MoveTo point).</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="Conic">
+      <MemberSignature Language="C#" Value="Conic" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype SkiaSharp.SKPath/Verb Conic = int32(3)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>Conic path, a call to the iterator’s Next() method will return three points, plus the ConicWeight point.</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="Cubic">
+      <MemberSignature Language="C#" Value="Cubic" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype SkiaSharp.SKPath/Verb Cubic = int32(4)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>Cubic path, a call to the iterator’s Next() method will return four points</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="Done">
+      <MemberSignature Language="C#" Value="Done" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype SkiaSharp.SKPath/Verb Done = int32(6)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>The path is completed, points will not contain any data.</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="Line">
+      <MemberSignature Language="C#" Value="Line" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype SkiaSharp.SKPath/Verb Line = int32(1)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>Line path, a call to the iterator’s Next() method will return two points.</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="Move">
+      <MemberSignature Language="C#" Value="Move" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype SkiaSharp.SKPath/Verb Move = int32(0)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>Move command, a call to the iterator’s Next() method will return a single point.</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="Quad">
+      <MemberSignature Language="C#" Value="Quad" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype SkiaSharp.SKPath/Verb Quad = int32(2)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Verb</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>Quad command, a call to the iterator’s Next() method will return three points.</summary>
+      </Docs>
+    </Member>
+  </Members>
+</Type>

docs/en/SkiaSharp/SKPath.xml

@@ -44,9 +44,9 @@
         <Parameter Name="path" Type="SkiaSharp.SKPath" />
       </Parameters>
       <Docs>
-        <param name="path">To be added.</param>
-        <summary>To be added.</summary>
-        <remarks>To be added.</remarks>
+        <param name="path">The path to clone.</param>
+        <summary>Creates an SKPath by making a copy of an existing path</summary>
+        <remarks>This constructor can throw InvalidOperationException if there is a problem copying the source path.</remarks>
       </Docs>
     </Member>
     <Member MemberName="AddArc">
@@ -94,8 +94,103 @@
         <param name="direction">The direction to wind the oval's contour.</param>
         <summary>Adds an oval to the current path.</summary>
         <remarks>
-          <para>
-          </para>
+          <para></para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="AddPath">
+      <MemberSignature Language="C#" Value="public void AddPath (SkiaSharp.SKPath other, SkiaSharp.SKPath.AddMode mode = SkiaSharp.SKPath+AddMode.Append);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void AddPath(class SkiaSharp.SKPath other, valuetype SkiaSharp.SKPath/AddMode mode) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="other" Type="SkiaSharp.SKPath" />
+        <Parameter Name="mode" Type="SkiaSharp.SKPath+AddMode" />
+      </Parameters>
+      <Docs>
+        <param name="other">The path containing the elements to be added to the current path.</param>
+        <param name="mode">Determines how the <paramref name="other" /> path contours are added to the path.   On Append mode, contours are added as new contours.   On Extend mode, the last contour of the path is extended with the first contour of the <paramref name="other" /> path.</param>
+        <summary>Extends the current path with the path elements from another path, using the specified extension mode.</summary>
+        <remarks>
+          <para></para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="AddPath">
+      <MemberSignature Language="C#" Value="public void AddPath (SkiaSharp.SKPath other, ref SkiaSharp.SKMatrix matrix, SkiaSharp.SKPath.AddMode mode = SkiaSharp.SKPath+AddMode.Append);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void AddPath(class SkiaSharp.SKPath other, valuetype SkiaSharp.SKMatrix matrix, valuetype SkiaSharp.SKPath/AddMode mode) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="other" Type="SkiaSharp.SKPath" />
+        <Parameter Name="matrix" Type="SkiaSharp.SKMatrix&amp;" RefType="ref" />
+        <Parameter Name="mode" Type="SkiaSharp.SKPath+AddMode" />
+      </Parameters>
+      <Docs>
+        <param name="other">The path containing the elements to be added to the current path.</param>
+        <param name="matrix">Transformation applied to the <paramref name="other" /> path.</param>
+        <param name="mode">Determines how the <paramref name="other" /> path contours are added to the path.   On Append mode, contours are added as new contours.   On Extend mode, the last contour of the path is extended with the first contour of the <paramref name="other" /> path.</param>
+        <summary>Extends the current path with the path elements from another path, by applying the specified transformation matrix, using the specified extension mode.</summary>
+        <remarks>
+          <para />
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="AddPath">
+      <MemberSignature Language="C#" Value="public void AddPath (SkiaSharp.SKPath other, float dx, float dy, SkiaSharp.SKPath.AddMode mode = SkiaSharp.SKPath+AddMode.Append);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void AddPath(class SkiaSharp.SKPath other, float32 dx, float32 dy, valuetype SkiaSharp.SKPath/AddMode mode) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="other" Type="SkiaSharp.SKPath" />
+        <Parameter Name="dx" Type="System.Single" />
+        <Parameter Name="dy" Type="System.Single" />
+        <Parameter Name="mode" Type="SkiaSharp.SKPath+AddMode" />
+      </Parameters>
+      <Docs>
+        <param name="other">The path containing the elements to be added to the current path.</param>
+        <param name="dx">The amount to translate the path in X as it is added.</param>
+        <param name="dy">The amount to translate the path in Y as it is added.</param>
+        <param name="mode">Determines how the <paramref name="other" /> path contours are added to the path.   On Append mode, contours are added as new contours.   On Extend mode, the last contour of the path is extended with the first contour of the <paramref name="other" /> path.</param>
+        <summary>Extends the current path with the path elements from another path offset by (<paramref name="dx" />, <paramref name="dy" />), using the specified extension mode.</summary>
+        <remarks>
+          <para></para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="AddPathReverse">
+      <MemberSignature Language="C#" Value="public void AddPathReverse (SkiaSharp.SKPath other);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void AddPathReverse(class SkiaSharp.SKPath other) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="other" Type="SkiaSharp.SKPath" />
+      </Parameters>
+      <Docs>
+        <param name="other">The path containing the elements to be added to the current path.</param>
+        <summary>Extends the current path with the path elements from another path in reverse.</summary>
+        <remarks>
+          <para />
         </remarks>
       </Docs>
     </Member>
@@ -192,11 +287,51 @@
         <summary>Add a conic path from the last point.</summary>
         <remarks>
           <para> If no <see cref="M:SkiaSharp.SKPath.MoveTo" /> call has been made for this contour, the first point is automatically set to (0,0).</para>
-          <para>
-          </para>
+          <para></para>
         </remarks>
       </Docs>
     </Member>
+    <Member MemberName="CreateIterator">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKPath.Iterator CreateIterator (bool forceClose);" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class SkiaSharp.SKPath/Iterator CreateIterator(bool forceClose) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+Iterator</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="forceClose" Type="System.Boolean" />
+      </Parameters>
+      <Docs>
+        <param name="forceClose">
+          <para>When this is true, each contour (as defined by a new starting move command) will be completed with a close verb regardless of the contour's contents.</para>
+        </param>
+        <summary>Creates an iterator object to scan the all of the segments (lines, quadratics, cubics) of each contours in a path.</summary>
+        <returns>An object that can be used to iterate over the various elements of the path.</returns>
+        <remarks>
+          <para>This iterator is able to clean up the path as the values are returned.   If you do not desire to get verbs that have been cleaned up, use the <see cref="M:SkiaSharp.SKPath.CreateRawIterator" /> method instead.</para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="CreateRawIterator">
+      <MemberSignature Language="C#" Value="public SkiaSharp.SKPath.RawIterator CreateRawIterator ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class SkiaSharp.SKPath/RawIterator CreateRawIterator() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>SkiaSharp.SKPath+RawIterator</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>Creates a raw iterator object to scan the all of the segments (lines, quadratics, cubics) of each contours in a path.</summary>
+        <returns>An object that can be used to iterate over the various elements of the path.</returns>
+        <remarks>Unlike the <see cref="M:SkiaSharp.SKPath.CreateIterator" /> method, this iterator does not clean up or normalize the values in the path.   It returns the raw elements contained in the path.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="CubicTo">
       <MemberSignature Language="C#" Value="public void CubicTo (float x0, float y0, float x1, float y1, float x2, float y2);" />
       <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void CubicTo(float32 x0, float32 y0, float32 x1, float32 y1, float32 x2, float32 y2) cil managed" />
@@ -342,8 +477,7 @@
         <param name="y">The y-coordinate of the start of a new contour</param>
         <summary>Set the beginning of the next contour to the point.</summary>
         <remarks>
-          <para>
-          </para>
+          <para></para>
         </remarks>
       </Docs>
     </Member>
@@ -434,8 +568,47 @@
         <summary>Same as <see cref="M:SkiaSharp.SKPath.CubicTo" /> but the coordinates are considered relative to the last point on this contour.</summary>
         <remarks>
           <para> If no <see cref="M:SkiaSharp.SKPath.MoveTo" /> call has been made for this contour, the first point is automatically set to (0,0).</para>
-          <para>
-          </para>
+          <para></para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Reset">
+      <MemberSignature Language="C#" Value="public void Reset ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Reset() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>Clear any lines and curves from the path, making it empty.</summary>
+        <remarks>
+          <para>This frees up internal storage associated with those segments.</para>
+          <para />
+          <para>On Android, does not change fSourcePath.</para>
+        </remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="Rewind">
+      <MemberSignature Language="C#" Value="public void Rewind ();" />
+      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Rewind() cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>1.49.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters />
+      <Docs>
+        <summary>Clear any lines and curves from the path, making it empty.</summary>
+        <remarks>
+          <para>However, any internal storage for those lines/curves is retained, making reuse of the path potentially faster.</para>
+          <para />
+          <para>On Android, does not change fSourcePath.</para>
         </remarks>
       </Docs>
     </Member>
@@ -479,8 +652,7 @@
         <param name="dy">The amount to add to the x-coordinate of the last point on this contour, to specify the start of a new contour.</param>
         <summary>Same as <see cref="M:SkiaSharp.SKPath.MoveTo" /> but the coordinates are considered relative to the last point on this contour.</summary>
         <remarks>
-          <para>
-          </para>
+          <para></para>
         </remarks>
       </Docs>
     </Member>
@@ -524,7 +696,7 @@
       </Parameters>
       <Docs>
         <param name="matrix">To be added.</param>
-        <summary>To be added.</summary>
+        <summary>Applies a transformation matrix to the all the elements in the path.</summary>
         <remarks>To be added.</remarks>
       </Docs>
     </Member>

docs/en/SkiaSharp/SKTypeface.xml

@@ -14,10 +14,18 @@
     <summary>The SkTypeface class specifies the typeface and intrinsic style of a font.</summary>
     <remarks>
       <para>The SkTypeface class specifies the typeface and intrinsic style of a font.</para>
-      <para>This is used in the paint, along with optionally algorithmic settings like textSize, textSkewX, textScaleX, kFakeBoldText_Mask, to specifyhow text appears when drawn (and measured).</para>
+      <para>This is used in the paint, along with optionally algorithmic settings like textSize, textSkewX, textScaleX, FakeBoldText, to specifyhow text appears when drawn (and measured).</para>
       <para>
       </para>
       <para>Typeface objects are immutable, and so they can be shared between threads.</para>
+      <para>If you want to create type faces with specific weights not covered by the SKTypefaceStyle, you can pass a suffix to the font family name to trigger this, like this:</para>
+      <para>
+      </para>
+      <para>
+      </para>
+      <code lang="C#"><![CDATA[var myThinFace = SKTypeface.FromFamilyName ("sans-serif-thin");]]></code>
+      <para>
+      </para>
       <para>
       </para>
     </remarks>

docs/en/SkiaSharp/SKTypefaceStyle.xml

@@ -10,10 +10,15 @@
     <BaseTypeName>System.Enum</BaseTypeName>
   </Base>
   <Docs>
-    <summary>Specifies the intrinsic style attributes of a given typeface</summary>
+    <summary>Specifies the intrinsic style attributes of a given typeface.</summary>
     <remarks>
+      <para>While the API does not surface enumeration values for other thin, light, ultra-light, heavy and black, you can achieve the same result by creating an SKTypeface with the suffix “-light”, “-thin” and so on.</para>
       <para>
       </para>
+      <para>Like this:</para>
+      <para>
+      </para>
+      <code lang="C#"><![CDATA[var myThinFace = SKTypeface.FromFamilyName ("sans-serif-thin");]]></code>
     </remarks>
   </Docs>
   <Members>

docs/en/index.xml

@@ -3,7 +3,7 @@
     <Assembly Name="SkiaSharp" Version="1.49.0.0">
       <Attributes>
         <Attribute>
-          <AttributeName>System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute+DebuggingModes.IgnoreSymbolStoreSequencePoints)</AttributeName>
+          <AttributeName>System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute+DebuggingModes.DisableOptimizations | System.Diagnostics.DebuggableAttribute+DebuggingModes.IgnoreSymbolStoreSequencePoints)</AttributeName>
         </Attribute>
         <Attribute>
           <AttributeName>System.Reflection.AssemblyCompany("")</AttributeName>
@@ -21,7 +21,7 @@
           <AttributeName>System.Reflection.AssemblyFileVersion("1.49.4.0")</AttributeName>
         </Attribute>
         <Attribute>
-          <AttributeName>System.Reflection.AssemblyInformationalVersion("1.49.4.0")</AttributeName>
+          <AttributeName>System.Reflection.AssemblyInformationalVersion("1.49.4.0-{GIT_SHA}")</AttributeName>
         </Attribute>
         <Attribute>
           <AttributeName>System.Reflection.AssemblyProduct("SkiaSharp")</AttributeName>
@@ -82,6 +82,10 @@
       <Type Name="SKObject" Kind="Class" />
       <Type Name="SKPaint" Kind="Class" />
       <Type Name="SKPath" Kind="Class" />
+      <Type Name="SKPath+AddMode" Kind="Enumeration" />
+      <Type Name="SKPath+Iterator" Kind="Class" />
+      <Type Name="SKPath+RawIterator" Kind="Class" />
+      <Type Name="SKPath+Verb" Kind="Enumeration" />
       <Type Name="SKPathDirection" Kind="Enumeration" />
       <Type Name="SKPathFillType" Kind="Enumeration" />
       <Type Name="SKPicture" Kind="Class" />

native-builds/libSkiaSharp_ios/libSkiaSharp.xcodeproj/project.pbxproj

@@ -1143,6 +1143,8 @@
 				TargetAttributes = {
 					21FD2B2F1C014C000023CFAE = {
 						CreatedOnToolsVersion = 7.1.1;
+						DevelopmentTeam = PJQC57N853;
+						DevelopmentTeamName = "Miguel De Icaza";
 					};
 				};
 			};

native-builds/src/SkiaKeeper.c

@@ -31,6 +31,7 @@
 #include "xamarin/sk_x_maskfilter.h"
 #include "xamarin/sk_x_paint.h"
 #include "xamarin/sk_x_path.h"
+#include "xamarin/sk_x_patheffect.h"
 #include "xamarin/sk_x_shader.h"
 #include "xamarin/sk_x_stream.h"
 #include "xamarin/sk_x_typeface.h"
@@ -75,6 +76,7 @@ void** KeepSkiaCSymbols ()
         (void*)sk_string_new_empty,
         (void*)sk_document_unref,
         (void*)sk_wstream_write,
+        (void*)sk_path_effect_create_dash,
 
         // Xamarin
         (void*)sk_managedstream_new,

samples/SharedDemo/SkiaSharp.Demos.cs

@@ -992,6 +992,40 @@ namespace SkiaSharp
 			OpenFileDelegate?.Invoke ("document.pdf");
 		}
 
+		public static void PathEffects (SKCanvas canvas, int width, int height)
+		{
+			canvas.Clear (SKColors.White);
+
+			var step = height / 4;
+
+			using (var paint = new SKPaint ())
+			using (var effect = SKPathEffect.CreateDash (new [] { 15f, 5f }, 0)) {
+				paint.IsStroke = true;
+				paint.StrokeWidth = 4;
+				paint.PathEffect = effect;
+				canvas.DrawLine (10, step, width - 10 - 10, step, paint);
+			}
+
+			using (var paint = new SKPaint ())
+			using (var effect = SKPathEffect.CreateDiscrete (10, 10)) {
+				paint.IsStroke = true;
+				paint.StrokeWidth = 4;
+				paint.PathEffect = effect;
+				canvas.DrawLine (10, step * 2, width - 10 - 10, step * 2, paint);
+			}
+
+			using (var paint = new SKPaint ())
+			using (var dashEffect = SKPathEffect.CreateDash (new [] { 15f, 5f }, 0))
+			using (var discreteEffect = SKPathEffect.CreateDiscrete (10, 10))
+			using (var effect = SKPathEffect.CreateCompose (dashEffect, discreteEffect)) {
+				paint.IsStroke = true;
+				paint.StrokeWidth = 4;
+				paint.PathEffect = effect;
+				canvas.DrawLine (10, step * 3, width - 10 - 10, step * 3, paint);
+			}
+
+		}
+
 
 		[Flags]
 		public enum Platform
@@ -1059,6 +1093,7 @@ namespace SkiaSharp
 			new Sample {Title="Chained Image Filter", Method = ChainedImageFilter, Platform = Platform.All},
 			new Sample {Title="Measure Text Sample", Method = MeasureTextSample, Platform = Platform.All},
 			new Sample {Title="Create PDF", Method = CreatePdfSample, Platform = Platform.All, TapMethod = CreatePdfSampleTapped},
+			new Sample {Title="Path Effects", Method = PathEffects, Platform = Platform.All},
 		};
 	}
 }

skia

@@ -1 +1 @@
-Subproject commit c2a03e939a4a0b53c147a78c1fa349c8b2a3034f
+Subproject commit 7234fc471549f9b6d694bd71a75261840afd18e9