1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/External/OxyPlot/GlobalAssemblyInfo.cs	Sat Jun 08 16:53:22 2013 +0000
     1.3 @@ -0,0 +1,38 @@
     1.4 +//-----------------------------------------------------------------------
     1.5 +// <copyright file="GlobalAssemblyInfo.cs" company="OxyPlot">
     1.6 +//   The MIT License (MIT)
     1.7 +//
     1.8 +//   Copyright (c) 2012 Oystein Bjorke
     1.9 +//
    1.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
    1.11 +//   copy of this software and associated documentation files (the
    1.12 +//   "Software"), to deal in the Software without restriction, including
    1.13 +//   without limitation the rights to use, copy, modify, merge, publish,
    1.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
    1.15 +//   permit persons to whom the Software is furnished to do so, subject to
    1.16 +//   the following conditions:
    1.17 +//
    1.18 +//   The above copyright notice and this permission notice shall be included
    1.19 +//   in all copies or substantial portions of the Software.
    1.20 +//
    1.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    1.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    1.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    1.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    1.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    1.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    1.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    1.28 +// </copyright>
    1.29 +//-----------------------------------------------------------------------
    1.30 +
    1.31 +using System.Reflection;
    1.32 +
    1.33 +[assembly: AssemblyConfiguration("")]
    1.34 +[assembly: AssemblyProduct("OxyPlot")]
    1.35 +[assembly: AssemblyCompany("OxyPlot")]
    1.36 +[assembly: AssemblyCopyright("Copyright (C) OxyPlot 2012.")]
    1.37 +[assembly: AssemblyTrademark("")]
    1.38 +[assembly: AssemblyCulture("")]
    1.39 +
    1.40 +[assembly: AssemblyVersion("2013.1.1.1")]
    1.41 +[assembly: AssemblyFileVersion("2013.1.1.1")]

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/External/OxyPlot/OxyPlot.WindowsForms/GraphicsRenderContext.cs	Sat Jun 08 16:53:22 2013 +0000
     2.3 @@ -0,0 +1,558 @@
     2.4 +// --------------------------------------------------------------------------------------------------------------------
     2.5 +// <copyright file="GraphicsRenderContext.cs" company="OxyPlot">
     2.6 +//   The MIT License (MIT)
     2.7 +//
     2.8 +//   Copyright (c) 2012 Oystein Bjorke
     2.9 +//
    2.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
    2.11 +//   copy of this software and associated documentation files (the
    2.12 +//   "Software"), to deal in the Software without restriction, including
    2.13 +//   without limitation the rights to use, copy, modify, merge, publish,
    2.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
    2.15 +//   permit persons to whom the Software is furnished to do so, subject to
    2.16 +//   the following conditions:
    2.17 +//
    2.18 +//   The above copyright notice and this permission notice shall be included
    2.19 +//   in all copies or substantial portions of the Software.
    2.20 +//
    2.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    2.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    2.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    2.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    2.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    2.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    2.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    2.28 +// </copyright>
    2.29 +// <summary>
    2.30 +//   The graphics render context.
    2.31 +// </summary>
    2.32 +// --------------------------------------------------------------------------------------------------------------------
    2.33 +namespace OxyPlot.WindowsForms
    2.34 +{
    2.35 +    using System;
    2.36 +    using System.Collections.Generic;
    2.37 +    using System.Drawing;
    2.38 +    using System.Drawing.Drawing2D;
    2.39 +    using System.Drawing.Imaging;
    2.40 +    using System.IO;
    2.41 +    using System.Linq;
    2.42 +
    2.43 +    using OxyPlot;
    2.44 +
    2.45 +    /// <summary>
    2.46 +    /// The graphics render context.
    2.47 +    /// </summary>
    2.48 +    internal class GraphicsRenderContext : RenderContextBase
    2.49 +    {
    2.50 +        /// <summary>
    2.51 +        /// The font size factor.
    2.52 +        /// </summary>
    2.53 +        private const float FontsizeFactor = 0.8f;
    2.54 +
    2.55 +        /// <summary>
    2.56 +        /// The GDI+ drawing surface.
    2.57 +        /// </summary>
    2.58 +        private Graphics g;
    2.59 +
    2.60 +        /// <summary>
    2.61 +        /// Initializes a new instance of the <see cref="GraphicsRenderContext"/> class.
    2.62 +        /// </summary>
    2.63 +        public GraphicsRenderContext()
    2.64 +        {
    2.65 +        }
    2.66 +
    2.67 +        /// <summary>
    2.68 +        /// Sets the graphics target.
    2.69 +        /// </summary>
    2.70 +        /// <param name="graphics">The graphics surface.</param>
    2.71 +        public void SetGraphicsTarget(Graphics graphics)
    2.72 +        {
    2.73 +            this.g = graphics;
    2.74 +        }
    2.75 +
    2.76 +        /// <summary>
    2.77 +        /// Draws the ellipse.
    2.78 +        /// </summary>
    2.79 +        /// <param name="rect">The rect.</param>
    2.80 +        /// <param name="fill">The fill.</param>
    2.81 +        /// <param name="stroke">The stroke.</param>
    2.82 +        /// <param name="thickness">The thickness.</param>
    2.83 +        public override void DrawEllipse(OxyRect rect, OxyColor fill, OxyColor stroke, double thickness)
    2.84 +        {
    2.85 +            if (fill != null)
    2.86 +            {
    2.87 +                this.g.FillEllipse(
    2.88 +                    this.ToBrush(fill), (float)rect.Left, (float)rect.Top, (float)rect.Width, (float)rect.Height);
    2.89 +            }
    2.90 +
    2.91 +            if (stroke == null || thickness <= 0)
    2.92 +            {
    2.93 +                return;
    2.94 +            }
    2.95 +
    2.96 +            using (var pen = new Pen(this.ToColor(stroke), (float)thickness))
    2.97 +            {
    2.98 +                this.g.SmoothingMode = SmoothingMode.HighQuality;
    2.99 +                this.g.DrawEllipse(pen, (float)rect.Left, (float)rect.Top, (float)rect.Width, (float)rect.Height);
   2.100 +            }
   2.101 +        }
   2.102 +
   2.103 +        /// <summary>
   2.104 +        /// Draws the line.
   2.105 +        /// </summary>
   2.106 +        /// <param name="points">The points.</param>
   2.107 +        /// <param name="stroke">The stroke.</param>
   2.108 +        /// <param name="thickness">The thickness.</param>
   2.109 +        /// <param name="dashArray">The dash array.</param>
   2.110 +        /// <param name="lineJoin">The line join.</param>
   2.111 +        /// <param name="aliased">if set to <c>true</c> [aliased].</param>
   2.112 +        public override void DrawLine(
   2.113 +            IList<ScreenPoint> points,
   2.114 +            OxyColor stroke,
   2.115 +            double thickness,
   2.116 +            double[] dashArray,
   2.117 +            OxyPenLineJoin lineJoin,
   2.118 +            bool aliased)
   2.119 +        {
   2.120 +            if (stroke == null || thickness <= 0 || points.Count < 2)
   2.121 +            {
   2.122 +                return;
   2.123 +            }
   2.124 +
   2.125 +            this.g.SmoothingMode = aliased ? SmoothingMode.None : SmoothingMode.HighQuality;
   2.126 +            using (var pen = new Pen(this.ToColor(stroke), (float)thickness))
   2.127 +            {
   2.128 +
   2.129 +                if (dashArray != null)
   2.130 +                {
   2.131 +                    pen.DashPattern = this.ToFloatArray(dashArray);
   2.132 +                }
   2.133 +
   2.134 +                switch (lineJoin)
   2.135 +                {
   2.136 +                    case OxyPenLineJoin.Round:
   2.137 +                        pen.LineJoin = LineJoin.Round;
   2.138 +                        break;
   2.139 +                    case OxyPenLineJoin.Bevel:
   2.140 +                        pen.LineJoin = LineJoin.Bevel;
   2.141 +                        break;
   2.142 +
   2.143 +                    // The default LineJoin is Miter
   2.144 +                }
   2.145 +
   2.146 +                this.g.DrawLines(pen, this.ToPoints(points));
   2.147 +            }
   2.148 +        }
   2.149 +
   2.150 +        /// <summary>
   2.151 +        /// Draws the polygon.
   2.152 +        /// </summary>
   2.153 +        /// <param name="points">The points.</param>
   2.154 +        /// <param name="fill">The fill.</param>
   2.155 +        /// <param name="stroke">The stroke.</param>
   2.156 +        /// <param name="thickness">The thickness.</param>
   2.157 +        /// <param name="dashArray">The dash array.</param>
   2.158 +        /// <param name="lineJoin">The line join.</param>
   2.159 +        /// <param name="aliased">if set to <c>true</c> [aliased].</param>
   2.160 +        public override void DrawPolygon(
   2.161 +            IList<ScreenPoint> points,
   2.162 +            OxyColor fill,
   2.163 +            OxyColor stroke,
   2.164 +            double thickness,
   2.165 +            double[] dashArray,
   2.166 +            OxyPenLineJoin lineJoin,
   2.167 +            bool aliased)
   2.168 +        {
   2.169 +            if (points.Count < 2)
   2.170 +            {
   2.171 +                return;
   2.172 +            }
   2.173 +
   2.174 +            this.g.SmoothingMode = aliased ? SmoothingMode.None : SmoothingMode.HighQuality;
   2.175 +
   2.176 +            PointF[] pts = this.ToPoints(points);
   2.177 +            if (fill != null)
   2.178 +            {
   2.179 +                this.g.FillPolygon(this.ToBrush(fill), pts);
   2.180 +            }
   2.181 +
   2.182 +            if (stroke != null && thickness > 0)
   2.183 +            {
   2.184 +                using (var pen = new Pen(this.ToColor(stroke), (float)thickness))
   2.185 +                {
   2.186 +
   2.187 +                    if (dashArray != null)
   2.188 +                    {
   2.189 +                        pen.DashPattern = this.ToFloatArray(dashArray);
   2.190 +                    }
   2.191 +
   2.192 +                    switch (lineJoin)
   2.193 +                    {
   2.194 +                        case OxyPenLineJoin.Round:
   2.195 +                            pen.LineJoin = LineJoin.Round;
   2.196 +                            break;
   2.197 +                        case OxyPenLineJoin.Bevel:
   2.198 +                            pen.LineJoin = LineJoin.Bevel;
   2.199 +                            break;
   2.200 +
   2.201 +                        // The default LineJoin is Miter
   2.202 +                    }
   2.203 +
   2.204 +                    this.g.DrawPolygon(pen, pts);
   2.205 +                }
   2.206 +            }
   2.207 +        }
   2.208 +
   2.209 +        /// <summary>
   2.210 +        /// The draw rectangle.
   2.211 +        /// </summary>
   2.212 +        /// <param name="rect">
   2.213 +        /// The rect.
   2.214 +        /// </param>
   2.215 +        /// <param name="fill">
   2.216 +        /// The fill.
   2.217 +        /// </param>
   2.218 +        /// <param name="stroke">
   2.219 +        /// The stroke.
   2.220 +        /// </param>
   2.221 +        /// <param name="thickness">
   2.222 +        /// The thickness.
   2.223 +        /// </param>
   2.224 +        public override void DrawRectangle(OxyRect rect, OxyColor fill, OxyColor stroke, double thickness)
   2.225 +        {
   2.226 +            if (fill != null)
   2.227 +            {
   2.228 +                this.g.FillRectangle(
   2.229 +                    this.ToBrush(fill), (float)rect.Left, (float)rect.Top, (float)rect.Width, (float)rect.Height);
   2.230 +            }
   2.231 +
   2.232 +            if (stroke == null || thickness <= 0)
   2.233 +            {
   2.234 +                return;
   2.235 +            }
   2.236 +
   2.237 +            using (var pen = new Pen(this.ToColor(stroke), (float)thickness))
   2.238 +            {
   2.239 +                this.g.DrawRectangle(pen, (float)rect.Left, (float)rect.Top, (float)rect.Width, (float)rect.Height);
   2.240 +            }
   2.241 +        }
   2.242 +
   2.243 +        /// <summary>
   2.244 +        /// The draw text.
   2.245 +        /// </summary>
   2.246 +        /// <param name="p">
   2.247 +        /// The p.
   2.248 +        /// </param>
   2.249 +        /// <param name="text">
   2.250 +        /// The text.
   2.251 +        /// </param>
   2.252 +        /// <param name="fill">
   2.253 +        /// The fill.
   2.254 +        /// </param>
   2.255 +        /// <param name="fontFamily">
   2.256 +        /// The font family.
   2.257 +        /// </param>
   2.258 +        /// <param name="fontSize">
   2.259 +        /// The font size.
   2.260 +        /// </param>
   2.261 +        /// <param name="fontWeight">
   2.262 +        /// The font weight.
   2.263 +        /// </param>
   2.264 +        /// <param name="rotate">
   2.265 +        /// The rotate.
   2.266 +        /// </param>
   2.267 +        /// <param name="halign">
   2.268 +        /// The halign.
   2.269 +        /// </param>
   2.270 +        /// <param name="valign">
   2.271 +        /// The valign.
   2.272 +        /// </param>
   2.273 +        /// <param name="maxSize">
   2.274 +        /// The maximum size of the text.
   2.275 +        /// </param>
   2.276 +        public override void DrawText(
   2.277 +            ScreenPoint p,
   2.278 +            string text,
   2.279 +            OxyColor fill,
   2.280 +            string fontFamily,
   2.281 +            double fontSize,
   2.282 +            double fontWeight,
   2.283 +            double rotate,
   2.284 +            HorizontalAlignment halign,
   2.285 +            VerticalAlignment valign,
   2.286 +            OxySize? maxSize)
   2.287 +        {
   2.288 +            var fs = FontStyle.Regular;
   2.289 +            if (fontWeight >= 700)
   2.290 +            {
   2.291 +                fs = FontStyle.Bold;
   2.292 +            }
   2.293 +
   2.294 +            using (var font = new Font(fontFamily, (float)fontSize * FontsizeFactor, fs))
   2.295 +            {
   2.296 +                using (var sf = new StringFormat { Alignment = StringAlignment.Near })
   2.297 +                {
   2.298 +                    var size = this.g.MeasureString(text, font);
   2.299 +                    if (maxSize != null)
   2.300 +                    {
   2.301 +                        if (size.Width > maxSize.Value.Width)
   2.302 +                        {
   2.303 +                            size.Width = (float)maxSize.Value.Width;
   2.304 +                        }
   2.305 +
   2.306 +                        if (size.Height > maxSize.Value.Height)
   2.307 +                        {
   2.308 +                            size.Height = (float)maxSize.Value.Height;
   2.309 +                        }
   2.310 +                    }
   2.311 +
   2.312 +                    float dx = 0;
   2.313 +                    if (halign == HorizontalAlignment.Center)
   2.314 +                    {
   2.315 +                        dx = -size.Width / 2;
   2.316 +                    }
   2.317 +
   2.318 +                    if (halign == HorizontalAlignment.Right)
   2.319 +                    {
   2.320 +                        dx = -size.Width;
   2.321 +                    }
   2.322 +
   2.323 +                    float dy = 0;
   2.324 +                    sf.LineAlignment = StringAlignment.Near;
   2.325 +                    if (valign == VerticalAlignment.Middle)
   2.326 +                    {
   2.327 +                        dy = -size.Height / 2;
   2.328 +                    }
   2.329 +
   2.330 +                    if (valign == VerticalAlignment.Bottom)
   2.331 +                    {
   2.332 +                        dy = -size.Height;
   2.333 +                    }
   2.334 +
   2.335 +                    this.g.TranslateTransform((float)p.X, (float)p.Y);
   2.336 +                    if (Math.Abs(rotate) > double.Epsilon)
   2.337 +                    {
   2.338 +                        this.g.RotateTransform((float)rotate);
   2.339 +                    }
   2.340 +
   2.341 +                    this.g.TranslateTransform(dx, dy);
   2.342 +
   2.343 +                    var layoutRectangle = new RectangleF(0, 0, size.Width, size.Height);
   2.344 +                    this.g.DrawString(text, font, this.ToBrush(fill), layoutRectangle, sf);
   2.345 +
   2.346 +                    this.g.ResetTransform();
   2.347 +                }
   2.348 +            }
   2.349 +        }
   2.350 +
   2.351 +        /// <summary>
   2.352 +        /// The measure text.
   2.353 +        /// </summary>
   2.354 +        /// <param name="text">The text.</param>
   2.355 +        /// <param name="fontFamily">The font family.</param>
   2.356 +        /// <param name="fontSize">The font size.</param>
   2.357 +        /// <param name="fontWeight">The font weight.</param>
   2.358 +        /// <returns>The size of the text.</returns>
   2.359 +        public override OxySize MeasureText(string text, string fontFamily, double fontSize, double fontWeight)
   2.360 +        {
   2.361 +            if (text == null)
   2.362 +            {
   2.363 +                return OxySize.Empty;
   2.364 +            }
   2.365 +
   2.366 +            var fs = FontStyle.Regular;
   2.367 +            if (fontWeight >= 700)
   2.368 +            {
   2.369 +                fs = FontStyle.Bold;
   2.370 +            }
   2.371 +
   2.372 +            using (var font = new Font(fontFamily, (float)fontSize * FontsizeFactor, fs))
   2.373 +            {
   2.374 +                var size = this.g.MeasureString(text, font);
   2.375 +                return new OxySize(size.Width, size.Height);
   2.376 +            }
   2.377 +        }
   2.378 +
   2.379 +        /// <summary>
   2.380 +        /// Converts a fill color to a System.Drawing.Brush.
   2.381 +        /// </summary>
   2.382 +        /// <param name="fill">
   2.383 +        /// The fill color.
   2.384 +        /// </param>
   2.385 +        /// <returns>
   2.386 +        /// The brush.
   2.387 +        /// </returns>
   2.388 +        private Brush ToBrush(OxyColor fill)
   2.389 +        {
   2.390 +            if (fill != null)
   2.391 +            {
   2.392 +                return new SolidBrush(this.ToColor(fill));
   2.393 +            }
   2.394 +
   2.395 +            return null;
   2.396 +        }
   2.397 +
   2.398 +        /// <summary>
   2.399 +        /// Converts a color to a System.Drawing.Color.
   2.400 +        /// </summary>
   2.401 +        /// <param name="c">
   2.402 +        /// The color.
   2.403 +        /// </param>
   2.404 +        /// <returns>
   2.405 +        /// The System.Drawing.Color.
   2.406 +        /// </returns>
   2.407 +        private Color ToColor(OxyColor c)
   2.408 +        {
   2.409 +            return Color.FromArgb(c.A, c.R, c.G, c.B);
   2.410 +        }
   2.411 +
   2.412 +        /// <summary>
   2.413 +        /// Converts a double array to a float array.
   2.414 +        /// </summary>
   2.415 +        /// <param name="a">
   2.416 +        /// The a.
   2.417 +        /// </param>
   2.418 +        /// <returns>
   2.419 +        /// The float array.
   2.420 +        /// </returns>
   2.421 +        private float[] ToFloatArray(double[] a)
   2.422 +        {
   2.423 +            if (a == null)
   2.424 +            {
   2.425 +                return null;
   2.426 +            }
   2.427 +
   2.428 +            var r = new float[a.Length];
   2.429 +            for (int i = 0; i < a.Length; i++)
   2.430 +            {
   2.431 +                r[i] = (float)a[i];
   2.432 +            }
   2.433 +
   2.434 +            return r;
   2.435 +        }
   2.436 +
   2.437 +        /// <summary>
   2.438 +        /// Converts a list of point to an array of PointF.
   2.439 +        /// </summary>
   2.440 +        /// <param name="points">
   2.441 +        /// The points.
   2.442 +        /// </param>
   2.443 +        /// <returns>
   2.444 +        /// An array of points.
   2.445 +        /// </returns>
   2.446 +        private PointF[] ToPoints(IList<ScreenPoint> points)
   2.447 +        {
   2.448 +            if (points == null)
   2.449 +            {
   2.450 +                return null;
   2.451 +            }
   2.452 +
   2.453 +            var r = new PointF[points.Count()];
   2.454 +            int i = 0;
   2.455 +            foreach (ScreenPoint p in points)
   2.456 +            {
   2.457 +                r[i++] = new PointF((float)p.X, (float)p.Y);
   2.458 +            }
   2.459 +
   2.460 +            return r;
   2.461 +        }
   2.462 +
   2.463 +        public override void CleanUp()
   2.464 +        {
   2.465 +            var imagesToRelease = imageCache.Keys.Where(i => !imagesInUse.Contains(i));
   2.466 +            foreach (var i in imagesToRelease)
   2.467 +            {
   2.468 +                var image = this.GetImage(i);
   2.469 +                image.Dispose();
   2.470 +                imageCache.Remove(i);
   2.471 +            }
   2.472 +
   2.473 +            imagesInUse.Clear();
   2.474 +        }
   2.475 +
   2.476 +        public override OxyImageInfo GetImageInfo(OxyImage source)
   2.477 +        {
   2.478 +            var image = this.GetImage(source);
   2.479 +            return image == null ? null : new OxyImageInfo { Width = (uint)image.Width, Height = (uint)image.Height, DpiX = image.HorizontalResolution, DpiY = image.VerticalResolution };
   2.480 +        }
   2.481 +
   2.482 +        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)
   2.483 +        {
   2.484 +            var image = this.GetImage(source);
   2.485 +            if (image != null)
   2.486 +            {
   2.487 +                ImageAttributes ia = null;
   2.488 +                if (opacity < 1)
   2.489 +                {
   2.490 +                    var cm = new ColorMatrix
   2.491 +                                 {
   2.492 +                                     Matrix00 = 1f,
   2.493 +                                     Matrix11 = 1f,
   2.494 +                                     Matrix22 = 1f,
   2.495 +                                     Matrix33 = 1f,
   2.496 +                                     Matrix44 = (float)opacity
   2.497 +                                 };
   2.498 +
   2.499 +                    ia = new ImageAttributes();
   2.500 +                    ia.SetColorMatrix(cm, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
   2.501 +                }
   2.502 +
   2.503 +                g.InterpolationMode = interpolate ? InterpolationMode.HighQualityBicubic : InterpolationMode.NearestNeighbor;
   2.504 +                int sx = (int)Math.Round(x);
   2.505 +                int sy = (int)Math.Round(y);
   2.506 +                int sw = (int)Math.Round(x + w) - sx;
   2.507 +                int sh = (int)Math.Round(y + h) - sy;
   2.508 +                g.DrawImage(image, new Rectangle(sx, sy, sw, sh), srcX, srcY, srcWidth, srcHeight, GraphicsUnit.Pixel, ia);
   2.509 +            }
   2.510 +        }
   2.511 +
   2.512 +        private HashSet<OxyImage> imagesInUse = new HashSet<OxyImage>();
   2.513 +
   2.514 +        private Dictionary<OxyImage, Image> imageCache = new Dictionary<OxyImage, Image>();
   2.515 +
   2.516 +
   2.517 +        private Image GetImage(OxyImage source)
   2.518 +        {
   2.519 +            if (source == null)
   2.520 +            {
   2.521 +                return null;
   2.522 +            }
   2.523 +
   2.524 +            if (!this.imagesInUse.Contains(source))
   2.525 +            {
   2.526 +                this.imagesInUse.Add(source);
   2.527 +            }
   2.528 +
   2.529 +            Image src;
   2.530 +            if (this.imageCache.TryGetValue(source, out src))
   2.531 +            {
   2.532 +                return src;
   2.533 +            }
   2.534 +
   2.535 +            if (source != null)
   2.536 +            {
   2.537 +                Image btm;
   2.538 +                using (var ms = new MemoryStream(source.GetData()))
   2.539 +                {
   2.540 +                    btm = Image.FromStream(ms);
   2.541 +                }
   2.542 +
   2.543 +                this.imageCache.Add(source, btm);
   2.544 +                return btm;
   2.545 +            }
   2.546 +
   2.547 +            return null;
   2.548 +        }
   2.549 +
   2.550 +        public override bool SetClip(OxyRect rect)
   2.551 +        {
   2.552 +            this.g.SetClip(rect.ToRect(false));
   2.553 +            return true;
   2.554 +        }
   2.555 +
   2.556 +        public override void ResetClip()
   2.557 +        {
   2.558 +            this.g.ResetClip();
   2.559 +        }
   2.560 +    }
   2.561 +}
   2.562 \ No newline at end of file

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/External/OxyPlot/OxyPlot.WindowsForms/Helpers/ConverterExtensions.cs	Sat Jun 08 16:53:22 2013 +0000
     3.3 @@ -0,0 +1,251 @@
     3.4 +// --------------------------------------------------------------------------------------------------------------------
     3.5 +// <copyright file="ConverterExtensions.cs" company="OxyPlot">
     3.6 +//   The MIT License (MIT)
     3.7 +//
     3.8 +//   Copyright (c) 2012 Oystein Bjorke
     3.9 +//
    3.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
    3.11 +//   copy of this software and associated documentation files (the
    3.12 +//   "Software"), to deal in the Software without restriction, including
    3.13 +//   without limitation the rights to use, copy, modify, merge, publish,
    3.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
    3.15 +//   permit persons to whom the Software is furnished to do so, subject to
    3.16 +//   the following conditions:
    3.17 +//
    3.18 +//   The above copyright notice and this permission notice shall be included
    3.19 +//   in all copies or substantial portions of the Software.
    3.20 +//
    3.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    3.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    3.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    3.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    3.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    3.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    3.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    3.28 +// </copyright>
    3.29 +// <summary>
    3.30 +//   Extension method used to convert to/from Windows/Windows.Media classes.
    3.31 +// </summary>
    3.32 +// --------------------------------------------------------------------------------------------------------------------
    3.33 +namespace OxyPlot.WindowsForms
    3.34 +{
    3.35 +    using System;
    3.36 +    using System.Drawing;
    3.37 +    using System.Windows.Forms;
    3.38 +
    3.39 +    /// <summary>
    3.40 +    /// Extension method used to convert to/from Windows/Windows.Media classes.
    3.41 +    /// </summary>
    3.42 +    public static class ConverterExtensions
    3.43 +    {
    3.44 +        /// <summary>
    3.45 +        /// Calculate the distance between two points.
    3.46 +        /// </summary>
    3.47 +        /// <param name="p1">
    3.48 +        /// The first point.
    3.49 +        /// </param>
    3.50 +        /// <param name="p2">
    3.51 +        /// The second point.
    3.52 +        /// </param>
    3.53 +        /// <returns>
    3.54 +        /// The distance.
    3.55 +        /// </returns>
    3.56 +        public static double DistanceTo(this Point p1, Point p2)
    3.57 +        {
    3.58 +            double dx = p1.X - p2.X;
    3.59 +            double dy = p1.Y - p2.Y;
    3.60 +            return Math.Sqrt((dx * dx) + (dy * dy));
    3.61 +        }
    3.62 +
    3.63 +        /// <summary>
    3.64 +        /// Converts a color to a Brush.
    3.65 +        /// </summary>
    3.66 +        /// <param name="c">
    3.67 +        /// The color.
    3.68 +        /// </param>
    3.69 +        /// <returns>
    3.70 +        /// A SolidColorBrush.
    3.71 +        /// </returns>
    3.72 +        public static Brush ToBrush(this OxyColor c)
    3.73 +        {
    3.74 +            return new SolidBrush(c.ToColor());
    3.75 +        }
    3.76 +
    3.77 +        /// <summary>
    3.78 +        /// Converts an OxyColor to a Color.
    3.79 +        /// </summary>
    3.80 +        /// <param name="c">
    3.81 +        /// The color.
    3.82 +        /// </param>
    3.83 +        /// <returns>
    3.84 +        /// A Color.
    3.85 +        /// </returns>
    3.86 +        public static Color ToColor(this OxyColor c)
    3.87 +        {
    3.88 +            return Color.FromArgb(c.A, c.R, c.G, c.B);
    3.89 +        }
    3.90 +
    3.91 +        /// <summary>
    3.92 +        /// Converts a HorizontalAlignment to a HorizontalTextAlign.
    3.93 +        /// </summary>
    3.94 +        /// <param name="alignment">
    3.95 +        /// The alignment.
    3.96 +        /// </param>
    3.97 +        /// <returns>
    3.98 +        /// A HorizontalTextAlign.
    3.99 +        /// </returns>
   3.100 +        public static OxyPlot.HorizontalAlignment ToHorizontalTextAlign(this HorizontalAlignment alignment)
   3.101 +        {
   3.102 +            switch (alignment)
   3.103 +            {
   3.104 +                case HorizontalAlignment.Center:
   3.105 +                    return OxyPlot.HorizontalAlignment.Center;
   3.106 +                case HorizontalAlignment.Right:
   3.107 +                    return OxyPlot.HorizontalAlignment.Right;
   3.108 +                default:
   3.109 +                    return OxyPlot.HorizontalAlignment.Left;
   3.110 +            }
   3.111 +        }
   3.112 +
   3.113 +        /// <summary>
   3.114 +        /// Converts a Color to an OxyColor.
   3.115 +        /// </summary>
   3.116 +        /// <param name="color">
   3.117 +        /// The color.
   3.118 +        /// </param>
   3.119 +        /// <returns>
   3.120 +        /// An OxyColor.
   3.121 +        /// </returns>
   3.122 +        public static OxyColor ToOxyColor(this Color color)
   3.123 +        {
   3.124 +            return OxyColor.FromArgb(color.A, color.R, color.G, color.B);
   3.125 +        }
   3.126 +
   3.127 +        /// <summary>
   3.128 +        /// Converts a nullable Color to an OxyColor.
   3.129 +        /// </summary>
   3.130 +        /// <param name="color">
   3.131 +        /// The color.
   3.132 +        /// </param>
   3.133 +        /// <returns>
   3.134 +        /// An OxyColor.
   3.135 +        /// </returns>
   3.136 +        public static OxyColor ToOxyColor(this Color? color)
   3.137 +        {
   3.138 +            return color.HasValue ? color.Value.ToOxyColor() : null;
   3.139 +        }
   3.140 +
   3.141 +        /// <summary>
   3.142 +        /// Converts a Brush to an OxyColor.
   3.143 +        /// </summary>
   3.144 +        /// <param name="brush">
   3.145 +        /// The brush.
   3.146 +        /// </param>
   3.147 +        /// <returns>
   3.148 +        /// An oxycolor.
   3.149 +        /// </returns>
   3.150 +        public static OxyColor ToOxyColor(this Brush brush)
   3.151 +        {
   3.152 +            var scb = brush as SolidBrush;
   3.153 +            return scb != null ? scb.Color.ToOxyColor() : null;
   3.154 +        }
   3.155 +
   3.156 +        /// <summary>
   3.157 +        /// Converts a Thickness to an OxyThickness.
   3.158 +        /// </summary>
   3.159 +        /// <returns>
   3.160 +        /// An OxyPlot thickness.
   3.161 +        /// </returns>
   3.162 +        /// <summary>
   3.163 +        /// Converts a ScreenPoint to a Point.
   3.164 +        /// </summary>
   3.165 +        /// <param name="pt">
   3.166 +        /// The screen point.
   3.167 +        /// </param>
   3.168 +        /// <param name="aliased">
   3.169 +        /// use pixel alignment conversion if set to <c>true</c>.
   3.170 +        /// </param>
   3.171 +        /// <returns>
   3.172 +        /// A point.
   3.173 +        /// </returns>
   3.174 +        public static Point ToPoint(this ScreenPoint pt, bool aliased)
   3.175 +        {
   3.176 +            // adding 0.5 to get pixel boundary alignment, seems to work
   3.177 +            // http://weblogs.asp.net/mschwarz/archive/2008/01/04/silverlight-rectangles-paths-and-line-comparison.aspx
   3.178 +            // http://www.wynapse.com/Silverlight/Tutor/Silverlight_Rectangles_Paths_And_Lines_Comparison.aspx
   3.179 +            if (aliased)
   3.180 +            {
   3.181 +                return new Point((int)pt.X, (int)pt.Y);
   3.182 +            }
   3.183 +
   3.184 +            return new Point((int)Math.Round(pt.X), (int)Math.Round(pt.Y));
   3.185 +        }
   3.186 +
   3.187 +        /// <summary>
   3.188 +        /// Converts an OxyRect to a Rect.
   3.189 +        /// </summary>
   3.190 +        /// <param name="r">
   3.191 +        /// The rectangle.
   3.192 +        /// </param>
   3.193 +        /// <param name="aliased">
   3.194 +        /// use pixel alignment if set to <c>true</c>.
   3.195 +        /// </param>
   3.196 +        /// <returns>
   3.197 +        /// A rect.
   3.198 +        /// </returns>
   3.199 +        public static Rectangle ToRect(this OxyRect r, bool aliased)
   3.200 +        {
   3.201 +            if (aliased)
   3.202 +            {
   3.203 +                var x = (int)r.Left;
   3.204 +                var y = (int)r.Top;
   3.205 +                var ri = (int)r.Right;
   3.206 +                var bo = (int)r.Bottom;
   3.207 +                return new Rectangle(x, y, ri - x, bo - y);
   3.208 +            }
   3.209 +
   3.210 +            return new Rectangle(
   3.211 +                (int)Math.Round(r.Left), (int)Math.Round(r.Top), (int)Math.Round(r.Width), (int)Math.Round(r.Height));
   3.212 +        }
   3.213 +
   3.214 +        /// <summary>
   3.215 +        /// Converts a point to a ScreenPoint.
   3.216 +        /// </summary>
   3.217 +        /// <param name="pt">
   3.218 +        /// The point.
   3.219 +        /// </param>
   3.220 +        /// <returns>
   3.221 +        /// A screen point.
   3.222 +        /// </returns>
   3.223 +        public static ScreenPoint ToScreenPoint(this Point pt)
   3.224 +        {
   3.225 +            return new ScreenPoint(pt.X, pt.Y);
   3.226 +        }
   3.227 +
   3.228 +        /// <summary>
   3.229 +        /// Converts a Point array to a ScreenPoint array.
   3.230 +        /// </summary>
   3.231 +        /// <param name="points">
   3.232 +        /// The points.
   3.233 +        /// </param>
   3.234 +        /// <returns>
   3.235 +        /// A ScreenPoint array.
   3.236 +        /// </returns>
   3.237 +        public static ScreenPoint[] ToScreenPointArray(this Point[] points)
   3.238 +        {
   3.239 +            if (points == null)
   3.240 +            {
   3.241 +                return null;
   3.242 +            }
   3.243 +
   3.244 +            var pts = new ScreenPoint[points.Length];
   3.245 +            for (int i = 0; i < points.Length; i++)
   3.246 +            {
   3.247 +                pts[i] = points[i].ToScreenPoint();
   3.248 +            }
   3.249 +
   3.250 +            return pts;
   3.251 +        }
   3.252 +
   3.253 +    }
   3.254 +}
   3.255 \ No newline at end of file

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/External/OxyPlot/OxyPlot.WindowsForms/NamespaceDoc.cs	Sat Jun 08 16:53:22 2013 +0000
     4.3 @@ -0,0 +1,37 @@
     4.4 +// --------------------------------------------------------------------------------------------------------------------
     4.5 +// <copyright file="NamespaceDoc.cs" company="OxyPlot">
     4.6 +//   The MIT License (MIT)
     4.7 +//   
     4.8 +//   Copyright (c) 2012 Oystein Bjorke
     4.9 +//   
    4.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
    4.11 +//   copy of this software and associated documentation files (the
    4.12 +//   "Software"), to deal in the Software without restriction, including
    4.13 +//   without limitation the rights to use, copy, modify, merge, publish,
    4.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
    4.15 +//   permit persons to whom the Software is furnished to do so, subject to
    4.16 +//   the following conditions:
    4.17 +//   
    4.18 +//   The above copyright notice and this permission notice shall be included
    4.19 +//   in all copies or substantial portions of the Software.
    4.20 +//   
    4.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    4.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    4.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    4.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    4.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    4.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    4.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    4.28 +// </copyright>
    4.29 +// --------------------------------------------------------------------------------------------------------------------
    4.30 +
    4.31 +namespace OxyPlot.WindowsForms
    4.32 +{
    4.33 +    /// <summary>
    4.34 +    /// The OxyPlot.WindowsForms namespace contains controls for Windows Forms and a bitmap exporter.
    4.35 +    /// </summary>
    4.36 +    [System.Runtime.CompilerServices.CompilerGenerated]
    4.37 +    internal class NamespaceDoc
    4.38 +    {
    4.39 +    }
    4.40 +}
    4.41 \ No newline at end of file

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/External/OxyPlot/OxyPlot.WindowsForms/OxyPlot.WindowsForms.csproj	Sat Jun 08 16:53:22 2013 +0000
     5.3 @@ -0,0 +1,79 @@
     5.4 +<?xml version="1.0" encoding="utf-8"?>
     5.5 +<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
     5.6 +  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
     5.7 +  <PropertyGroup>
     5.8 +    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     5.9 +    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    5.10 +    <ProjectGuid>{D4554296-094E-4CAC-8EAE-44EB250666C6}</ProjectGuid>
    5.11 +    <OutputType>Library</OutputType>
    5.12 +    <AppDesignerFolder>Properties</AppDesignerFolder>
    5.13 +    <RootNamespace>OxyPlot.WindowsForms</RootNamespace>
    5.14 +    <AssemblyName>OxyPlot.WindowsForms</AssemblyName>
    5.15 +    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    5.16 +    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
    5.17 +    <FileAlignment>512</FileAlignment>
    5.18 +  </PropertyGroup>
    5.19 +  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    5.20 +    <DebugSymbols>true</DebugSymbols>
    5.21 +    <DebugType>full</DebugType>
    5.22 +    <Optimize>false</Optimize>
    5.23 +    <OutputPath>bin\Debug\NET40\</OutputPath>
    5.24 +    <IntermediateOutputPath>obj\Debug\NET40\</IntermediateOutputPath>
    5.25 +    <DefineConstants>DEBUG;TRACE</DefineConstants>
    5.26 +    <ErrorReport>prompt</ErrorReport>
    5.27 +    <WarningLevel>4</WarningLevel>
    5.28 +  </PropertyGroup>
    5.29 +  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    5.30 +    <DebugType>pdbonly</DebugType>
    5.31 +    <Optimize>true</Optimize>
    5.32 +    <OutputPath>..\..\Output\NET40\</OutputPath>
    5.33 +    <IntermediateOutputPath>obj\Release\NET40\</IntermediateOutputPath>
    5.34 +    <DefineConstants>TRACE</DefineConstants>
    5.35 +    <ErrorReport>prompt</ErrorReport>
    5.36 +    <WarningLevel>4</WarningLevel>
    5.37 +    <DocumentationFile>..\..\Output\NET40\OxyPlot.WindowsForms.XML</DocumentationFile>
    5.38 +  </PropertyGroup>
    5.39 +  <PropertyGroup>
    5.40 +    <SignAssembly>true</SignAssembly>
    5.41 +  </PropertyGroup>
    5.42 +  <PropertyGroup>
    5.43 +    <AssemblyOriginatorKeyFile>OxyPlot.WindowsForms.snk</AssemblyOriginatorKeyFile>
    5.44 +  </PropertyGroup>
    5.45 +  <ItemGroup>
    5.46 +    <Reference Include="System" />
    5.47 +    <Reference Include="System.Core" />
    5.48 +    <Reference Include="System.Drawing" />
    5.49 +    <Reference Include="System.Windows.Forms" />
    5.50 +  </ItemGroup>
    5.51 +  <ItemGroup>
    5.52 +    <Compile Include="..\GlobalAssemblyInfo.cs">
    5.53 +      <Link>Properties\GlobalAssemblyInfo.cs</Link>
    5.54 +    </Compile>
    5.55 +    <Compile Include="Helpers\ConverterExtensions.cs" />
    5.56 +    <Compile Include="GraphicsRenderContext.cs" />
    5.57 +    <Compile Include="NamespaceDoc.cs" />
    5.58 +    <Compile Include="Plot.cs">
    5.59 +      <SubType>Component</SubType>
    5.60 +    </Compile>
    5.61 +    <Compile Include="PngExporter.cs" />
    5.62 +    <Compile Include="Properties\AssemblyInfo.cs" />
    5.63 +    <Service Include="{94E38DFF-614B-4cbd-B67C-F211BB35CE8B}" />
    5.64 +  </ItemGroup>
    5.65 +  <ItemGroup>
    5.66 +    <None Include="OxyPlot.WindowsForms.snk" />
    5.67 +  </ItemGroup>
    5.68 +  <ItemGroup>
    5.69 +    <ProjectReference Include="..\OxyPlot\OxyPlot.csproj">
    5.70 +      <Project>{7a0b35c0-dd17-4964-8e9a-44d6cecdc692}</Project>
    5.71 +      <Name>OxyPlot</Name>
    5.72 +    </ProjectReference>
    5.73 +  </ItemGroup>
    5.74 +  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
    5.75 +  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
    5.76 +       Other similar extension points exist, see Microsoft.Common.targets.
    5.77 +  <Target Name="BeforeBuild">
    5.78 +  </Target>
    5.79 +  <Target Name="AfterBuild">
    5.80 +  </Target>
    5.81 +  -->
    5.82 +</Project>
    5.83 \ No newline at end of file

     6.1 Binary file External/OxyPlot/OxyPlot.WindowsForms/OxyPlot.WindowsForms.snk has changed

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/External/OxyPlot/OxyPlot.WindowsForms/Plot.cs	Sat Jun 08 16:53:22 2013 +0000
     7.3 @@ -0,0 +1,897 @@
     7.4 +// --------------------------------------------------------------------------------------------------------------------
     7.5 +// <copyright file="Plot.cs" company="OxyPlot">
     7.6 +//   The MIT License (MIT)
     7.7 +//
     7.8 +//   Copyright (c) 2012 Oystein Bjorke
     7.9 +//
    7.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
    7.11 +//   copy of this software and associated documentation files (the
    7.12 +//   "Software"), to deal in the Software without restriction, including
    7.13 +//   without limitation the rights to use, copy, modify, merge, publish,
    7.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
    7.15 +//   permit persons to whom the Software is furnished to do so, subject to
    7.16 +//   the following conditions:
    7.17 +//
    7.18 +//   The above copyright notice and this permission notice shall be included
    7.19 +//   in all copies or substantial portions of the Software.
    7.20 +//
    7.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    7.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    7.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    7.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    7.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    7.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    7.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    7.28 +// </copyright>
    7.29 +// <summary>
    7.30 +//   Represents a control that displays a plot.
    7.31 +// </summary>
    7.32 +// --------------------------------------------------------------------------------------------------------------------
    7.33 +namespace OxyPlot.WindowsForms
    7.34 +{
    7.35 +    using System;
    7.36 +    using System.ComponentModel;
    7.37 +    using System.Diagnostics;
    7.38 +    using System.Drawing;
    7.39 +    using System.Runtime.InteropServices;
    7.40 +    using System.Windows.Forms;
    7.41 +
    7.42 +    using OxyPlot.Axes;
    7.43 +    using OxyPlot.Series;
    7.44 +
    7.45 +    /// <summary>
    7.46 +    /// Represents a control that displays a plot.
    7.47 +    /// </summary>
    7.48 +    [Serializable]
    7.49 +    public class Plot : Control, IPlotControl
    7.50 +    {
    7.51 +        /// <summary>
    7.52 +        /// The category for the properties of this control.
    7.53 +        /// </summary>
    7.54 +        private const string OxyPlotCategory = "OxyPlot";
    7.55 +
    7.56 +        /// <summary>
    7.57 +        /// The invalidate lock.
    7.58 +        /// </summary>
    7.59 +        private readonly object invalidateLock = new object();
    7.60 +
    7.61 +        /// <summary>
    7.62 +        /// The model lock.
    7.63 +        /// </summary>
    7.64 +        private readonly object modelLock = new object();
    7.65 +
    7.66 +        /// <summary>
    7.67 +        /// The rendering lock.
    7.68 +        /// </summary>
    7.69 +        private readonly object renderingLock = new object();
    7.70 +
    7.71 +        /// <summary>
    7.72 +        /// The current model (holding a reference to this plot control).
    7.73 +        /// </summary>
    7.74 +        [NonSerialized]
    7.75 +        private PlotModel currentModel;
    7.76 +
    7.77 +        /// <summary>
    7.78 +        /// The is model invalidated.
    7.79 +        /// </summary>
    7.80 +        private bool isModelInvalidated;
    7.81 +
    7.82 +        /// <summary>
    7.83 +        /// The model.
    7.84 +        /// </summary>
    7.85 +        private PlotModel model;
    7.86 +
    7.87 +        /// <summary>
    7.88 +        /// The mouse manipulator.
    7.89 +        /// </summary>
    7.90 +        [NonSerialized]
    7.91 +        private ManipulatorBase mouseManipulator;
    7.92 +
    7.93 +        /// <summary>
    7.94 +        /// The update data flag.
    7.95 +        /// </summary>
    7.96 +        private bool updateDataFlag = true;
    7.97 +
    7.98 +        /// <summary>
    7.99 +        /// The zoom rectangle.
   7.100 +        /// </summary>
   7.101 +        private Rectangle zoomRectangle;
   7.102 +
   7.103 +        /// <summary>
   7.104 +        /// The render context.
   7.105 +        /// </summary>
   7.106 +        private GraphicsRenderContext renderContext;
   7.107 +
   7.108 +        /// <summary>
   7.109 +        /// Initializes a new instance of the <see cref="Plot"/> class.
   7.110 +        /// </summary>
   7.111 +        public Plot()
   7.112 +        {
   7.113 +            this.renderContext = new GraphicsRenderContext();
   7.114 +
   7.115 +            // ReSharper disable DoNotCallOverridableMethodsInConstructor
   7.116 +            this.DoubleBuffered = true;
   7.117 +            // ReSharper restore DoNotCallOverridableMethodsInConstructor
   7.118 +            this.KeyboardPanHorizontalStep = 0.1;
   7.119 +            this.KeyboardPanVerticalStep = 0.1;
   7.120 +            this.PanCursor = Cursors.Hand;
   7.121 +            this.ZoomRectangleCursor = Cursors.SizeNWSE;
   7.122 +            this.ZoomHorizontalCursor = Cursors.SizeWE;
   7.123 +            this.ZoomVerticalCursor = Cursors.SizeNS;
   7.124 +        }
   7.125 +
   7.126 +        /// <summary>
   7.127 +        /// Gets the actual model.
   7.128 +        /// </summary>
   7.129 +        /// <value> The actual model. </value>
   7.130 +        public PlotModel ActualModel
   7.131 +        {
   7.132 +            get
   7.133 +            {
   7.134 +                return this.Model;
   7.135 +            }
   7.136 +        }
   7.137 +
   7.138 +        /// <summary>
   7.139 +        /// Gets or sets the keyboard pan horizontal step.
   7.140 +        /// </summary>
   7.141 +        /// <value> The keyboard pan horizontal step. </value>
   7.142 +        [Category(OxyPlotCategory)]
   7.143 +        public double KeyboardPanHorizontalStep { get; set; }
   7.144 +
   7.145 +        /// <summary>
   7.146 +        /// Gets or sets the keyboard pan vertical step.
   7.147 +        /// </summary>
   7.148 +        /// <value> The keyboard pan vertical step. </value>
   7.149 +        [Category(OxyPlotCategory)]
   7.150 +        public double KeyboardPanVerticalStep { get; set; }
   7.151 +
   7.152 +        /// <summary>
   7.153 +        /// Gets or sets the model.
   7.154 +        /// </summary>
   7.155 +        [Browsable(false)]
   7.156 +        [DefaultValue(null)]
   7.157 +        [Category(OxyPlotCategory)]
   7.158 +        public PlotModel Model
   7.159 +        {
   7.160 +            get
   7.161 +            {
   7.162 +                return this.model;
   7.163 +            }
   7.164 +
   7.165 +            set
   7.166 +            {
   7.167 +                if (this.model != value)
   7.168 +                {
   7.169 +                    this.model = value;
   7.170 +                    this.OnModelChanged();
   7.171 +                }
   7.172 +            }
   7.173 +        }
   7.174 +
   7.175 +        /// <summary>
   7.176 +        /// Gets or sets the pan cursor.
   7.177 +        /// </summary>
   7.178 +        [Category(OxyPlotCategory)]
   7.179 +        public Cursor PanCursor { get; set; }
   7.180 +
   7.181 +        /// <summary>
   7.182 +        /// Gets or sets the horizontal zoom cursor.
   7.183 +        /// </summary>
   7.184 +        [Category(OxyPlotCategory)]
   7.185 +        public Cursor ZoomHorizontalCursor { get; set; }
   7.186 +
   7.187 +        /// <summary>
   7.188 +        /// Gets or sets the rectangle zoom cursor.
   7.189 +        /// </summary>
   7.190 +        [Category(OxyPlotCategory)]
   7.191 +        public Cursor ZoomRectangleCursor { get; set; }
   7.192 +
   7.193 +        /// <summary>
   7.194 +        /// Gets or sets vertical zoom cursor.
   7.195 +        /// </summary>
   7.196 +        [Category(OxyPlotCategory)]
   7.197 +        public Cursor ZoomVerticalCursor { get; set; }
   7.198 +
   7.199 +        /// <summary>
   7.200 +        /// Get the axes from a point.
   7.201 +        /// </summary>
   7.202 +        /// <param name="pt">
   7.203 +        /// The point.
   7.204 +        /// </param>
   7.205 +        /// <param name="xaxis">
   7.206 +        /// The x axis.
   7.207 +        /// </param>
   7.208 +        /// <param name="yaxis">
   7.209 +        /// The y axis.
   7.210 +        /// </param>
   7.211 +        public void GetAxesFromPoint(ScreenPoint pt, out Axis xaxis, out Axis yaxis)
   7.212 +        {
   7.213 +            if (this.Model == null)
   7.214 +            {
   7.215 +                xaxis = null;
   7.216 +                yaxis = null;
   7.217 +                return;
   7.218 +            }
   7.219 +
   7.220 +            this.Model.GetAxesFromPoint(pt, out xaxis, out yaxis);
   7.221 +        }
   7.222 +
   7.223 +        /// <summary>
   7.224 +        /// Get the series from a point.
   7.225 +        /// </summary>
   7.226 +        /// <param name="pt">
   7.227 +        /// The point (screen coordinates).
   7.228 +        /// </param>
   7.229 +        /// <param name="limit">
   7.230 +        /// The limit.
   7.231 +        /// </param>
   7.232 +        /// <returns>
   7.233 +        /// The series.
   7.234 +        /// </returns>
   7.235 +        public Series GetSeriesFromPoint(ScreenPoint pt, double limit)
   7.236 +        {
   7.237 +            if (this.Model == null)
   7.238 +            {
   7.239 +                return null;
   7.240 +            }
   7.241 +
   7.242 +            return this.Model.GetSeriesFromPoint(pt, limit);
   7.243 +        }
   7.244 +
   7.245 +        /// <summary>
   7.246 +        /// The hide tracker.
   7.247 +        /// </summary>
   7.248 +        public void HideTracker()
   7.249 +        {
   7.250 +        }
   7.251 +
   7.252 +        /// <summary>
   7.253 +        /// The hide zoom rectangle.
   7.254 +        /// </summary>
   7.255 +        public void HideZoomRectangle()
   7.256 +        {
   7.257 +            this.zoomRectangle = Rectangle.Empty;
   7.258 +            this.Invalidate();
   7.259 +        }
   7.260 +
   7.261 +        /// <summary>
   7.262 +        /// The invalidate plot.
   7.263 +        /// </summary>
   7.264 +        /// <param name="updateData">
   7.265 +        /// The update data.
   7.266 +        /// </param>
   7.267 +        public void InvalidatePlot(bool updateData)
   7.268 +        {
   7.269 +            lock (this.invalidateLock)
   7.270 +            {
   7.271 +                this.isModelInvalidated = true;
   7.272 +                this.updateDataFlag = this.updateDataFlag || updateData;
   7.273 +            }
   7.274 +
   7.275 +            this.Invalidate();
   7.276 +        }
   7.277 +
   7.278 +        /// <summary>
   7.279 +        /// Called when the Model property has been changed.
   7.280 +        /// </summary>
   7.281 +        public void OnModelChanged()
   7.282 +        {
   7.283 +            lock (this.modelLock)
   7.284 +            {
   7.285 +                if (this.currentModel != null)
   7.286 +                {
   7.287 +                    this.currentModel.AttachPlotControl(null);
   7.288 +                }
   7.289 +
   7.290 +                if (this.Model != null)
   7.291 +                {
   7.292 +                    if (this.Model.PlotControl != null)
   7.293 +                    {
   7.294 +                        throw new InvalidOperationException(
   7.295 +                            "This PlotModel is already in use by some other plot control.");
   7.296 +                    }
   7.297 +
   7.298 +                    this.Model.AttachPlotControl(this);
   7.299 +                    this.currentModel = this.Model;
   7.300 +                }
   7.301 +            }
   7.302 +
   7.303 +            this.InvalidatePlot(true);
   7.304 +        }
   7.305 +
   7.306 +        /// <summary>
   7.307 +        /// The pan.
   7.308 +        /// </summary>
   7.309 +        /// <param name="axis">
   7.310 +        /// The axis.
   7.311 +        /// </param>
   7.312 +        /// <param name="x0">
   7.313 +        /// The x 0.
   7.314 +        /// </param>
   7.315 +        /// <param name="x1">
   7.316 +        /// The x 1.
   7.317 +        /// </param>
   7.318 +        public void Pan(Axis axis, ScreenPoint x0, ScreenPoint x1)
   7.319 +        {
   7.320 +            axis.Pan(x0, x1);
   7.321 +            this.InvalidatePlot(false);
   7.322 +        }
   7.323 +
   7.324 +        /// <summary>
   7.325 +        /// Pans all axes.
   7.326 +        /// </summary>
   7.327 +        /// <param name="deltax">
   7.328 +        /// The horizontal delta.
   7.329 +        /// </param>
   7.330 +        /// <param name="deltay">
   7.331 +        /// The vertical delta.
   7.332 +        /// </param>
   7.333 +        public void PanAll(double deltax, double deltay)
   7.334 +        {
   7.335 +            foreach (var a in this.ActualModel.Axes)
   7.336 +            {
   7.337 +                a.Pan(a.IsHorizontal() ? deltax : deltay);
   7.338 +            }
   7.339 +
   7.340 +            this.InvalidatePlot(false);
   7.341 +        }
   7.342 +
   7.343 +        /// <summary>
   7.344 +        /// The refresh plot.
   7.345 +        /// </summary>
   7.346 +        /// <param name="updateData">
   7.347 +        /// The update data.
   7.348 +        /// </param>
   7.349 +        public void RefreshPlot(bool updateData)
   7.350 +        {
   7.351 +            lock (this.invalidateLock)
   7.352 +            {
   7.353 +                this.isModelInvalidated = true;
   7.354 +                this.updateDataFlag = this.updateDataFlag || updateData;
   7.355 +            }
   7.356 +
   7.357 +            this.Refresh();
   7.358 +        }
   7.359 +
   7.360 +        /// <summary>
   7.361 +        /// The reset.
   7.362 +        /// </summary>
   7.363 +        /// <param name="axis">
   7.364 +        /// The axis.
   7.365 +        /// </param>
   7.366 +        public void Reset(Axis axis)
   7.367 +        {
   7.368 +            axis.Reset();
   7.369 +            this.InvalidatePlot(false);
   7.370 +        }
   7.371 +
   7.372 +        /// <summary>
   7.373 +        /// Sets the cursor type.
   7.374 +        /// </summary>
   7.375 +        /// <param name="cursorType">
   7.376 +        /// The cursor type.
   7.377 +        /// </param>
   7.378 +        public void SetCursorType(CursorType cursorType)
   7.379 +        {
   7.380 +            switch (cursorType)
   7.381 +            {
   7.382 +                case CursorType.Pan:
   7.383 +                    this.Cursor = this.PanCursor;
   7.384 +                    break;
   7.385 +                case CursorType.ZoomRectangle:
   7.386 +                    this.Cursor = this.ZoomRectangleCursor;
   7.387 +                    break;
   7.388 +                case CursorType.ZoomHorizontal:
   7.389 +                    this.Cursor = this.ZoomHorizontalCursor;
   7.390 +                    break;
   7.391 +                case CursorType.ZoomVertical:
   7.392 +                    this.Cursor = this.ZoomVerticalCursor;
   7.393 +                    break;
   7.394 +                default:
   7.395 +                    this.Cursor = Cursors.Arrow;
   7.396 +                    break;
   7.397 +            }
   7.398 +        }
   7.399 +
   7.400 +        /// <summary>
   7.401 +        /// The show tracker.
   7.402 +        /// </summary>
   7.403 +        /// <param name="data">
   7.404 +        /// The data.
   7.405 +        /// </param>
   7.406 +        public void ShowTracker(TrackerHitResult data)
   7.407 +        {
   7.408 +            // not implemented for WindowsForms
   7.409 +        }
   7.410 +
   7.411 +        /// <summary>
   7.412 +        /// The show zoom rectangle.
   7.413 +        /// </summary>
   7.414 +        /// <param name="r">
   7.415 +        /// The r.
   7.416 +        /// </param>
   7.417 +        public void ShowZoomRectangle(OxyRect r)
   7.418 +        {
   7.419 +            this.zoomRectangle = new Rectangle((int)r.Left, (int)r.Top, (int)r.Width, (int)r.Height);
   7.420 +            this.Invalidate();
   7.421 +        }
   7.422 +
   7.423 +        /// <summary>
   7.424 +        /// The zoom.
   7.425 +        /// </summary>
   7.426 +        /// <param name="axis">
   7.427 +        /// The axis.
   7.428 +        /// </param>
   7.429 +        /// <param name="p1">
   7.430 +        /// The p 1.
   7.431 +        /// </param>
   7.432 +        /// <param name="p2">
   7.433 +        /// The p 2.
   7.434 +        /// </param>
   7.435 +        public void Zoom(Axis axis, double p1, double p2)
   7.436 +        {
   7.437 +            axis.Zoom(p1, p2);
   7.438 +            this.InvalidatePlot(false);
   7.439 +        }
   7.440 +
   7.441 +        /// <summary>
   7.442 +        /// The zoom all.
   7.443 +        /// </summary>
   7.444 +        public void ZoomAll()
   7.445 +        {
   7.446 +            foreach (var a in this.Model.Axes)
   7.447 +            {
   7.448 +                a.Reset();
   7.449 +            }
   7.450 +
   7.451 +            this.InvalidatePlot(false);
   7.452 +        }
   7.453 +
   7.454 +        /// <summary>
   7.455 +        /// Zooms all axes.
   7.456 +        /// </summary>
   7.457 +        /// <param name="delta">
   7.458 +        /// The delta.
   7.459 +        /// </param>
   7.460 +        public void ZoomAllAxes(double delta)
   7.461 +        {
   7.462 +            foreach (var a in this.ActualModel.Axes)
   7.463 +            {
   7.464 +                this.ZoomAt(a, delta);
   7.465 +            }
   7.466 +
   7.467 +            this.RefreshPlot(false);
   7.468 +        }
   7.469 +
   7.470 +        /// <summary>
   7.471 +        /// The zoom at.
   7.472 +        /// </summary>
   7.473 +        /// <param name="axis">
   7.474 +        /// The axis.
   7.475 +        /// </param>
   7.476 +        /// <param name="factor">
   7.477 +        /// The factor.
   7.478 +        /// </param>
   7.479 +        /// <param name="x">
   7.480 +        /// The x.
   7.481 +        /// </param>
   7.482 +        public void ZoomAt(Axis axis, double factor, double x = double.NaN)
   7.483 +        {
   7.484 +            if (double.IsNaN(x))
   7.485 +            {
   7.486 +                double sx = (axis.Transform(axis.ActualMaximum) + axis.Transform(axis.ActualMinimum)) * 0.5;
   7.487 +                x = axis.InverseTransform(sx);
   7.488 +            }
   7.489 +
   7.490 +            axis.ZoomAt(factor, x);
   7.491 +            this.InvalidatePlot(false);
   7.492 +        }
   7.493 +
   7.494 +        /// <summary>
   7.495 +        /// The on mouse down.
   7.496 +        /// </summary>
   7.497 +        /// <param name="e">
   7.498 +        /// The e.
   7.499 +        /// </param>
   7.500 +        protected override void OnMouseDown(MouseEventArgs e)
   7.501 +        {
   7.502 +            base.OnMouseDown(e);
   7.503 +
   7.504 +            if (this.mouseManipulator != null)
   7.505 +            {
   7.506 +                return;
   7.507 +            }
   7.508 +
   7.509 +            this.Focus();
   7.510 +            this.Capture = true;
   7.511 +
   7.512 +            if (this.ActualModel != null)
   7.513 +            {
   7.514 +                var args = this.CreateMouseEventArgs(e);
   7.515 +                this.ActualModel.HandleMouseDown(this, args);
   7.516 +                if (args.Handled)
   7.517 +                {
   7.518 +                    return;
   7.519 +                }
   7.520 +            }
   7.521 +
   7.522 +            this.mouseManipulator = this.GetManipulator(e);
   7.523 +
   7.524 +            if (this.mouseManipulator != null)
   7.525 +            {
   7.526 +                this.mouseManipulator.Started(this.CreateManipulationEventArgs(e));
   7.527 +            }
   7.528 +        }
   7.529 +
   7.530 +        /// <summary>
   7.531 +        /// The on mouse move.
   7.532 +        /// </summary>
   7.533 +        /// <param name="e">
   7.534 +        /// The e.
   7.535 +        /// </param>
   7.536 +        protected override void OnMouseMove(MouseEventArgs e)
   7.537 +        {
   7.538 +            base.OnMouseMove(e);
   7.539 +
   7.540 +            if (this.ActualModel != null)
   7.541 +            {
   7.542 +                var args = this.CreateMouseEventArgs(e);
   7.543 +                this.ActualModel.HandleMouseMove(this, args);
   7.544 +                if (args.Handled)
   7.545 +                {
   7.546 +                    return;
   7.547 +                }
   7.548 +            }
   7.549 +
   7.550 +            if (this.mouseManipulator != null)
   7.551 +            {
   7.552 +                this.mouseManipulator.Delta(this.CreateManipulationEventArgs(e));
   7.553 +            }
   7.554 +        }
   7.555 +
   7.556 +        /// <summary>
   7.557 +        /// Raises the <see cref="E:System.Windows.Forms.Control.MouseUp"/> event.
   7.558 +        /// </summary>
   7.559 +        /// <param name="e">
   7.560 +        /// A <see cref="T:System.Windows.Forms.MouseEventArgs"/> that contains the event data.
   7.561 +        /// </param>
   7.562 +        protected override void OnMouseUp(MouseEventArgs e)
   7.563 +        {
   7.564 +            base.OnMouseUp(e);
   7.565 +            this.Capture = false;
   7.566 +
   7.567 +            if (this.ActualModel != null)
   7.568 +            {
   7.569 +                var args = this.CreateMouseEventArgs(e);
   7.570 +                this.ActualModel.HandleMouseUp(this, args);
   7.571 +                if (args.Handled)
   7.572 +                {
   7.573 +                    return;
   7.574 +                }
   7.575 +            }
   7.576 +
   7.577 +            if (this.mouseManipulator != null)
   7.578 +            {
   7.579 +                this.mouseManipulator.Completed(this.CreateManipulationEventArgs(e));
   7.580 +            }
   7.581 +
   7.582 +            this.mouseManipulator = null;
   7.583 +        }
   7.584 +
   7.585 +        /// <summary>
   7.586 +        /// Raises the <see cref="E:System.Windows.Forms.Control.MouseWheel"/> event.
   7.587 +        /// </summary>
   7.588 +        /// <param name="e">
   7.589 +        /// A <see cref="T:System.Windows.Forms.MouseEventArgs"/> that contains the event data.
   7.590 +        /// </param>
   7.591 +        protected override void OnMouseWheel(MouseEventArgs e)
   7.592 +        {
   7.593 +            base.OnMouseWheel(e);
   7.594 +            bool isControlDown = ModifierKeys == Keys.Control;
   7.595 +            var m = new ZoomStepManipulator(this, e.Delta * 0.001, isControlDown);
   7.596 +            m.Started(new ManipulationEventArgs(e.Location.ToScreenPoint()));
   7.597 +        }
   7.598 +
   7.599 +        /// <summary>
   7.600 +        /// Raises the <see cref="E:System.Windows.Forms.Control.Paint"/> event.
   7.601 +        /// </summary>
   7.602 +        /// <param name="e">
   7.603 +        /// A <see cref="T:System.Windows.Forms.PaintEventArgs"/> that contains the event data.
   7.604 +        /// </param>
   7.605 +        protected override void OnPaint(PaintEventArgs e)
   7.606 +        {
   7.607 +            base.OnPaint(e);
   7.608 +            try
   7.609 +            {
   7.610 +                lock (this.invalidateLock)
   7.611 +                {
   7.612 +                    if (this.isModelInvalidated)
   7.613 +                    {
   7.614 +                        if (this.model != null)
   7.615 +                        {
   7.616 +                            this.model.Update(this.updateDataFlag);
   7.617 +                            this.updateDataFlag = false;
   7.618 +                        }
   7.619 +
   7.620 +                        this.isModelInvalidated = false;
   7.621 +                    }
   7.622 +                }
   7.623 +
   7.624 +                lock (this.renderingLock)
   7.625 +                {
   7.626 +                    this.renderContext.SetGraphicsTarget(e.Graphics);
   7.627 +                    if (this.model != null)
   7.628 +                    {
   7.629 +                        this.model.Render(this.renderContext, this.Width, this.Height);
   7.630 +                    }
   7.631 +
   7.632 +                    if (this.zoomRectangle != Rectangle.Empty)
   7.633 +                    {
   7.634 +                        using (var zoomBrush = new SolidBrush(Color.FromArgb(0x40, 0xFF, 0xFF, 0x00)))
   7.635 +                        using (var zoomPen = new Pen(Color.Black))
   7.636 +                        {
   7.637 +                            zoomPen.DashPattern = new float[] { 3, 1 };
   7.638 +                            e.Graphics.FillRectangle(zoomBrush, this.zoomRectangle);
   7.639 +                            e.Graphics.DrawRectangle(zoomPen, this.zoomRectangle);
   7.640 +                        }
   7.641 +                    }
   7.642 +                }
   7.643 +            }
   7.644 +            catch (Exception paintException)
   7.645 +            {
   7.646 +                var trace = new StackTrace(paintException);
   7.647 +                Debug.WriteLine(paintException);
   7.648 +                Debug.WriteLine(trace);
   7.649 +                using (var font = new Font("Arial", 10))
   7.650 +                {
   7.651 +                    e.Graphics.DrawString(
   7.652 +                        "OxyPlot paint exception: " + paintException.Message, font, Brushes.Red, 10, 10);
   7.653 +                }
   7.654 +            }
   7.655 +        }
   7.656 +
   7.657 +        /// <summary>
   7.658 +        /// Raises the <see cref="E:System.Windows.Forms.Control.PreviewKeyDown"/> event.
   7.659 +        /// </summary>
   7.660 +        /// <param name="e">
   7.661 +        /// A <see cref="T:System.Windows.Forms.PreviewKeyDownEventArgs"/> that contains the event data.
   7.662 +        /// </param>
   7.663 +        protected override void OnPreviewKeyDown(PreviewKeyDownEventArgs e)
   7.664 +        {
   7.665 +            base.OnPreviewKeyDown(e);
   7.666 +            if (e.KeyCode == Keys.A)
   7.667 +            {
   7.668 +                this.ZoomAll();
   7.669 +            }
   7.670 +
   7.671 +            bool control = (e.Modifiers & Keys.Control) == Keys.Control;
   7.672 +            bool alt = (e.Modifiers & Keys.Alt) == Keys.Alt;
   7.673 +
   7.674 +            double deltax = 0;
   7.675 +            double deltay = 0;
   7.676 +            double zoom = 0;
   7.677 +            switch (e.KeyCode)
   7.678 +            {
   7.679 +                case Keys.Up:
   7.680 +                    deltay = -1;
   7.681 +                    break;
   7.682 +                case Keys.Down:
   7.683 +                    deltay = 1;
   7.684 +                    break;
   7.685 +                case Keys.Left:
   7.686 +                    deltax = -1;
   7.687 +                    break;
   7.688 +                case Keys.Right:
   7.689 +                    deltax = 1;
   7.690 +                    break;
   7.691 +                case Keys.Add:
   7.692 +                case Keys.Oemplus:
   7.693 +                case Keys.PageUp:
   7.694 +                    zoom = 1;
   7.695 +                    break;
   7.696 +                case Keys.Subtract:
   7.697 +                case Keys.OemMinus:
   7.698 +                case Keys.PageDown:
   7.699 +                    zoom = -1;
   7.700 +                    break;
   7.701 +            }
   7.702 +
   7.703 +            if ((deltax * deltax) + (deltay * deltay) > 0)
   7.704 +            {
   7.705 +                deltax = deltax * this.ActualModel.PlotArea.Width * this.KeyboardPanHorizontalStep;
   7.706 +                deltay = deltay * this.ActualModel.PlotArea.Height * this.KeyboardPanVerticalStep;
   7.707 +
   7.708 +                // small steps if the user is pressing control
   7.709 +                if (control)
   7.710 +                {
   7.711 +                    deltax *= 0.2;
   7.712 +                    deltay *= 0.2;
   7.713 +                }
   7.714 +
   7.715 +                this.PanAll(deltax, deltay);
   7.716 +
   7.717 +                // e.Handled = true;
   7.718 +            }
   7.719 +
   7.720 +            if (Math.Abs(zoom) > 1e-8)
   7.721 +            {
   7.722 +                if (control)
   7.723 +                {
   7.724 +                    zoom *= 0.2;
   7.725 +                }
   7.726 +
   7.727 +                this.ZoomAllAxes(1 + (zoom * 0.12));
   7.728 +
   7.729 +                // e.Handled = true;
   7.730 +            }
   7.731 +
   7.732 +            if (control && alt && this.ActualModel != null)
   7.733 +            {
   7.734 +                switch (e.KeyCode)
   7.735 +                {
   7.736 +                    case Keys.R:
   7.737 +                        this.SetClipboardText(this.ActualModel.CreateTextReport());
   7.738 +                        break;
   7.739 +                    case Keys.C:
   7.740 +                        this.SetClipboardText(this.ActualModel.ToCode());
   7.741 +                        break;
   7.742 +                    case Keys.X:
   7.743 +
   7.744 +                        // this.SetClipboardText(this.ActualModel.ToXml());
   7.745 +                        break;
   7.746 +                }
   7.747 +            }
   7.748 +        }
   7.749 +
   7.750 +        /// <summary>
   7.751 +        /// Raises the <see cref="E:System.Windows.Forms.Control.Resize"/> event.
   7.752 +        /// </summary>
   7.753 +        /// <param name="e">
   7.754 +        /// An <see cref="T:System.EventArgs"/> that contains the event data.
   7.755 +        /// </param>
   7.756 +        protected override void OnResize(EventArgs e)
   7.757 +        {
   7.758 +            base.OnResize(e);
   7.759 +            this.InvalidatePlot(false);
   7.760 +        }
   7.761 +
   7.762 +        /// <summary>
   7.763 +        /// Converts the changed button.
   7.764 +        /// </summary>
   7.765 +        /// <param name="e">
   7.766 +        /// The <see cref="System.Windows.Forms.MouseEventArgs"/> instance containing the event data.
   7.767 +        /// </param>
   7.768 +        /// <returns>
   7.769 +        /// The mouse button.
   7.770 +        /// </returns>
   7.771 +        private static OxyMouseButton ConvertChangedButton(MouseEventArgs e)
   7.772 +        {
   7.773 +            switch (e.Button)
   7.774 +            {
   7.775 +                case MouseButtons.Left:
   7.776 +                    return OxyMouseButton.Left;
   7.777 +                case MouseButtons.Middle:
   7.778 +                    return OxyMouseButton.Middle;
   7.779 +                case MouseButtons.Right:
   7.780 +                    return OxyMouseButton.Right;
   7.781 +                case MouseButtons.XButton1:
   7.782 +                    return OxyMouseButton.XButton1;
   7.783 +                case MouseButtons.XButton2:
   7.784 +                    return OxyMouseButton.XButton2;
   7.785 +            }
   7.786 +
   7.787 +            return OxyMouseButton.Left;
   7.788 +        }
   7.789 +
   7.790 +        /// <summary>
   7.791 +        /// Creates the mouse event arguments.
   7.792 +        /// </summary>
   7.793 +        /// <param name="e">
   7.794 +        /// The <see cref="System.Windows.Forms.MouseEventArgs"/> instance containing the event data.
   7.795 +        /// </param>
   7.796 +        /// <returns>
   7.797 +        /// Mouse event arguments.
   7.798 +        /// </returns>
   7.799 +        private OxyMouseEventArgs CreateMouseEventArgs(MouseEventArgs e)
   7.800 +        {
   7.801 +            return new OxyMouseEventArgs
   7.802 +            {
   7.803 +                ChangedButton = ConvertChangedButton(e),
   7.804 +                Position = new ScreenPoint(e.Location.X, e.Location.Y),
   7.805 +                IsShiftDown = (ModifierKeys & Keys.Shift) == Keys.Shift,
   7.806 +                IsControlDown = (ModifierKeys & Keys.Control) == Keys.Control,
   7.807 +                IsAltDown = (ModifierKeys & Keys.Alt) == Keys.Alt,
   7.808 +            };
   7.809 +        }
   7.810 +
   7.811 +        /// <summary>
   7.812 +        /// Creates the manipulation event args.
   7.813 +        /// </summary>
   7.814 +        /// <param name="e">
   7.815 +        /// The MouseEventArgs instance containing the event data.
   7.816 +        /// </param>
   7.817 +        /// <returns>
   7.818 +        /// A manipulation event args object.
   7.819 +        /// </returns>
   7.820 +        private ManipulationEventArgs CreateManipulationEventArgs(MouseEventArgs e)
   7.821 +        {
   7.822 +            return new ManipulationEventArgs(e.Location.ToScreenPoint());
   7.823 +        }
   7.824 +
   7.825 +        /// <summary>
   7.826 +        /// Gets the manipulator for the current mouse button and modifier keys.
   7.827 +        /// </summary>
   7.828 +        /// <param name="e">
   7.829 +        /// The event args.
   7.830 +        /// </param>
   7.831 +        /// <returns>
   7.832 +        /// A manipulator or null if no gesture was recognized.
   7.833 +        /// </returns>
   7.834 +        private ManipulatorBase GetManipulator(MouseEventArgs e)
   7.835 +        {
   7.836 +            bool control = (ModifierKeys & Keys.Control) == Keys.Control;
   7.837 +            bool shift = (ModifierKeys & Keys.Shift) == Keys.Shift;
   7.838 +            bool alt = (ModifierKeys & Keys.Alt) == Keys.Alt;
   7.839 +
   7.840 +            bool lmb = e.Button == MouseButtons.Left;
   7.841 +            bool rmb = e.Button == MouseButtons.Right;
   7.842 +            bool mmb = e.Button == MouseButtons.Middle;
   7.843 +            bool xb1 = e.Button == MouseButtons.XButton1;
   7.844 +            bool xb2 = e.Button == MouseButtons.XButton2;
   7.845 +
   7.846 +            // MMB / control RMB / control+alt LMB
   7.847 +            if (mmb || (control && rmb) || (control && alt && lmb))
   7.848 +            {
   7.849 +                if (e.Clicks == 2)
   7.850 +                {
   7.851 +                    return new ResetManipulator(this);
   7.852 +                }
   7.853 +
   7.854 +                return new ZoomRectangleManipulator(this);
   7.855 +            }
   7.856 +
   7.857 +            // Right mouse button / alt+left mouse button
   7.858 +            if (rmb || (lmb && alt))
   7.859 +            {
   7.860 +                return new PanManipulator(this);
   7.861 +            }
   7.862 +
   7.863 +            // Left mouse button
   7.864 +            if (lmb)
   7.865 +            {
   7.866 +                return new TrackerManipulator(this) { Snap = !control, PointsOnly = shift };
   7.867 +            }
   7.868 +
   7.869 +            // XButtons are zoom-stepping
   7.870 +            if (xb1 || xb2)
   7.871 +            {
   7.872 +                double d = xb1 ? 0.05 : -0.05;
   7.873 +                return new ZoomStepManipulator(this, d, control);
   7.874 +            }
   7.875 +
   7.876 +            return null;
   7.877 +        }
   7.878 +
   7.879 +        /// <summary>
   7.880 +        /// The set clipboard text.
   7.881 +        /// </summary>
   7.882 +        /// <param name="text">
   7.883 +        /// The text.
   7.884 +        /// </param>
   7.885 +        private void SetClipboardText(string text)
   7.886 +        {
   7.887 +            try
   7.888 +            {
   7.889 +                // todo: can't get the following solution to work
   7.890 +                // http://stackoverflow.com/questions/5707990/requested-clipboard-operation-did-not-succeed
   7.891 +                Clipboard.SetText(text);
   7.892 +            }
   7.893 +            catch (ExternalException ee)
   7.894 +            {
   7.895 +                // Requested Clipboard operation did not succeed.
   7.896 +                MessageBox.Show(this, ee.Message, "OxyPlot");
   7.897 +            }
   7.898 +        }
   7.899 +    }
   7.900 +}
   7.901 \ No newline at end of file

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/External/OxyPlot/OxyPlot.WindowsForms/PlotControl.cs	Sat Jun 08 16:53:22 2013 +0000
     8.3 @@ -0,0 +1,237 @@
     8.4 +// --------------------------------------------------------------------------------------------------------------------
     8.5 +// <copyright file="PlotControl.cs" company="OxyPlot">
     8.6 +//   The MIT License (MIT)
     8.7 +//
     8.8 +//   Copyright (c) 2012 Oystein Bjorke
     8.9 +//
    8.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
    8.11 +//   copy of this software and associated documentation files (the
    8.12 +//   "Software"), to deal in the Software without restriction, including
    8.13 +//   without limitation the rights to use, copy, modify, merge, publish,
    8.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
    8.15 +//   permit persons to whom the Software is furnished to do so, subject to
    8.16 +//   the following conditions:
    8.17 +//
    8.18 +//   The above copyright notice and this permission notice shall be included
    8.19 +//   in all copies or substantial portions of the Software.
    8.20 +//
    8.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    8.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    8.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    8.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    8.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    8.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    8.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    8.28 +// </copyright>
    8.29 +// --------------------------------------------------------------------------------------------------------------------
    8.30 +using System;
    8.31 +using System.Collections.Generic;
    8.32 +using System.ComponentModel;
    8.33 +using System.Drawing;
    8.34 +using System.Windows.Forms;
    8.35 +using OxyPlot;
    8.36 +
    8.37 +namespace Oxyplot.WindowsForms
    8.38 +{
    8.39 +    public class PlotControl : Control, IPlotControl
    8.40 +    {
    8.41 +        public List<MouseAction> MouseActions { get; private set; }
    8.42 +
    8.43 +        private readonly PanAction panAction;
    8.44 +        private readonly SliderAction sliderAction;
    8.45 +        private readonly ZoomAction zoomAction;
    8.46 +        private Rectangle zoomRectangle;
    8.47 +
    8.48 +        public PlotControl()
    8.49 +        {
    8.50 +            //    InitializeComponent();
    8.51 +            DoubleBuffered = true;
    8.52 +            Model = new PlotModel();
    8.53 +
    8.54 +            panAction = new PanAction(this);
    8.55 +            zoomAction = new ZoomAction(this);
    8.56 +            sliderAction = new SliderAction(this);
    8.57 +
    8.58 +            MouseActions = new List<MouseAction>();
    8.59 +            MouseActions.Add(panAction);
    8.60 +            MouseActions.Add(zoomAction);
    8.61 +            MouseActions.Add(sliderAction);
    8.62 +        }
    8.63 +
    8.64 +        private PlotModel model;
    8.65 +
    8.66 +        [Browsable(false), DefaultValue(null)]
    8.67 +        public PlotModel Model
    8.68 +        {
    8.69 +            get { return model; }
    8.70 +            set
    8.71 +            {
    8.72 +                model = value;
    8.73 +                Refresh();
    8.74 +            }
    8.75 +        }
    8.76 +
    8.77 +        public override void Refresh()
    8.78 +        {
    8.79 +            if (model != null)
    8.80 +                model.UpdateData();
    8.81 +            base.Refresh();
    8.82 +        }
    8.83 +
    8.84 +        protected override void OnResize(EventArgs e)
    8.85 +        {
    8.86 +            base.OnResize(e);
    8.87 +            Invalidate();
    8.88 +        }
    8.89 +
    8.90 +        protected override void OnPaint(PaintEventArgs e)
    8.91 +        {
    8.92 +            base.OnPaint(e);
    8.93 +
    8.94 +            var rc = new GraphicsRenderContext(this, e.Graphics, e.ClipRectangle);
    8.95 +            if (model != null)
    8.96 +                model.Render(rc);
    8.97 +            if (zoomRectangle != Rectangle.Empty)
    8.98 +            {
    8.99 +                using (var zoomBrush = new SolidBrush(Color.FromArgb(0x40, 0xFF, 0xFF, 0x00)))
   8.100 +                using (var zoomPen = new Pen(Color.Black))
   8.101 +                {
   8.102 +                    zoomPen.DashPattern = new float[] { 3, 1 };
   8.103 +                    e.Graphics.FillRectangle(zoomBrush, zoomRectangle);
   8.104 +                    e.Graphics.DrawRectangle(zoomPen, zoomRectangle);
   8.105 +                }
   8.106 +            }
   8.107 +        }
   8.108 +
   8.109 +        protected override void OnKeyDown(KeyEventArgs e)
   8.110 +        {
   8.111 +            base.OnKeyDown(e);
   8.112 +            if (e.KeyCode == Keys.A)
   8.113 +            {
   8.114 +                ZoomAll();
   8.115 +            }
   8.116 +        }
   8.117 +
   8.118 +        public void ZoomAll()
   8.119 +        {
   8.120 +            foreach (var a in Model.Axes)
   8.121 +                a.Reset();
   8.122 +            Refresh();
   8.123 +        }
   8.124 +
   8.125 +        protected override void OnMouseDown(MouseEventArgs e)
   8.126 +        {
   8.127 +            base.OnMouseDown(e);
   8.128 +
   8.129 +            Focus();
   8.130 +            Capture = true;
   8.131 +
   8.132 +            bool control = Control.ModifierKeys == Keys.Control;
   8.133 +            bool shift = Control.ModifierKeys == Keys.Shift;
   8.134 +
   8.135 +            var button = OxyMouseButton.Left;
   8.136 +            if (e.Button == MouseButtons.Middle)
   8.137 +                button = OxyMouseButton.Middle;
   8.138 +            if (e.Button == MouseButtons.Right)
   8.139 +                button = OxyMouseButton.Right;
   8.140 +            if (e.Button == MouseButtons.XButton1)
   8.141 +                button = OxyMouseButton.XButton1;
   8.142 +            if (e.Button == MouseButtons.XButton2)
   8.143 +                button = OxyMouseButton.XButton2;
   8.144 +
   8.145 +            var p = new ScreenPoint(e.X, e.Y);
   8.146 +            foreach (var a in MouseActions)
   8.147 +                a.OnMouseDown(p, button, e.Clicks, control, shift);
   8.148 +        }
   8.149 +
   8.150 +        protected override void OnMouseMove(MouseEventArgs e)
   8.151 +        {
   8.152 +            base.OnMouseMove(e);
   8.153 +            bool control = Control.ModifierKeys == Keys.Control;
   8.154 +            bool shift = Control.ModifierKeys == Keys.Shift;
   8.155 +            var p = new ScreenPoint(e.X, e.Y);
   8.156 +            foreach (var a in MouseActions)
   8.157 +                a.OnMouseMove(p, control, shift);
   8.158 +        }
   8.159 +
   8.160 +        protected override void OnMouseUp(MouseEventArgs e)
   8.161 +        {
   8.162 +            base.OnMouseUp(e);
   8.163 +            foreach (var a in MouseActions)
   8.164 +                a.OnMouseUp();
   8.165 +            Capture = false;
   8.166 +        }
   8.167 +
   8.168 +        protected override void OnMouseWheel(MouseEventArgs e)
   8.169 +        {
   8.170 +            base.OnMouseWheel(e);
   8.171 +            bool control = Control.ModifierKeys == Keys.Control;
   8.172 +            bool shift = Control.ModifierKeys == Keys.Shift;
   8.173 +            var p = new ScreenPoint(e.X, e.Y);
   8.174 +            foreach (var a in MouseActions)
   8.175 +                a.OnMouseWheel(p, e.Delta, control, shift);
   8.176 +        }
   8.177 +
   8.178 +        public void GetAxesFromPoint(ScreenPoint pt, out AxisBase xaxis, out AxisBase yaxis)
   8.179 +        {
   8.180 +            Model.GetAxesFromPoint(pt, out xaxis, out yaxis);
   8.181 +        }
   8.182 +
   8.183 +        public DataSeries GetSeriesFromPoint(ScreenPoint pt, double limit)
   8.184 +        {
   8.185 +            return Model.GetSeriesFromPoint(pt, limit);
   8.186 +        }
   8.187 +
   8.188 +        public void Refresh(bool refreshData)
   8.189 +        {
   8.190 +            if (refreshData)
   8.191 +                Model.UpdateData();
   8.192 +            Invalidate();
   8.193 +        }
   8.194 +
   8.195 +        public void Pan(AxisBase axis, double dx)
   8.196 +        {
   8.197 +            axis.Pan(dx);
   8.198 +        }
   8.199 +
   8.200 +        public void Reset(AxisBase axis)
   8.201 +        {
   8.202 +            axis.Reset();
   8.203 +        }
   8.204 +
   8.205 +        public void Zoom(AxisBase axis, double p1, double p2)
   8.206 +        {
   8.207 +            axis.Zoom(p1, p2);
   8.208 +        }
   8.209 +
   8.210 +        public void ZoomAt(AxisBase axis, double factor, double x)
   8.211 +        {
   8.212 +            axis.ZoomAt(factor, x);
   8.213 +        }
   8.214 +
   8.215 +        public OxyRect GetPlotArea()
   8.216 +        {
   8.217 +            return Model.PlotArea;
   8.218 +        }
   8.219 +
   8.220 +        public void ShowSlider(DataSeries s, DataPoint dp)
   8.221 +        {
   8.222 +        }
   8.223 +
   8.224 +        public void HideSlider()
   8.225 +        {
   8.226 +        }
   8.227 +
   8.228 +        public void ShowZoomRectangle(OxyRect r)
   8.229 +        {
   8.230 +            zoomRectangle = new Rectangle((int)r.Left, (int)r.Top, (int)r.Width, (int)r.Height);
   8.231 +            Invalidate();
   8.232 +        }
   8.233 +
   8.234 +        public void HideZoomRectangle()
   8.235 +        {
   8.236 +            zoomRectangle = Rectangle.Empty;
   8.237 +            Invalidate();
   8.238 +        }
   8.239 +    }
   8.240 +}
   8.241 \ No newline at end of file

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/External/OxyPlot/OxyPlot.WindowsForms/PngExporter.cs	Sat Jun 08 16:53:22 2013 +0000
     9.3 @@ -0,0 +1,81 @@
     9.4 +// --------------------------------------------------------------------------------------------------------------------
     9.5 +// <copyright file="PngExporter.cs" company="OxyPlot">
     9.6 +//   The MIT License (MIT)
     9.7 +//
     9.8 +//   Copyright (c) 2012 Oystein Bjorke
     9.9 +//
    9.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
    9.11 +//   copy of this software and associated documentation files (the
    9.12 +//   "Software"), to deal in the Software without restriction, including
    9.13 +//   without limitation the rights to use, copy, modify, merge, publish,
    9.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
    9.15 +//   permit persons to whom the Software is furnished to do so, subject to
    9.16 +//   the following conditions:
    9.17 +//
    9.18 +//   The above copyright notice and this permission notice shall be included
    9.19 +//   in all copies or substantial portions of the Software.
    9.20 +//
    9.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    9.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    9.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    9.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    9.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    9.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    9.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    9.28 +// </copyright>
    9.29 +// <summary>
    9.30 +//   The png exporter.
    9.31 +// </summary>
    9.32 +// --------------------------------------------------------------------------------------------------------------------
    9.33 +namespace OxyPlot.WindowsForms
    9.34 +{
    9.35 +    using System.Drawing;
    9.36 +    using System.Drawing.Imaging;
    9.37 +
    9.38 +    using OxyPlot.WindowsForms;
    9.39 +
    9.40 +    /// <summary>
    9.41 +    /// The png exporter.
    9.42 +    /// </summary>
    9.43 +    public static class PngExporter
    9.44 +    {
    9.45 +        /// <summary>
    9.46 +        /// The export.
    9.47 +        /// </summary>
    9.48 +        /// <param name="model">
    9.49 +        /// The model.
    9.50 +        /// </param>
    9.51 +        /// <param name="fileName">
    9.52 +        /// The file name.
    9.53 +        /// </param>
    9.54 +        /// <param name="width">
    9.55 +        /// The width.
    9.56 +        /// </param>
    9.57 +        /// <param name="height">
    9.58 +        /// The height.
    9.59 +        /// </param>
    9.60 +        /// <param name="background">
    9.61 +        /// The background.
    9.62 +        /// </param>
    9.63 +        public static void Export(PlotModel model, string fileName, int width, int height, Brush background = null)
    9.64 +        {
    9.65 +            using (var bm = new Bitmap(width, height))
    9.66 +            {
    9.67 +                using (Graphics g = Graphics.FromImage(bm))
    9.68 +                {
    9.69 +                    if (background != null)
    9.70 +                    {
    9.71 +                        g.FillRectangle(background, 0, 0, width, height);
    9.72 +                    }
    9.73 +
    9.74 +                    var rc = new GraphicsRenderContext { RendersToScreen = false };
    9.75 +                    rc.SetGraphicsTarget(g);
    9.76 +                    model.Update();
    9.77 +                    model.Render(rc, width, height);
    9.78 +                    bm.Save(fileName, ImageFormat.Png);
    9.79 +                }
    9.80 +            }
    9.81 +        }
    9.82 +
    9.83 +    }
    9.84 +}
    9.85 \ No newline at end of file

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/External/OxyPlot/OxyPlot.WindowsForms/Properties/AssemblyInfo.cs	Sat Jun 08 16:53:22 2013 +0000
    10.3 @@ -0,0 +1,10 @@
    10.4 +//-----------------------------------------------------------------------
    10.5 +// <copyright file="AssemblyInfo.cs" company="OxyPlot">
    10.6 +//     http://oxyplot.codeplex.com, license: MIT
    10.7 +// </copyright>
    10.8 +//-----------------------------------------------------------------------
    10.9 +
   10.10 +using System.Reflection;
   10.11 +
   10.12 +[assembly: AssemblyTitle("OxyPlot for Windows Forms")]
   10.13 +[assembly: AssemblyDescription("OxyPlot controls for Windows Forms.")]
   10.14 \ No newline at end of file

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/External/OxyPlot/OxyPlot.sln	Sat Jun 08 16:53:22 2013 +0000
    11.3 @@ -0,0 +1,26 @@
    11.4 +
    11.5 +Microsoft Visual Studio Solution File, Format Version 11.00
    11.6 +# Visual Studio 2010
    11.7 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OxyPlot", "OxyPlot\OxyPlot.csproj", "{BCC43E58-E473-403E-A84D-63FEDC723040}"
    11.8 +EndProject
    11.9 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OxyPlot.WindowsForms", "OxyPlot.WindowsForms\OxyPlot.WindowsForms.csproj", "{D4554296-094E-4CAC-8EAE-44EB250666C6}"
   11.10 +EndProject
   11.11 +Global
   11.12 +	GlobalSection(SolutionConfigurationPlatforms) = preSolution
   11.13 +		Debug|Any CPU = Debug|Any CPU
   11.14 +		Release|Any CPU = Release|Any CPU
   11.15 +	EndGlobalSection
   11.16 +	GlobalSection(ProjectConfigurationPlatforms) = postSolution
   11.17 +		{BCC43E58-E473-403E-A84D-63FEDC723040}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   11.18 +		{BCC43E58-E473-403E-A84D-63FEDC723040}.Debug|Any CPU.Build.0 = Debug|Any CPU
   11.19 +		{BCC43E58-E473-403E-A84D-63FEDC723040}.Release|Any CPU.ActiveCfg = Release|Any CPU
   11.20 +		{BCC43E58-E473-403E-A84D-63FEDC723040}.Release|Any CPU.Build.0 = Release|Any CPU
   11.21 +		{D4554296-094E-4CAC-8EAE-44EB250666C6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   11.22 +		{D4554296-094E-4CAC-8EAE-44EB250666C6}.Debug|Any CPU.Build.0 = Debug|Any CPU
   11.23 +		{D4554296-094E-4CAC-8EAE-44EB250666C6}.Release|Any CPU.ActiveCfg = Release|Any CPU
   11.24 +		{D4554296-094E-4CAC-8EAE-44EB250666C6}.Release|Any CPU.Build.0 = Release|Any CPU
   11.25 +	EndGlobalSection
   11.26 +	GlobalSection(SolutionProperties) = preSolution
   11.27 +		HideSolutionNode = FALSE
   11.28 +	EndGlobalSection
   11.29 +EndGlobal

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/External/OxyPlot/OxyPlot/Annotations/Annotation.cs	Sat Jun 08 16:53:22 2013 +0000
    12.3 @@ -0,0 +1,181 @@
    12.4 +// --------------------------------------------------------------------------------------------------------------------
    12.5 +// <copyright file="Annotation.cs" company="OxyPlot">
    12.6 +//   The MIT License (MIT)
    12.7 +//   
    12.8 +//   Copyright (c) 2012 Oystein Bjorke
    12.9 +//   
   12.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
   12.11 +//   copy of this software and associated documentation files (the
   12.12 +//   "Software"), to deal in the Software without restriction, including
   12.13 +//   without limitation the rights to use, copy, modify, merge, publish,
   12.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
   12.15 +//   permit persons to whom the Software is furnished to do so, subject to
   12.16 +//   the following conditions:
   12.17 +//   
   12.18 +//   The above copyright notice and this permission notice shall be included
   12.19 +//   in all copies or substantial portions of the Software.
   12.20 +//   
   12.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   12.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   12.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   12.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   12.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   12.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   12.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   12.28 +// </copyright>
   12.29 +// <summary>
   12.30 +//   Annotation base class.
   12.31 +// </summary>
   12.32 +// --------------------------------------------------------------------------------------------------------------------
   12.33 +namespace OxyPlot.Annotations
   12.34 +{
   12.35 +    using System;
   12.36 +    using System.Globalization;
   12.37 +
   12.38 +    using OxyPlot.Axes;
   12.39 +
   12.40 +    /// <summary>
   12.41 +    /// Provides an abstract base class for annotations.
   12.42 +    /// </summary>
   12.43 +    public abstract class Annotation : UIPlotElement
   12.44 +    {
   12.45 +        /// <summary>
   12.46 +        /// Gets the actual culture.
   12.47 +        /// </summary>
   12.48 +        /// <remarks>
   12.49 +        /// The culture is defined in the parent PlotModel.
   12.50 +        /// </remarks>
   12.51 +        public CultureInfo ActualCulture
   12.52 +        {
   12.53 +            get
   12.54 +            {
   12.55 +                return this.PlotModel != null ? this.PlotModel.ActualCulture : CultureInfo.CurrentCulture;
   12.56 +            }
   12.57 +        }
   12.58 +
   12.59 +        /// <summary>
   12.60 +        /// Gets or sets the layer.
   12.61 +        /// </summary>
   12.62 +        public AnnotationLayer Layer { get; set; }
   12.63 +
   12.64 +        /// <summary>
   12.65 +        /// Gets or sets the X axis.
   12.66 +        /// </summary>
   12.67 +        /// <value>The X axis.</value>
   12.68 +        public Axis XAxis { get; set; }
   12.69 +
   12.70 +        /// <summary>
   12.71 +        /// Gets or sets the X axis key.
   12.72 +        /// </summary>
   12.73 +        /// <value>The X axis key.</value>
   12.74 +        public string XAxisKey { get; set; }
   12.75 +
   12.76 +        /// <summary>
   12.77 +        /// Gets or sets the Y axis.
   12.78 +        /// </summary>
   12.79 +        /// <value>The Y axis.</value>
   12.80 +        public Axis YAxis { get; set; }
   12.81 +
   12.82 +        /// <summary>
   12.83 +        /// Gets or sets the Y axis key.
   12.84 +        /// </summary>
   12.85 +        /// <value>The Y axis key.</value>
   12.86 +        public string YAxisKey { get; set; }
   12.87 +
   12.88 +        /// <summary>
   12.89 +        /// Ensures that the annotation axes are set.
   12.90 +        /// </summary>
   12.91 +        public void EnsureAxes()
   12.92 +        {
   12.93 +            this.XAxis = this.PlotModel.GetAxisOrDefault(this.XAxisKey, this.PlotModel.DefaultXAxis);
   12.94 +            this.YAxis = this.PlotModel.GetAxisOrDefault(this.YAxisKey, this.PlotModel.DefaultYAxis);
   12.95 +        }
   12.96 +
   12.97 +        /// <summary>
   12.98 +        /// Renders the annotation on the specified context.
   12.99 +        /// </summary>
  12.100 +        /// <param name="rc">
  12.101 +        /// The render context.
  12.102 +        /// </param>
  12.103 +        /// <param name="model">
  12.104 +        /// The model.
  12.105 +        /// </param>
  12.106 +        public virtual void Render(IRenderContext rc, PlotModel model)
  12.107 +        {
  12.108 +        }
  12.109 +
  12.110 +        /// <summary>
  12.111 +        /// Tests if the plot element is hit by the specified point.
  12.112 +        /// </summary>
  12.113 +        /// <param name="point">The point.</param>
  12.114 +        /// <param name="tolerance">The tolerance.</param>
  12.115 +        /// <returns>
  12.116 +        /// A hit test result.
  12.117 +        /// </returns>
  12.118 +        protected internal override HitTestResult HitTest(ScreenPoint point, double tolerance)
  12.119 +        {
  12.120 +            return null;
  12.121 +        }
  12.122 +
  12.123 +        /// <summary>
  12.124 +        /// Transforms the specified coordinates to a screen point.
  12.125 +        /// </summary>
  12.126 +        /// <param name="x">
  12.127 +        /// The x coordinate.
  12.128 +        /// </param>
  12.129 +        /// <param name="y">
  12.130 +        /// The y coordinate.
  12.131 +        /// </param>
  12.132 +        /// <returns>
  12.133 +        /// A screen point.
  12.134 +        /// </returns>
  12.135 +        public ScreenPoint Transform(double x, double y)
  12.136 +        {
  12.137 +            return this.XAxis.Transform(x, y, this.YAxis);
  12.138 +        }
  12.139 +
  12.140 +        /// <summary>
  12.141 +        /// Transforms the specified data point to a screen point.
  12.142 +        /// </summary>
  12.143 +        /// <param name="p">
  12.144 +        /// The point.
  12.145 +        /// </param>
  12.146 +        /// <returns>
  12.147 +        /// A screen point.
  12.148 +        /// </returns>
  12.149 +        public ScreenPoint Transform(IDataPoint p)
  12.150 +        {
  12.151 +            return this.XAxis.Transform(p.X, p.Y, this.YAxis);
  12.152 +        }
  12.153 +
  12.154 +        /// <summary>
  12.155 +        /// Transforms the specified screen position to a data point.
  12.156 +        /// </summary>
  12.157 +        /// <param name="position">
  12.158 +        /// The position.
  12.159 +        /// </param>
  12.160 +        /// <returns>
  12.161 +        /// A data point
  12.162 +        /// </returns>
  12.163 +        public DataPoint InverseTransform(ScreenPoint position)
  12.164 +        {
  12.165 +            return Axis.InverseTransform(position, this.XAxis, this.YAxis);
  12.166 +        }
  12.167 +
  12.168 +        /// <summary>
  12.169 +        /// Gets the clipping rectangle.
  12.170 +        /// </summary>
  12.171 +        /// <returns>
  12.172 +        /// The clipping rectangle.
  12.173 +        /// </returns>
  12.174 +        protected OxyRect GetClippingRect()
  12.175 +        {
  12.176 +            double minX = Math.Min(this.XAxis.ScreenMin.X, this.XAxis.ScreenMax.X);
  12.177 +            double minY = Math.Min(this.YAxis.ScreenMin.Y, this.YAxis.ScreenMax.Y);
  12.178 +            double maxX = Math.Max(this.XAxis.ScreenMin.X, this.XAxis.ScreenMax.X);
  12.179 +            double maxY = Math.Max(this.YAxis.ScreenMin.Y, this.YAxis.ScreenMax.Y);
  12.180 +
  12.181 +            return new OxyRect(minX, minY, maxX - minX, maxY - minY);
  12.182 +        }
  12.183 +    }
  12.184 +}
  12.185 \ No newline at end of file

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/External/OxyPlot/OxyPlot/Annotations/AnnotationLayer.cs	Sat Jun 08 16:53:22 2013 +0000
    13.3 @@ -0,0 +1,52 @@
    13.4 +// --------------------------------------------------------------------------------------------------------------------
    13.5 +// <copyright file="AnnotationLayer.cs" company="OxyPlot">
    13.6 +//   The MIT License (MIT)
    13.7 +//
    13.8 +//   Copyright (c) 2012 Oystein Bjorke
    13.9 +//
   13.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
   13.11 +//   copy of this software and associated documentation files (the
   13.12 +//   "Software"), to deal in the Software without restriction, including
   13.13 +//   without limitation the rights to use, copy, modify, merge, publish,
   13.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
   13.15 +//   permit persons to whom the Software is furnished to do so, subject to
   13.16 +//   the following conditions:
   13.17 +//
   13.18 +//   The above copyright notice and this permission notice shall be included
   13.19 +//   in all copies or substantial portions of the Software.
   13.20 +//
   13.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   13.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   13.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   13.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   13.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   13.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   13.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   13.28 +// </copyright>
   13.29 +// <summary>
   13.30 +//   The annotation layer.
   13.31 +// </summary>
   13.32 +// --------------------------------------------------------------------------------------------------------------------
   13.33 +namespace OxyPlot.Annotations
   13.34 +{
   13.35 +    /// <summary>
   13.36 +    /// Specifies the layer for an <see cref="Annotation"/>.
   13.37 +    /// </summary>
   13.38 +    public enum AnnotationLayer
   13.39 +    {
   13.40 +        /// <summary>
   13.41 +        /// Render the annotation below the gridlines of the axes.
   13.42 +        /// </summary>
   13.43 +        BelowAxes,
   13.44 +
   13.45 +        /// <summary>
   13.46 +        /// Render the annotation below the series.
   13.47 +        /// </summary>
   13.48 +        BelowSeries,
   13.49 +
   13.50 +        /// <summary>
   13.51 +        /// Render the annotation above the series.
   13.52 +        /// </summary>
   13.53 +        AboveSeries
   13.54 +    }
   13.55 +}
   13.56 \ No newline at end of file

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/External/OxyPlot/OxyPlot/Annotations/ArrowAnnotation.cs	Sat Jun 08 16:53:22 2013 +0000
    14.3 @@ -0,0 +1,228 @@
    14.4 +// --------------------------------------------------------------------------------------------------------------------
    14.5 +// <copyright file="ArrowAnnotation.cs" company="OxyPlot">
    14.6 +//   The MIT License (MIT)
    14.7 +//   
    14.8 +//   Copyright (c) 2012 Oystein Bjorke
    14.9 +//   
   14.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
   14.11 +//   copy of this software and associated documentation files (the
   14.12 +//   "Software"), to deal in the Software without restriction, including
   14.13 +//   without limitation the rights to use, copy, modify, merge, publish,
   14.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
   14.15 +//   permit persons to whom the Software is furnished to do so, subject to
   14.16 +//   the following conditions:
   14.17 +//   
   14.18 +//   The above copyright notice and this permission notice shall be included
   14.19 +//   in all copies or substantial portions of the Software.
   14.20 +//   
   14.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   14.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   14.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   14.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   14.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   14.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   14.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   14.28 +// </copyright>
   14.29 +// <summary>
   14.30 +//   Represents an arrow annotation.
   14.31 +// </summary>
   14.32 +// --------------------------------------------------------------------------------------------------------------------
   14.33 +namespace OxyPlot.Annotations
   14.34 +{
   14.35 +    /// <summary>
   14.36 +    /// Represents an arrow annotation.
   14.37 +    /// </summary>
   14.38 +    public class ArrowAnnotation : TextualAnnotation
   14.39 +    {
   14.40 +        /// <summary>
   14.41 +        /// The end point in screen coordinates.
   14.42 +        /// </summary>
   14.43 +        private ScreenPoint screenEndPoint;
   14.44 +
   14.45 +        /// <summary>
   14.46 +        /// The start point in screen coordinates.
   14.47 +        /// </summary>
   14.48 +        private ScreenPoint screenStartPoint;
   14.49 +
   14.50 +        /// <summary>
   14.51 +        /// Initializes a new instance of the <see cref="ArrowAnnotation"/> class.
   14.52 +        /// </summary>
   14.53 +        public ArrowAnnotation()
   14.54 +        {
   14.55 +            this.HeadLength = 10;
   14.56 +            this.HeadWidth = 3;
   14.57 +            this.Color = OxyColors.Blue;
   14.58 +            this.StrokeThickness = 2;
   14.59 +            this.LineStyle = LineStyle.Solid;
   14.60 +            this.LineJoin = OxyPenLineJoin.Miter;
   14.61 +        }
   14.62 +
   14.63 +        /// <summary>
   14.64 +        /// Gets or sets the arrow direction.
   14.65 +        /// </summary>
   14.66 +        /// <remarks>
   14.67 +        /// Setting this property overrides the StartPoint property.
   14.68 +        /// </remarks>
   14.69 +        public ScreenVector ArrowDirection { get; set; }
   14.70 +
   14.71 +        /// <summary>
   14.72 +        /// Gets or sets the color of the arrow.
   14.73 +        /// </summary>
   14.74 +        public OxyColor Color { get; set; }
   14.75 +
   14.76 +        /// <summary>
   14.77 +        /// Gets or sets the end point.
   14.78 +        /// </summary>
   14.79 +        public DataPoint EndPoint { get; set; }
   14.80 +
   14.81 +        /// <summary>
   14.82 +        /// Gets or sets the length of the head (relative to the stroke thickness) (the default value is 10).
   14.83 +        /// </summary>
   14.84 +        /// <value> The length of the head. </value>
   14.85 +        public double HeadLength { get; set; }
   14.86 +
   14.87 +        /// <summary>
   14.88 +        /// Gets or sets the width of the head (relative to the stroke thickness) (the default value is 3).
   14.89 +        /// </summary>
   14.90 +        /// <value> The width of the head. </value>
   14.91 +        public double HeadWidth { get; set; }
   14.92 +
   14.93 +        /// <summary>
   14.94 +        /// Gets or sets the line join type.
   14.95 +        /// </summary>
   14.96 +        /// <value> The line join type. </value>
   14.97 +        public OxyPenLineJoin LineJoin { get; set; }
   14.98 +
   14.99 +        /// <summary>
  14.100 +        /// Gets or sets the line style.
  14.101 +        /// </summary>
  14.102 +        /// <value> The line style. </value>
  14.103 +        public LineStyle LineStyle { get; set; }
  14.104 +
  14.105 +        /// <summary>
  14.106 +        /// Gets or sets the start point.
  14.107 +        /// </summary>
  14.108 +        /// <remarks>
  14.109 +        /// This property is overridden by the ArrowDirection property, if set.
  14.110 +        /// </remarks>
  14.111 +        public DataPoint StartPoint { get; set; }
  14.112 +
  14.113 +        /// <summary>
  14.114 +        /// Gets or sets the stroke thickness (the default value is 2).
  14.115 +        /// </summary>
  14.116 +        /// <value> The stroke thickness. </value>
  14.117 +        public double StrokeThickness { get; set; }
  14.118 +
  14.119 +        /// <summary>
  14.120 +        /// Gets or sets the 'veeness' of the arrow head (relative to thickness) (the default value is 0).
  14.121 +        /// </summary>
  14.122 +        /// <value> The 'veeness'. </value>
  14.123 +        public double Veeness { get; set; }
  14.124 +
  14.125 +        /// <summary>
  14.126 +        /// Renders the arrow annotation.
  14.127 +        /// </summary>
  14.128 +        /// <param name="rc">
  14.129 +        /// The render context.
  14.130 +        /// </param>
  14.131 +        /// <param name="model">
  14.132 +        /// The plot model.
  14.133 +        /// </param>
  14.134 +        public override void Render(IRenderContext rc, PlotModel model)
  14.135 +        {
  14.136 +            base.Render(rc, model);
  14.137 +
  14.138 +            this.screenEndPoint = this.Transform(this.EndPoint);
  14.139 +
  14.140 +            if (!this.ArrowDirection.x.IsZero() || !this.ArrowDirection.y.IsZero())
  14.141 +            {
  14.142 +                this.screenStartPoint = this.screenEndPoint - this.ArrowDirection;
  14.143 +            }
  14.144 +            else
  14.145 +            {
  14.146 +                this.screenStartPoint = this.Transform(this.StartPoint);
  14.147 +            }
  14.148 +
  14.149 +            var d = this.screenEndPoint - this.screenStartPoint;
  14.150 +            d.Normalize();
  14.151 +            var n = new ScreenVector(d.Y, -d.X);
  14.152 +
  14.153 +            var p1 = this.screenEndPoint - (d * this.HeadLength * this.StrokeThickness);
  14.154 +            var p2 = p1 + (n * this.HeadWidth * this.StrokeThickness);
  14.155 +            var p3 = p1 - (n * this.HeadWidth * this.StrokeThickness);
  14.156 +            var p4 = p1 + (d * this.Veeness * this.StrokeThickness);
  14.157 +
  14.158 +            OxyRect clippingRect = this.GetClippingRect();
  14.159 +            const double MinimumSegmentLength = 4;
  14.160 +
  14.161 +            rc.DrawClippedLine(
  14.162 +                new[] { this.screenStartPoint, p4 },
  14.163 +                clippingRect,
  14.164 +                MinimumSegmentLength * MinimumSegmentLength,
  14.165 +                this.GetSelectableColor(this.Color),
  14.166 +                this.StrokeThickness,
  14.167 +                this.LineStyle,
  14.168 +                this.LineJoin,
  14.169 +                false);
  14.170 +
  14.171 +            rc.DrawClippedPolygon(
  14.172 +                new[] { p3, this.screenEndPoint, p2, p4 },
  14.173 +                clippingRect,
  14.174 +                MinimumSegmentLength * MinimumSegmentLength,
  14.175 +                this.GetSelectableColor(this.Color),
  14.176 +                null);
  14.177 +
  14.178 +            if (!string.IsNullOrEmpty(this.Text))
  14.179 +            {
  14.180 +                var ha = d.X < 0 ? HorizontalAlignment.Left : HorizontalAlignment.Right;
  14.181 +                var va = d.Y < 0 ? VerticalAlignment.Top : VerticalAlignment.Bottom;
  14.182 +
  14.183 +                var textPoint = this.screenStartPoint;
  14.184 +                rc.DrawClippedText(
  14.185 +                    clippingRect,
  14.186 +                    textPoint,
  14.187 +                    this.Text,
  14.188 +                    this.ActualTextColor,
  14.189 +                    this.ActualFont,
  14.190 +                    this.ActualFontSize,
  14.191 +                    this.ActualFontWeight,
  14.192 +                    0,
  14.193 +                    ha,
  14.194 +                    va);
  14.195 +            }
  14.196 +        }
  14.197 +
  14.198 +        /// <summary>
  14.199 +        /// Tests if the plot element is hit by the specified point.
  14.200 +        /// </summary>
  14.201 +        /// <param name="point">
  14.202 +        /// The point.
  14.203 +        /// </param>
  14.204 +        /// <param name="tolerance">
  14.205 +        /// The tolerance.
  14.206 +        /// </param>
  14.207 +        /// <returns>
  14.208 +        /// A hit test result.
  14.209 +        /// </returns>
  14.210 +        protected internal override HitTestResult HitTest(ScreenPoint point, double tolerance)
  14.211 +        {
  14.212 +            if ((point - this.screenStartPoint).Length < tolerance)
  14.213 +            {
  14.214 +                return new HitTestResult(this.screenStartPoint, null, 1);
  14.215 +            }
  14.216 +
  14.217 +            if ((point - this.screenEndPoint).Length < tolerance)
  14.218 +            {
  14.219 +                return new HitTestResult(this.screenEndPoint, null, 2);
  14.220 +            }
  14.221 +
  14.222 +            var p = ScreenPointHelper.FindPointOnLine(point, this.screenStartPoint, this.screenEndPoint);
  14.223 +            if ((p - point).Length < tolerance)
  14.224 +            {
  14.225 +                return new HitTestResult(p);
  14.226 +            }
  14.227 +
  14.228 +            return null;
  14.229 +        }
  14.230 +    }
  14.231 +}
  14.232 \ No newline at end of file

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/External/OxyPlot/OxyPlot/Annotations/EllipseAnnotation.cs	Sat Jun 08 16:53:22 2013 +0000
    15.3 @@ -0,0 +1,152 @@
    15.4 +// --------------------------------------------------------------------------------------------------------------------
    15.5 +// <copyright file="RectangleAnnotation.cs" company="OxyPlot">
    15.6 +//   The MIT License (MIT)
    15.7 +//
    15.8 +//   Copyright (c) 2012 Oystein Bjorke
    15.9 +//
   15.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
   15.11 +//   copy of this software and associated documentation files (the
   15.12 +//   "Software"), to deal in the Software without restriction, including
   15.13 +//   without limitation the rights to use, copy, modify, merge, publish,
   15.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
   15.15 +//   permit persons to whom the Software is furnished to do so, subject to
   15.16 +//   the following conditions:
   15.17 +//
   15.18 +//   The above copyright notice and this permission notice shall be included
   15.19 +//   in all copies or substantial portions of the Software.
   15.20 +//
   15.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   15.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   15.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   15.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   15.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   15.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   15.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   15.28 +// </copyright>
   15.29 +// <summary>
   15.30 +//   Represents a rectangle annotation.
   15.31 +// </summary>
   15.32 +// --------------------------------------------------------------------------------------------------------------------
   15.33 +namespace OxyPlot.Annotations
   15.34 +{
   15.35 +    /// <summary>
   15.36 +    /// Represents an ellipse annotation.
   15.37 +    /// </summary>
   15.38 +    public class EllipseAnnotation : TextualAnnotation
   15.39 +    {
   15.40 +        /// <summary>
   15.41 +        /// The rectangle transformed to screen coordinates.
   15.42 +        /// </summary>
   15.43 +        private OxyRect screenRectangle;
   15.44 +
   15.45 +        /// <summary>
   15.46 +        /// Initializes a new instance of the <see cref="EllipseAnnotation"/> class.
   15.47 +        /// </summary>
   15.48 +        public EllipseAnnotation()
   15.49 +        {
   15.50 +            this.Stroke = OxyColors.Black;
   15.51 +            this.Fill = OxyColors.LightBlue;
   15.52 +        }
   15.53 +
   15.54 +        /// <summary>
   15.55 +        /// Gets or sets the fill color.
   15.56 +        /// </summary>
   15.57 +        /// <value> The fill. </value>
   15.58 +        public OxyColor Fill { get; set; }
   15.59 +
   15.60 +        /// <summary>
   15.61 +        /// Gets or sets the stroke color.
   15.62 +        /// </summary>
   15.63 +        public OxyColor Stroke { get; set; }
   15.64 +
   15.65 +        /// <summary>
   15.66 +        /// Gets or sets the stroke thickness.
   15.67 +        /// </summary>
   15.68 +        public double StrokeThickness { get; set; }
   15.69 +
   15.70 +        /// <summary>
   15.71 +        /// Gets or sets the x-coordinate of the center.
   15.72 +        /// </summary>
   15.73 +        public double X { get; set; }
   15.74 +
   15.75 +        /// <summary>
   15.76 +        /// Gets or sets the y-coordinate of the center.
   15.77 +        /// </summary>
   15.78 +        public double Y { get; set; }
   15.79 +
   15.80 +        /// <summary>
   15.81 +        /// Gets or sets the width of the ellipse.
   15.82 +        /// </summary>
   15.83 +        public double Width { get; set; }
   15.84 +
   15.85 +        /// <summary>
   15.86 +        /// Gets or sets the height of the ellipse.
   15.87 +        /// </summary>
   15.88 +        public double Height { get; set; }
   15.89 +
   15.90 +        /// <summary>
   15.91 +        /// Gets or sets the text rotation (degrees).
   15.92 +        /// </summary>
   15.93 +        /// <value>The text rotation in degrees.</value>
   15.94 +        public double TextRotation { get; set; }
   15.95 +
   15.96 +        /// <summary>
   15.97 +        /// Renders the polygon annotation.
   15.98 +        /// </summary>
   15.99 +        /// <param name="rc">
  15.100 +        /// The render context.
  15.101 +        /// </param>
  15.102 +        /// <param name="model">
  15.103 +        /// The plot model.
  15.104 +        /// </param>
  15.105 +        public override void Render(IRenderContext rc, PlotModel model)
  15.106 +        {
  15.107 +            base.Render(rc, model);
  15.108 +
  15.109 +            this.screenRectangle = OxyRect.Create(this.Transform(this.X - (Width / 2), Y - (Height / 2)), this.Transform(X + (Width / 2), Y + (Height / 2)));
  15.110 +
  15.111 +            // clip to the area defined by the axes
  15.112 +            var clipping = this.GetClippingRect();
  15.113 +
  15.114 +            rc.DrawClippedEllipse(clipping, this.screenRectangle, this.Fill, this.Stroke, this.StrokeThickness);
  15.115 +
  15.116 +            if (!string.IsNullOrEmpty(this.Text))
  15.117 +            {
  15.118 +                var textPosition = this.screenRectangle.Center;
  15.119 +                rc.DrawClippedText(
  15.120 +                    clipping,
  15.121 +                    textPosition,
  15.122 +                    this.Text,
  15.123 +                    this.ActualTextColor,
  15.124 +                    this.ActualFont,
  15.125 +                    this.ActualFontSize,
  15.126 +                    this.ActualFontWeight,
  15.127 +                    this.TextRotation,
  15.128 +                    HorizontalAlignment.Center,
  15.129 +                    VerticalAlignment.Middle);
  15.130 +            }
  15.131 +        }
  15.132 +
  15.133 +        /// <summary>
  15.134 +        /// Tests if the plot element is hit by the specified point.
  15.135 +        /// </summary>
  15.136 +        /// <param name="point">
  15.137 +        /// The point.
  15.138 +        /// </param>
  15.139 +        /// <param name="tolerance">
  15.140 +        /// The tolerance.
  15.141 +        /// </param>
  15.142 +        /// <returns>
  15.143 +        /// A hit test result.
  15.144 +        /// </returns>
  15.145 +        protected internal override HitTestResult HitTest(ScreenPoint point, double tolerance)
  15.146 +        {
  15.147 +            if (this.screenRectangle.Contains(point))
  15.148 +            {
  15.149 +                return new HitTestResult(point);
  15.150 +            }
  15.151 +
  15.152 +            return null;
  15.153 +        }
  15.154 +    }
  15.155 +}
  15.156 \ No newline at end of file

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/External/OxyPlot/OxyPlot/Annotations/ImageAnnotation.cs	Sat Jun 08 16:53:22 2013 +0000
    16.3 @@ -0,0 +1,451 @@
    16.4 +// --------------------------------------------------------------------------------------------------------------------
    16.5 +// <copyright file="ImageAnnotation.cs" company="OxyPlot">
    16.6 +//   The MIT License (MIT)
    16.7 +//   
    16.8 +//   Copyright (c) 2012 Oystein Bjorke
    16.9 +//   
   16.10 +//   Permission is hereby granted, free of charge, to any person obtaining a
   16.11 +//   copy of this software and associated documentation files (the
   16.12 +//   "Software"), to deal in the Software without restriction, including
   16.13 +//   without limitation the rights to use, copy, modify, merge, publish,
   16.14 +//   distribute, sublicense, and/or sell copies of the Software, and to
   16.15 +//   permit persons to whom the Software is furnished to do so, subject to
   16.16 +//   the following conditions:
   16.17 +//   
   16.18 +//   The above copyright notice and this permission notice shall be included
   16.19 +//   in all copies or substantial portions of the Software.
   16.20 +//   
   16.21 +//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   16.22 +//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   16.23 +//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   16.24 +//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   16.25 +//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   16.26 +//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   16.27 +//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   16.28 +// </copyright>
   16.29 +// <summary>
   16.30 +//   Represents a text object annotation.
   16.31 +// </summary>
   16.32 +// --------------------------------------------------------------------------------------------------------------------
   16.33 +namespace OxyPlot.Annotations
   16.34 +{
   16.35 +    /// <summary>
   16.36 +    /// Represents a text annotation.
   16.37 +    /// </summary>
   16.38 +    public class ImageAnnotation : Annotation
   16.39 +    {
   16.40 +        /// <summary>
   16.41 +        /// The actual bounds of the rendered image.
   16.42 +        /// </summary>
   16.43 +        private OxyRect actualBounds;
   16.44 +
   16.45 +        /// <summary>
   16.46 +        /// Initializes a new instance of the <see cref="ImageAnnotation" /> class.
   16.47 +        /// </summary>
   16.48 +        public ImageAnnotation()
   16.49 +        {
   16.50 +            this.X = new PlotLength(0.5, PlotLengthUnit.RelativeToPlotArea);
   16.51 +            this.Y = new PlotLength(0.5, PlotLengthUnit.RelativeToPlotArea);
   16.52 +            this.OffsetX = new PlotLength(0, PlotLengthUnit.ScreenUnits);
   16.53 +            this.OffsetY = new PlotLength(0, PlotLengthUnit.ScreenUnits);
   16.54 +            this.Width = new PlotLength(double.NaN, PlotLengthUnit.ScreenUnits);
   16.55 +            this.Height = new PlotLength(double.NaN, PlotLengthUnit.ScreenUnits);
   16.56 +            this.Opacity = 1.0;
   16.57 +            this.Interpolate = true;
   16.58 +            this.HorizontalAlignment = OxyPlot.HorizontalAlignment.Center;
   16.59 +            this.VerticalAlignment = OxyPlot.VerticalAlignment.Middle;
   16.60 +        }
   16.61 +
   16.62 +        /// <summary>
   16.63 +        /// Initializes a new instance of the <see cref="ImageAnnotation"/> class.
   16.64 +        /// </summary>
   16.65 +        /// <param name="image">
   16.66 +        /// The image.
   16.67 +        /// </param>
   16.68 +        /// <param name="position">
   16.69 +        /// The position in screen coordinates.
   16.70 +        /// </param>
   16.71 +        /// <param name="horizontalAlignment">
   16.72 +        /// The horizontal alignment.
   16.73 +        /// </param>
   16.74 +        /// <param name="verticalAlignment">
   16.75 +        /// The vertical alignment.
   16.76 +        /// </param>
   16.77 +        public ImageAnnotation(
   16.78 +            OxyImage image, 
   16.79 +            ScreenPoint position, 
   16.80 +            HorizontalAlignment horizontalAlignment = OxyPlot.HorizontalAlignment.Center, 
   16.81 +            VerticalAlignment verticalAlignment = OxyPlot.VerticalAlignment.Middle)
   16.82 +            : this()
   16.83 +        {
   16.84 +            this.ImageSource = image;
   16.85 +            this.X = new PlotLength(position.X, PlotLengthUnit.ScreenUnits);
   16.86 +            this.Y = new PlotLength(position.Y, PlotLengthUnit.ScreenUnits);
   16.87 +            this.HorizontalAlignment = horizontalAlignment;
   16.88 +            this.VerticalAlignment = verticalAlignment;
   16.89 +        }
   16.90 +
   16.91 +        /// <summary>
   16.92 +        /// Initializes a new instance of the <see cref="ImageAnnotation"/> class.
   16.93 +        /// </summary>
   16.94 +        /// <param name="image">
   16.95 +        /// The image.
   16.96 +        /// </param>
   16.97 +        /// <param name="position">
   16.98 +        /// The position in data coordinates.
   16.99 +        /// </param>
  16.100 +        /// <param name="horizontalAlignment">
  16.101 +        /// The horizontal alignment.
  16.102 +        /// </param>
  16.103 +        /// <param name="verticalAlignment">
  16.104 +        /// The vertical alignment.
  16.105 +        /// </param>
  16.106 +        public ImageAnnotation(
  16.107 +            OxyImage image, 
  16.108 +            IDataPoint position, 
  16.109 +            HorizontalAlignment horizontalAlignment = OxyPlot.HorizontalAlignment.Center, 
  16.110 +            VerticalAlignment verticalAlignment = OxyPlot.VerticalAlignment.Middle)
  16.111 +            : this()
  16.112 +        {
  16.113 +            this.ImageSource = image;
  16.114 +            this.X = new PlotLength(position.X, PlotLengthUnit.Data);
  16.115 +            this.Y = new PlotLength(position.Y, PlotLengthUnit.Data);
  16.116 +            this.HorizontalAlignment = horizontalAlignment;
  16.117 +            this.VerticalAlignment = verticalAlignment;
  16.118 +        }
  16.119 +
  16.120 +        /// <summary>
  16.121 +        /// Initializes a new instance of the <see cref="ImageAnnotation"/> class.
  16.122 +        /// </summary>
  16.123 +        /// <param name="image">
  16.124 +        /// The image.
  16.125 +        /// </param>
  16.126 +        /// <param name="relativeX">
  16.127 +        /// The x-coordinate relative to the plot area (0-1).
  16.128 +        /// </param>
  16.129 +        /// <param name="relativeY">
  16.130 +        /// The y-coordinate relative to the plot area (0-1).
  16.131 +        /// </param>
  16.132 +        /// <param name="horizontalAlignment">
  16.133 +        /// The horizontal alignment.
  16.134 +        /// </param>
  16.135 +        /// <param name="verticalAlignment">
  16.136 +        /// The vertical alignment.
  16.137 +        /// </param>
  16.138 +        public ImageAnnotation(
  16.139 +            OxyImage image, 
  16.140 +            double relativeX, 
  16.141 +            double relativeY, 
  16.142 +            HorizontalAlignment horizontalAlignment = OxyPlot.HorizontalAlignment.Center, 
  16.143 +            VerticalAlignment verticalAlignment = OxyPlot.VerticalAlignment.Middle)
  16.144 +            : this()
  16.145 +        {
  16.146 +            this.ImageSource = image;
  16.147 +            this.X = new PlotLength(relativeX, PlotLengthUnit.RelativeToPlotArea);
  16.148 +            this.Y = new PlotLength(relativeY, PlotLengthUnit.RelativeToPlotArea);
  16.149 +            this.HorizontalAlignment = horizontalAlignment;
  16.150 +            this.VerticalAlignment = verticalAlignment;
  16.151 +        }
  16.152 +
  16.153 +        /// <summary>
  16.154 +        /// Gets or sets the image source.
  16.155 +        /// </summary>
  16.156 +        /// <value>
  16.157 +        /// The image source.
  16.158 +        /// </value>
  16.159 +        public OxyImage ImageSource { get; set; }
  16.160 +
  16.161 +        /// <summary>
  16.162 +        /// Gets or sets the horizontal alignment.
  16.163 +        /// </summary>
  16.164 +        /// <value> The horizontal alignment. </value>
  16.165 +        public HorizontalAlignment HorizontalAlignment { get; set; }
  16.166 +
  16.167 +        /// <summary>
  16.168 +        /// Gets or sets the X position of the image.
  16.169 +        /// </summary>
  16.170 +        /// <value>
  16.171 +        /// The X.
  16.172 +        /// </value>
  16.173 +        public PlotLength X { get; set; }
  16.174 +
  16.175 +        /// <summary>
  16.176 +        /// Gets or sets the Y position of the image.
  16.177 +        /// </summary>
  16.178 +        /// <value>
  16.179 +        /// The Y.
  16.180 +        /// </value>
  16.181 +        public PlotLength Y { get; set; }
  16.182 +
  16.183 +        /// <summary>
  16.184 +        /// Gets or sets the X offset.
  16.185 +        /// </summary>
  16.186 +        /// <value>
  16.187 +        /// The offset X.
  16.188 +        /// </value>
  16.189 +        public PlotLength OffsetX { get; set; }
  16.190 +
  16.191 +        /// <summary>
  16.192 +        /// Gets or sets the Y offset.
  16.193 +        /// </summary>
  16.194 +        /// <value>
  16.195 +        /// The offset Y.
  16.196 +        /// </value>
  16.197 +        public PlotLength OffsetY { get; set; }
  16.198 +
  16.199 +        /// <summary>
  16.200 +        /// Gets or sets the width.
  16.201 +        /// </summary>
  16.202 +        /// <value>
  16.203 +        /// The width.
  16.204 +        /// </value>
  16.205 +        public PlotLength Width { get; set; }
  16.206 +
  16.207 +        /// <summary>
  16.208 +        /// Gets or sets the height.
  16.209 +        /// </summary>
  16.210 +        /// <value>
  16.211 +        /// The height.
  16.212 +        /// </value>
  16.213 +        public PlotLength Height { get; set; }
  16.214 +
  16.215 +        /// <summary>
  16.216 +        /// Gets or sets the opacity (0-1).
  16.217 +        /// </summary>
  16.218 +        /// <value>
  16.219 +        /// The opacity value.
  16.220 +        /// </value>
  16.221 +        public double Opacity { get; set; }
  16.222 +
  16.223 +        /// <summary>
  16.224 +        /// Gets or sets a value indicating whether to apply smooth interpolation to the image.
  16.225 +        /// </summary>
  16.226 +        /// <value>
  16.227 +        ///   <c>true</c> if the image should be interpolated (using a high-quality bi-cubic interpolation); <c>false</c> if the nearest neighbor should be used.
  16.228 +        /// </value>
  16.229 +        public bool Interpolate { get; set; }
  16.230 +
  16.231 +        /// <summary>
  16.232 +        /// Gets or sets the vertical alignment.
  16.233 +        /// </summary>
  16.234 +        /// <value> The vertical alignment. </value>
  16.235 +        public VerticalAlignment VerticalAlignment { get; set; }
  16.236 +
  16.237 +        /// <summary>
  16.238 +        /// Renders the image annotation.
  16.239 +        /// </summary>
  16.240 +        /// <param name="rc">
  16.241 +        /// The render context.
  16.242 +        /// </param>
  16.243 +        /// <param name="model">
  16.244 +        /// The plot model.
  16.245 +        /// </param>
  16.246 +        public override void Render(IRenderContext rc, PlotModel model)
  16.247 +        {
  16.248 +            base.Render(rc, model);
  16.249 +
  16.250 +            var p = this.GetPoint(this.X, this.Y, rc, model);
  16.251 +            var o = this.GetVector(this.OffsetX, this.OffsetY, rc, model);
  16.252 +            var position = p + o;
  16.253 +
  16.254 +            var clippingRect = this.GetClippingRect();
  16.255 +
  16.256 +            var imageInfo = rc.GetImageInfo(this.ImageSource);
  16.257 +            if (imageInfo == null)
  16.258 +            {
  16.259 +                return;
  16.260 +            }
  16.261 +
  16.262 +            var s = this.GetVector(this.Width, this.Height, rc, model);
  16.263 +
  16.264 +            var width = s.X;
  16.265 +            var height = s.Y;
  16.266 +
  16.267 +            if (double.IsNaN(width) && double.IsNaN(height))
  16.268 +            {
  16.269 +                width = imageInfo.Width;
  16.270 +                height = imageInfo.Height;
  16.271 +            }
  16.272 +
  16.273 +            if (double.IsNaN(width))
  16.274 +            {
  16.275 +                width = height / imageInfo.Height * imageInfo.Width;
  16.276 +            }
  16.277 +
  16.278 +            if (double.IsNaN(height))
  16.279 +            {
  16.280 +                height = width / imageInfo.Width * imageInfo.Height;
  16.281 +            }
  16.282 +
  16.283 +            double x = position.X;
  16.284 +            double y = position.Y;
  16.285 +
  16.286 +            if (this.HorizontalAlignment == HorizontalAlignment.Center)
  16.287 +            {
  16.288 +                x -= width * 0.5;
  16.289 +            }
  16.290 +
  16.291 +            if (this.HorizontalAlignment == HorizontalAlignment.Right)
  16.292 +            {
  16.293 +                x -= width;
  16.294 +            }
  16.295 +
  16.296 +            if (this.VerticalAlignment == VerticalAlignment.Middle)
  16.297 +            {
  16.298 +                y -= height * 0.5;
  16.299 +            }
  16.300 +
  16.301 +            if (this.VerticalAlignment == VerticalAlignment.Bottom)
  16.302 +            {
  16.303 +                y -= height;
  16.304 +            }
  16.305 +
  16.306 +            this.actualBounds = new OxyRect(x, y, width, height);
  16.307 +
  16.308 +            if (this.X.Unit == PlotLengthUnit.Data || this.Y.Unit == PlotLengthUnit.Data)
  16.309 +            {
  16.310 +                rc.DrawClippedImage(clippingRect, this.ImageSource, x, y, width, height, this.Opacity, this.Interpolate);
  16.311 +            }
  16.312 +            else
  16.313 +            {
  16.314 +                rc.DrawImage(this.ImageSource, x, y, width, height, this.Opacity, this.Interpolate);
  16.315 +            }
  16.316 +        }
  16.317 +
  16.318 +        /// <summary>
  16.319 +        /// Tests if the plot element is hit by the specified point.
  16.320 +        /// </summary>
  16.321 +        /// <param name="point">
  16.322 +        /// The point.
  16.323 +        /// </param>
  16.324 +        /// <param name="tolerance">
  16.325 +        /// The tolerance.
  16.326 +        /// </param>
  16.327 +        /// <returns>
  16.328 +        /// A hit test result.
  16.329 +        /// </returns>
  16.330 +        protected internal override HitTestResult HitTest(ScreenPoint point, double tolerance)
  16.331 +        {
  16.332 +            if (this.actualBounds.Contains(point))
  16.333 +            {
  16.334 +                return new HitTestResult(point);
  16.335 +            }
  16.336 +
  16.337 +            return null;
  16.338 +        }
  16.339 +
  16.340 +        /// <summary>
  16.341 +        /// Gets the point.
  16.342 +        /// </summary>
  16.343 +        /// <param name="x">
  16.344 +        /// The x.
  16.345 +        /// </param>
  16.346 +        /// <param name="y">
  16.347 +        /// The y.
  16.348 +        /// </param>
  16.349 +        /// <param name="rc">
  16.350 +        /// The render context.
  16.351 +        /// </param>
  16.352 +        /// <param name="model">
  16.353 +        /// The model.
  16.354 +        /// </param>
  16.355 +        /// <returns>
  16.356 +        /// The point in screen coordinates.
  16.357 +        /// </returns>
  16.358 +        protected ScreenPoint GetPoint(PlotLength x, PlotLength y, IRenderContext rc, PlotModel model)
  16.359 +        {
  16.360 +            if (x.Unit == PlotLengthUnit.Data || y.Unit == PlotLengthUnit.Data)
  16.361 +            {
  16.362 +                return this.XAxis.Transform(x.Value, y.Value, this.YAxis);
  16.363 +            }
  16.364 +
  16.365 +            double sx;
  16.366 +            double sy;
  16.367 +            switch (x.Unit)
  16.368 +            {
  16.369 +                case PlotLengthUnit.RelativeToPlotArea:
  16.370 +                    sx = model.PlotArea.Left + (model.PlotArea.Width * x.Value);
  16.371 +                    break;
  16.372 +                case PlotLengthUnit.RelativeToViewport:
  16.373 +                    sx = model.Width * x.Value;
  16.374 +                    break;
  16.375 +                default:
  16.376 +                    sx = x.Value;
  16.377 +                    break;
  16.378 +            }
  16.379 +
  16.380 +            switch (y.Unit)
  16.381 +            {
  16.382 +                case PlotLengthUnit.RelativeToPlotArea:
  16.383 +                    sy = model.PlotArea.Top + (model.PlotArea.Height * y.Value);
  16.384 +                    break;
  16.385 +                case PlotLengthUnit.RelativeToViewport:
  16.386 +                    sy = model.Height * y.Value;
  16.387 +                    break;
  16.388 +                default:
  16.389 +                    sy = y.Value;
  16.390 +                    break;
  16.391 +            }
  16.392 +
  16.393 +            return new ScreenPoint(sx, sy);
  16.394 +        }
  16.395 +
  16.396 +        /// <summary>
  16.397 +        /// Gets the vector.
  16.398 +        /// </summary>
  16.399 +        /// <param name="x">
  16.400 +        /// The x component.
  16.401 +        /// </param>
  16.402 +        /// <param name="y">
  16.403 +        /// The y component.
  16.404 +        /// </param>
  16.405 +        /// <param name="rc">
  16.406 +        /// The render context.
  16.407 +        /// </param>
  16.408 +        /// <param name="model">
  16.409 +        /// The model.
  16.410 +        /// </param>
  16.411 +        /// <returns>
  16.412 +        /// The vector in screen coordinates.
  16.413 +        /// </returns>
  16.414 +        protected ScreenVector GetVector(PlotLength x, PlotLength y, IRenderContext rc, PlotModel model)
  16.415 +        {
  16.416 +            double sx;
  16.417 +            double sy;
  16.418 +
  16.419 +            switch (x.Unit)
  16.420 +            {
  16.421 +                case PlotLengthUnit.Data:
  16.422 +                    sx = this.XAxis.Transform(x.Value) - this.XAxis.Transform(0);
  16.423 +                    break;
  16.424 +                case PlotLengthUnit.RelativeToPlotArea:
  16.425 +                    sx = model.PlotArea.Width * x.Value;
  16.426 +                    break;
  16.427 +                case PlotLengthUnit.RelativeToViewport:
  16.428 +                    sx = model.Width * x.Value;
  16.429 +                    break;
  16.430 +                default:
  16.431 +                    sx = x.Value;
  16.432 +                    break;
  16.433 +            }
  16.434 +
  16.435 +            switch (y.Unit)
  16.436 +            {
  16.437 +                case PlotLengthUnit.Data:
  16.438 +                    sy = this.YAxis.Transform(y.Value) - this.YAxis.Transform(0);
  16.439 +                    break;
  16.440 +                case PlotLengthUnit.RelativeToPlotArea:
  16.441 +                    sy = model.PlotArea.Height * y.Value;
  16.442 +                    break;
  16.443 +                case PlotLengthUnit.RelativeToViewport:
  16.444 +                    sy = model.Height * y.Value;
  16.445 +                    break;
  16.446 +                default:
  16.447 +                    sy = y.Value;
  16.448 +                    break;
  16.449 +            }
  16.450 +
  16.451 +            return new ScreenVector(sx, sy);
  16.452 +        }
  16.453 +    }
  16.454 +}
  16.455 \ No newline at end of file