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

import CWaterUI
import Foundation

final class WuiRedrawCallbackBox: @unchecked Sendable {
  private let wake: @MainActor @Sendable () -> Void

  init(wake: @escaping @MainActor @Sendable () -> Void) {
    self.wake = wake
  }

  func requestWake() {
    if Thread.isMainThread {
      MainActor.assumeIsolated {
        wake()
      }
    } else {
      DispatchQueue.main.async { [self] in
        wake()
      }
    }
  }
}

let wuiRedrawWakeCallback: @convention(c) (UnsafeMutableRawPointer?) -> Void = { context in
  guard let context else {
    fatalError("GPU redraw callback received a null context")
  }
  Unmanaged<WuiRedrawCallbackBox>
    .fromOpaque(context)
    .takeUnretainedValue()
    .requestWake()
}

let wuiRedrawDropCallback: @convention(c) (UnsafeMutableRawPointer?) -> Void = { context in
  guard let context else {
    fatalError("GPU redraw callback drop received a null context")
  }
  _ = Unmanaged<WuiRedrawCallbackBox>.fromOpaque(context).takeRetainedValue()
}

// Compiled out when the app disables WaterUI's `gpu` feature: the capture
// fence symbol this half binds does not exist in that build. The redraw box
// above stays — layout invalidation uses it with no GPU involved.
#if !WATERUI_NO_GPU
final class WuiGpuCaptureCompletionBox: @unchecked Sendable {
  private let completion: @MainActor @Sendable () -> Void

  init(completion: @escaping @MainActor @Sendable () -> Void) {
    self.completion = completion
  }

  func enqueueCompletion() {
    DispatchQueue.main.async { [completion] in
      completion()
    }
  }
}

let wuiGpuCaptureCompletionCallback: @convention(c) (UnsafeMutableRawPointer?) -> Void = {
  context in
  guard let context else {
    fatalError("GPU capture completion received a null context")
  }
  Unmanaged<WuiGpuCaptureCompletionBox>
    .fromOpaque(context)
    .takeUnretainedValue()
    .enqueueCompletion()
}

let wuiGpuCaptureCompletionDrop: @convention(c) (UnsafeMutableRawPointer?) -> Void = { context in
  guard let context else {
    fatalError("GPU capture completion drop received a null context")
  }
  _ = Unmanaged<WuiGpuCaptureCompletionBox>.fromOpaque(context).takeRetainedValue()
}

@MainActor
func observeGpuCaptureFence(
  _ fence: OpaquePointer,
  completion: @escaping @MainActor @Sendable () -> Void
) {
  let box = WuiGpuCaptureCompletionBox(completion: completion)
  waterui_gpu_capture_fence_on_complete(
    fence,
    Unmanaged.passRetained(box).toOpaque(),
    wuiGpuCaptureCompletionCallback,
    wuiGpuCaptureCompletionDrop
  )
}
#endif  // !WATERUI_NO_GPU