waterui 0.3.0

A modern UI framework for Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

import CWaterUI

#if canImport(UIKit)
  import UIKit
#elseif canImport(AppKit)
  import AppKit
  import QuartzCore
#endif

/// Component for Metadata<Rotation>.
///
/// Applies a rotation transform to the wrapped view around the specified anchor point.
/// Rotations are purely visual and do not affect layout.
@MainActor
final class WuiRotation: PlatformView, WuiComponent {
  static var rawId: CWaterUI.WuiTypeId { waterui_metadata_rotation_id() }

  private let contentView: any WuiComponent
  private var rotationObservation: WuiComputedObservation<Float>?

  // Current transform value
  private var currentRotation: CGFloat = 0.0
  private let anchor: CGPoint
  private var lastBoundsSize: CGSize = .zero

  var stretchAxis: WuiStretchAxis {
    contentView.stretchAxis
  }

  required init(anyview: OpaquePointer, env: WuiEnvironment) {
    let metadata = waterui_force_as_metadata_rotation(anyview)

    // Convert anchor from normalized (0-1) to CGPoint
    self.anchor = CGPoint(
      x: CGFloat(metadata.value.anchor.x),
      y: CGFloat(metadata.value.anchor.y)
    )

    // Resolve the content
    self.contentView = WuiAnyView.resolve(anyview: metadata.content, env: env)

    super.init(frame: .zero)

    // Enable layer for transforms
    #if canImport(AppKit)
      wantsLayer = true
      contentView.wantsLayer = true
    #endif

    contentView.translatesAutoresizingMaskIntoConstraints = true
    addSubview(contentView)

    // Setup watcher for reactive rotation property
    setupWatcher(metadata.value)
  }

  @available(*, unavailable)
  required init?(coder: NSCoder) {
    fatalError("init(coder:) has not been implemented")
  }

  private func setupWatcher(_ rotation: WuiRotation_Struct) {
    let observation = WuiComputedObservation(WuiComputed<Float>(rotation.angle)) {
      [weak self] value, metadata in
      guard let self else { return }
      self.currentRotation = CGFloat(value)
      #if canImport(UIKit)
        withPlatformAnimation(metadata) {
          self.applyTransform()
        }
      #elseif canImport(AppKit)
        let animation = parseAnimation(metadata.getAnimation())
        self.applyTransform(animation: animation)
      #endif
    }
    rotationObservation = observation
    currentRotation = CGFloat(observation.value)
    applyTransform()
  }

  private func applyTransform() {
    let radians = currentRotation * .pi / 180.0

    #if canImport(UIKit)
      let transform = CGAffineTransform(rotationAngle: radians)
      contentView.transform = transform

    #elseif canImport(AppKit)
      let layer = transformedContentLayer()
      let transform = CATransform3DMakeRotation(radians, 0, 0, 1)
      wuiSetLayerTransformWithoutImplicitAnimation(layer, transform)
    #endif
    invalidateCapturedRendering()
  }

  #if canImport(AppKit)
    private func applyTransform(animation: Animation) {
      let radians = currentRotation * .pi / 180.0
      let layer = transformedContentLayer()
      let toTransform = CATransform3DMakeRotation(radians, 0, 0, 1)
      wuiApplyLayerTransform(layer, to: toTransform, animation: animation, key: "wuiRotation")
      invalidateCapturedRendering()
    }

    private func transformedContentLayer() -> CALayer {
      wuiLayoutTransformedContent(
        contentView,
        in: bounds,
        anchor: anchor,
        lastBoundsSize: &lastBoundsSize
      )
      guard let layer = contentView.layer else {
        fatalError("WuiRotation content must be layer-backed after transformed layout")
      }
      return layer
    }
  #endif

  func layoutPriority() -> Int32 {
    contentView.layoutPriority()
  }

  func sizeThatFits(_ proposal: WuiProposalSize) -> CGSize {
    // Transform doesn't affect layout size
    contentView.sizeThatFits(proposal)
  }

  #if canImport(UIKit)
    override func layoutSubviews() {
      super.layoutSubviews()
      // Set anchorPoint and position for proper rotation pivot
      contentView.layer.anchorPoint = anchor
      contentView.bounds = CGRect(origin: .zero, size: bounds.size)
      contentView.center = CGPoint(
        x: bounds.width * anchor.x,
        y: bounds.height * anchor.y
      )
    }
  #elseif canImport(AppKit)
    nonisolated override var isFlipped: Bool { true }

    override func layout() {
      super.layout()

      if wuiLayoutTransformedContent(
        contentView,
        in: bounds,
        anchor: anchor,
        lastBoundsSize: &lastBoundsSize
      ) {
        applyTransform()
      }
    }
  #endif
}

// Type alias for the FFI rotation struct
private typealias WuiRotation_Struct = CWaterUI.WuiRotation