MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Media;

/// 출처 : https://www.codeproject.com/Articles/85603/A-WPF-custom-control-for-zooming-and-panning#ZoomAndPanControlMethods

namespace ZoomAndPan

{

    public partial class ZoomAndPanControl : ContentControl

    {

        /// <summary>

        /// Reference to the underlying content, which is named PART_Content in the template.

        /// </summary>

        private FrameworkElement content;

        /// <summary>

        /// The transform that is applied to the content to scale it by 'ContentScale'

        /// </summary>

        private ScaleTransform contentScaleTransform = null;

        /// <summary>

        /// The transform that is applied to the content to offset it by 'ContentOffsetX' and 'ContentOffsetY'

        /// </summary>

        private TranslateTransform contentOffsetTransform = null;

        /// <summary>

        /// Enable the udate of the content offset as the content scale changes.

        /// This enabled for zooming about a point (google-maps stlye zooming) and zooming to a rect

        /// </summary>

        private bool enableContentOffsetUpdateFromScale = false;

        private bool disableScrollOffsetSync = false; 

        //public double UnScaledExtentWidth

        //{

        //    get

        //    {

        //        return (double)GetValue(UnScaledExtentWidthProperty);

        //    }

        //    set

        //    {

        //        SetValue(UnScaledExtentWidthProperty, value);

        //    }

        //}

        //public double UnScaledExtentHeight

        //{

        //    get

        //    {

        //        return (double)GetValue(UnScaledExtentHeightProperty);

        //    }

        //    set

        //    {

        //        SetValue(UnScaledExtentHeightProperty, value);

        //    }

        //}

        ///// <summary>

        ///// The width of the viewport in content coordinate, clamped to the width of the content.

        ///// </summary>

        public double ConstrainedContentViewportWidth

        {

            get

            {

                return (double)GetValue(ConstrainedContentViewportWidthProperty);

            }

            set

            {

                SetValue(ConstrainedContentViewportWidthProperty, value);

            }

        }

        ///// <summary>

        ///// The height of the viewport in content coordinate, clamped to the height of the content.

        ///// </summary>

        public double ConstrainedContentViewportHeight

        {

            get

            {

                return (double)GetValue(ConstrainedContentViewportHeightProperty);

            }

            set

            {

                SetValue(ConstrainedContentViewportHeightProperty, value);

            }

        }

        #region IScrollInfo

        /// <summary>

        /// Set to 'true' when the vertical scrollbar is enabled.

        /// </summary>

        private bool canVerticallyScroll = false;

        /// <summary>

        /// Set to 'true' when the vertical scrollbar is enabled.

        /// </summary>

        private bool canHorizontallyScroll = false;

        /// <summary>

        /// Reference to the ScrollViewer that is wrapped (in XAML) around the ZoomAndPanControl.

        /// Or set to null if there is no ScrollViewer.

        /// </summary>

        private ScrollViewer scrollOwner;

        /// <summary>

        /// Records the unscaled extent of the content.

        /// This is calculated during the measure and arrange.

        /// </summary>

        private Size unScaledExtent = new Size();

        /// <summary>

        /// Records the size of the viewport (in viewport coordinates) onto the content.

        /// This is calculated during the measure and arrange.

        /// </summary>

        private Size viewport = new Size(0, 0);

        #endregion

        #region Properties

        /// <summary>

        /// Get/set the current scale (or zoom factor) of the content.

        /// </summary>

        public double ContentScale

        {

            get

            {

                return (double)GetValue(ContentScaleProperty);

            }

            set

            {

                SetValue(ContentScaleProperty, value);

            }

        }

        /// <summary>

        /// Get/set the minimum value for 'ContentScale'

        /// </summary>

        public double MinContentScale

        {

            get

            {

                return (double)GetValue(MinContentScaleProperty);

            }

            set

            {

                SetValue(MinContentScaleProperty, value);

            }

        }

        /// <summary>

        /// Get/set the maximum value  for 'ContentScale'

        /// </summary>

        public double MaxContentScale

