/// <summary>
/// Resize FrameworkElement that is laid on Canvas.
/// </summary>
/// <param name="element">Target FrameworkElement.</param>
/// <param name="resizeMode">Resize mode.</param>
/// <param name="deltaX">Distance that is changed horizontally.</param>
/// <param name="deltaY">Distance that is changed vertically.</param>
/// <returns>True if the FrameworkElement is resized.</returns>
public static bool Resize(FrameworkElement element, BorderResizeMode resizeMode, double deltaX, double deltaY)
{
// Resizes the target element.
if (element is Window window)
{
return(ResizeWindow(window, resizeMode, deltaX, deltaY));
}
return(ResizeFrameworkElement(element, resizeMode, deltaX, deltaY));
}
/// <summary>
/// Resize window.
/// </summary>
/// <param name="window">Target window.</param>
/// <param name="resizeMode">Resize mode.</param>
/// <param name="deltaX">Distance that is changed horizontally.</param>
/// <param name="deltaY">Distance that is changed vertically.</param>
/// <returns>True if the window is resized.</returns>
private static bool ResizeWindow(Window window, BorderResizeMode resizeMode, double deltaX, double deltaY)
{
if (window == null)
{
throw new ArgumentNullException(nameof(window));
}
bool isResized = CalculateHorizontalResize
(
window.Left,
window.ActualWidth,
window.MinWidth,
window.MaxWidth,
resizeMode,
deltaX,
out bool isNewLeft,
out double newLeftOrRight,
out double newWidth
);
isResized = CalculateVerticalResize
(
window.Top,
window.ActualHeight,
window.MinHeight,
window.MaxHeight,
resizeMode,
deltaY,
out bool isNewTop,
out double newTopOrBottom,
out double newHeight
) || isResized;
if (isResized)
{
// Window has inherent min width and height.
// So the ActualWidth and ActualHeight must be used.
window.Width = newWidth;
window.Left = isNewLeft ? newLeftOrRight : newLeftOrRight - window.ActualWidth;
window.Height = newHeight;
window.Top = isNewTop ? newTopOrBottom : newTopOrBottom - window.ActualHeight;
}
return(isResized);
}
/// <summary>
/// Resize FrameworkElement that is laid on Canvas.
/// </summary>
/// <param name="element">Target FrameworkElement.</param>
/// <param name="resizeMode">Resize mode.</param>
/// <param name="deltaX">Distance that is changed horizontally.</param>
/// <param name="deltaY">Distance that is changed vertically.</param>
/// <returns>True if the FrameworkElement is resized.</returns>
private static bool ResizeFrameworkElement(FrameworkElement element, BorderResizeMode resizeMode, double deltaX, double deltaY)
{
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
bool isResized = CalculateHorizontalResize
(
GetCanvasLeft(element),
element.ActualWidth,
element.MinWidth,
element.MaxWidth,
resizeMode,
deltaX,
out bool isNewLeft,
out double newLeftOrRight,
out double newWidth
);
isResized = CalculateVerticalResize
(
GetCanvasTop(element),
element.ActualHeight,
element.MinHeight,
element.MaxHeight,
resizeMode,
deltaY,
out bool isNewTop,
out double newTopOrBottom,
out double newHeight
) || isResized;
if (isResized)
{
// Do not use the ActualWidth and ActualHeight because it is not work.
element.Width = newWidth;
Canvas.SetLeft(element, isNewLeft ? newLeftOrRight : newLeftOrRight - newWidth);
element.Height = newHeight;
Canvas.SetTop(element, isNewTop ? newTopOrBottom : newTopOrBottom - newHeight);
}
return(isResized);
}
/// <summary>
/// Resizes the target.
/// </summary>
/// <param name="mode">The resize mode.</param>
/// <param name="e">The event arguments.</param>
private void Resize(BorderResizeMode mode, DragDeltaEventArgs e)
{
if (Target == null)
{
return;
}
// Converts the DragDeltaEventArgs into a Vector.
Vector dragDelta = new Vector(e.HorizontalChange, e.VerticalChange);
// Raises the Resizing event.
if (!RaiseResizingEvent(this, Target, mode, ref dragDelta))
{
return;
}
// Resizes the target element.
FrameworkElementHelper.Resize(Target, mode, dragDelta);
// Raises the Resized event.
RaiseResizedEvent(this, Target, mode, dragDelta);
}
/// <summary>
/// Calculate horizontal resize.
/// </summary>
/// <param name="left">Resized target's left.</param>
/// <param name="width">Resized target's width.</param>
/// <param name="minWidth">Resized target's minimum width.</param>
/// <param name="maxWidth">Resized target's maximum width.</param>
/// <param name="resizeMode">Resize mode.</param>
/// <param name="deltaX">Distance that is changed horizontally.</param>
/// <param name="isNewLeft">True if the newLeftOrRight is left; otherwise false.</param>
/// <param name="newLeftOrRight">New left or right resulted by resize. If it is right, it is equal to the sum of the left and width.</param>
/// <param name="newWidth">New width resulted by resize.</param>
/// <returns>True if the width is changed.</returns>
private static bool CalculateHorizontalResize(double left, double width, double minWidth, double maxWidth, BorderResizeMode resizeMode, double deltaX,
out bool isNewLeft, out double newLeftOrRight, out double newWidth)
{
// Initializes out variables.
isNewLeft = true;
newLeftOrRight = left;
newWidth = width;
// If not changed
if (deltaX == 0d)
{
return(false);
}
// If it is not related to horizontal resize
if (resizeMode == BorderResizeMode.Top || resizeMode == BorderResizeMode.Bottom)
{
return(false);
}
// If it is positioned left
if (resizeMode == BorderResizeMode.Left || resizeMode == BorderResizeMode.TopLeft || resizeMode == BorderResizeMode.BottomLeft)
{
newWidth = Math.Max(width - deltaX, minWidth);
// Saves the right.
isNewLeft = false;
newLeftOrRight = left + width;
}
else
{
newWidth = Math.Max(width + deltaX, minWidth);
}
// Adjusts not to exceed the max width.
newWidth = Math.Min(newWidth, maxWidth);
// If it is not changed
if (width == newWidth)
{
return(false);
}
return(true);
}
/// <summary>
/// Resize FrameworkElement that is laid on Canvas.
/// </summary>
/// <param name="element">Target FrameworkElement.</param>
/// <param name="resizeMode">Resize mode.</param>
/// <param name="e">Thumb's DragDelta event argument.</param>
/// <returns>True if the FrameworkElement is resized.</returns>
public static bool Resize(FrameworkElement element, BorderResizeMode resizeMode, DragDeltaEventArgs e)
{
return(Resize(element, resizeMode, e.HorizontalChange, e.VerticalChange));
}
/// <summary>
/// Resize FrameworkElement that is laid on Canvas.
/// </summary>
/// <param name="element">Target FrameworkElement.</param>
/// <param name="resizeMode">Resize mode.</param>
/// <param name="delta">Changed distance.</param>
/// <returns>True if the FrameworkElement is resized.</returns>
public static bool Resize(FrameworkElement element, BorderResizeMode resizeMode, Vector delta)
{
return(Resize(element, resizeMode, delta.X, delta.Y));
}
/// <summary>
/// Calculate vertical resize.
/// </summary>
/// <param name="top">Resized target's top.</param>
/// <param name="height">Resized target's height.</param>
/// <param name="minHeight">Resized target's minimum height.</param>
/// <param name="maxHeight">Resized target's maximum height.</param>
/// <param name="resizeMode">Resize mode.</param>
/// <param name="deltaY">Distance that is changed vertically.</param>
/// <param name="isNewTop">True if the newTopOrBottom is top; otherwise false.</param>
/// <param name="newTopOrBottom">New top or bottom resulted by resize. If it is bottom, it is equal to the sum of the top and height.</param>
/// <param name="newHeight">New height resulted by resize.</param>
/// <returns>True if the height is changed.</returns>
private static bool CalculateVerticalResize(double top, double height, double minHeight, double maxHeight, BorderResizeMode resizeMode, double deltaY,
out bool isNewTop, out double newTopOrBottom, out double newHeight)
{
// Initializes out variables.
isNewTop = true;
newTopOrBottom = top;
newHeight = height;
// If not changed
if (deltaY == 0d)
{
return(false);
}
// If it is not related to vertical resize
if (resizeMode == BorderResizeMode.Left || resizeMode == BorderResizeMode.Right)
{
return(false);
}
// If it is positioned top
if (resizeMode == BorderResizeMode.Top || resizeMode == BorderResizeMode.TopLeft || resizeMode == BorderResizeMode.TopRight)
{
newHeight = Math.Max(height - deltaY, minHeight);
// Saves the bottom.
isNewTop = false;
newTopOrBottom = top + height;
}
else
{
newHeight = Math.Max(height + deltaY, minHeight);
}
// Adjusts not to exceed the max height.
newHeight = Math.Min(newHeight, maxHeight);
// If it is not changed
if (height == newHeight)
{
return(false);
}
return(true);
}
/// <summary>
/// Initialize a new instance of the ResizingEventArgs class.
/// </summary>
/// <param name="routedEvent">The routed event identifier for this instance of the RoutedEventArgs class.</param>
/// <param name="source">An alternate source that will be reported when the event is handled. This pre-populates the Source property.</param>
/// <param name="target">The target element that is related. It can be a Window.</param>
/// <param name="mode">The resize mode.</param>
/// <param name="dragDelta">The dragged distance.</param>
public DragResizerResizingEventArgs(RoutedEvent routedEvent, object source, FrameworkElement target, BorderResizeMode mode, Vector dragDelta)
: base(routedEvent, source, target)
{
Mode = mode;
DragDelta = dragDelta;
}
/// <summary>
/// Raises PreviewResizedEvent and ResizedEvent.
/// </summary>
/// <param name="source">An alternate source that will be reported when the event is handled. This pre-populates the Source property.</param>
/// <param name="target">The target element that is related. It can be a Window.</param>
/// <param name="resizeMode">The resize mode.</param>
/// <param name="dragDelta">The dragged distance.</param>
private static void RaiseResizedEvent(UIElement source, FrameworkElement target, BorderResizeMode resizeMode, Vector dragDelta)
{
Debug.Assert(source != null);
Debug.Assert(target != null);
// Creates an event argument.
DragResizerResizedEventArgs eventArgs = new DragResizerResizedEventArgs
(
PreviewResizedEvent,
source,
target,
resizeMode,
dragDelta
);
// Raises the PreviewResized routed event.
source.RaiseEvent(eventArgs);
// Raises the Resized routed event.
eventArgs.RoutedEvent = ResizedEvent;
source.RaiseEvent(eventArgs);
}
/// <summary>
/// Raises PreviewResizingEvent and ResizingEvent.
/// </summary>
/// <param name="source">An alternate source that will be reported when the event is handled. This pre-populates the Source property.</param>
/// <param name="target">The target element that is related. It can be a Window.</param>
/// <param name="resizeMode">The resize mode.</param>
/// <param name="dragDelta">The dragged distance.</param>
/// <returns>True if it is not canceled; otherwise false.</returns>
private static bool RaiseResizingEvent(UIElement source, FrameworkElement target, BorderResizeMode resizeMode, ref Vector dragDelta)
{
Debug.Assert(source != null);
Debug.Assert(target != null);
// Creates an event argument.
DragResizerResizingEventArgs eventArgs = new DragResizerResizingEventArgs
(
PreviewResizingEvent,
source,
target,
resizeMode,
dragDelta
);
// Raises the PreviewResizing routed event.
source.RaiseEvent(eventArgs);
// Raises the Resizing routed event.
eventArgs.RoutedEvent = ResizingEvent;
source.RaiseEvent(eventArgs);
// Saves the delta.
dragDelta = eventArgs.DragDelta;
// If user cancels the move
if (eventArgs.Cancel)
{
return(false);
}
return(true);
}
