我该如何调整，而不改变基于当前位置的X和Y长宽比旋转的控制？ [英] How can i resize a rotated control without change the aspect ratio based on the current position X and Y?

问题描述

目前我用下面的代码，它工作正常，但不尊重宽高比：

 私人双人角度; 
私人点transformOrigin; 
私人ContentControl中designerItem; 
 
公共ResizeThumb（）
 {
 DragStarted + =新DragStartedEventHandler（this.ResizeThumb_DragStarted）; 
 DragDelta + =新DragDeltaEventHandler（this.ResizeThumb_DragDelta）; 
} 
 
私人无效ResizeThumb_DragStarted（对象发件人，DragStartedEventArgs E）
 {
 this.designerItem =的DataContext作为ContentControl中; 
 
如果（this.designerItem！= NULL）
 {
 this.transformOrigin = this.designerItem.RenderTransformOrigin; 
 RotateTransform rotateTransform = this.designerItem.RenderTransform为RotateTransform; 
如果（rotateTransform！= NULL）
 this.angle = rotateTransform.Angle * Math.PI / 180.0; 
，否则
 this.angle = 0; 
} 
} 
 
私人无效ResizeThumb_DragDelta（对象发件人，DragDeltaEventArgs E）
 {
如果（this.designerItem！= NULL）
 {
双deltaVertical，deltaHorizo​​ntal; 
 
开关（VerticalAlignment）
 {
情况下System.Windows.VerticalAlignment.Bottom：
 deltaVertical = Math.Min（-e.VerticalChange，this.designerItem.ActualHeight -  this.designerItem.MinHeight）; 
 Canvas.SetTop（this.designerItem，Canvas.GetTop（this.designerItem）+（this.transformOrigin.Y * deltaVertical *（1  -  Math.Cos（-this.angle））））; 
 Canvas.SetLeft（this.designerItem，Canvas.GetLeft（this.designerItem） -  deltaVertical * this.transformOrigin.Y * Math.Sin（-this.angle））; 
 this.designerItem.Height  -  = deltaVertical; 
中断; 
情况下System.Windows.VerticalAlignment.Top：
 deltaVertical = Math.Min（e.VerticalChange，this.designerItem.ActualHeight  -  this.designerItem.MinHeight）; 
 Canvas.SetTop（this.designerItem，Canvas.GetTop（this.designerItem）+ deltaVertical * Math.Cos（-this.angle）+（this.transformOrigin.Y * deltaVertical *（1  -  Math.Cos（ - this.angle））））; 
 Canvas.SetLeft（this.designerItem，Canvas.GetLeft（this.designerItem）+ deltaVertical * Math.Sin（-this.angle） - （this.transformOrigin.Y * deltaVertical * Math.Sin（-this.angle ）））; 
 this.designerItem.Height  -  = deltaVertical; 
中断; 
默认：
中断; 
} 
 
开关（的Horizo​​ntalAlignment）
 {
情况下System.Windows.Horizo​​ntalAlignment.Left：
 deltaHorizo​​ntal = Math.Min（e.Horizo​​ntalChange，这.designerItem.ActualWidth  -  this.designerItem.MinWidth）; 
 Canvas.SetTop（this.designerItem，Canvas.GetTop（this.designerItem）+ deltaHorizo​​ntal * Math.Sin（this.angle） -  this.transformOrigin.X * deltaHorizo​​ntal * Math.Sin（this.angle））; 
 Canvas.SetLeft（this.designerItem，Canvas.GetLeft（this.designerItem）+ deltaHorizo​​ntal * Math.Cos（this.angle）+（this.transformOrigin.X * deltaHorizo​​ntal *（1  -  Math.Cos（这一点。角度））））; 
 this.designerItem.Width  -  = deltaHorizo​​ntal; 
中断; 
情况下System.Windows.Horizo​​ntalAlignment.Right：
 deltaHorizo​​ntal = Math.Min（-e.Horizo​​ntalChange，this.designerItem.ActualWidth  -  this.designerItem.MinWidth）; 
 Canvas.SetTop（this.designerItem，Canvas.GetTop（this.designerItem） -  this.transformOrigin.X * deltaHorizo​​ntal * Math.Sin（this.angle））; 
 Canvas.SetLeft（this.designerItem，Canvas.GetLeft（this.designerItem）+（deltaHorizo​​ntal * this.transformOrigin.X *（1  -  Math.Cos（this.angle））））; 
 this.designerItem.Width  -  = deltaHorizo​​ntal; 
中断; 
默认：
中断; 
} 
} 
} 
} 
  

