Rotation #1

Author: SaadArdati

packages/box_transform/lib/src/enums.dart

@@ -413,3 +413,21 @@ enum ResizeMode {
   /// w.r.t the center.
   bool get hasSymmetry => isSymmetric || isSymmetricScale;
 }
+
+/// An enum that defines how a box should be constrained and/or clamped when
+/// undergoing a box transformation operation.
+enum BindingStrategy {
+  /// When a box transformation occurs, clamps and constraints are considered
+  /// on the original unrotated dimensions of the box. Rotation is not
+  /// considered with this strategy, and therefore, if a box is rotated,
+  /// its vertices may leak out of its terminal dimensions and positions.
+  originalBox,
+
+  /// When a box transformation occurs, clamps and constraints are considered
+  /// on the entire bounding box of the box. The bounding box is the smallest
+  /// box that can contain all the vertices of its rotated box.
+  ///
+  /// This is the default strategy to ensure that the box does not
+  /// leak out of its terminal dimensions and positions.
+  boundingBox,
+}

packages/box_transform/lib/src/geometry.dart

@@ -474,8 +474,9 @@ class Box {
   static const Box largest =
       Box.fromLTRB(-_giantScalar, -_giantScalar, _giantScalar, _giantScalar);
 
-  /// Whether any of the coordinates of this rectangle are equal to positive infinity.
-  // included for consistency with Vector2 and Dimension
+  /// Whether any of the coordinates of this rectangle are equal to positive
+  /// infinity.
+  /// Included for consistency with Vector2 and Dimension
   bool get isInfinite =>
       left >= double.infinity ||
       top >= double.infinity ||
@@ -721,5 +722,5 @@ class Box {
 
   @override
   String toString() =>
-      'Box.fromLTRB(${left.toStringAsFixed(1)}, ${top.toStringAsFixed(1)}, ${right.toStringAsFixed(1)}, ${bottom.toStringAsFixed(1)})';
+      'Box.fromLTWH(${left.toStringAsFixed(1)}, ${top.toStringAsFixed(1)}, ${width.toStringAsFixed(1)}, ${height.toStringAsFixed(1)})';
 }

packages/box_transform/lib/src/resizers/freeform_resizing.dart

@@ -13,49 +13,114 @@ final class FreeformResizer extends Resizer {
     required HandlePosition handle,
     required Constraints constraints,
     required Flip flip,
+    required double rotation,
+    required BindingStrategy bindingStrategy,
   }) {
+    final Box effectiveInitialRect = flipRect(initialRect, flip, handle);
+    final Box initialBoundingRect = BoxTransformer.calculateBoundingRect(
+      rotation: rotation,
+      unrotatedBox: effectiveInitialRect,
+    );
+
     final flippedHandle = handle.flip(flip);
-    Box effectiveInitialRect = flipRect(initialRect, flip, handle);
+
+    final Box effectiveInitialBoundingRect =
+        flipRect(initialBoundingRect, flip, handle);
 
     Box newRect = Box.fromLTRB(
       max(explodedRect.left, clampingRect.left),
       max(explodedRect.top, clampingRect.top),
       min(explodedRect.right, clampingRect.right),
       min(explodedRect.bottom, clampingRect.bottom),
     );
+    Box newBoundingRect = BoxTransformer.calculateBoundingRect(
+      rotation: rotation,
+      unrotatedBox: newRect,
+    );
 
     bool isValid = true;
     if (!constraints.isUnconstrained) {
-      final constrainedWidth =
-          newRect.width.clamp(constraints.minWidth, constraints.maxWidth);
-      final constrainedHeight =
-          newRect.height.clamp(constraints.minHeight, constraints.maxHeight);
+      final bindingRect = bindingStrategy == BindingStrategy.originalBox
+          ? newRect
+          : newBoundingRect;
+
+      final Dimension constrainedSize = Dimension(
+        bindingRect.width.clamp(constraints.minWidth, constraints.maxWidth),
+        bindingRect.height.clamp(constraints.minHeight, constraints.maxHeight),
+      );
+      final Dimension constrainedDelta = Dimension(
+        constrainedSize.width - bindingRect.width,
+        constrainedSize.height - bindingRect.height,
+      );
 
       newRect = Box.fromHandle(
         flippedHandle.anchor(effectiveInitialRect),
         flippedHandle,
-        constrainedWidth,
-        constrainedHeight,
+        newRect.width + constrainedDelta.width,
+        newRect.height + constrainedDelta.height,
+      );
+      newBoundingRect = Box.fromHandle(
+        flippedHandle.anchor(effectiveInitialBoundingRect),
+        flippedHandle,
+        newBoundingRect.width + constrainedDelta.width,
+        newBoundingRect.height + constrainedDelta.height,
       );
 
-      isValid = isValidRect(newRect, constraints, clampingRect);
+      isValid = isValidRect(
+        switch (bindingStrategy) {
+          BindingStrategy.originalBox => newRect,
+          BindingStrategy.boundingBox => newBoundingRect,
+        },
+        constraints,
+        clampingRect,
+      );
       if (!isValid) {
         newRect = Box.fromHandle(
           handle.anchor(initialRect),
           handle,
           !handle.isSide || handle.isHorizontal
               ? constraints.minWidth
-              : constrainedWidth,
+              : newRect.width,
           !handle.isSide || handle.isVertical
               ? constraints.minHeight
-              : constrainedHeight,
+              : newRect.height,
+        );
+        newBoundingRect = Box.fromHandle(
+          handle.anchor(initialBoundingRect),
+          handle,
+          !handle.isSide || handle.isHorizontal
+              ? constraints.minWidth
+              : newBoundingRect.width,
+          !handle.isSide || handle.isVertical
+              ? constraints.minHeight
+              : newBoundingRect.height,
         );
       }
     }
 
-    // Not used but calculating it for returning correct largest box.
+    if (rotation != 0) {
+      final Vector2 positionDelta = newRect.topLeft - initialRect.topLeft;
+      final Vector2 newPos = BoxTransformer.calculateUnrotatedPos(
+        initialRect,
+        rotation,
+        positionDelta,
+        newRect.size,
+      );
+      newRect = Box.fromLTWH(newPos.x, newPos.y, newRect.width, newRect.height);
+    }
+
+    final Box effectiveBindingRect = switch (bindingStrategy) {
+      BindingStrategy.originalBox => effectiveInitialRect,
+      BindingStrategy.boundingBox => effectiveInitialBoundingRect,
+    };
+    final Box bindingRect = switch (bindingStrategy) {
+      BindingStrategy.originalBox => initialRect,
+      BindingStrategy.boundingBox => initialBoundingRect,
+    };
+
+    // Only used for calculating the correct largest box.
     final Box area = getAvailableAreaForHandle(
-      rect: isValid ? effectiveInitialRect : initialRect,
+      rect: isValid ? effectiveBindingRect : bindingRect,
       handle: isValid ? flippedHandle : handle,
       clampingRect: clampingRect,
     );

packages/box_transform/lib/src/resizers/resizer.dart

@@ -2,9 +2,9 @@ library resize_handlers;
 
 import 'dart:math';
 
-import '../enums.dart';
-import '../geometry.dart';
-import '../helpers.dart';
+import 'package:vector_math/vector_math.dart';
+
+import '../../box_transform.dart';
 
 part 'freeform_resizing.dart';
 part 'scale_resizing.dart';
@@ -43,5 +43,7 @@ sealed class Resizer {
     required HandlePosition handle,
     required Constraints constraints,
     required Flip flip,
+    required double rotation,
+    required BindingStrategy bindingStrategy,
   });
 }

packages/box_transform/lib/src/resizers/scale_resizing.dart

@@ -13,6 +13,8 @@ final class ScaleResizer extends Resizer {
     required HandlePosition handle,
     required Constraints constraints,
     required Flip flip,
+    required double rotation,
+    required BindingStrategy bindingStrategy,
   }) {
     ({Box rect, Box largest, bool hasValidFlip}) result = _resizeRect(
       initialRect: initialRect,

packages/box_transform/lib/src/resizers/symmetric_resizing.dart

@@ -13,6 +13,8 @@ final class SymmetricResizer extends Resizer {
     required HandlePosition handle,
     required Constraints constraints,
     required Flip flip,
+    required double rotation,
+    required BindingStrategy bindingStrategy,
   }) {
     final double horizontalMirrorRight =
         clampingRect.right - explodedRect.center.x;

packages/box_transform/lib/src/resizers/symmetric_scale_resizing.dart

@@ -13,6 +13,8 @@ final class SymmetricScaleResizer extends Resizer {
     required HandlePosition handle,
     required Constraints constraints,
     required Flip flip,
+    required double rotation,
+    required BindingStrategy bindingStrategy,
   }) {
     switch (handle) {
       case HandlePosition.none: