Rect: add additional Rect interfaces

This adds the `standardized`, `integeral`, `isEmpty` properties, the
`insetBy` method and fixes an oversight in the `applying` method.

Author: compnerd

Sources/SwiftWin32/CG/Rect.swift

@@ -1,6 +1,9 @@
 // Copyright © 2019 Saleem Abdulrasool <[email protected]>
 // SPDX-License-Identifier: BSD-3-Clause
 
+@_implementationOnly import func CRT.floor
+@_implementationOnly import func CRT.ceil
+
 /// A structure that contains the location and dimensions of a rectangle.
 public struct Rect {
   // MARK - Creating Rectangle Values
@@ -90,9 +93,33 @@ public struct Rect {
 
   // MARK - Creating Derived Rectangles
 
+  /// Returns a rectangle with a positive width and height.
+  public var standardized: Rect {
+    guard !self.isNull else { return .null }
+
+    guard self.size.width < 0 || self.size.height < 0 else { return self }
+    return Rect(x: self.origin.x + (self.width < 0 ? self.width : 0),
+                y: self.origin.y + (self.height < 0 ? self.height : 0),
+                width: abs(self.width), height: abs(self.height))
+  }
+
+  /// Returns the smallest rectangle that results from converting the source
+  /// rectangle values to integers.
+  public var integral: Rect {
+    guard !self.isNull else { return .null }
+
+    let standardized = self.standardized
+    let origin: Point = Point(x: floor(standardized.minX),
+                              y: floor(standardized.minY))
+    let size: Size = Size(width: ceil(standardized.maxX) - origin.x,
+                          height: ceil(standardized.maxY) - origin.y)
+    return Rect(origin: origin, size: size)
+  }
+
   /// Applies an affine transform to a rectangle.
   public func applying(_ transform: AffineTransform) -> Rect {
-    if transform.isIdentity { return self }
+    guard !self.isNull else { return .null }
+    if transform.isIdentity { return self.standardized }
 
     let points: [Point] = [
       Point(x: minX, y: minY),  // top left
@@ -111,16 +138,39 @@ public struct Rect {
                 size: Size(width: maxX - minX, height: maxY - minY))
   }
 
+  /// Returns a rectangle that is smaller or larger than the source rectangle,
+  /// with the same center point.
+  public func insetBy(dx: Double, dy: Double) -> Rect {
+    let standardized = self.standardized
+    let origin: Point =
+        Point(x: standardized.minX + dx, y: standardized.minY + dy)
+    let size: Size = Size(width: standardized.width - 2 * dx,
+                          height: standardized.height - 2 * dy)
+    guard size.width > 0, size.height > 0 else { return .null }
+    return Rect(origin: origin, size: size)
+  }
+
   /// Returns a rectangle with an origin that is offset from that of the source
   /// rectangle.
   public func offsetBy(dx: Double, dy: Double) -> Rect {
     guard !self.isNull else { return self }
-    return Rect(x: self.origin.x + dx, y: self.origin.y + dy,
-                width: self.size.width, height: self.size.height)
+
+    let standardized = self.standardized
+    return Rect(x: standardized.origin.x + dx,
+                y: standardized.origin.y + dy,
+                width: standardized.size.width,
+                height: standardized.size.height)
   }
 
   // MARK - Checking Characteristics
 
+
+  /// Returns whether a rectangle has zero width or height, or is a null
+  /// rectangle.
+  public var isEmpty: Bool {
+    return self.size.height == 0 || self.size.width == 0 || self.isNull
+  }
+
   /// Returns whether the rectangle is equal to the null rectangle.
   public var isNull: Bool {
     return self == .null

Tests/CoreGraphicsTests/CoreGraphicsTests.swift

@@ -40,6 +40,20 @@ final class CoreGraphicsTests: XCTestCase {
   }
 
   func testRectApplyAffineTransform() {
+    let null: Rect = .null
+    XCTAssertEqual(null.applying(AffineTransform(rotationAngle: .pi)),
+                   Rect.null)
+
+    let nonStandardized: Rect =
+        Rect(origin: .zero, size: Size(width: -32, height: -32))
+    XCTAssertEqual(nonStandardized.applying(.identity),
+                   Rect(x: -32.0, y: -32.0, width: 32.0, height: 32.0))
+
+    let nonStandardizedOblong: Rect =
+        Rect(origin: Point(x: -16, y: -8), size: Size(width: -16, height: -8))
+    XCTAssertEqual(nonStandardizedOblong.applying(AffineTransform(rotationAngle: .pi / 2)),
+                   Rect(x: 7.999999999999998, y: -32, width: 8, height: 16))
+
     var rect: Rect =
         Rect(origin: Point(x: -6, y: -7),
              size: Size(width: 12, height: 14))
@@ -95,6 +109,58 @@ final class CoreGraphicsTests: XCTestCase {
                        .offsetBy(dx: 4.0, dy: 4.0)
     XCTAssertEqual(r2.origin, Point(x: 8.0, y: 8.0))
     XCTAssertEqual(r2.size, Size(width: 4.0, height: 4.0))
+
+    let nonStandardized: Rect =
+        Rect(origin: .zero, size: Size(width: -32, height: -32))
+    XCTAssertEqual(nonStandardized.offsetBy(dx: 16.0, dy: 16.0),
+                   Rect(x: -16.0, y: -16.0, width: 32.0, height: 32.0))
+  }
+
+  func testRectStandardizing() {
+    let null: Rect = .null
+    XCTAssertEqual(null.standardized, Rect.null)
+
+    let normal: Rect = Rect(x: 0, y: 0, width: 32, height: 32)
+    XCTAssertEqual(normal.standardized, normal)
+
+    let negativeHeight: Rect = Rect(x: 0, y: 0, width: -32, height: 32)
+    XCTAssertEqual(negativeHeight.standardized,
+                   Rect(x: -32, y: 0, width: 32, height: 32))
+
+    let negativeWidth: Rect = Rect(x: 0, y: 0, width: 32, height: -32)
+    XCTAssertEqual(negativeWidth.standardized,
+                   Rect(x: 0, y: -32, width: 32, height: 32))
+
+    let negativeHeightAndWidth: Rect = Rect(x: 0, y: 0, width: -32, height: -32)
+    XCTAssertEqual(negativeHeightAndWidth.standardized,
+                   Rect(x: -32, y: -32, width: 32, height: 32))
+
+    let positiveOrigin: Rect = Rect(x: 32, y: 32, width: -32, height: -32)
+    XCTAssertEqual(positiveOrigin.standardized,
+                   Rect(origin: .zero, size: Size(width: 32, height: 32)))
+
+    let negativeOrigin: Rect = Rect(x: -32, y: -32, width: -32, height: -32)
+    XCTAssertEqual(negativeOrigin.standardized,
+                   Rect(x: -64, y: -64, width: 32, height: 32))
+  }
+
+  func testRectIntegral() {
+    let null: Rect = .null
+    XCTAssertEqual(null.integral, Rect.null)
+  }
+
+  func testRectInsetBy() {
+    let null: Rect = .null
+    XCTAssertEqual(null.insetBy(dx: 0.0, dy: 0.0), Rect.null)
+
+    let normal: Rect = Rect(x: 4.0, y: 4.0, width: 16.0, height: 8.0)
+    XCTAssertEqual(normal.insetBy(dx: 2.0, dy: 2.0),
+                   Rect(x: 6.0, y: 6.0, width: 12.0, height: 4.0))
+
+    let nonStandardized: Rect =
+        Rect(origin: .zero, size: Size(width: -32, height: -32))
+    XCTAssertEqual(nonStandardized.insetBy(dx: 4.0, dy: 4.0),
+                   Rect(x: -28.0, y: -28.0, width: 24.0, height: 24.0))
   }
 
   static var allTests = [
@@ -104,5 +170,8 @@ final class CoreGraphicsTests: XCTestCase {
     ("testRectApplyAffineTransform", testRectApplyAffineTransform),
     ("testRectOffsetByNullRect", testRectOffsetByNullRect),
     ("testRectOffsetBy", testRectOffsetBy),
+    ("testRectStandardizing", testRectStandardizing),
+    ("testRectIntegral", testRectIntegral),
+    ("testRectInsetBy", testRectInsetBy),
   ]
 }