/ZoomAndPan/ZoomAndPanControl.cs - 이력해설 - MARKUS - 일정관리

markus / ZoomAndPan / ZoomAndPanControl.cs @ e1c892f7

-a4489
+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;
-            cdfb57ff
+        public event RoutedEventHandler ScaleChanged;
-a4489
+        /// <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();
+            }
-            cdfb57ff
+            if(c.ScaleChanged != null)
+            {
                 c.ScaleChanged(c, new RoutedEventArgs());
+            }
-a4489
+            KangIngu
         #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)));
+        }
-            d974f3f8
+        public void ZoomToTalk(Rect contentRect, int Angle)
+        {
             double scaleX = ContentViewportWidth / contentRect.Width;
             double scaleY = ContentViewportHeight / contentRect.Height;
             double newScale = ContentScale * Math.Min(scaleX, scaleY);
             //각도가 변경 됨에 따라 해당 Width, Height가 변경이 되지 않아 조건에 맞춰 변경해줌 ,값이 소수 점이 생겨서 (int) .
             if ((int)ConstrainedContentViewportWidth == (int)ConstrainedContentViewportHeight && (Angle == 180 || Angle == 0))
+            {
                 ConstrainedContentViewportWidth = unScaledExtent.Height;
                 ConstrainedContentViewportHeight = unScaledExtent.Width;
                 ContentViewportHeight = unScaledExtent.Width;
                 unScaledExtent.Height = ContentViewportHeight;
                 unScaledExtent.Width = ConstrainedContentViewportWidth;
+            }
             else if ((int)ConstrainedContentViewportWidth == (int)ConstrainedContentViewportHeight && (Angle == 90 || Angle == 270))
+            {
                 double emptySize = unScaledExtent.Height;
                 ConstrainedContentViewportWidth = ConstrainedContentViewportHeight;
                 ConstrainedContentViewportHeight = emptySize;
                 unScaledExtent.Width = ConstrainedContentViewportWidth;
                 unScaledExtent.Height = ConstrainedContentViewportHeight;
+            }
             else if ((int)ConstrainedContentViewportHeight == (int)ContentViewportHeight && (Angle == 90 || Angle == 270))
+            {
                 double emptySize = ConstrainedContentViewportWidth;
                 ConstrainedContentViewportWidth = ConstrainedContentViewportHeight;
                 ConstrainedContentViewportHeight = emptySize;
                 unScaledExtent.Width = ConstrainedContentViewportWidth;
                 unScaledExtent.Height = ConstrainedContentViewportHeight;
+            }
             else if ((int)ConstrainedContentViewportHeight != (int)ContentViewportHeight && (Angle == 180 || Angle == 0))
+            {
                 double emptySize = ConstrainedContentViewportWidth;
                 ConstrainedContentViewportWidth = ConstrainedContentViewportHeight;
                 ConstrainedContentViewportHeight = emptySize;
                 unScaledExtent.Width = ConstrainedContentViewportWidth;
                 unScaledExtent.Height = ConstrainedContentViewportHeight;
+            }
             ZoomPointToViewportCenter(newScale, new Point(contentRect.X + (contentRect.Width / 2), contentRect.Y + (contentRect.Height / 2)));
+        }
-a4489
+        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);
-            d974f3f8
+            ZoomPointToViewportCenter(newScale, new Point(contentRect.X + (contentRect.Width / 2), contentRect.Y + (contentRect.Height / 2)));
-a4489
+            KangIngu
         public void ZoomPointToViewportCenter(double newContentScale, Point contentZoomFocus)
-            d974f3f8
+            ljiyeon
-a4489
+            newContentScale = Math.Min(Math.Max(newContentScale, MinContentScale), MaxContentScale);
             this.ContentScale = newContentScale;
             this.ContentOffsetX = contentZoomFocus.X - (ContentViewportWidth / 2);
             this.ContentOffsetY = contentZoomFocus.Y - (ContentViewportHeight / 2);
-            d974f3f8
+            ljiyeon
-a4489
+            KangIngu
+}

프로젝트

일반

사용자정보

MARKUS

markus / ZoomAndPan / ZoomAndPanControl.cs @ e1c892f7