和其视觉（XAML）：

 <网格和GT; 
< S：ResizeThumb身高=3光标=SizeNS保证金=0 -4 0 0
 VerticalAlignment =顶部的Horizo​​ntalAlignment =拉伸/> 
< S：ResizeThumb WIDTH =3光标=SizeWE保证金= -  4 0 0 0
 VerticalAlignment =弹力的Horizo​​ntalAlignment =左/> 
< S：ResizeThumb WIDTH =3光标=SizeWE保证金=0 0 -4 0
 VerticalAlignment =弹力的Horizo​​ntalAlignment =右/> 
< S：ResizeThumb身高=3光标=SizeNS保证金=0 0 0 -4
 VerticalAlignment =底的Horizo​​ntalAlignment =拉伸/> 
< S：ResizeThumb WIDTH =7HEIGHT =7光标=SizeNWSE保证金= -  6 -6 0 0
 VerticalAlignment =顶部的Horizo​​ntalAlignment =左/> ; 
< S：ResizeThumb WIDTH =7HEIGHT =7光标=SizeNESW保证金=0 -6 -6 0
 VerticalAlignment =顶部的Horizo​​ntalAlignment =右/> ; 
< S：ResizeThumb WIDTH =7HEIGHT =7光标=SizeNESW保证金= -  6 0 0 -6
 VerticalAlignment =底的Horizo​​ntalAlignment =左/> ; 
< S：ResizeThumb WIDTH =7HEIGHT =7光标=SizeNWSE保证金=0 0 -6 -6
 VerticalAlignment =底的Horizo​​ntalAlignment =右/> ; 
<！ -  ...  - > 
< /网格和GT; 
  

就像我说的它工作得很好，特别是如果控制旋转，x和y位置该组件的工作原理完全如预期，不管它是多么转动

完整的源代码：的 http://www.codeproject.com/Articles/22952/WPF-Diagram-Designer-Part-1

我如何调整它的大小保持宽高比和具有X和Y轴的位置没有问题？

试过在很多方面，这是很容易得到的新的大小，同时保持高宽比。但我不能让它正常工作，因为该组件可旋转X和Y位置是一个烂摊子。我不知道该如何调整和纠正新的X和Y保持的比率。

解决方案

1. 计算deltaVertical和deltaHorizo​​ntal。


2. 应用宽高比三角洲


3. 更新designerItem位置和大小

更新：从工作的解决方案ResizeThumb类实现。设计师项绑定到一个视图模式（位置，大小，角度旋转）：

  ///<总结> 
 ///定义调整形状的拇指。 
 ///< /总结> 