        {

            get

            {

                return (double)GetValue(MaxContentScaleProperty);

            }

            set

            {

                SetValue(MaxContentScaleProperty, value);

            }

        }

        /// <summary>

        /// Get the viewport width, in content coordinates.

        /// </summary>

        public double ContentViewportWidth

        {

            get 

            { 

                return (double)GetValue(ContentViewportWidthProperty); 

            }

            set

            { 

                SetValue(ContentViewportWidthProperty, value); 

            }

        }

        /// <summary>

        /// Get the viewport height, in content coordinates

        /// </summary>

        public double ContentViewportHeight

        {

            get

            { 

                return (double)GetValue(ContentViewportHeightProperty); 

            }

            set 

            { 

                SetValue(ContentViewportHeightProperty, value); 

            }

        }

        /// <summary>

        /// Get/set the X offset (in content coordinates) of the view on the content.

        /// </summary>

        public double ContentOffsetX

        {

            get

            {

                return (double)GetValue(ContentOffsetXProperty);

            }

            set

            {

                SetValue(ContentOffsetXProperty, value);

            }

        }

        /// <summary>

        /// Get/Set the offset (in content coordinates) of the view on the content

        /// </summary>

        public double ContentOffsetY

        {

            get

            {

                return (double)GetValue(ContentOffsetYProperty);

            }

            set

            {

                SetValue(ContentOffsetYProperty, value);

            }

        }

        /// <summary>

        /// ContentOffsetTransformX is TranslateTranform value

        /// </summary>

        public double ContentOffsetTransformX 

        {

            get

            {

                return (double)GetValue(ContentOffsetTransformXProperty);

            }

            set

            {

                SetValue(ContentOffsetTransformXProperty, value);

            }

        }

        /// <summary>

        /// ContentOffsetTransformY is TranslateTranform value

        /// </summary>

        public double ContentOffsetTransformY

        {

            get

            {

                return (double)GetValue(ContentOffsetTransformYProperty);

            }

            set

            {

                SetValue(ContentOffsetTransformYProperty, value);

            }

        }

        /// <summary>

        /// unScaledExtentWidth * ContentScale

        /// </summary>

        public double ScaledContentWidth

        {

            get

            {

                return (double)GetValue(ScaledContentWidthProperty);

            }

            set

            {

                SetValue(ScaledContentWidthProperty, value);

            }

        }

        /// <summary>

        /// unScaledExtentHeight * ContentScale

        /// </summary>

        public double ScaledContentHeight

        {

            get

            {

                return (double)GetValue(ScaledContentHeightProperty);

            }

            set

            {

                SetValue(ScaledContentHeightProperty, value);

            }

        }

        /// <summary>

        /// The X coordinate of the content focus, this is the point that we are focusing on when zooming.

        /// </summary>

        public double ContentZoomFocusX 

        { 

            get 

            {

                return (double)GetValue(ContentZoomFocusXProperty);

            }

            set

            {

                SetValue(ContentZoomFocusXProperty, value) ;

            }

        }

        /// <summary>

        /// The Y coordinate of the content focus, this is the point that we are focusing on when zooming.

        /// </summary>

        public double ContentZoomFocusY

        {

            get

            {

                return (double)GetValue(ContentZoomFocusYProperty);

            }

            set

            {

                SetValue(ContentZoomFocusYProperty,value);

            }

        }

        public double RotationAngle

        {

            get { return (double)GetValue(RotationAngleProperty); }

            set { SetValue(RotationAngleProperty, value); }

        }

        public bool IsMouseWheelScrollingEnabled

        {

            get

            {

                return (bool)GetValue(IsMouseWheelScrollingEnabledProperty);

            }

            set

            {

                SetValue(IsMouseWheelScrollingEnabledProperty, value);

            }

        }

        public double AnimationDuration

        {

            get 

            {

                return (double)GetValue(AnimationDurationProperty); 

            }

            set 

            { 

                SetValue(AnimationDurationProperty, value);

            }

        }

        /// <summary>

        /// The X coordinate of the viewport focus, this is the point in the viewport (in viewport coordinates) 

        /// that the content focus point is locked to while zooming in.

        /// </summary>

