ScrollViewerZoomPanHelper

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows;
using System.Windows.Media;

namespace WpfCore.Helpers {
    public class ScrollViewerZoomPanHelper {//adapted from http://www.codeproject.com/KB/docview/WpfZoomAndDragPanel.aspx
        Point? lastCenterPositionOnTarget;
        Point? lastMousePositionOnTarget;
        Point? lastDragPoint;

        public event EventHandler ZoomChanged;

        protected void Call_ZoomChanged() {
            if (ZoomChanged != null) {
                ZoomChanged(null, new EventArgs());
            }
        }

        private ScrollViewer m_ScrollViewer;
        public ScrollViewer ScrollViewer {
            get {
                return m_ScrollViewer;
            }
            set {
                m_ScrollViewer = value;
                SubscribeEvents();
            }
        }

        private FrameworkElement m_ScaledElement;
        public FrameworkElement ScaledElement {
            get {
                return m_ScaledElement;
            }
            set {
                m_ScaledElement = value;

            }
        }

        private double m_MinZoom;
        public double MinZoom {
            get {
                return m_MinZoom;
            }
            set {
                m_MinZoom = value;
            }
        }

        private double m_MaxZoom;
        public double MaxZoom {
            get {
                return m_MaxZoom;
            }
            set {
                m_MaxZoom = value;
            }
        }

        private double m_Zoom;
        public double Zoom {
            get {
                return m_Zoom;
            }
            set {
                m_Zoom = Math.Min(m_MaxZoom, Math.Max(m_MinZoom, value));
                UpdateZoom();
            }
        }

        private double m_ChangePercent = 0.1;
        public double ChangePercent {
            get {
                return m_ChangePercent;
            }
            set {
                m_ChangePercent = value;
            }
        }

        private void UpdateZoom() {
            m_ScaledElement.LayoutTransform.SetValue(ScaleTransform.ScaleYProperty, m_Zoom);
            m_ScaledElement.LayoutTransform.SetValue(ScaleTransform.ScaleXProperty, m_Zoom);

            var centerOfViewport = new Point(m_ScrollViewer.ViewportWidth / 2, m_ScrollViewer.ViewportHeight / 2);
            lastCenterPositionOnTarget = m_ScrollViewer.TranslatePoint(centerOfViewport, m_ScaledElement);
        }

        private void SubscribeEvents() {
            if (m_ScrollViewer == null) return;
            m_ScrollViewer.ScrollChanged += OnScrollViewerScrollChanged;
            m_ScrollViewer.MouseLeftButtonUp += OnMouseLeftButtonUp;
            m_ScrollViewer.PreviewMouseLeftButtonUp += OnMouseLeftButtonUp;
            m_ScrollViewer.PreviewMouseWheel += OnPreviewMouseWheel;

            m_ScrollViewer.PreviewMouseLeftButtonDown += OnMouseLeftButtonDown;
            m_ScrollViewer.MouseMove += OnMouseMove;
        }

        void OnMouseMove(object sender, MouseEventArgs e) {
            if (lastDragPoint.HasValue) {
                Point posNow = e.GetPosition(m_ScrollViewer);

                double dX = posNow.X - lastDragPoint.Value.X;
                double dY = posNow.Y - lastDragPoint.Value.Y;

                lastDragPoint = posNow;

                m_ScrollViewer.ScrollToHorizontalOffset(m_ScrollViewer.HorizontalOffset - dX);
                m_ScrollViewer.ScrollToVerticalOffset(m_ScrollViewer.VerticalOffset - dY);
            }
        }

        void OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e) {
            var mousePos = e.GetPosition(m_ScrollViewer);
            if (mousePos.X <= m_ScrollViewer.ViewportWidth && mousePos.Y < m_ScrollViewer.ViewportHeight) //make sure we still can use the scrollbars
            {
                m_ScrollViewer.Cursor = Cursors.SizeAll;
                lastDragPoint = mousePos;
                Mouse.Capture(m_ScrollViewer);
            }
        }

        void OnPreviewMouseWheel(object sender, MouseWheelEventArgs e) {
            lastMousePositionOnTarget = Mouse.GetPosition(m_ScaledElement);

            if (e.Delta > 0) {
                Zoom *= (1 + m_ChangePercent);
                Call_ZoomChanged();
            }
            if (e.Delta < 0) {
                Zoom /= (1 + m_ChangePercent);
                Call_ZoomChanged();
            }

            e.Handled = true;
        }

        void OnMouseLeftButtonUp(object sender, MouseButtonEventArgs e) {
            m_ScrollViewer.Cursor = Cursors.Arrow;
            m_ScrollViewer.ReleaseMouseCapture();
            lastDragPoint = null;
        }

        void OnScrollViewerScrollChanged(object sender, ScrollChangedEventArgs e) {
            if (e.ExtentHeightChange != 0 || e.ExtentWidthChange != 0) {
                Point? targetBefore = null;
                Point? targetNow = null;

                if (!lastMousePositionOnTarget.HasValue) {
                    if (lastCenterPositionOnTarget.HasValue) {
                        var centerOfViewport = new Point(m_ScrollViewer.ViewportWidth / 2, m_ScrollViewer.ViewportHeight / 2);
                        Point centerOfTargetNow = m_ScrollViewer.TranslatePoint(centerOfViewport, m_ScaledElement);

                        targetBefore = lastCenterPositionOnTarget;
                        targetNow = centerOfTargetNow;
                    }
                } else {
                    targetBefore = lastMousePositionOnTarget;
                    targetNow = Mouse.GetPosition(m_ScaledElement);

                    lastMousePositionOnTarget = null;
                }

                if (targetBefore.HasValue) {
                    double dXInTargetPixels = targetNow.Value.X - targetBefore.Value.X;
                    double dYInTargetPixels = targetNow.Value.Y - targetBefore.Value.Y;

                    double multiplicatorX = e.ExtentWidth / m_ScaledElement.Width;
                    double multiplicatorY = e.ExtentHeight / m_ScaledElement.Height;

                    double newOffsetX = m_ScrollViewer.HorizontalOffset - dXInTargetPixels * multiplicatorX;
                    double newOffsetY = m_ScrollViewer.VerticalOffset - dYInTargetPixels * multiplicatorY;

                    if (double.IsNaN(newOffsetX) || double.IsNaN(newOffsetY)) {
                        return;
                    }

                    m_ScrollViewer.ScrollToHorizontalOffset(newOffsetX);
                    m_ScrollViewer.ScrollToVerticalOffset(newOffsetY);
                }
            }
        }
    }
}