公共类ResizeThumb：拇指
 {
 ///<总结> 
 ///举行一个设计师项目。 
 ///< /总结> 
私人DesignerItem _designerItem; 
 
 ///<总结> 
 ///持有设计师项的集合。 
 ///< /总结> 
私人DesignerItems _designerItems; 
 
 ///<总结> 
 ///保存设计者项
 ///℃的变换原点; /总结> 
私人点_transformOrigin; 
 
 ///<总结> 
 ///保存设计者项
的旋转变换的所述角度///&; /总结> 
私人双_angle = 0.0; 
 
 ///<总结> 
 ///初始化中的<一个新的实例;见CREF =ResizeThumb/>类。 
 ///< /总结> 
公共ResizeThumb（）
 {
 DragStarted + = ResizeThumbDragStarted; 
 DragDelta + = ResizeThumbDragDelta; 
 DragCompleted + = ResizeThumbDragCompleted; 
} 
 
 ///<总结>拇指的拖动开始时
 ///手柄通知。 
 ///< /总结> 
 ///< PARAM NAME =发件人>在发送对象< /参数> 
 ///< PARAM NAME =E>该事件的参数和LT; /参数> 
私人无效ResizeThumbDragStarted（对象发件人，DragStartedEventArgs E）
 {
 _designerItem =的DataContext作为DesignerItem; 
 
如果（_designerItem == NULL）
的回报; 
 
 _designerItem.IsResizing = TRUE; 
 _designerItem.IsDragging = TRUE; 
 _designerItems = _designerItem.GetItemsControl（）; 
 
 _transformOrigin = _designerItem.RenderTransformOrigin; 
 VAR rotateTransform = _designerItem.RenderTransform为RotateTransform; 
如果（rotateTransform！= NULL）
 _angle = rotateTransform.Angle * Math.PI / 180.0; 
，否则
 _angle = 0.0; 
} 
 
 ///<总结>拇指拖动完成时
 ///手柄通知。 
 ///< /总结> 
 ///< PARAM NAME =发件人>在发送对象< /参数> 
 ///< PARAM NAME =E>该事件的参数和LT; /参数> 
私人无效ResizeThumbDragCompleted（对象发件人，DragCompletedEventArgs E）
 {
如果（_designerItem！= NULL）
 {
 _designerItem.IsResizing = FALSE; 
 _designerItem.IsDragging = FALSE; 
} 
} 
 
 ///<总结>当拇指一直拖到
 ///手柄通知。 
 ///< /总结> 
 ///< PARAM NAME =发件人>在发送对象< /参数> 
 ///< PARAM NAME =E>该事件的参数和LT; /参数> 
私人无效ResizeThumbDragDelta（对象发件人，DragDeltaEventArgs E）
 {
如果（_designerItem == NULL || 
 _designerItems == NULL || 
！_designerItem.IsSelected） 
 {
的回报; 
} 
 
 VAR项目= _designerItem; 
 VAR minLeft = double.MaxValue; 
 VAR minTop = double.MaxValue; 
 VAR minDeltaHorizo​​ntal = double.MaxValue; 
 VAR minDeltaVertical = double.MaxValue; 
 
 minLeft = Math.Min（Canvas.GetLeft（项目），minLeft）; 
 minTop = Math.Min（Canvas.GetTop（项目），minTop）; 
 
 minDeltaVertical = Math.Min（minDeltaVertical，item.ActualHeight  -  item.MinHeight）; 
 minDeltaHorizo​​ntal = Math.Min（minDeltaHorizo​​ntal，item.ActualWidth  -  item.MinWidth）; 
 
 //停止移动时，
所选择的项目//至少一个锁定
如果（item.IsLocked）
 {
的回报; 
} 
 
翻番？ dragDeltaVertical = NULL; 
开关（VerticalAlignment）
 {
情况下VerticalAlignment.Bottom：
 dragDeltaVertical = Math.Min（-e.VerticalChange，minDeltaVertical）; 
中断; 
情况下VerticalAlignment.Top：
 dragDeltaVertical = Math.Min（Math.Max（-minTop，e.VerticalChange），minDeltaVertical）; 
中断; 
} 
 
翻番？ dragDeltaHorizo​​ntal = NULL; 
开关（的Horizo​​ntalAlignment）
 {
情况下Horizo​​ntalAlignment.Left：
 dragDeltaHorizo​​ntal = Math.Min（Math.Max（-minLeft，e.Horizo​​ntalChange），minDeltaHorizo​​ntal）; 
中断; 
情况下Horizo​​ntalAlignment.Right：
 dragDeltaHorizo​​ntal = Math.Min（-e.Horizo​​ntalChange，minDeltaHorizo​​ntal）; 
中断; 
} 
 
 //情况下的纵横比保持然后调整宽度和高度
如果（item.KeepAspectRatio）
 {
 CheckAspectRatio（参照dragDeltaHorizo​​ntal，楼盘dragDeltaVertical，item.ActualHeight / item.ActualWidth）; 
} 
 
如果（dragDeltaVertical.HasValue）
 {
开关（VerticalAlignment）
 {
的情况下System.Windows.VerticalAlignment.Bottom： 
 Canvas.SetTop（项目，Canvas.GetTop（项目）+（_transformOrigin.Y * dragDeltaVertical.Value *（1  -  Math.Cos（-_角））））; 
 Canvas.SetLeft（项目，Canvas.GetLeft（项目） -  dragDeltaVertical.Value * _transformOrigin.Y * Math.Sin（-_角））; 
中断; 
情况下System.Windows.VerticalAlignment.Top：
 Canvas.SetTop（项目，Canvas.GetTop（项目）+ dragDeltaVertical.Value * Math.Cos（-_角）+（_transformOrigin.Y * dragDeltaVertical.Value *（1  -  Math.Cos（-_角））））; 
 Canvas.SetLeft（项目，Canvas.GetLeft（项目）+ dragDeltaVertical.Value * Math.Sin（-_角） - （_transformOrigin.Y * dragDeltaVertical.Value * Math.Sin（-_角）））; 
中断; 
默认：
中断; 
} 
 
 item.Height = item.ActualHeight  -  dragDeltaVertical.Value; 
} 
 
如果（dragDeltaHorizo​​ntal.HasValue）
 {
开关（的Horizo​​ntalAlignment）
 {
的情况下System.Windows.Horizo​​ntalAlignment.Left： 
 Canvas.SetTop（项目，Canvas.GetTop（项目）+ dragDeltaHorizo​​ntal.Value * Math.Sin（_angle） -  _transformOrigin.X * dragDeltaHorizo​​ntal.Value * Math.Sin（_angle））; 
 Canvas.SetLeft（项目，Canvas.GetLeft（项目）+ dragDeltaHorizo​​ntal.Value * Math.Cos（_angle）+（_transformOrigin.X * dragDeltaHorizo​​ntal.Value *（1  -  Math.Cos（_angle））））; 
中断; 
情况下System.Windows.Horizo​​ntalAlignment.Right：
 Canvas.SetTop（项目，Canvas.GetTop（项目） -  _transformOrigin.X * dragDeltaHorizo​​ntal.Value * Math.Sin（_angle））; 
 Canvas.SetLeft（项目，Canvas.GetLeft（项目）+（dragDeltaHorizo​​ntal.Value * _transformOrigin.X *（1  -  Math.Cos（_angle））））; 
中断; 
默认：
中断; 
} 
 
 item.Width = item.ActualWidth  -  dragDeltaHorizo​​ntal.Value; 
} 
 
 e.Handled = TRUE; 
} 
 
 ///<总结> 
 ///检查值，以便beween他们比有一个定义的值。 
 ///< /总结> 
 ///< PARAM NAME =dragDeltaHorizo​​ntal>水平三角洲< /参数> 
 ///< PARAM NAME =dragDeltaVertical>垂直三角洲< /参数> 
 ///< PARAM NAME =的aspectRatio>水平垂直比< /参数> 
私人无效CheckAspectRatio（参考翻番？dragDeltaHorizo​​ntal，楼盘翻倍？dragDeltaVertical，双层的aspectRatio）
 {
翻番？ dragValue = NULL; 
如果（dragDeltaVertical.HasValue&安培;&安培; dragDeltaHorizo​​ntal.HasValue）
 {
 dragValue = Math.Max（dragDeltaVertical.Value，dragDeltaHorizo​​ntal.Value）; 
} 
，否则如果（dragDeltaVertical.HasValue）
 {
 dragValue = dragDeltaVertical; 
} 
，否则如果（dragDeltaHorizo​​ntal.HasValue）
 {
 dragValue = dragDeltaHorizo​​ntal; 
} 
 
如果（dragValue.HasValue）
 {
 dragDeltaVertical = dragValue.Value *的aspectRatio; 
 dragDeltaHorizo​​ntal = dragValue; 
} 
} 
} 
  

