public class TouchablePlotView : View , IPlotControl, ScaleGestureDetector.IOnScaleGestureListener, GestureDetector.IOnGestureListener
    {
        private ScaleGestureDetector _scaleDetector;
        private GestureDetector _gestureDetector;

        public override bool OnTouchEvent(MotionEvent e) {
            bool isConsumed = _gestureDetector.OnTouchEvent(e);
            if (!isConsumed)
                isConsumed = _scaleDetector.OnTouchEvent(e);
            return isConsumed;
        }

        private PlotModel model;

        public PlotModel Model
        {
            get
            {
                return this.model;
            }
            set
            {
                if (this.model == value)
                {
                    return;
                }

                this.model = value;
                this.OnModelChanged();
            }
        }

        private void OnModelChanged()
        {
            this.InvalidatePlot(true);
        }

        private readonly object invalidateLock = new object();
        private bool isModelInvalidated;
        private bool updateDataFlag = true;

        
        protected override void OnAttachedToWindow()
        {
            base.OnAttachedToWindow();
            _scaleDetector = new ScaleGestureDetector(this.Context, this);
            _gestureDetector = new GestureDetector(this.Context, this);
        }
        public PlotModel ActualModel {
            get { return Model; }
        }

        public void GetAxesFromPoint(ScreenPoint pt, out Axis xaxis, out Axis yaxis) {
            if (this.ActualModel != null) {
                this.ActualModel.GetAxesFromPoint(pt, out xaxis, out yaxis);
            } else {
                xaxis = null;
                yaxis = null;
            }
        }

        public Series GetSeriesFromPoint(ScreenPoint pt, double limit = 100) {
            return this.ActualModel != null ? this.ActualModel.GetSeriesFromPoint(pt, limit) : null;
        }

        public void HideTracker() {
            //
        }

        public void HideZoomRectangle() {
            //
        }

        public void InvalidatePlot(bool updateData)
        {
            lock (this.invalidateLock)
            {
                this.isModelInvalidated = true;
                this.updateDataFlag = this.updateDataFlag || updateData;
            }

            this.Invalidate();
        }

        public void Pan(Axis axis, ScreenPoint ppt, ScreenPoint cpt) {
            axis.Pan(ppt, cpt);
            this.InvalidatePlot(false);
        }

        public void RefreshPlot(bool updateData = true) {
            UpdateModelAndVisuals(updateData);
        }

        public void Reset(Axis axis) {
            axis.Reset();
        }

        public void SetCursorType(CursorType cursorType) {
            /*
            switch (cursorType)
            {
                case CursorType.Pan:
                    this.Cursor = this.PanCursor;
                    break;
                case CursorType.ZoomRectangle:
                    this.Cursor = this.ZoomRectangleCursor;
                    break;
                case CursorType.ZoomHorizontal:
                    this.Cursor = this.ZoomHorizontalCursor;
                    break;
                case CursorType.ZoomVertical:
                    this.Cursor = this.ZoomVerticalCursor;
                    break;
                default:
                    this.Cursor = Cursors.Arrow;
                    break;
            }
            */
        }

        public void ShowTracker(TrackerHitResult trackerHitResult) {
            //throw new System.NotImplementedException();
        }

        public void ShowZoomRectangle(OxyRect r) {
            //throw new System.NotImplementedException();
        }

        public void Zoom(Axis axis, double p1, double p2) {
            axis.Zoom(p1, p2);
            this.RefreshPlot(false);
        }

        public void ZoomAt(Axis axis, double factor, double x) {
            if (double.IsNaN(x))
            {
                double sx = (axis.Transform(axis.ActualMaximum) + axis.Transform(axis.ActualMinimum)) * 0.5;
                x = axis.InverseTransform(sx);
            }

            axis.ZoomAt(factor, x);
        }

        private void UpdateModelAndVisuals(bool updateData = true) {
            this.UpdateModel(updateData);
            this.UpdateVisuals();
        }

        private void UpdateModel(bool updateData) {
            this.ActualModel.Update(updateData);
        }

        private void UpdateVisuals() {
            this.Invalidate();
        }

        public TouchablePlotView(Context context, IAttributeSet attrs) :
            base(context, attrs)
        {
            Initialize();
        }

        public TouchablePlotView(Context context, IAttributeSet attrs, int defStyle) :
            base(context, attrs, defStyle)
        {
            Initialize();
        }

        private void Initialize()
        {
        }

        private readonly object renderingLock = new object();
        private readonly object modelLock = new object();

        protected override void OnDraw(Canvas canvas)
        {
            base.OnDraw(canvas);
            canvas.DrawColor(Color.White);

            lock (this.invalidateLock)
            {
                if (this.isModelInvalidated)
                {
                    if (this.model != null)
                    {
                        this.model.Update(this.updateDataFlag);
                        this.updateDataFlag = false;
                    }

                    this.isModelInvalidated = false;
                }
            }

            lock (this.renderingLock)
            {
                if (this.model != null)
                {
                    var rc = new CanvasRenderContext(canvas);
                    this.model.Render(rc);
                }
            }
            /*
            canvas.DrawColor(Color.White);

            using (var paint = new Paint())
            {
                paint.AntiAlias = true;
                paint.Color = new Color(0, 0, 0, 220);
                paint.StrokeWidth = 2;
                canvas.DrawLine(10f, 10f, canvas.Width - 10, h - 10, paint);
                canvas.DrawLine(canvas.Width - 10, 10f, 10, h - 10, paint);
                paint.TextSize = 24;
                paint.TextAlign = Paint.Align.Left;
                var textbounds = new Rect();
                paint.GetTextBounds("ABC", 0, 1, textbounds);
                var tw = paint.MeasureText("ABC");
                // canvas.DrawText(this.Text, 40, 200, paint);
                canvas.Translate(40, 40);
                canvas.DrawText("ABC=" + tw + "/" + textbounds, 0, 0, paint);
                canvas.Rotate(20);
                canvas.DrawText("ABC=" + tw, 0, 0, paint);
            }*/
        }

        #region Implementation of IOnScaleGestureListener

        public bool OnScale(ScaleGestureDetector detector) {
            float scale = detector.ScaleFactor;
            if (OnPlotZoomed != null)
                OnPlotZoomed(this, new PlotScaleEventArgs(scale));
            return false;
        }

        public class PlotScaleEventArgs : System.EventArgs {
            public float Scale { get; set; }
            public PlotScaleEventArgs(float scale) {
                Scale = scale;
            }
        }

        public event EventHandler<PlotScaleEventArgs> OnPlotZoomed;
       
        public bool OnScaleBegin(ScaleGestureDetector detector) {
            return true;
        }

        public void OnScaleEnd(ScaleGestureDetector detector) {}

        #endregion

        #region Implementation of IOnGestureListener

        public bool OnDown(MotionEvent e) {
            return false;
        }

        public bool OnFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
            return false;
        }

        public void OnLongPress(MotionEvent e) {
            //return false;
        }
        public class PlotScrollEventArgs : EventArgs {
            public float DistanceX { get; set; }
            public float DistanceY { get; set; }
            public PlotScrollEventArgs(float distanceX, float distanceY) {
                DistanceX = distanceX;
                DistanceY = distanceY;
            }
        }

        public event EventHandler<PlotScrollEventArgs> OnPlotScroll;
        public bool OnScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
            if (OnPlotScroll!=null)
                OnPlotScroll(this, new PlotScrollEventArgs(distanceX, distanceY));
            return false;
        }

        public void OnShowPress(MotionEvent e) {
            //
        }

        public bool OnSingleTapUp(MotionEvent e) {
            return false;
        }

        #endregion
    }