        public double ViewportZoomFocusX

        {

            get

            {

                return (double)GetValue(ViewportZoomFocusXProperty);

            }

            set

            {

                SetValue(ViewportZoomFocusXProperty, value);

            }

        }

        /// <summary>

        /// The Y coordinate of the viewport focus, this is the point in the viewport (in viewport coordinates) 

        /// that the content focus point is locked to while zooming in.

        /// </summary>

        public double ViewportZoomFocusY

        {

            get

            {

                return (double)GetValue(ViewportZoomFocusYProperty);

            }

            set

            {

                SetValue(ViewportZoomFocusYProperty, value);

            }

        }

        public ImageBrush BackgroundImage

        {

            get { return (ImageBrush)GetValue(BackgroundImageProperty); }

            set { SetValue(BackgroundImageProperty, value); }

        }

        #endregion Properties

        #region Internal Method

        static ZoomAndPanControl()

        {

            DefaultStyleKeyProperty.OverrideMetadata(typeof(ZoomAndPanControl),

            new FrameworkPropertyMetadata(typeof(ZoomAndPanControl)));

        }

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            content = this.Template.FindName("PART_Content", this) as FrameworkElement;

            if (content != null)

            {

                this.contentScaleTransform = new ScaleTransform(ContentScale, ContentScale);

                this.contentOffsetTransform = new TranslateTransform();

                TransformGroup transformGroup = new TransformGroup();

                transformGroup.Children.Add(this.contentOffsetTransform);

                transformGroup.Children.Add(this.contentScaleTransform);

                content.RenderTransform = transformGroup;

            }

        }

        protected override Size MeasureOverride(Size constraint)

        {

            //System.Diagnostics. Debug.WriteLine(Name);

            Size infiniteSize = new Size(double.PositiveInfinity, double.PositiveInfinity);

            Size childSize = base.MeasureOverride(infiniteSize);

            //Size childSize = new Size(1024,1754);

            if (childSize != unScaledExtent )

            {

                unScaledExtent = childSize;

                //unScaledExtent가 결정된 이후 UpdateViewportSize가 일어나야한다.

                UpdateViewportSize(constraint);

            }

            double width = constraint.Width;

            double height = constraint.Height;

            if (double.IsPositiveInfinity(width))

                width = childSize.Width;

            if (double.IsPositiveInfinity(height))

                height = childSize.Height;

            if (scrollOwner != null)

                scrollOwner.InvalidateScrollInfo();

            return new Size(width, height);

        }

        protected override Size ArrangeOverride(Size arrangeBounds)

        {

            Size size = base.ArrangeOverride(arrangeBounds);

            //unScaledExtent가 결정된 이후 UpdateViewportSize가 일어나야한다.

            if (content.DesiredSize != unScaledExtent)

            {

                unScaledExtent = content.DesiredSize;

                if (scrollOwner != null)

                    scrollOwner.InvalidateScrollInfo();

            }

            UpdateViewportSize(arrangeBounds);

            return size;

        } 

        #endregion

        #region Dependency Properties

        #region Max & Min ContentScale

        public static readonly DependencyProperty ContentScaleProperty =

                DependencyProperty.Register("ContentScale", typeof(double), typeof(ZoomAndPanControl),

                                            new FrameworkPropertyMetadata(1.0, ContentScale_PropertyChanged, ContentScale_Coerce));

        public static readonly DependencyProperty MinContentScaleProperty =

          DependencyProperty.Register("MinContentScale", typeof(double), typeof(ZoomAndPanControl),

                                      new FrameworkPropertyMetadata(0.01, MinOrMaxContentScale_PropertyChanged));

        public static readonly DependencyProperty MaxContentScaleProperty =

                DependencyProperty.Register("MaxContentScale", typeof(double), typeof(ZoomAndPanControl),

                                            new FrameworkPropertyMetadata(10.0, MinOrMaxContentScale_PropertyChanged));

        #endregion Max & Min ContentScale

        #region ContentOffset X & Y

        public static readonly DependencyProperty ContentOffsetXProperty =

              DependencyProperty.Register("ContentOffsetX", typeof(double), typeof(ZoomAndPanControl),

                                          new FrameworkPropertyMetadata(0.0, ContentOffsetX_PropertyChanged, ContentOffsetX_Coerce));

        public static readonly DependencyProperty ContentOffsetYProperty =

                DependencyProperty.Register("ContentOffsetY", typeof(double), typeof(ZoomAndPanControl),

                                        new FrameworkPropertyMetadata(0.0, ContentOffsetY_PropertyChanged, ContentOffsetY_Coerce));

        #endregion ContentOffset X & Y

        #region ContentViewportProperty

        public static readonly DependencyProperty ContentViewportHeightProperty =

                DependencyProperty.Register("ContentViewportHeight", typeof(double), typeof(ZoomAndPanControl),

                                        new FrameworkPropertyMetadata(0.0));

        public static readonly DependencyProperty ContentViewportWidthProperty =

                DependencyProperty.Register("ContentViewportWidth", typeof(double), typeof(ZoomAndPanControl),

                                        new FrameworkPropertyMetadata(0.0));

        #endregion ContentViewportProperty

        #region TranslateTransform

        public static readonly DependencyProperty ContentOffsetTransformXProperty =

              DependencyProperty.Register("ContentOffsetTransformX", typeof(double), typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(0.0, ContentOffsetTransformXPropertyChanged));

        public static readonly DependencyProperty ContentOffsetTransformYProperty =

                DependencyProperty.Register("ContentOffsetTransformY", typeof(double), typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(0.0, ContentOffsetTransformYPropertyChanged));

        #endregion

        #region ContentZoomFocus X & Y

        public static readonly DependencyProperty ContentZoomFocusXProperty =

              DependencyProperty.Register("ContentZoomFocusX", typeof(double), typeof(ZoomAndPanControl),

                                          new FrameworkPropertyMetadata(0.0));

        public static readonly DependencyProperty ContentZoomFocusYProperty =

                DependencyProperty.Register("ContentZoomFocusY", typeof(double), typeof(ZoomAndPanControl),

                                            new FrameworkPropertyMetadata(0.0));

        #endregion

        #region ScaleContentProperty

        public static readonly DependencyProperty ScaledContentWidthProperty =

        DependencyProperty.Register("ScaledContentWidth", typeof(double),

        typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(0.0));

        public static readonly DependencyProperty ScaledContentHeightProperty =

        DependencyProperty.Register("ScaledContentHeight", typeof(double),

        typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(0.0));

        #endregion ScaleContentProperty

        #region ConstrainedContentViewport Width, Height

        public static readonly DependencyProperty ConstrainedContentViewportHeightProperty =

      DependencyProperty.Register("ConstrainedContentViewportHeight", typeof(double),

      typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(0.0));

        public static readonly DependencyProperty ConstrainedContentViewportWidthProperty =

        DependencyProperty.Register("ConstrainedContentViewportWidth", typeof(double),

        typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(0.0)); 

        #endregion

        #region Unscaled Width, Height

    //    public static readonly DependencyProperty UnScaledExtentWidthProperty =

    //DependencyProperty.Register("UnScaledExtentWidth", typeof(double),

    //typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(0.0));

    //    public static readonly DependencyProperty UnScaledExtentHeightProperty =

    //    DependencyProperty.Register("UnScaledExtentHeight", typeof(double),

    //    typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(0.0));  

        #endregion

        #region RotationAngle

        public static readonly DependencyProperty

                    RotationAngleProperty =

                    DependencyProperty.Register("RotationAngle",

                    typeof(double), typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(0.0));

        #endregion

        #region IsMouseWheelScrolling

        public static readonly DependencyProperty IsMouseWheelScrollingEnabledProperty =

            DependencyProperty.Register("IsMouseWheelScrollingEnabled", typeof(bool), typeof(ZoomAndPanControl), new FrameworkPropertyMetadata(false));

        #endregion IsMouseWheelScrolling

        #region AnimationDuration

        public static readonly DependencyProperty AnimationDurationProperty =