Currently I have used the following code, it works fine, but doesn't respect the aspect ratio:

    private double angle;
    private Point transformOrigin;
    private ContentControl designerItem;

    public ResizeThumb()
    {
        DragStarted += new DragStartedEventHandler(this.ResizeThumb_DragStarted);
        DragDelta += new DragDeltaEventHandler(this.ResizeThumb_DragDelta);
    }

    private void ResizeThumb_DragStarted(object sender, DragStartedEventArgs e)
    {
        this.designerItem = DataContext as ContentControl;

        if (this.designerItem != null)
        {
            this.transformOrigin = this.designerItem.RenderTransformOrigin;
            RotateTransform rotateTransform = this.designerItem.RenderTransform as RotateTransform;
            if (rotateTransform != null)
                this.angle = rotateTransform.Angle * Math.PI / 180.0;
            else
                this.angle = 0;
        }
    }

    private void ResizeThumb_DragDelta(object sender, DragDeltaEventArgs e)
    {
        if (this.designerItem != null)
        {
            double deltaVertical, deltaHorizontal;

            switch (VerticalAlignment)
            {
                case System.Windows.VerticalAlignment.Bottom:
                    deltaVertical = Math.Min(-e.VerticalChange, this.designerItem.ActualHeight - this.designerItem.MinHeight);
                    Canvas.SetTop(this.designerItem, Canvas.GetTop(this.designerItem) + (this.transformOrigin.Y * deltaVertical * (1 - Math.Cos(-this.angle))));
                    Canvas.SetLeft(this.designerItem, Canvas.GetLeft(this.designerItem) - deltaVertical * this.transformOrigin.Y * Math.Sin(-this.angle));
                    this.designerItem.Height -= deltaVertical;
                    break;
                case System.Windows.VerticalAlignment.Top:
                    deltaVertical = Math.Min(e.VerticalChange, this.designerItem.ActualHeight - this.designerItem.MinHeight);
                    Canvas.SetTop(this.designerItem, Canvas.GetTop(this.designerItem) + deltaVertical * Math.Cos(-this.angle) + (this.transformOrigin.Y * deltaVertical * (1 - Math.Cos(-this.angle))));
                    Canvas.SetLeft(this.designerItem, Canvas.GetLeft(this.designerItem) + deltaVertical * Math.Sin(-this.angle) - (this.transformOrigin.Y * deltaVertical * Math.Sin(-this.angle)));
                    this.designerItem.Height -= deltaVertical;
                    break;
                default:
                    break;
            }

            switch (HorizontalAlignment)
            {
                case System.Windows.HorizontalAlignment.Left:
                    deltaHorizontal = Math.Min(e.HorizontalChange, this.designerItem.ActualWidth - this.designerItem.MinWidth);
                    Canvas.SetTop(this.designerItem, Canvas.GetTop(this.designerItem) + deltaHorizontal * Math.Sin(this.angle) - this.transformOrigin.X * deltaHorizontal * Math.Sin(this.angle));
                    Canvas.SetLeft(this.designerItem, Canvas.GetLeft(this.designerItem) + deltaHorizontal * Math.Cos(this.angle) + (this.transformOrigin.X * deltaHorizontal * (1 - Math.Cos(this.angle))));
                    this.designerItem.Width -= deltaHorizontal;
                    break;
                case System.Windows.HorizontalAlignment.Right:
                    deltaHorizontal = Math.Min(-e.HorizontalChange, this.designerItem.ActualWidth - this.designerItem.MinWidth);
                    Canvas.SetTop(this.designerItem, Canvas.GetTop(this.designerItem) - this.transformOrigin.X * deltaHorizontal * Math.Sin(this.angle));
                    Canvas.SetLeft(this.designerItem, Canvas.GetLeft(this.designerItem) + (deltaHorizontal * this.transformOrigin.X * (1 - Math.Cos(this.angle))));
                    this.designerItem.Width -= deltaHorizontal;
                    break;
                default:
                    break;
            }
        }
    }
}

