public ArcTo(Size radius, bool largeArc, bool sweepClockwise, Point point)
 {
     Radius = radius;
     LargeArc = largeArc;
     SweepClockwise = sweepClockwise;
     Point = point;
 }

		public RadialGradientBrush (Point relCenter, Size relRadius, params GradientStop[] stops)
		{
			Center = relCenter;
			Focus = relCenter;
			Radius = relRadius;
			Stops.AddRange (stops);
		}

		public WICBitmapCanvas (Size size, double scale = 1.0, bool transparency = true, Direct2DFactories factories = null)
			: this (
				// DIPs = pixels / (DPI/96.0)
				new WIC.Bitmap ((factories ?? Direct2DFactories.Shared).WICFactory, (int)(Math.Ceiling (size.Width * scale)), (int)(Math.Ceiling (size.Height * scale)), transparency ? WIC.PixelFormat.Format32bppPBGRA : WIC.PixelFormat.Format32bppBGR, WIC.BitmapCreateCacheOption.CacheOnLoad),
				new D2D1.RenderTargetProperties (D2D1.RenderTargetType.Default, new D2D1.PixelFormat (DXGI.Format.Unknown, D2D1.AlphaMode.Unknown), (float)(96.0 * scale), (float)(96.0 * scale), D2D1.RenderTargetUsage.None, D2D1.FeatureLevel.Level_DEFAULT))
		{
		}

 public static Size ScaleDownProportional (this Size size, Size max)
 {
     if (size.Width <= max.Width && size.Height <= max.Height) {
         return size;
     }
     return size.ScaleProportional (max);
 }

		public static void Scale (this ICanvas canvas, Size scale, Point point)
		{
			if (scale.Width != 1 || scale.Height != 1) {
				canvas.Translate (point);
				canvas.Scale (scale);
				canvas.Translate (-point);
			}
		}

 public Drawing(Size size, DrawingFunc func)
 {
     if (func == null) {
         throw new ArgumentNullException ("func");
     }
     this.size = size;
     this.func = func;
 }

		public Drawing (Size size, DrawingFunc func, IPlatform textPlatform)
		{
			if (func == null) {
				throw new ArgumentNullException ("func");
			}
			this.size = size;
			this.func = func;
			this.textPlatform = textPlatform ?? new NullPlatform ();
		}

        public static Size ScaleProportional (this Size size, Size max)
        {
            double fitScale = size.ScaleThatFits (max);
            if (fitScale == 1) {
                return size;
            }

            Size scaledSize = new Size (size.Width * fitScale, size.Height * fitScale);
            return scaledSize;
        }

 public IImageCanvas CreateImageCanvas(Size size, double scale = 1.0, bool transparency = true)
 {
     var pixelWidth = (int)Math.Ceiling (size.Width * scale);
     var pixelHeight = (int)Math.Ceiling (size.Height * scale);
     var bitmap = Bitmap.CreateBitmap (pixelWidth, pixelHeight, Bitmap.Config.Argb8888);
     if (!transparency) {
         bitmap.EraseColor (Colors.Black.Argb);
     }
     return new BitmapCanvas (bitmap, scale);
 }

 public IImageCanvas CreateImageCanvas(Size size, double scale = 1.0, bool transparency = true)
 {
     var pixelWidth = (int)Math.Ceiling (size.Width * scale);
     var pixelHeight = (int)Math.Ceiling (size.Height * scale);
     var bitmapInfo = transparency ? CGImageAlphaInfo.PremultipliedFirst : CGImageAlphaInfo.NoneSkipFirst;
     var bitsPerComp = 8;
     var bytesPerRow = transparency ? 4 * pixelWidth : 4 * pixelWidth;
     var colorSpace = CGColorSpace.CreateDeviceRGB ();
     var bitmap = new CGBitmapContext (IntPtr.Zero, pixelWidth, pixelHeight, bitsPerComp, bytesPerRow, colorSpace, bitmapInfo);
     return new CGBitmapContextCanvas (bitmap, scale);
 }

        public static double ScaleThatFits (this Size size, Size max)
        {
            if (size == max || max.Width == 0 || max.Height == 0 || size.Width == 0 || size.Height == 0) {
                return 1;
            }

            double widthScale = max.Width / size.Width;
            double heightScale = max.Height / size.Height;
            double fitScale = (double)Math.Min (widthScale, heightScale);
            return fitScale;
        }

 public static IImage CreateImage(this IPlatform platform, Func<int, int, Color> colorFunc, Size size, double scale = 1.0)
 {
     var w = (int)Math.Ceiling (size.Width);
     var h = (int)Math.Ceiling (size.Height);
     var colors = new Color[w * h];
     for (var y = 0; y < h; y++) {
         var o = y * w;
         for (var x = 0; x < w; x++) {
             colors [o + x] = colorFunc (x, y);
         }
     }
     return platform.CreateImage (colors, w, scale);
 }

		public override void Draw (CGRect rect)
		{
			base.Draw (rect);

			if (_formsControl != null) {
				using (CGContext context = UIGraphics.GetCurrentContext ()) {
					context.SetAllowsAntialiasing (true);
					context.SetShouldAntialias (true);
					context.SetShouldSmoothFonts (true);

					var outputSize = new Size (rect.Width, rect.Height);
					var finalCanvas = _formsControl.RenderSvgToCanvas (outputSize, ScreenScale, CreatePlatformImageCanvas);
					var image = finalCanvas.GetImage ();
					var uiImage = image.GetUIImage ();
					Control.Image = uiImage;
				}
			}
		}

		void Read (XDocument doc)
		{
			var svg = doc.Root;
			var ns = svg.Name.Namespace;

			//
			// Find the defs (gradients)
			//
			foreach (var d in svg.Descendants ()) {
				var idA = d.Attribute ("id");
				if (idA != null) {
					defs [ReadString (idA).Trim ()] = d;
				}
			}

			//
			// Get the dimensions
			//
			var widthA = svg.Attribute ("width");
			var heightA = svg.Attribute ("height");
			var width = ReadNumber (widthA);
			var height = ReadNumber (heightA);
			var size = new Size (width, height);

			var viewBox = new Rect (size);
			var viewBoxA = svg.Attribute ("viewBox") ?? svg.Attribute ("viewPort");
			if (viewBoxA != null) {
				viewBox = ReadRectangle (viewBoxA.Value);
			}

			if (widthA != null && widthA.Value.Contains ("%")) {
				size.Width *= viewBox.Width;
			}
			if (heightA != null && heightA.Value.Contains ("%")) {
				size.Height *= viewBox.Height;
			}

			//
			// Add the elements
			//
			Graphic = new Graphic (size, viewBox);

			AddElements (Graphic.Children, svg.Elements (), null, Brushes.Black);
		}

		public ForeignObject (Point pos, Size size) : base(null, null)
		{
			this.pos = pos;
			this.size = size;
		}

 public IImageCanvas CreateImageCanvas(Size size, double scale = 1.0, bool transparency = true)
 {
     return new NullImageSurface ();
 }

        void ReadPath(Path p, string pathDescriptor)
        {
            var args = pathDescriptor.Split (WSC, StringSplitOptions.RemoveEmptyEntries);

            var i = 0;
            var n = args.Length;

            while (i < n) {
                var a = args[i];
                //
                // Get the operation
                //
                var op = "";
                if (a.Length == 1) {
                    op = a;
                    i++;
                } else {
                    op = a.Substring (0, 1);
                    args [i] = a.Substring (1);
                }

                //
                // Execute
                //
                if (op == "M" && i + 1 < n) {
                    p.MoveTo (new Point (ReadNumber (args [i]), ReadNumber (args [i + 1])));
                    i += 2;
                } else if (op == "L" && i + 1 < n) {
                    p.LineTo (new Point (ReadNumber (args [i]), ReadNumber (args [i + 1])));
                    i += 2;
                } else if (op == "C" && i + 5 < n) {
                    var c1 = new Point (ReadNumber (args [i]), ReadNumber (args [i + 1]));
                    var c2 = new Point (ReadNumber (args [i + 2]), ReadNumber (args [i + 3]));
                    var pt = new Point (ReadNumber (args [i + 4]), ReadNumber (args [i + 5]));
                    p.CurveTo (c1, c2, pt);
                    i += 6;
                } else if (op == "S" && i + 3 < n) {
                    var c  = new Point (ReadNumber (args [i]), ReadNumber (args [i + 1]));
                    var pt = new Point (ReadNumber (args [i + 2]), ReadNumber (args [i + 3]));
                    p.ContinueCurveTo (c, pt);
                    i += 4;
                } else if (op == "A" && i + 6 < n) {
                    var r = new Size (ReadNumber (args [i]), ReadNumber (args [i + 1]));
            //					var xr = ReadNumber (args [i + 2]);
                    var laf = ReadNumber (args [i + 3]) != 0;
                    var swf = ReadNumber (args [i + 4]) != 0;
                    var pt = new Point (ReadNumber (args [i + 5]), ReadNumber (args [i + 6]));
                    p.ArcTo (r, laf, swf, pt);
                    i += 7;
                } else if (op == "z" || op == "Z") {
                    p.Close ();
                } else {
                    throw new NotSupportedException ("Path Operation " + op);
                }
            }
        }

 public void DrawImage(IImage image, Rect frame, double alpha = 1.0)
 {
     var ii = image as BitmapImage;
     if (ii != null) {
         var paint = GetImagePaint (alpha);
         var isize = new Size (ii.Bitmap.Width, ii.Bitmap.Height);
         var scale = frame.Size / isize;
         var m = new Matrix ();
         m.PreTranslate ((float)frame.X, (float)frame.Y);
         m.PreScale ((float)scale.Width, (float)scale.Height);
         graphics.DrawBitmap (ii.Bitmap, m, paint);
     }
 }

		public IImageCanvas RenderSvgToCanvas (Size outputSize, double finalScale, Func<Size, double, IImageCanvas> createPlatformImageCanvas)
		{
			var originalSvgSize = LoadedGraphic.Size;
			var finalCanvas = createPlatformImageCanvas (outputSize, finalScale);

			if (SvgStretchableInsets != ResizableSvgInsets.Zero) {
				// Doing a stretchy 9-slice manipulation on the original SVG.
				// Partition into 9 segments, based on _formsControl.Svg9SliceInsets, storing both original and scaled sizes.
				var sliceInsets = SvgStretchableInsets;
				var sliceFramePairs = new[] {
					ResizableSvgSection.TopLeft,
					ResizableSvgSection.TopCenter,
					ResizableSvgSection.TopRight,
					ResizableSvgSection.CenterLeft,
					ResizableSvgSection.CenterCenter,
					ResizableSvgSection.CenterRight,
					ResizableSvgSection.BottomLeft,
					ResizableSvgSection.BottomCenter,
					ResizableSvgSection.BottomRight,
				}.Select (section => {
					return Tuple.Create (
						sliceInsets.GetSection (originalSvgSize, section),
						sliceInsets.ScaleSection (outputSize, section));
				}).ToArray ();

				foreach (var sliceFramePair in sliceFramePairs) {
					var sliceImage = RenderSectionToImage (LoadedGraphic, sliceFramePair.Item1, sliceFramePair.Item2, finalScale, createPlatformImageCanvas);
					finalCanvas.DrawImage (sliceImage, sliceFramePair.Item2);
				}
			} else {
				// Typical approach to rendering an SVG; just draw it to the canvas.
				double proportionalOutputScale = originalSvgSize.ScaleThatFits (outputSize);
				// Make sure ViewBox is reset to a proportionally-scaled default in case it was previous set by slicing.
				LoadedGraphic.ViewBox = new Rect (Point.Zero, originalSvgSize / proportionalOutputScale);
				LoadedGraphic.Draw (finalCanvas);
			}
			return finalCanvas;
		}

 /// <summary>
 /// Creates an object implementing the IImageCanvas interface
 /// </summary>
 /// <param name="size"></param>
 /// <param name="scale"></param>
 /// <param name="transparency"></param>
 /// <returns></returns>
 public IImageCanvas CreateImageCanvas(Size size, double scale = 1.0, bool transparency = true)
 {
     throw new NotImplementedException();
 }