public static void RenderGlyphToContext (CGContext context, PointF position, Glyph g, Fnt font, byte[] palette, int offset)
		{
			byte[] buf = new byte[g.Width * g.Height * 4];
			int i = 0;

			for (int y = g.Height - 1; y >= 0; y--) {
				for (int x = g.Width - 1; x >= 0; x--) {
					if (g.Bitmap[y,x] == 0)
						buf [i + 0] = 0;
					else if (g.Bitmap[y,x] == 1)
						buf [i + 0] = 255;
					else
						buf [i + 0] = 128;

					buf[i + 1] = palette[ (g.Bitmap[y,x]) * 3 + offset + 0];
					buf[i + 2] = palette[ (g.Bitmap[y,x]) * 3 + offset + 1];
					buf[i + 3] = palette[ (g.Bitmap[y,x]) * 3 + offset + 2];

					if (buf[i+1] == 252 && buf[i+2] == 0 && buf[i+3] == 252)
						buf[i + 0] = 0;

					i += 4;
				}
			}

			CGImage glyphImage = CreateImage (buf, (ushort)g.Width, (ushort)g.Height, 32, g.Width * 4);
			
			context.DrawImage (new RectangleF (position, new SizeF (g.Width, g.Height)), glyphImage);
		}

 public Graphics(CGContext context, bool flipped = true)
 {
     if (context == null)
         throw new ArgumentNullException ("context");
     isFlipped = flipped;
     InitializeContext(context);
 }

 public CocoaGraphDrawer(CGContext g, int w, int h)
 {
     this.g = g;
     this.w = w;
     this.h = h;
     g.SetAllowsAntialiasing(true);
     g.InterpolationQuality = CGInterpolationQuality.High;
 }

		public override void DrawInContext (CGContext context)
		{
			base.DrawInContext (context);
			
			context.AddEllipseInRect (Bounds);
			context.SetFillColor (ClockColor);
			context.FillPath ();
		}

 public static void FillEllipsis(CGContext context, RectangleF rect, CGColor color, float lineWidth)
 {
     context.SaveState();
     context.SetFillColor(color);
     context.AddEllipseInRect(rect);
     context.FillPath();
     context.RestoreState();
 }

 public GraphicsContextWrapper(CGContext context, float boundsWidth, float boundsHeight, BasicRectangle dirtyRect)
 {
     Context = context;
     BoundsWidth = boundsWidth;
     BoundsHeight = boundsHeight;
     DirtyRect = dirtyRect;
     Density = GetDisplayScale();
 }

 public static void FillRect(CGContext context, RectangleF rect, CGColor color)
 {
     context.SaveState();
     context.AddRect(rect);
     context.Clip();
     context.SetFillColor(color);
     context.FillRect(rect);
     context.RestoreState();
 }

 public static void DrawEllipsis(CGContext context, RectangleF rect, CGColor color, float lineWidth)
 {
     context.SaveState();
     context.SetStrokeColor(color);
     context.SetLineWidth(lineWidth);
     context.AddEllipseInRect(rect);
     context.StrokePath();
     context.RestoreState();
 }

 public static void DrawRect(CGContext context, RectangleF rect, CGColor color, float lineWidth)
 {
     context.SaveState();
     context.AddRect(rect);
     context.Clip();
     context.SetLineWidth(lineWidth);
     context.SetStrokeColor(color);
     context.StrokeRect(rect);
     context.RestoreState();
 }

		internal static void Draw (CGContext ctx, GradientInfo gradient)
		{
			ctx.SaveState ();
			ctx.Clip ();
			using (var cg = new CGGradient (Util.DeviceRGBColorSpace, gradient.Colors.ToArray (), gradient.Stops.ToArray ())) {
				if (gradient.Linear)
					ctx.DrawLinearGradient (cg, gradient.Start, gradient.End, CGGradientDrawingOptions.DrawsBeforeStartLocation | CGGradientDrawingOptions.DrawsAfterEndLocation);
				else
					ctx.DrawRadialGradient (cg, gradient.Start, gradient.StartRadius, gradient.End, gradient.EndRadius, CGGradientDrawingOptions.DrawsBeforeStartLocation | CGGradientDrawingOptions.DrawsAfterEndLocation);
			}
			ctx.RestoreState ();
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="CoreGraphicsRenderContext"/> class.
        /// </summary>
        /// <param name="context">The context.</param>
        public CoreGraphicsRenderContext(CGContext context)
        {
            this.gctx = context;

            // Set rendering quality
            this.gctx.SetAllowsFontSmoothing (true);
            this.gctx.SetAllowsFontSubpixelQuantization (true);
            this.gctx.SetAllowsAntialiasing (true);
            this.gctx.SetShouldSmoothFonts (true);
            this.gctx.SetShouldAntialias (true);
            this.gctx.InterpolationQuality = CGInterpolationQuality.High;
            this.gctx.SetTextDrawingMode (CGTextDrawingMode.Fill);
            this.gctx.TextMatrix = CGAffineTransform.MakeScale (1, 1);
        }

        public static float MeasureStringWidth(CGContext context, string text, string fontName, float fontSize)
        {
            if (string.IsNullOrEmpty(text))
                return 0;

            context.SaveState();
            PointF pos = context.TextPosition;
            context.SelectFont(fontName, fontSize, CGTextEncoding.MacRoman);
            context.TextMatrix = CGAffineTransform.MakeScale(1.0f, -1.0f);
            //context.TranslateCTM(0, 20);
            context.ScaleCTM(1, -1);
            context.SetTextDrawingMode(CGTextDrawingMode.Invisible);
            context.ShowTextAtPoint(pos.X, pos.Y, text);
            PointF pos2 = context.TextPosition;
            context.RestoreState();
            
            return pos2.X - pos.X;
        }

 public static void DrawText(CGContext context, string text, string fontName, float fontSize, float translateHeight, float x, float y)
 {
     context.SaveState();
     context.SelectFont(fontName, fontSize, CGTextEncoding.MacRoman);
     context.SetTextDrawingMode(CGTextDrawingMode.Fill);
     context.SetFillColor(new CGColor(1, 1));
     context.SetStrokeColor(new CGColor(1.0f, 1.0f));
     //context.AddRect(rectText);
     //context.Clip();
     context.TextMatrix = CGAffineTransform.MakeScale(1.0f, -1.0f);
     context.TranslateCTM(0, translateHeight);
     context.ScaleCTM(1, -1);
     context.ShowTextAtPoint(x, y, text);
     context.RestoreState();
 }

 public static void DrawTextInRect(CGContext context, RectangleF rect, string text, string fontName, float fontSize, NSColor fontColor)
 {
     context.SaveState();
     NSString str = new NSString(text);
     var dict = new NSMutableDictionary();
     dict.Add(NSAttributedString.ForegroundColorAttributeName, fontColor);
     dict.Add(NSAttributedString.FontAttributeName, NSFont.FromFontName(fontName, fontSize));
     str.DrawString(rect, dict);
     context.RestoreState();
 }

 public static SizeF MeasureText(CGContext context, string text, string fontName, float fontSize)
 {
     NSString str = new NSString(text);
     var dict = new NSMutableDictionary();
     dict.Add(NSAttributedString.FontAttributeName, NSFont.FromFontName(fontName, fontSize));
     var size = str.StringSize(dict);
     return size;
 }

 public static void EOFillPath(CGContext context, CGPath path, CGColor color)
 {
     context.SaveState();
     context.SetFillColor(color);
     context.AddPath(path);
     context.EOFillPath();
     context.RestoreState();
 }

 public static void FillGradient(CGContext context, RectangleF rect, CGColor color1, CGColor color2, bool isHorizontal)
 {
     CGGradient gradientBackground;
     CGColorSpace colorSpace = CGColorSpace.CreateDeviceRGB();
     
     float[] locationListBackground = new float[] { 1.0f, 0.0f };
     List<float> colorListBackground = new List<float>();
     colorListBackground.AddRange(color1.Components);
     colorListBackground.AddRange(color2.Components);
     gradientBackground = new CGGradient(colorSpace, colorListBackground.ToArray(), locationListBackground);
     
     context.SaveState();
     context.AddRect(rect);
     context.Clip();
     //context.ScaleCTM(1, -1);
     if(isHorizontal)
         context.DrawLinearGradient(gradientBackground, new PointF(rect.X, rect.Y), new PointF(rect.X + rect.Width, rect.Y + rect.Height), CGGradientDrawingOptions.DrawsBeforeStartLocation);
     else
         context.DrawLinearGradient(gradientBackground, new PointF(0, 0), new PointF(0, rect.Height), CGGradientDrawingOptions.DrawsBeforeStartLocation);
     context.RestoreState();
 }       

        /// <summary>
        /// Rasterizes the triangle specified by the vector / points and their associated colors
        /// using barycentric coordinates.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="vt1"></param>
        /// <param name="vt2"></param>
        /// <param name="vt3"></param>
        /// <param name="colorV1"></param>
        /// <param name="colorV2"></param>
        /// <param name="colorV3"></param>
        internal void RasterizeTriangle(CGContext context, PointF vt1, PointF vt2, PointF vt3, Color colorV1, Color colorV2, Color colorV3)
        {
            // get the bounding box of the triangle
            int maxX = (int)Math.Max(vt1.X, Math.Max(vt2.X, vt3.X));
            int minX = (int)Math.Min(vt1.X, Math.Min(vt2.X, vt3.X));
            int maxY = (int)Math.Max(vt1.Y, Math.Max(vt2.Y, vt3.Y));
            int minY = (int)Math.Min(vt1.Y, Math.Min(vt2.Y, vt3.Y));

            // Barycentric coordinates at minX/minY corner
            PointF pm = new PointF( minX, minY );

            var edge32 = new Edge(vt3, vt2, vt1, pm, colorV1);
            var edge13 = new Edge (vt1, vt3, vt2, pm, colorV2);
            var edge21 = new Edge (vt2, vt1, vt3, pm, colorV3);

            int span32 = edge32.EdgeOrigin;
            int span13 = edge13.EdgeOrigin;
            int span21 = edge21.EdgeOrigin;

            edge32Red = colorV1.R;
            edge32Green = colorV1.G;
            edge32Blue = colorV1.B;
            edge32Alpha = colorV1.A;

            edge13Red = colorV2.R;
            edge13Green = colorV2.G;
            edge13Blue = colorV2.B;
            edge13Alpha = colorV2.A;

            edge21Red = colorV3.R;
            edge21Green = colorV3.G;
            edge21Blue = colorV3.B;
            edge21Alpha = colorV3.A;

            int span32XOffset = 0;
            int span13XOffset = 0;
            int span21XOffset = 0;

            bool inside = false;
            int mask = 0;
            //  Iterate over each pixel of bounding box and check if it's inside
            //  the triangle using the barycentirc approach.
            for (int y = minY; y <= maxY; y += Edge.StepYSize)
            {
                // Barycentric coordinates at start of row
                span32XOffset = span32;
                span13XOffset = span13;
                span21XOffset = span21;

                inside = false;
                for (int x = minX; x <= maxX; x += Edge.StepXSize)
                {

                    mask = span32XOffset | span13XOffset | span21XOffset;

                    // If p is on or inside all edges for any pixels,
                    // render those pixels.
                    if (mask >= 0)
                    {
                        if (!inside)
                        {
                            inside = true;
                        }
                        RenderPixels(context, x, y, edge32, edge13, edge21, span32XOffset, span13XOffset, span21XOffset);
                    }

                    // Step to the right
                    span32XOffset += edge32.StepX;
                    span13XOffset += edge13.StepX;
                    span21XOffset += edge21.StepX;
                    if (mask < 0 && inside)
                    {
                        inside = false;
                        break;
                    }

                }

                // Row step
                span32 += edge32.StepY;
                span13 += edge13.StepY;
                span21 += edge21.StepY;
            }
        }

 public static void StrokePath(CGContext context, CGPath path, float pathWidth, CGColor color)
 {
     context.SaveState();
     context.SetLineWidth(pathWidth);
     context.SetStrokeColor(color);
     context.AddPath(path);
     context.StrokePath();
     context.RestoreState();
 }

        void RenderPixels(CGContext context, int x, int y, Edge edge32, Edge edge13, Edge edge21, int w1, int w2, int w3)
        {
            //VertexInterpoliation = A * x + B * y + C;
            //			float alpha = (edge32.A * x + edge32.B * y + edge32.C) * edge32.VertexFactor;
            //			float beta = (edge13.A * x + edge13.B * y + edge13.C)  * edge13.VertexFactor;
            //			float gamma = (edge21.A * x + edge21.B * y + edge21.C) * edge21.VertexFactor;

            // Determine barycentric coordinates
            float alpha = (float)(w1 * edge32.VertexFactor);
            float beta = (float)(w2 * edge13.VertexFactor);
            float gamma = (float)(w3 * edge21.VertexFactor);

            GradientLerp3 (alpha, beta, gamma);
            // Set the color
            context.SetFillColor (colorOutput [0], colorOutput [1], colorOutput [2], colorOutput [3]);

            // Set our pixel location
            pixelRect.X = x;
            pixelRect.Y = y;

            // Fill the pixel
            context.FillRect (pixelRect);
        }