and its visual (xaml):

    <Grid>
  <s:ResizeThumb Height="3" Cursor="SizeNS" Margin="0 -4 0 0"
                 VerticalAlignment="Top" HorizontalAlignment="Stretch"/>
  <s:ResizeThumb Width="3" Cursor="SizeWE" Margin="-4 0 0 0"
                 VerticalAlignment="Stretch" HorizontalAlignment="Left"/>
  <s:ResizeThumb Width="3" Cursor="SizeWE" Margin="0 0 -4 0"
                 VerticalAlignment="Stretch" HorizontalAlignment="Right"/>
  <s:ResizeThumb Height="3" Cursor="SizeNS" Margin="0 0 0 -4"
                 VerticalAlignment="Bottom" HorizontalAlignment="Stretch"/>
  <s:ResizeThumb Width="7" Height="7" Cursor="SizeNWSE" Margin="-6 -6 0 0"
                 VerticalAlignment="Top" HorizontalAlignment="Left"/>
  <s:ResizeThumb Width="7" Height="7" Cursor="SizeNESW" Margin="0 -6 -6 0"
                 VerticalAlignment="Top" HorizontalAlignment="Right"/>
  <s:ResizeThumb Width="7" Height="7" Cursor="SizeNESW" Margin="-6 0 0 -6"
                 VerticalAlignment="Bottom" HorizontalAlignment="Left"/>
  <s:ResizeThumb Width="7" Height="7" Cursor="SizeNWSE" Margin="0 0 -6 -6"
                 VerticalAlignment="Bottom" HorizontalAlignment="Right"/>
        <!-- ... -->
    </Grid>