            DependencyProperty.Register("AnimationDuration", typeof(double), typeof(ZoomAndPanControl),

            new FrameworkPropertyMetadata(0.4));

        #endregion

        #region ViewportZoomFocus

        public static readonly DependencyProperty ViewportZoomFocusXProperty =

            DependencyProperty.Register("ViewportZoomFocusX", typeof(double), typeof(ZoomAndPanControl),

            new FrameworkPropertyMetadata(0.0));

        public static readonly DependencyProperty ViewportZoomFocusYProperty =

            DependencyProperty.Register("ViewportZoomFocusY", typeof(double), typeof(ZoomAndPanControl),

            new FrameworkPropertyMetadata(0.0));

        #endregion

        // Using a DependencyProperty as the backing store for BackGroundImage.  This enables animation, styling, binding, etc...

        public static readonly DependencyProperty BackgroundImageProperty =

            DependencyProperty.Register("BackgroundImage", typeof(ImageBrush), typeof(ZoomAndPanControl), null);

        #endregion Dependency Properties

        #region Dependency PropertyChangedEvent

        #region TranslateTransform

        private static void ContentOffsetTransformXPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

        {

            var zoomAndPanControl = (ZoomAndPanControl)d;

            if (zoomAndPanControl != null)

                zoomAndPanControl.SetContentOffsetTransformX();

        }

        private static void ContentOffsetTransformYPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

        {

            var zoomAndPanControl = (ZoomAndPanControl)d;

            if (zoomAndPanControl != null)

                zoomAndPanControl.SetContentOffsetTransformY();

        } 

        #endregion

        #region ScaleContentProperty

        /// <summary>

        /// Method called to clamp the 'ContentScale' value to its valid range.

        /// </summary>

        private static object ContentScale_Coerce(DependencyObject d, object baseValue)

        {

            ZoomAndPanControl c = (ZoomAndPanControl)d;

            double value = (double)baseValue;

            value = Math.Min(Math.Max(value, c.MinContentScale), c.MaxContentScale);

            return value;

        }

        /// <summary>

        /// Event raised when the 'ContentScale' property has changed value.

        /// </summary>

