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