c# - 現在の位置XとYに基づいてアスペクト比を変更せずに、回転したコントロールのサイズを変更するにはどうすればよいですか？

Question

現在、次のコードを使用しています。正常に動作しますが、アスペクト比を尊重しません。

    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;
            }
        }
    }
}

およびそのビジュアル（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>

私が言ったように、それは非常にうまく機能します。特に、コントロールが回転している場合、コンポーネントのxとyの位置は、どれだけ回転しても、期待どおりに機能します。

完全なソースコード： http： //www.codeproject.com/Articles/22952/WPF-Diagram-Designer-Part-1

アスペクト比を維持し、XとYの位置に問題がないようにサイズを変更するにはどうすればよいですか？

いろいろ試してみましたが、アスペクト比を保ちながら新しいサイズを簡単に手に入れることができます。しかし、コンポーネントを回転させることができ、XとYの位置が混乱しているため、正しく機能させることができません。比率を維持しながら新しいXとYを調整および修正する方法がわかりません。

score 5 · Accepted Answer

deltaVerticalとdeltaHorizontalを計算します。
アスペクト比をデルタに適用する
DesignerItemの位置とサイズを更新します

更新：実用的なソリューションからのResizeThumbクラスの実装。デザイナアイテムはビューモデル（位置、サイズ、回転角）にバインドされています。

    /// <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;
        }
    }
    }

c# - 現在の位置XとYに基づいてアスペクト比を変更せずに、回転したコントロールのサイズを変更するにはどうすればよいですか？

1 に答える 1

Related

Reference