WPF Thumb rectangle移动改变大小，旋转 mvvmlight 方式实现

好的，针对您的问题，我提供如下实现思路：

1. 在 WPF 中，可以使用 Thumb 控件来实现拖动操作。您可以将 Thumb 控件放置在矩形的角落或边缘，通过 Thumb 控件的 DragDelta 事件来获取鼠标拖动的偏移量，然后将该偏移量应用到您要移动的矩形上。

2. 对于改变大小操作，您可以使用 Thumb 控件的 ResizeThumb 模板来实现。在 ResizeThumb 模板中，可以设置鼠标拖动事件，获取鼠标拖动的偏移量，然后将该偏移量应用到矩形的宽度和高度上。

3. 对于旋转操作，您可以使用 Thumb 控件的 RotateThumb 模板来实现。在 RotateThumb 模板中，可以设置鼠标拖动事件，获取鼠标拖动的偏移量，然后将该偏移量应用到矩形的旋转角度上。

4. 在 MVVMLight 中，您可以使用 ViewModel 来实现矩形的属性绑定。可以在 ViewModel 中定义矩形的位置、大小和旋转角度等属性，然后在 UI 中将这些属性与矩形的实际属性进行绑定。在鼠标拖动事件中，您可以修改 ViewModel 中的属性值，然后通知 UI 更新矩形的属性。

以上是一些实现思路，具体的代码实现需要根据您的需求进行调整。希望能对您有所帮助！

相关问题

WPF Thumb rectangle移动缩放旋转 mvvmlight

WPF Thumb和Rectangle都可以用于实现用户界面中的交互功能，例如移动、缩放、旋转等。在使用mvvmlight框架时，可以将Thumb或Rectangle控件与ViewModel绑定，实现更加优雅的MVVM架构。以下是实现移动、缩放、旋转功能的示例代码：

1. 首先，定义一个Thumb或Rectangle控件，并将其与ViewModel绑定：

<Thumb Width="50" Height="50" Canvas.Left="{Binding X}" Canvas.Top="{Binding Y}" 
       Canvas.ZIndex="{Binding ZIndex}" 
       RenderTransformOrigin="0.5,0.5" 
       RenderTransform="{Binding Transform}">
    <!-- 控件内容 -->
</Thumb>

<Rectangle Width="50" Height="50" Canvas.Left="{Binding X}" Canvas.Top="{Binding Y}" 
           Canvas.ZIndex="{Binding ZIndex}" 
           RenderTransformOrigin="0.5,0.5" 
           RenderTransform="{Binding Transform}">
    <!-- 控件内容 -->
</Rectangle>

2. 在ViewModel中，定义X、Y、ZIndex、Transform等属性，并在构造函数中初始化：

public class MyViewModel : ViewModelBase
{
    private double x;
    public double X
    {
        get { return x; }
        set { Set(ref x, value); }
    }

    private double y;
    public double Y
    {
        get { return y; }
        set { Set(ref y, value); }
    }

    private int zIndex;
    public int ZIndex
    {
        get { return zIndex; }
        set { Set(ref zIndex, value); }
    }

    private Transform transform;
    public Transform Transform
    {
        get { return transform; }
        set { Set(ref transform, value); }
    }

    public MyViewModel()
    {
        X = 100;
        Y = 100;
        ZIndex = 1;
        Transform = new RotateTransform(0);
    }
}

3. 实现移动功能：

private Point startPoint;

public void OnThumbDragStarted(object sender, DragStartedEventArgs e)
{
    startPoint = e.GetPosition(null);
}

public void OnThumbDragDelta(object sender, DragDeltaEventArgs e)
{
    double left = X + e.HorizontalChange;
    double top = Y + e.VerticalChange;

    X = left;
    Y = top;
}

4. 实现缩放功能：

public void OnThumbResizeStarted(object sender, DragStartedEventArgs e)
{
    startPoint = e.GetPosition(null);
}

public void OnThumbResizeDelta(object sender, DragDeltaEventArgs e)
{
    double scaleX = 1 + e.HorizontalChange / Width;
    double scaleY = 1 + e.VerticalChange / Height;

    Transform = new ScaleTransform(scaleX * Transform.Value.M11, scaleY * Transform.Value.M22);
}

5. 实现旋转功能：

public void OnThumbRotateStarted(object sender, DragStartedEventArgs e)
{
    startPoint = e.GetPosition(null);
}

public void OnThumbRotateDelta(object sender, DragDeltaEventArgs e)
{
    Point currentPoint = e.GetPosition(null);
    Vector vector = startPoint - currentPoint;
    double angle = Math.Atan2(vector.Y, vector.X) * 180 / Math.PI;

    Transform = new RotateTransform(angle + Transform.Value.Angle);
}

通过以上代码实现Thumb或Rectangle控件的移动、缩放、旋转功能，可以在WPF应用程序中实现更加优雅的用户界面交互。

WPF Thumb 移动rectangle改变rectangle大小，旋转 rectangle mvvmlight提供实现代码

好的，下面是一个简单的代码示例，演示了如何使用 WPF Thumb 控件实现拖动、改变大小和旋转矩形，以及如何使用 MVVMLight 框架来实现数据绑定。该示例中，我们使用了一个名为 RectangleViewModel 的 ViewModel 类来管理矩形的属性。

XAML 代码：

