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

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

 //   The MIT License (MIT)

 //

 //   Copyright (c) 2012 Oystein Bjorke

 //

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

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

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

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

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

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

 //   the following conditions:

 //

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

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

 //

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

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

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

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

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

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

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

 // </copyright>

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

 using System;

 using System.Collections.Generic;

 using System.ComponentModel;

 using System.Drawing;

 using System.Windows.Forms;

 using OxyPlot;

 namespace Oxyplot.WindowsForms

 {

     public class PlotControl : Control, IPlotControl

     {

         public List<MouseAction> MouseActions { get; private set; }

         private readonly PanAction panAction;

         private readonly SliderAction sliderAction;

         private readonly ZoomAction zoomAction;

         private Rectangle zoomRectangle;

         public PlotControl()

         {

             //    InitializeComponent();

             DoubleBuffered = true;

             Model = new PlotModel();

             panAction = new PanAction(this);

             zoomAction = new ZoomAction(this);

             sliderAction = new SliderAction(this);

             MouseActions = new List<MouseAction>();

             MouseActions.Add(panAction);

             MouseActions.Add(zoomAction);

             MouseActions.Add(sliderAction);

         }

         private PlotModel model;

         [Browsable(false), DefaultValue(null)]

         public PlotModel Model

         {

             get { return model; }

             set

             {

                 model = value;

                 Refresh();

             }

         }

         public override void Refresh()

         {

             if (model != null)

                 model.UpdateData();

             base.Refresh();

         }

         protected override void OnResize(EventArgs e)

         {

             base.OnResize(e);

             Invalidate();

         }

         protected override void OnPaint(PaintEventArgs e)

         {

             base.OnPaint(e);

             var rc = new GraphicsRenderContext(this, e.Graphics, e.ClipRectangle);

             if (model != null)

                 model.Render(rc);

             if (zoomRectangle != Rectangle.Empty)

             {

                 using (var zoomBrush = new SolidBrush(Color.FromArgb(0x40, 0xFF, 0xFF, 0x00)))

                 using (var zoomPen = new Pen(Color.Black))

                 {

                     zoomPen.DashPattern = new float[] { 3, 1 };

                     e.Graphics.FillRectangle(zoomBrush, zoomRectangle);

                     e.Graphics.DrawRectangle(zoomPen, zoomRectangle);

                 }

             }

         }

         protected override void OnKeyDown(KeyEventArgs e)

         {

             base.OnKeyDown(e);

             if (e.KeyCode == Keys.A)

             {

                 ZoomAll();

             }

         }

         public void ZoomAll()

         {

             foreach (var a in Model.Axes)

                 a.Reset();

             Refresh();

         }

         protected override void OnMouseDown(MouseEventArgs e)

         {

             base.OnMouseDown(e);

             Focus();

             Capture = true;

             bool control = Control.ModifierKeys == Keys.Control;

             bool shift = Control.ModifierKeys == Keys.Shift;

             var button = OxyMouseButton.Left;

             if (e.Button == MouseButtons.Middle)

                 button = OxyMouseButton.Middle;

             if (e.Button == MouseButtons.Right)

                 button = OxyMouseButton.Right;

             if (e.Button == MouseButtons.XButton1)

                 button = OxyMouseButton.XButton1;

             if (e.Button == MouseButtons.XButton2)

                 button = OxyMouseButton.XButton2;

             var p = new ScreenPoint(e.X, e.Y);

             foreach (var a in MouseActions)

                 a.OnMouseDown(p, button, e.Clicks, control, shift);

         }

         protected override void OnMouseMove(MouseEventArgs e)

         {

             base.OnMouseMove(e);

             bool control = Control.ModifierKeys == Keys.Control;

             bool shift = Control.ModifierKeys == Keys.Shift;

             var p = new ScreenPoint(e.X, e.Y);

             foreach (var a in MouseActions)

                 a.OnMouseMove(p, control, shift);

         }

         protected override void OnMouseUp(MouseEventArgs e)

         {

             base.OnMouseUp(e);

             foreach (var a in MouseActions)

                 a.OnMouseUp();

             Capture = false;

         }

         protected override void OnMouseWheel(MouseEventArgs e)

         {

             base.OnMouseWheel(e);

             bool control = Control.ModifierKeys == Keys.Control;

             bool shift = Control.ModifierKeys == Keys.Shift;

             var p = new ScreenPoint(e.X, e.Y);

             foreach (var a in MouseActions)

                 a.OnMouseWheel(p, e.Delta, control, shift);

         }

         public void GetAxesFromPoint(ScreenPoint pt, out AxisBase xaxis, out AxisBase yaxis)

         {

             Model.GetAxesFromPoint(pt, out xaxis, out yaxis);

         }

         public DataSeries GetSeriesFromPoint(ScreenPoint pt, double limit)

         {

             return Model.GetSeriesFromPoint(pt, limit);

         }

         public void Refresh(bool refreshData)

         {

             if (refreshData)

                 Model.UpdateData();

             Invalidate();

         }

         public void Pan(AxisBase axis, double dx)

         {

             axis.Pan(dx);

         }

         public void Reset(AxisBase axis)

         {

             axis.Reset();

         }

         public void Zoom(AxisBase axis, double p1, double p2)

         {

             axis.Zoom(p1, p2);

         }

         public void ZoomAt(AxisBase axis, double factor, double x)

         {

             axis.ZoomAt(factor, x);

         }

         public OxyRect GetPlotArea()

         {

             return Model.PlotArea;

         }

         public void ShowSlider(DataSeries s, DataPoint dp)

         {

         }

         public void HideSlider()

         {

         }

         public void ShowZoomRectangle(OxyRect r)

         {

             zoomRectangle = new Rectangle((int)r.Left, (int)r.Top, (int)r.Width, (int)r.Height);

             Invalidate();

         }

         public void HideZoomRectangle()

         {

             zoomRectangle = Rectangle.Empty;

             Invalidate();

         }

     }

 }