        private static void ContentScale_PropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)

        {

            ZoomAndPanControl c = (ZoomAndPanControl)o;

            if (c.contentScaleTransform != null)

            {

                c.contentScaleTransform.ScaleX = c.ContentScale;

                c.contentScaleTransform.ScaleY = c.ContentScale;

            }

            c.UpdateContentViewportSize();

            c.UpdateContentZoomFocusX();

            c.UpdateContentZoomFocusY();

            if(c.enableContentOffsetUpdateFromScale)

            {

                try

                {

                    double viewportOffsetX = c.ViewportZoomFocusX - (c.ViewportWidth / 2);

                    double viewportOffsetY = c.ViewportZoomFocusY - (c.ViewportHeight / 2);

                    double contentOffsetX = viewportOffsetX / c.ContentScale;

                    double contentOffsetY = viewportOffsetY / c.ContentScale;

                    c.ContentOffsetX = (c.ContentZoomFocusX - (c.ContentViewportWidth / 2)) - contentOffsetX;

                    c.ContentOffsetY = (c.ContentZoomFocusY - (c.ContentViewportHeight / 2)) - contentOffsetY;

                }

                finally

                {

                    c.enableContentOffsetUpdateFromScale = false;

                }

            }

            if (c.scrollOwner != null)

            {

                c.scrollOwner.InvalidateScrollInfo();

            }

        } 

        #endregion

        #region ContentOffset X & Y

        /// <summary>

        /// Method called to clamp the 'ContentOffsetX' value to its valid range.

        /// </summary>

        private static object ContentOffsetX_Coerce(DependencyObject d, object baseValue)

        {

            ZoomAndPanControl c = (ZoomAndPanControl)d;

            double value = (double)baseValue;

            double minOffsetX = 0.0;

            double maxOffsetX = Math.Max(0.0, c.unScaledExtent.Width - c.ConstrainedContentViewportWidth);

            value = Math.Min(Math.Max(value, minOffsetX), maxOffsetX);

            return value;

        }

        /// <summary>

        /// Event raised when the 'ContentOffsetX' property has changed value.

        /// </summary>

        private static void ContentOffsetX_PropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)

        {

            ZoomAndPanControl c = (ZoomAndPanControl)o;

            c.UpdateTranslationX();

            if (c.scrollOwner != null)

            {

                c.scrollOwner.InvalidateScrollInfo();

            }

        }

        /// <summary>

        /// Method called to clamp the 'ContentOffsetY' value to its valid range.

        /// </summary>

        private static object ContentOffsetY_Coerce(DependencyObject d, object baseValue)

        {

            ZoomAndPanControl c = (ZoomAndPanControl)d;

            double value = (double)baseValue;

            double minOffsetY = 0.0;

            double maxOffsetY = Math.Max(0.0, c.unScaledExtent.Height - c.ConstrainedContentViewportHeight);

            value = Math.Min(Math.Max(value, minOffsetY), maxOffsetY);

            return value;

        }

        /// <summary>

        /// Event raised when the 'ContentOffsetY' property has changed value.

        /// </summary>

        private static void ContentOffsetY_PropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)

        {

            ZoomAndPanControl c = (ZoomAndPanControl)o;

            c.UpdateTranslationY();

            if (c.scrollOwner != null)

            {

                c.scrollOwner.InvalidateScrollInfo();

            }

        } 

        public void AnimatedZoomTo(Rect contentRect)

        {

            var ScaleX = this.ContentViewportWidth / contentRect.Width;

            var ScaleY = this.ContentViewportHeight / contentRect.Height;

            var NewContentScale = this.ContentScale * Math.Min(ScaleX, ScaleY);

            ContentZoomFocusX = contentRect.X + (contentRect.Width / 2);

            ContentZoomFocusY = contentRect.Y + (contentRect.Height/ 2);

            AnimatedZoomPointToViewportCenter(NewContentScale, new Point(ContentZoomFocusX, ContentZoomFocusY), null);

        }

        /// <summary>

        /// Zoom to the specified scale and move the specified focus point to the center of the viewport.

        /// </summary>

        private void AnimatedZoomPointToViewportCenter(double newContentScale, Point contentZoomFocus, EventHandler callback)

        {

            newContentScale = Math.Min(Math.Max(newContentScale, MinContentScale), MaxContentScale);

            ContentZoomFocusX = contentZoomFocus.X;

            ContentZoomFocusY = contentZoomFocus.Y;

            enableContentOffsetUpdateFromScale = true;

            AnimationHelper.StartAnimation(this, ContentScaleProperty, newContentScale, AnimationDuration,

                delegate(object sender, EventArgs e ){

                    enableContentOffsetUpdateFromScale = false; 

                    if(callback  != null)

                    {

                        callback(this, EventArgs.Empty);

                    }

                });

        }

        /// <summary>

        /// Do animation that scales the content so that it fits completely in the control.

        /// </summary>

        public void AnimatedScaleToFit()

        {

            if (content == null)

            {

                throw new ApplicationException("PART_Content was not found in the ZoomAndPanControl visual template!");

            }

            AnimatedZoomTo(new Rect(0, 0, content.ActualWidth, content.ActualHeight));

        }

        #endregion Dependency PropertyChangedEvent

        #region Max & Min ContentScale

        private static void MinOrMaxContentScale_PropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)

        {

            ZoomAndPanControl c = (ZoomAndPanControl)o;

            c.ContentScale = Math.Min(Math.Max(c.ContentScale, c.MinContentScale), c.MaxContentScale);

        }  

        #endregion

        #endregion

        /// <summary>

        /// Set TranslateTransform X Coordinate

        /// </summary>

        public void SetContentOffsetTransformX()

        {

            this.contentOffsetTransform.X = ContentOffsetTransformX;

        }

        /// <summary>

        /// Set TranslateTransform Y Coordinate

        /// </summary>

        public void SetContentOffsetTransformY()

        {

            this.contentOffsetTransform.Y = ContentOffsetTransformY;

        }

        /// <summary>

        /// Update the Y coordinate of the translation transformation.

        /// </summary>

        private void UpdateTranslationY()

        {

            if(this.contentOffsetTransform != null)

            {

                ///Canvas의 Height 값 * ContentScaled 수치를 곱하여 scaledContentHeight를 구한다.

                ScaledContentHeight = this.unScaledExtent.Height * this.ContentScale;

                ////Viewport보다 scaledContentHeight 값이 작다면

                if (ScaledContentHeight < this.viewport.Height)

                {

                    this.ContentOffsetTransformY = (ContentViewportHeight - this.unScaledExtent.Height) / 2;

                }

                else

                {

                    this.ContentOffsetTransformY = -this.ContentOffsetY;

                }

                this.ContentOffsetY = this.ContentOffsetY;

            }

        }

        /// <summary>

        /// Update the X coordinate of the translation transformation.

        /// </summary>

        private void UpdateTranslationX()

        {

            if (this.contentOffsetTransform != null)

            {

                ScaledContentWidth = this.unScaledExtent.Width * this.ContentScale;

                if (ScaledContentWidth < this.viewport.Width)

                {

                    this.ContentOffsetTransformX = (ContentViewportWidth - this.unScaledExtent.Width) / 2;

                }

                else

                {

                    this.ContentOffsetTransformX = -this.ContentOffsetX;

                }

                this.ContentOffsetX = this.ContentOffsetX;

            }

        }

        /// <summary>

        /// Update the size of the viewport in content coordinates after the viewport size or 'ContentScale' has changed

        /// </summary>

        private void UpdateContentViewportSize()

        {

            ContentViewportWidth = viewport.Width / ContentScale;

            ContentViewportHeight = viewport.Height / ContentScale;

            ConstrainedContentViewportWidth = Math.Min(ContentViewportWidth, unScaledExtent.Width);

            ConstrainedContentViewportHeight = Math.Min(ContentViewportHeight, unScaledExtent.Height);

            UpdateTranslationX();

            UpdateTranslationY();

        }

        /// <summary>

        /// Update the viewport size from the specified size. (If viewport Changed Scale or Size)

        /// </summary>

        private void UpdateViewportSize(Size newSize)

        {

            //if (viewport == newSize)

            //{

            //    UpdateContentViewportSize();

            //    return;

            //}

            viewport = newSize;

            UpdateContentViewportSize();

            UpdateContentZoomFocusX();

            UpdateContentZoomFocusY();

            //

            // Update content offset from itself when the size of the viewport changes.

            // This ensures that the content offset remains properly clamped to its valid range.

            //

            this.ContentOffsetX = this.ContentOffsetX;

            this.ContentOffsetY = this.ContentOffsetY;

            if (scrollOwner != null)

            {

                scrollOwner.InvalidateScrollInfo();

            }

        }

        /// <summary>

        /// Zoom in/out centered on the specified point (in content coordinates).

        /// The focus point is kept locked to it's on sceen position (ala google maps).

        /// </summary>

        /// <param name="newContentScale">New Scale</param>

        /// <param name="contentZoomFocus">Zoom Focuse Point</param>

        public void ZoomAboutPoint(double newContentScale, Point contentZoomFocus)

        {

            newContentScale = Math.Min(Math.Max(newContentScale, MinContentScale), MaxContentScale);

            if (contentOffsetTransform !=null)

            {

                var diffPointAndOffsetX = (contentZoomFocus.X + contentOffsetTransform.X);

                var diffPointAndOffsetY = (contentZoomFocus.Y + contentOffsetTransform.Y);

                ///Scale로 압축

                ///ScreenSpace 좌표 내에서 Offset 좌표를 뺀 후 현재 Scale 로 압축.

                double screenSpaceZoomOffsetX = diffPointAndOffsetX * ContentScale;

                double screenSpaceZoomOffsetY = diffPointAndOffsetY * ContentScale;

                ///Scale로 늘림

                ///Scale로 압축된 좌표를 새로운 스케일로 늘린 contentSpaceZoom 좌표 

                double contentSpaceZoomOffsetX = screenSpaceZoomOffsetX / newContentScale;

                double contentSpaceZoomOffsetY = screenSpaceZoomOffsetY / newContentScale;

                ///내가 원하는 좌표 포인트에 contentSpaceZoom 좌표를 뺀 다. 

                double newContentOffsetX = contentZoomFocus.X - contentSpaceZoomOffsetX;

                double newContentOffsetY = contentZoomFocus.Y - contentSpaceZoomOffsetY;

                this.ContentScale = newContentScale;

                this.ContentOffsetX = newContentOffsetX;

                this.ContentOffsetY = newContentOffsetY;

            }

        }

        /// <summary>

        /// ContentOffsetX 

        /// </summary>

        private void UpdateContentZoomFocusX()

        {

            ContentZoomFocusX = ContentOffsetX + (ConstrainedContentViewportWidth / 2);

        }

        private void UpdateContentZoomFocusY()

        {

            ContentZoomFocusY = ContentOffsetY + (ConstrainedContentViewportHeight / 2);

        }

        public void AnimatedZoomTo(double contentScale)

        {

            Point zoomCenter = new Point(ContentOffsetX + (ContentViewportWidth / 2),

                ContentOffsetY + (ContentViewportHeight / 2));

            AnimatedZoomAboutPoint(contentScale, zoomCenter);

        }

        /// <summary>

        /// Use animation to center the view on the specified point (in content coordinates).

        /// </summary>

        public void AnimatedSnapTo(Point contentPoint)

        {

            double newX = contentPoint.X - (this.ContentViewportWidth / 2);

            double newY = contentPoint.Y - (this.ContentViewportHeight / 2);

            AnimationHelper.StartAnimation(this, ContentOffsetXProperty, newX, AnimationDuration);

            AnimationHelper.StartAnimation(this, ContentOffsetYProperty, newY, AnimationDuration);

        }

        public void AnimatedZoomAboutPoint(double newContentScale, Point contentZoomFocus)

        {

            newContentScale = Math.Min(Math.Max(newContentScale, MinContentScale), MaxContentScale);

            ContentZoomFocusX = contentZoomFocus.X;

            ContentZoomFocusY = contentZoomFocus.Y;

            enableContentOffsetUpdateFromScale = true;

            AnimationHelper.StartAnimation(this, ContentScaleProperty, newContentScale, AnimationDuration,

                delegate(object sender, EventArgs e)

                {

                    enableContentOffsetUpdateFromScale = false;

                });

        }

        public void ScaleToFit()

       {

            if(content== null)

            {

                throw new ApplicationException("PART_Content was not found in the ZoomAndPanControl visual template!");

            }

            ZoomTo(new Rect(0,0, content.ActualWidth, content.ActualHeight));

        }

        public void Sync_ZoomTo(Rect contentRect)

        {

            double scaleX = this.ContentViewportWidth / contentRect.Width;

            double scaleY = this.ContentViewportHeight / contentRect.Height;

            double newScale = this.ContentScale * Math.Min(scaleX, scaleY);

            newScale /= 2;

            ZoomPointToViewportCenter(newScale, new Point(contentRect.X +

                (contentRect.Width), contentRect.Y + (contentRect.Height / 2)));

        }

        public void ZoomTo(Rect contentRect)

        {

            double scaleX = this.ContentViewportWidth / contentRect.Width;

            double scaleY = this.ContentViewportHeight / contentRect.Height;

            double newScale = this.ContentScale * Math.Min(scaleX, scaleY);

            ZoomPointToViewportCenter(newScale, new Point(contentRect.X +

                (contentRect.Width / 2), contentRect.Y + (contentRect.Height / 2)));

        }

        public void ZoomPointToViewportCenter(double newContentScale, Point contentZoomFocus)

        {

            newContentScale = Math.Min(Math.Max(newContentScale, MinContentScale), MaxContentScale);

            this.ContentScale = newContentScale;

            this.ContentOffsetX = contentZoomFocus.X - (ContentViewportWidth / 2);

            this.ContentOffsetY = contentZoomFocus.Y - (ContentViewportHeight / 2);

        }

    }

}