<Window x:Class="WpfApp1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WpfApp1"
        Title="MainWindow" Height="450" Width="800">
    <Window.DataContext>
        <local:RectangleViewModel/>
    </Window.DataContext>
    <Canvas>
        <!-- 矩形 -->
        <Rectangle Width="{Binding Width}"
                   Height="{Binding Height}"
                   Fill="LightBlue"
                   Canvas.Left="{Binding X}"
                   Canvas.Top="{Binding Y}">
            <Rectangle.RenderTransform>
                <RotateTransform Angle="{Binding Angle}" CenterX="0.5" CenterY="0.5"/>
            </Rectangle.RenderTransform>
        </Rectangle>
        <!-- 拖动 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               DragDelta="Thumb_DragDelta"/>
        <!-- 上边缘改变大小 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               Cursor="SizeNS"
               DragDelta="ResizeTop_DragDelta"/>
        <!-- 下边缘改变大小 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               Cursor="SizeNS"
               DragDelta="ResizeBottom_DragDelta"/>
        <!-- 左边缘改变大小 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               Cursor="SizeWE"
               DragDelta="ResizeLeft_DragDelta"/>
        <!-- 右边缘改变大小 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               Cursor="SizeWE"
               DragDelta="ResizeRight_DragDelta"/>
        <!-- 左上角改变大小 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               Cursor="SizeNWSE"
               DragDelta="ResizeTopLeft_DragDelta"/>
        <!-- 右上角改变大小 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               Cursor="SizeNESW"
               DragDelta="ResizeTopRight_DragDelta"/>
        <!-- 左下角改变大小 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               Cursor="SizeNESW"
               DragDelta="ResizeBottomLeft_DragDelta"/>
        <!-- 右下角改变大小 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               Cursor="SizeNWSE"
               DragDelta="ResizeBottomRight_DragDelta"/>
        <!-- 旋转 Thumb -->
        <Thumb Canvas.Left="{Binding X}"
               Canvas.Top="{Binding Y}"
               Width="10" Height="10"
               Cursor="Hand"
               DragDelta="Rotate_DragDelta"/>
    </Canvas>
</Window>

C# 代码：

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;

namespace WpfApp1
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Thumb_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            viewModel.X += e.HorizontalChange;
            viewModel.Y += e.VerticalChange;
        }

        private void ResizeTop_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            viewModel.Y += e.VerticalChange;
            viewModel.Height -= e.VerticalChange;
        }

        private void ResizeBottom_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            viewModel.Height += e.VerticalChange;
        }

        private void ResizeLeft_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            viewModel.X += e.HorizontalChange;
            viewModel.Width -= e.HorizontalChange;
        }

        private void ResizeRight_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            viewModel.Width += e.HorizontalChange;
        }

        private void ResizeTopLeft_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            viewModel.X += e.HorizontalChange;
            viewModel.Width -= e.HorizontalChange;
            viewModel.Y += e.VerticalChange;
            viewModel.Height -= e.VerticalChange;
        }

        private void ResizeTopRight_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            viewModel.Width += e.HorizontalChange;
            viewModel.Y += e.VerticalChange;
            viewModel.Height -= e.VerticalChange;
        }

        private void ResizeBottomLeft_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            viewModel.X += e.HorizontalChange;
            viewModel.Width -= e.HorizontalChange;
            viewModel.Height += e.VerticalChange;
        }

        private void ResizeBottomRight_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            viewModel.Width += e.HorizontalChange;
            viewModel.Height += e.VerticalChange;
        }

        private void Rotate_DragDelta(object sender, DragDeltaEventArgs e)
        {
            RectangleViewModel viewModel = DataContext as RectangleViewModel;
            double centerX = viewModel.X + viewModel.Width / 2;
            double centerY = viewModel.Y + viewModel.Height / 2;
            Point mousePoint = Mouse.GetPosition(this);
            Point centerPoint = new Point(centerX, centerY);
            double angle = Math.Atan2(mousePoint.Y - centerPoint.Y, mousePoint.X - centerPoint.X) * 180 / Math.PI;
            viewModel.Angle = angle;
        }
    }

    public class RectangleViewModel : ViewModelBase
    {
        private double _x;
        public double X
        {
            get { return _x; }
            set
            {
                if (_x != value)
                {
                    _x = value;
                    RaisePropertyChanged("X");
                }
            }
        }

        private double _y;
        public double Y
        {
            get { return _y; }
            set
            {
                if (_y != value)
                {
                    _y = value;
                    RaisePropertyChanged("Y");
                }
            }
        }

        private double _width = 100;
        public double Width
        {
            get { return _width; }
            set
            {
                if (_width != value)
                {
                    _width = value;
                    RaisePropertyChanged("Width");
                }
            }
        }

        private double _height = 100;
        public double Height
        {
            get { return _height; }
            set
            {
                if (_height != value)
                {
                    _height = value;
                    RaisePropertyChanged("Height");
                }
            }
        }

        private double _angle;
        public double Angle
        {
            get { return _angle; }
            set
            {
                if (_angle != value)
                {
                    _angle = value;
                    RaisePropertyChanged("Angle");
                }
            }
        }
    }

    public class ViewModelBase : System.ComponentModel.INotifyPropertyChanged
    {
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

        protected void RaisePropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
        }
    }
}

这个示例演示了如何使用 WPF Thumb 控件实现矩形的拖动、改变大小和旋转，以及如何使用 MVVMLight 框架实现数据绑定。请注意，这只是一个简单的示例，可以根据您的需要进行修改和扩展。