// --------------------------------------------------------------------------------------------------------------------

 // <copyright file="GraphicsRenderContext.cs" company="OxyPlot">

 //   The MIT License (MIT)

 //

 //   Copyright (c) 2012 Oystein Bjorke

 //

 //   Permission is hereby granted, free of charge, to any person obtaining a

 //   copy of this software and associated documentation files (the

 //   "Software"), to deal in the Software without restriction, including

 //   without limitation the rights to use, copy, modify, merge, publish,

 //   distribute, sublicense, and/or sell copies of the Software, and to

 //   permit persons to whom the Software is furnished to do so, subject to

 //   the following conditions:

 //

 //   The above copyright notice and this permission notice shall be included

 //   in all copies or substantial portions of the Software.

 //

 //   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 //   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 //   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 //   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

 //   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 //   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 //   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 // </copyright>

 // <summary>

 //   The graphics render context.

 // </summary>

 // --------------------------------------------------------------------------------------------------------------------

 namespace OxyPlot.WindowsForms

 {

     using System;

     using System.Collections.Generic;

     using System.Drawing;

     using System.Drawing.Drawing2D;

     using System.Drawing.Imaging;

     using System.IO;

     using System.Linq;

     using OxyPlot;

     /// <summary>

     /// The graphics render context.

     /// </summary>

     internal class GraphicsRenderContext : RenderContextBase

     {

         /// <summary>

         /// The font size factor.

         /// </summary>

         private const float FontsizeFactor = 0.8f;

         /// <summary>

         /// The GDI+ drawing surface.

         /// </summary>

         private Graphics g;

         /// <summary>

         /// Initializes a new instance of the <see cref="GraphicsRenderContext"/> class.

         /// </summary>

         public GraphicsRenderContext()

         {

         }

         /// <summary>

         /// Sets the graphics target.

         /// </summary>

         /// <param name="graphics">The graphics surface.</param>

         public void SetGraphicsTarget(Graphics graphics)

         {

             this.g = graphics;

         }

         /// <summary>

         /// Draws the ellipse.

         /// </summary>

         /// <param name="rect">The rect.</param>

         /// <param name="fill">The fill.</param>

         /// <param name="stroke">The stroke.</param>

         /// <param name="thickness">The thickness.</param>

         public override void DrawEllipse(OxyRect rect, OxyColor fill, OxyColor stroke, double thickness)

         {

             if (fill != null)

             {

                 this.g.FillEllipse(

                     this.ToBrush(fill), (float)rect.Left, (float)rect.Top, (float)rect.Width, (float)rect.Height);

             }

             if (stroke == null || thickness <= 0)

             {

                 return;

             }

             using (var pen = new Pen(this.ToColor(stroke), (float)thickness))

             {

                 this.g.SmoothingMode = SmoothingMode.HighQuality;

                 this.g.DrawEllipse(pen, (float)rect.Left, (float)rect.Top, (float)rect.Width, (float)rect.Height);

             }

         }

         /// <summary>

         /// Draws the line.

         /// </summary>

         /// <param name="points">The points.</param>

         /// <param name="stroke">The stroke.</param>

         /// <param name="thickness">The thickness.</param>

         /// <param name="dashArray">The dash array.</param>

         /// <param name="lineJoin">The line join.</param>

         /// <param name="aliased">if set to <c>true</c> [aliased].</param>

         public override void DrawLine(

             IList<ScreenPoint> points,

             OxyColor stroke,

             double thickness,

             double[] dashArray,

             OxyPenLineJoin lineJoin,

             bool aliased)

         {

             if (stroke == null || thickness <= 0 || points.Count < 2)

             {

                 return;

             }

             this.g.SmoothingMode = aliased ? SmoothingMode.None : SmoothingMode.HighQuality;

             using (var pen = new Pen(this.ToColor(stroke), (float)thickness))

             {

                 if (dashArray != null)

                 {

                     pen.DashPattern = this.ToFloatArray(dashArray);

                 }

                 switch (lineJoin)

                 {

                     case OxyPenLineJoin.Round:

                         pen.LineJoin = LineJoin.Round;

                         break;

                     case OxyPenLineJoin.Bevel:

                         pen.LineJoin = LineJoin.Bevel;

                         break;

                     // The default LineJoin is Miter

                 }

                 this.g.DrawLines(pen, this.ToPoints(points));

             }

         }

         /// <summary>

         /// Draws the polygon.

         /// </summary>

         /// <param name="points">The points.</param>

         /// <param name="fill">The fill.</param>

         /// <param name="stroke">The stroke.</param>

         /// <param name="thickness">The thickness.</param>

         /// <param name="dashArray">The dash array.</param>

         /// <param name="lineJoin">The line join.</param>

         /// <param name="aliased">if set to <c>true</c> [aliased].</param>

         public override void DrawPolygon(

             IList<ScreenPoint> points,

             OxyColor fill,

             OxyColor stroke,

             double thickness,

             double[] dashArray,

             OxyPenLineJoin lineJoin,

             bool aliased)

         {

             if (points.Count < 2)

             {

                 return;

             }

             this.g.SmoothingMode = aliased ? SmoothingMode.None : SmoothingMode.HighQuality;

             PointF[] pts = this.ToPoints(points);

             if (fill != null)

             {

                 this.g.FillPolygon(this.ToBrush(fill), pts);

             }

             if (stroke != null && thickness > 0)

             {

                 using (var pen = new Pen(this.ToColor(stroke), (float)thickness))

                 {

                     if (dashArray != null)

                     {

                         pen.DashPattern = this.ToFloatArray(dashArray);

                     }

                     switch (lineJoin)

                     {

                         case OxyPenLineJoin.Round:

                             pen.LineJoin = LineJoin.Round;

                             break;

                         case OxyPenLineJoin.Bevel:

                             pen.LineJoin = LineJoin.Bevel;

                             break;

                         // The default LineJoin is Miter

                     }

                     this.g.DrawPolygon(pen, pts);

                 }

             }

         }

         /// <summary>

         /// The draw rectangle.

         /// </summary>

         /// <param name="rect">

         /// The rect.

         /// </param>

         /// <param name="fill">

         /// The fill.

         /// </param>

         /// <param name="stroke">

         /// The stroke.

         /// </param>

         /// <param name="thickness">

         /// The thickness.

         /// </param>

         public override void DrawRectangle(OxyRect rect, OxyColor fill, OxyColor stroke, double thickness)

         {

             if (fill != null)

             {

                 this.g.FillRectangle(

                     this.ToBrush(fill), (float)rect.Left, (float)rect.Top, (float)rect.Width, (float)rect.Height);

             }

             if (stroke == null || thickness <= 0)

             {

                 return;

             }

             using (var pen = new Pen(this.ToColor(stroke), (float)thickness))

             {

                 this.g.DrawRectangle(pen, (float)rect.Left, (float)rect.Top, (float)rect.Width, (float)rect.Height);

             }

         }

         /// <summary>

         /// The draw text.

         /// </summary>

         /// <param name="p">

         /// The p.

         /// </param>

         /// <param name="text">

         /// The text.

         /// </param>

         /// <param name="fill">

         /// The fill.

         /// </param>

         /// <param name="fontFamily">

         /// The font family.

         /// </param>

         /// <param name="fontSize">

         /// The font size.

         /// </param>

         /// <param name="fontWeight">

         /// The font weight.

         /// </param>

         /// <param name="rotate">

         /// The rotate.

         /// </param>

         /// <param name="halign">

         /// The halign.

         /// </param>

         /// <param name="valign">

         /// The valign.

         /// </param>

         /// <param name="maxSize">

         /// The maximum size of the text.

         /// </param>

         public override void DrawText(

             ScreenPoint p,

             string text,

             OxyColor fill,

             string fontFamily,

             double fontSize,

             double fontWeight,

             double rotate,

             HorizontalAlignment halign,

             VerticalAlignment valign,

             OxySize? maxSize)

         {

             var fs = FontStyle.Regular;

             if (fontWeight >= 700)

             {

                 fs = FontStyle.Bold;

             }

             using (var font = new Font(fontFamily, (float)fontSize * FontsizeFactor, fs))

             {

                 using (var sf = new StringFormat { Alignment = StringAlignment.Near })

                 {

                     var size = this.g.MeasureString(text, font);

                     if (maxSize != null)

                     {

                         if (size.Width > maxSize.Value.Width)

                         {

                             size.Width = (float)maxSize.Value.Width;

                         }

                         if (size.Height > maxSize.Value.Height)

                         {

                             size.Height = (float)maxSize.Value.Height;

                         }

                     }

                     float dx = 0;

                     if (halign == HorizontalAlignment.Center)

                     {

                         dx = -size.Width / 2;

                     }

                     if (halign == HorizontalAlignment.Right)

                     {

                         dx = -size.Width;

                     }

                     float dy = 0;

                     sf.LineAlignment = StringAlignment.Near;

                     if (valign == VerticalAlignment.Middle)

                     {

                         dy = -size.Height / 2;

                     }

                     if (valign == VerticalAlignment.Bottom)

                     {

                         dy = -size.Height;

                     }

                     this.g.TranslateTransform((float)p.X, (float)p.Y);

                     if (Math.Abs(rotate) > double.Epsilon)

                     {

                         this.g.RotateTransform((float)rotate);

                     }

                     this.g.TranslateTransform(dx, dy);

                     var layoutRectangle = new RectangleF(0, 0, size.Width, size.Height);

                     this.g.DrawString(text, font, this.ToBrush(fill), layoutRectangle, sf);

                     this.g.ResetTransform();

                 }

             }

         }

         /// <summary>

         /// The measure text.

         /// </summary>

         /// <param name="text">The text.</param>

         /// <param name="fontFamily">The font family.</param>

         /// <param name="fontSize">The font size.</param>

         /// <param name="fontWeight">The font weight.</param>

         /// <returns>The size of the text.</returns>

         public override OxySize MeasureText(string text, string fontFamily, double fontSize, double fontWeight)

         {

             if (text == null)

             {

                 return OxySize.Empty;

             }

             var fs = FontStyle.Regular;

             if (fontWeight >= 700)

             {

                 fs = FontStyle.Bold;

             }

             using (var font = new Font(fontFamily, (float)fontSize * FontsizeFactor, fs))

             {

                 var size = this.g.MeasureString(text, font);

                 return new OxySize(size.Width, size.Height);

             }

         }

         /// <summary>

         /// Converts a fill color to a System.Drawing.Brush.

         /// </summary>

         /// <param name="fill">

         /// The fill color.

         /// </param>

         /// <returns>

         /// The brush.

         /// </returns>

         private Brush ToBrush(OxyColor fill)

         {

             if (fill != null)

             {

                 return new SolidBrush(this.ToColor(fill));

             }

             return null;

         }

         /// <summary>

         /// Converts a color to a System.Drawing.Color.

         /// </summary>

         /// <param name="c">

         /// The color.

         /// </param>

         /// <returns>

         /// The System.Drawing.Color.

         /// </returns>

         private Color ToColor(OxyColor c)

         {

             return Color.FromArgb(c.A, c.R, c.G, c.B);

         }

         /// <summary>

         /// Converts a double array to a float array.

         /// </summary>

         /// <param name="a">

         /// The a.

         /// </param>

         /// <returns>

         /// The float array.

         /// </returns>

         private float[] ToFloatArray(double[] a)

         {

             if (a == null)

             {

                 return null;

             }

             var r = new float[a.Length];

             for (int i = 0; i < a.Length; i++)

             {

                 r[i] = (float)a[i];

             }

             return r;

         }

         /// <summary>

         /// Converts a list of point to an array of PointF.

         /// </summary>

         /// <param name="points">

         /// The points.

         /// </param>

         /// <returns>

         /// An array of points.

         /// </returns>

         private PointF[] ToPoints(IList<ScreenPoint> points)

         {

             if (points == null)

             {

                 return null;

             }

             var r = new PointF[points.Count()];

             int i = 0;

             foreach (ScreenPoint p in points)

             {

                 r[i++] = new PointF((float)p.X, (float)p.Y);

             }

             return r;

         }

         public override void CleanUp()

         {

             var imagesToRelease = imageCache.Keys.Where(i => !imagesInUse.Contains(i));

             foreach (var i in imagesToRelease)

             {

                 var image = this.GetImage(i);

                 image.Dispose();

                 imageCache.Remove(i);

             }

             imagesInUse.Clear();

         }

         public override OxyImageInfo GetImageInfo(OxyImage source)

         {

             var image = this.GetImage(source);

             return image == null ? null : new OxyImageInfo { Width = (uint)image.Width, Height = (uint)image.Height, DpiX = image.HorizontalResolution, DpiY = image.VerticalResolution };

         }

         public override void DrawImage(OxyImage source, uint srcX, uint srcY, uint srcWidth, uint srcHeight, double x, double y, double w, double h, double opacity, bool interpolate)

         {

             var image = this.GetImage(source);

             if (image != null)

             {

                 ImageAttributes ia = null;

                 if (opacity < 1)

                 {

                     var cm = new ColorMatrix

                                  {

                                      Matrix00 = 1f,

                                      Matrix11 = 1f,

                                      Matrix22 = 1f,

                                      Matrix33 = 1f,

                                      Matrix44 = (float)opacity

                                  };

                     ia = new ImageAttributes();

                     ia.SetColorMatrix(cm, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);

                 }

                 g.InterpolationMode = interpolate ? InterpolationMode.HighQualityBicubic : InterpolationMode.NearestNeighbor;

                 int sx = (int)Math.Round(x);

                 int sy = (int)Math.Round(y);

                 int sw = (int)Math.Round(x + w) - sx;

                 int sh = (int)Math.Round(y + h) - sy;

                 g.DrawImage(image, new Rectangle(sx, sy, sw, sh), srcX, srcY, srcWidth, srcHeight, GraphicsUnit.Pixel, ia);

             }

         }

         private HashSet<OxyImage> imagesInUse = new HashSet<OxyImage>();

         private Dictionary<OxyImage, Image> imageCache = new Dictionary<OxyImage, Image>();

         private Image GetImage(OxyImage source)

         {

             if (source == null)

             {

                 return null;

             }

             if (!this.imagesInUse.Contains(source))

             {

                 this.imagesInUse.Add(source);

             }

             Image src;

             if (this.imageCache.TryGetValue(source, out src))

             {

                 return src;

             }

             if (source != null)

             {

                 Image btm;

                 using (var ms = new MemoryStream(source.GetData()))

                 {

                     btm = Image.FromStream(ms);

                 }

                 this.imageCache.Add(source, btm);

                 return btm;

             }

             return null;

         }

         public override bool SetClip(OxyRect rect)

         {

             this.g.SetClip(rect.ToRect(false));

             return true;

         }

         public override void ResetClip()

         {

             this.g.ResetClip();

         }

     }

 }