TheXamlGuy
407 lines
12 KiB
C#
407 lines
12 KiB
C#
using Avalonia;
|
|
using Avalonia.Controls;
|
|
using Avalonia.Controls.Primitives;
|
|
using Avalonia.Controls.Shapes;
|
|
using Avalonia.Input;
|
|
using Avalonia.Interactivity;
|
|
using Avalonia.Media;
|
|
using Avalonia.Media.Imaging;
|
|
|
|
namespace Toolkit.UI.Controls.Avalonia;
|
|
|
|
public class ImageCropper : TemplatedControl
|
|
{
|
|
public static readonly StyledProperty<IImage?> CurrentAreaBitmapProperty =
|
|
AvaloniaProperty.Register<ImageCropper, IImage?>(nameof(CurrentAreaBitmap));
|
|
|
|
public static readonly StyledProperty<Rect> CurrentRectProperty =
|
|
AvaloniaProperty.Register<ImageCropper, Rect>(nameof(CurrentRect));
|
|
|
|
public static readonly StyledProperty<bool> IsRatioScaleProperty =
|
|
AvaloniaProperty.Register<ImageCropper, bool>(nameof(IsRatioScale));
|
|
|
|
public static readonly StyledProperty<double> RectScaleProperty =
|
|
AvaloniaProperty.Register<ImageCropper, double>(nameof(RectScale), 0.5);
|
|
|
|
public static readonly StyledProperty<Size> ScaleSizeProperty =
|
|
AvaloniaProperty.Register<ImageCropper, Size>(nameof(ScaleSize), new Size(2, 1));
|
|
|
|
public static readonly StyledProperty<IImage?> SourceProperty =
|
|
AvaloniaProperty.Register<ImageCropper, IImage?>(nameof(Source));
|
|
|
|
private Border? border;
|
|
private Thumb? bottomLeftButton;
|
|
private Thumb? bottomRightButton;
|
|
private Canvas? canvas;
|
|
private bool isDragging;
|
|
private double offsetX;
|
|
private double offsetY;
|
|
private Rectangle? rectangleBottom;
|
|
private Rectangle? rectangleLeft;
|
|
private Rectangle? rectangleRight;
|
|
private Rectangle? rectangleTop;
|
|
|
|
private Thumb? topLeftButton;
|
|
private Thumb? topRightButton;
|
|
|
|
static ImageCropper()
|
|
{
|
|
AffectsRender<ImageCropper>(SourceProperty, RectScaleProperty);
|
|
}
|
|
|
|
public IImage? CurrentAreaBitmap
|
|
{
|
|
get => GetValue(CurrentAreaBitmapProperty);
|
|
private set => SetValue(CurrentAreaBitmapProperty, value);
|
|
}
|
|
|
|
public Rect CurrentRect
|
|
{
|
|
get => GetValue(CurrentRectProperty);
|
|
private set => SetValue(CurrentRectProperty, value);
|
|
}
|
|
|
|
public bool IsRatioScale
|
|
{
|
|
get => GetValue(IsRatioScaleProperty);
|
|
set => SetValue(IsRatioScaleProperty, value);
|
|
}
|
|
|
|
public double RectScale
|
|
{
|
|
get => GetValue(RectScaleProperty);
|
|
set => SetValue(RectScaleProperty, value);
|
|
}
|
|
|
|
public Size ScaleSize
|
|
{
|
|
get => GetValue(ScaleSizeProperty);
|
|
set => SetValue(ScaleSizeProperty, value);
|
|
}
|
|
|
|
public IImage? Source
|
|
{
|
|
get => GetValue(SourceProperty);
|
|
set => SetValue(SourceProperty, value);
|
|
}
|
|
|
|
protected override void OnApplyTemplate(TemplateAppliedEventArgs args)
|
|
{
|
|
base.OnApplyTemplate(args);
|
|
|
|
canvas = args.NameScope.Find<Canvas>("Canvas");
|
|
rectangleLeft = args.NameScope.Find<Rectangle>("RectangleLeft");
|
|
rectangleTop = args.NameScope.Find<Rectangle>("RectangleTop");
|
|
rectangleRight = args.NameScope.Find<Rectangle>("RectangleRight");
|
|
rectangleBottom = args.NameScope.Find<Rectangle>("RectangleBottom");
|
|
border = args.NameScope.Find<Border>("Border");
|
|
|
|
topLeftButton = args.NameScope.Find<Thumb>("TopLeftButton");
|
|
if (topLeftButton is not null)
|
|
{
|
|
topLeftButton.DragDelta += OnThumbDragDelta;
|
|
}
|
|
|
|
topRightButton = args.NameScope.Find<Thumb>("TopRightButton");
|
|
if (topRightButton is not null)
|
|
{
|
|
topRightButton.DragDelta += OnThumbDragDelta;
|
|
}
|
|
|
|
bottomLeftButton = args.NameScope.Find<Thumb>("BottomLeftButton");
|
|
if (bottomLeftButton is not null)
|
|
{
|
|
bottomLeftButton.DragDelta += OnThumbDragDelta;
|
|
}
|
|
|
|
bottomRightButton = args.NameScope.Find<Thumb>("BottomRightButton");
|
|
if (bottomRightButton is not null)
|
|
{
|
|
bottomRightButton.DragDelta += OnThumbDragDelta;
|
|
}
|
|
|
|
DrawImage();
|
|
}
|
|
|
|
protected override void OnLoaded(RoutedEventArgs args)
|
|
{
|
|
base.OnLoaded(args);
|
|
DrawImage();
|
|
}
|
|
|
|
protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
|
|
{
|
|
base.OnPropertyChanged(change);
|
|
|
|
if (change.Property == SourceProperty ||
|
|
change.Property == IsRatioScaleProperty ||
|
|
change.Property == RectScaleProperty)
|
|
{
|
|
DrawImage();
|
|
}
|
|
}
|
|
|
|
private void DrawImage()
|
|
{
|
|
if (canvas is null || Source is not Bitmap bitmap)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double maxWidth = DesiredSize.Width;
|
|
double maxHeight = DesiredSize.Height;
|
|
|
|
double imageWidth = Source.Size.Width;
|
|
double imageHeight = Source.Size.Height;
|
|
|
|
double scaleFactor = Math.Min(maxWidth / imageWidth, maxHeight / imageHeight);
|
|
double width = imageWidth * scaleFactor;
|
|
double height = imageHeight * scaleFactor;
|
|
|
|
canvas.Width = width;
|
|
canvas.Height = height;
|
|
|
|
canvas.Background = new ImageBrush
|
|
{
|
|
Source = bitmap
|
|
};
|
|
|
|
UpdatePunchThrough(width, height);
|
|
Render();
|
|
}
|
|
|
|
private void OnBorderPointerMoved(object? sender,
|
|
PointerEventArgs args)
|
|
{
|
|
if (!isDragging || canvas is null || border is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Point position = args.GetPosition(this);
|
|
double newX = Math.Clamp(position.X - offsetX, 0, canvas.Bounds.Width - border.Bounds.Width);
|
|
double newY = Math.Clamp(position.Y - offsetY, 0, canvas.Bounds.Height - border.Bounds.Height);
|
|
|
|
Canvas.SetLeft(border, newX);
|
|
Canvas.SetTop(border, newY);
|
|
|
|
PositionThumbs();
|
|
Render();
|
|
}
|
|
|
|
private void OnBorderPointerPressed(object? sender,
|
|
PointerPressedEventArgs args)
|
|
{
|
|
if (!isDragging && border is not null)
|
|
{
|
|
isDragging = true;
|
|
Point position = args.GetPosition(this);
|
|
|
|
offsetX = position.X - Canvas.GetLeft(border);
|
|
offsetY = position.Y - Canvas.GetTop(border);
|
|
}
|
|
}
|
|
|
|
private void OnBorderPointerReleased(object? sender,
|
|
PointerReleasedEventArgs args) => isDragging = false;
|
|
|
|
private void OnThumbDragDelta(object? sender, VectorEventArgs args)
|
|
{
|
|
if (canvas is null || border is null || sender is not Thumb thumb)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double deltaX = args.Vector.X;
|
|
double deltaY = args.Vector.Y;
|
|
|
|
double leftPosition = Canvas.GetLeft(border);
|
|
double topPosition = Canvas.GetTop(border);
|
|
double newWidth = border.Width;
|
|
double newHeight = border.Height;
|
|
|
|
switch (thumb.Name)
|
|
{
|
|
case "TopLeftButton":
|
|
newWidth = Math.Max(0, border.Width - deltaX);
|
|
newHeight = Math.Max(0, border.Height - deltaY);
|
|
leftPosition += deltaX;
|
|
topPosition += deltaY;
|
|
break;
|
|
|
|
case "TopRightButton":
|
|
newWidth = Math.Max(0, border.Width + deltaX);
|
|
newHeight = Math.Max(0, border.Height - deltaY);
|
|
topPosition += deltaY;
|
|
break;
|
|
|
|
case "BottomLeftButton":
|
|
newWidth = Math.Max(0, border.Width - deltaX);
|
|
newHeight = Math.Max(0, border.Height + deltaY);
|
|
leftPosition += deltaX;
|
|
break;
|
|
|
|
case "BottomRightButton":
|
|
newWidth = Math.Max(0, border.Width + deltaX);
|
|
newHeight = Math.Max(0, border.Height + deltaY);
|
|
break;
|
|
}
|
|
|
|
if (newWidth < 0 || newHeight < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (thumb.Name == "TopLeftButton" || thumb.Name == "BottomLeftButton")
|
|
{
|
|
leftPosition = Math.Max(0, leftPosition);
|
|
newWidth = Math.Max(0, border.Width - (leftPosition - Canvas.GetLeft(border)));
|
|
}
|
|
else if (thumb.Name == "TopRightButton" || thumb.Name == "BottomRightButton")
|
|
{
|
|
double rightBoundary = canvas.Width;
|
|
newWidth = Math.Min(newWidth, rightBoundary - leftPosition);
|
|
}
|
|
|
|
if (thumb.Name == "TopLeftButton" || thumb.Name == "TopRightButton")
|
|
{
|
|
topPosition = Math.Max(0, topPosition);
|
|
newHeight = Math.Max(0, border.Height - (topPosition - Canvas.GetTop(border)));
|
|
}
|
|
else if (thumb.Name == "BottomLeftButton" || thumb.Name == "BottomRightButton")
|
|
{
|
|
double bottomBoundary = canvas.Height;
|
|
newHeight = Math.Min(newHeight, bottomBoundary - topPosition);
|
|
}
|
|
|
|
border.Width = newWidth;
|
|
border.Height = newHeight;
|
|
|
|
Canvas.SetLeft(border, leftPosition);
|
|
Canvas.SetTop(border, topPosition);
|
|
|
|
PositionThumbs();
|
|
Render();
|
|
}
|
|
|
|
|
|
private void PositionThumbs()
|
|
{
|
|
if (border == null ||
|
|
canvas == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double borderLeft = Canvas.GetLeft(border);
|
|
double borderTop = Canvas.GetTop(border);
|
|
double borderWidth = border.Width;
|
|
double borderHeight = border.Height;
|
|
|
|
if (topLeftButton is not null)
|
|
{
|
|
Canvas.SetLeft(topLeftButton, borderLeft - (topLeftButton.Width / 2));
|
|
Canvas.SetTop(topLeftButton, borderTop - (topLeftButton.Height / 2));
|
|
}
|
|
|
|
if (topRightButton is not null)
|
|
{
|
|
Canvas.SetLeft(topRightButton, borderLeft + borderWidth - (topRightButton.Width / 2));
|
|
Canvas.SetTop(topRightButton, borderTop - (topRightButton.Height / 2));
|
|
}
|
|
|
|
if (bottomLeftButton is not null)
|
|
{
|
|
Canvas.SetLeft(bottomLeftButton, borderLeft - (bottomLeftButton.Width / 2));
|
|
Canvas.SetTop(bottomLeftButton, borderTop + borderHeight - (bottomLeftButton.Height / 2));
|
|
}
|
|
|
|
if (bottomRightButton is not null)
|
|
{
|
|
Canvas.SetLeft(bottomRightButton, borderLeft + borderWidth - (bottomRightButton.Width / 2));
|
|
Canvas.SetTop(bottomRightButton, borderTop + borderHeight - (bottomRightButton.Height / 2));
|
|
}
|
|
}
|
|
|
|
private void Render()
|
|
{
|
|
if (canvas == null ||
|
|
border == null ||
|
|
rectangleLeft == null ||
|
|
rectangleTop == null ||
|
|
rectangleRight == null ||
|
|
rectangleBottom == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double borderTop = Canvas.GetTop(border);
|
|
double borderLeft = Canvas.GetLeft(border);
|
|
|
|
rectangleLeft.Width = Math.Max(0, borderLeft);
|
|
rectangleLeft.Height = Math.Max(0, border.Height);
|
|
Canvas.SetTop(rectangleLeft, borderTop);
|
|
|
|
rectangleTop.Width = Math.Max(0, canvas.Width);
|
|
rectangleTop.Height = Math.Max(0, borderTop);
|
|
|
|
double rightX = borderLeft + border.Width;
|
|
|
|
rectangleRight.Width = Math.Max(0, canvas.Width - rightX);
|
|
rectangleRight.Height = Math.Max(0, border.Height);
|
|
Canvas.SetLeft(rectangleRight, rightX);
|
|
Canvas.SetTop(rectangleRight, borderTop);
|
|
|
|
double bottomY = borderTop + border.Height;
|
|
|
|
rectangleBottom.Width = Math.Max(0, canvas.Width);
|
|
rectangleBottom.Height = Math.Max(0, canvas.Height - bottomY);
|
|
Canvas.SetTop(rectangleBottom, bottomY);
|
|
}
|
|
|
|
private void UpdatePunchThrough(double width,
|
|
double height)
|
|
{
|
|
if (canvas == null ||
|
|
border == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (IsRatioScale && ScaleSize.Width > 0 && ScaleSize.Height > 0)
|
|
{
|
|
if (ScaleSize.Width > ScaleSize.Height)
|
|
{
|
|
border.Width = width * RectScale;
|
|
border.Height = border.Width / ScaleSize.Width;
|
|
}
|
|
else
|
|
{
|
|
border.Height = height * RectScale;
|
|
border.Width = border.Height * ScaleSize.Height;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
border.Width = width * RectScale;
|
|
border.Height = height * RectScale;
|
|
}
|
|
|
|
double centreX = (canvas.Width - border.Width) / 2;
|
|
double centreY = (canvas.Height - border.Height) / 2;
|
|
|
|
Canvas.SetLeft(border, centreX);
|
|
Canvas.SetTop(border, centreY);
|
|
|
|
PositionThumbs();
|
|
|
|
border.PointerPressed -= OnBorderPointerPressed;
|
|
border.PointerPressed += OnBorderPointerPressed;
|
|
border.PointerMoved -= OnBorderPointerMoved;
|
|
border.PointerMoved += OnBorderPointerMoved;
|
|
border.PointerReleased -= OnBorderPointerReleased;
|
|
border.PointerReleased += OnBorderPointerReleased;
|
|
}
|
|
}
|
|
|