Like I said it works very well, especially if the control is rotated, the x and y position of the component works exactly as expected, no matter how much it is rotated.

Full Source Code: http://www.codeproject.com/Articles/22952/WPF-Diagram-Designer-Part-1

How can I resize it keeping the aspect ratio and having no problem with the X and Y position?

Tried in many ways, it is easy to get the new size while maintaining the aspect ratio. But I can not make it work properly because the component can be rotated and X and Y position is a mess. I do not know how to adjust and to correct the new X and Y keeping the ratio.

解决方案

1. calculate the deltaVertical and deltaHorizontal.
2. Apply aspect ratio to deltas
3. Update the designerItem position and size

Update: ResizeThumb class implementation from a working solution. The designer item is bound to a view model (position, size, angle rotation):

    /// <summary>
    /// Defines a thumb for resizing shapes.
    /// </summary>
    public class ResizeThumb : Thumb
    {  
    /// <summary>
    /// Holds a designer item.
    /// </summary>
    private DesignerItem _designerItem;

    /// <summary>
    /// Holds a collection of designer items.
    /// </summary>
    private DesignerItems _designerItems;

    /// <summary>
    /// holds a transform origin of the designer item 
    /// </summary>
    private Point _transformOrigin;

    /// <summary>
    /// holds an angle of the rotation transformation of the designer item
    /// </summary>
    private double _angle = 0.0;

    /// <summary>
    /// Initializes a new instance of the <see cref="ResizeThumb"/> class.
    /// </summary>
    public ResizeThumb()
    {
        DragStarted += ResizeThumbDragStarted;
        DragDelta += ResizeThumbDragDelta;
        DragCompleted += ResizeThumbDragCompleted;
    }

    /// <summary>
    /// Handles notifications when the dragging of the thumb starts.
    /// </summary>
    /// <param name="sender">the sender object</param>
    /// <param name="e">the event arguments</param>
    private void ResizeThumbDragStarted(object sender, DragStartedEventArgs e)
    {
        _designerItem = DataContext as DesignerItem;

        if (_designerItem == null) 
            return;

        _designerItem.IsResizing = true;
        _designerItem.IsDragging = true;
        _designerItems = _designerItem.GetItemsControl();

        _transformOrigin = _designerItem.RenderTransformOrigin;            
        var rotateTransform = _designerItem.RenderTransform as RotateTransform;
        if (rotateTransform != null)
            _angle = rotateTransform.Angle * Math.PI / 180.0;
        else
            _angle = 0.0;
    }

    /// <summary>
    /// Handles notifications when the dragging of the thumb completes.
    /// </summary>
    /// <param name="sender">the sender object</param>
    /// <param name="e">the event arguments</param>
    private void ResizeThumbDragCompleted(object sender, DragCompletedEventArgs e)
    {
        if (_designerItem != null)
        {
            _designerItem.IsResizing = false;
            _designerItem.IsDragging = false;
        }
    }

    /// <summary>
    /// Handles notifications when the thumb has been dragged.
    /// </summary>
    /// <param name="sender">the sender object</param>
    /// <param name="e">the event arguments</param>
    private void ResizeThumbDragDelta(object sender, DragDeltaEventArgs e)
    {
        if (_designerItem == null ||
            _designerItems == null ||
            !_designerItem.IsSelected)
        {
            return;
        }

        var item = _designerItem;
        var minLeft = double.MaxValue;
        var minTop = double.MaxValue;
        var minDeltaHorizontal = double.MaxValue;
        var minDeltaVertical = double.MaxValue;

        minLeft = Math.Min(Canvas.GetLeft(item), minLeft);
        minTop = Math.Min(Canvas.GetTop(item), minTop);

        minDeltaVertical = Math.Min(minDeltaVertical, item.ActualHeight - item.MinHeight);
        minDeltaHorizontal = Math.Min(minDeltaHorizontal, item.ActualWidth - item.MinWidth);

        // stop moving when
        // at least one of the selected items is locked
        if (item.IsLocked)
        {
            return;
        }

        double? dragDeltaVertical = null;
        switch (VerticalAlignment)
        {
            case VerticalAlignment.Bottom:
                dragDeltaVertical = Math.Min(-e.VerticalChange, minDeltaVertical);
                break;
            case VerticalAlignment.Top:
                dragDeltaVertical = Math.Min(Math.Max(-minTop, e.VerticalChange), minDeltaVertical);
                break;
        }

        double? dragDeltaHorizontal = null;
        switch (HorizontalAlignment)
        {
            case HorizontalAlignment.Left:
                dragDeltaHorizontal = Math.Min(Math.Max(-minLeft, e.HorizontalChange), minDeltaHorizontal);
                break;
            case HorizontalAlignment.Right:
                dragDeltaHorizontal = Math.Min(-e.HorizontalChange, minDeltaHorizontal);
                break;
        }

        // in case the aspect ratio is kept then adjust both width and height
        if (item.KeepAspectRatio)
        {
            CheckAspectRatio(ref dragDeltaHorizontal, ref dragDeltaVertical, item.ActualHeight / item.ActualWidth);
        }

        if (dragDeltaVertical.HasValue)
        {
            switch (VerticalAlignment)
            {
                case System.Windows.VerticalAlignment.Bottom:
                    Canvas.SetTop(item, Canvas.GetTop(item) + (_transformOrigin.Y * dragDeltaVertical.Value * (1 - Math.Cos(-_angle))));
                    Canvas.SetLeft(item, Canvas.GetLeft(item) - dragDeltaVertical.Value * _transformOrigin.Y * Math.Sin(-_angle));
                    break;
                case System.Windows.VerticalAlignment.Top:
                    Canvas.SetTop(item, Canvas.GetTop(item) + dragDeltaVertical.Value * Math.Cos(-_angle) + (_transformOrigin.Y * dragDeltaVertical.Value * (1 - Math.Cos(-_angle))));
                    Canvas.SetLeft(item, Canvas.GetLeft(item) + dragDeltaVertical.Value * Math.Sin(-_angle) - (_transformOrigin.Y * dragDeltaVertical.Value * Math.Sin(-_angle)));
                    break;
                default:
                    break;
            }

            item.Height = item.ActualHeight - dragDeltaVertical.Value;
        }

        if (dragDeltaHorizontal.HasValue)
        {
            switch (HorizontalAlignment)
            {
                case System.Windows.HorizontalAlignment.Left:
                    Canvas.SetTop(item, Canvas.GetTop(item) + dragDeltaHorizontal.Value * Math.Sin(_angle) - _transformOrigin.X * dragDeltaHorizontal.Value * Math.Sin(_angle));
                    Canvas.SetLeft(item, Canvas.GetLeft(item) + dragDeltaHorizontal.Value * Math.Cos(_angle) + (_transformOrigin.X * dragDeltaHorizontal.Value * (1 - Math.Cos(_angle))));
                    break;
                case System.Windows.HorizontalAlignment.Right:
                    Canvas.SetTop(item, Canvas.GetTop(item) - _transformOrigin.X * dragDeltaHorizontal.Value * Math.Sin(_angle));
                    Canvas.SetLeft(item, Canvas.GetLeft(item) + (dragDeltaHorizontal.Value * _transformOrigin.X * (1 - Math.Cos(_angle))));
                    break;
                default:
                    break;
            }

            item.Width = item.ActualWidth - dragDeltaHorizontal.Value;
        }

        e.Handled = true;
    }

    /// <summary>
    /// Checks the values so that the ratio beween them has a defined value.
    /// </summary>
    /// <param name="dragDeltaHorizontal">horizontal delta</param>
    /// <param name="dragDeltaVertical">vertical delta</param>
    /// <param name="aspectRatio">horizontal to vertical ration</param>
    private void CheckAspectRatio(ref double? dragDeltaHorizontal, ref double? dragDeltaVertical, double aspectRatio)
    {
        double? dragValue = null;
        if (dragDeltaVertical.HasValue && dragDeltaHorizontal.HasValue)
        {
            dragValue = Math.Max(dragDeltaVertical.Value, dragDeltaHorizontal.Value);
        }
        else if (dragDeltaVertical.HasValue)
        {
            dragValue = dragDeltaVertical;
        }
        else if (dragDeltaHorizontal.HasValue)
        {
            dragValue = dragDeltaHorizontal;
        }

        if (dragValue.HasValue)
        {
            dragDeltaVertical = dragValue.Value * aspectRatio;
            dragDeltaHorizontal = dragValue;
        }
    }
    }

这篇关于我该如何调整，而不改变基于当前位置的X和Y长宽比旋转的控制？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！