mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 23:52:12 +00:00
195 lines
7.5 KiB
Swift
195 lines
7.5 KiB
Swift
import ExpoModulesCore
|
|
import UIKit
|
|
|
|
/// Wraps a screen's header scroll view. Where a column pads its content away from the iPhone Duo's
|
|
/// vertical bar, this widens the scroll view under the bar, like the system apps' lists. UIKit
|
|
/// draws the header's scroll-edge effect inside the scroll view, so the blur reaches the bar while
|
|
/// the content stays in the safe area, and the scroll indicator runs along the screen edge past the
|
|
/// bar, as in Messages. Everything happens in UIKit layout, so folds move the blur and the content
|
|
/// together.
|
|
final class HanzoScrollEdgeBleedView: ExpoView {
|
|
// Fabric recycles scroll views, so everything changed here is put back before this view leaves
|
|
// the window, which unmounting does before any recycling.
|
|
private var scrollView: UIScrollView?
|
|
private var container: UIView?
|
|
/// React Native's content view, which every row lives in.
|
|
private var content: UIView?
|
|
private var bleed = UIEdgeInsets.zero
|
|
/// Whether the scroll view currently carries this view's changes.
|
|
private var applied = false
|
|
/// React Native's clipping, saved while bleeding. React Native only rewrites it when the
|
|
/// `overflow` style changes, so it stays off while bleeding.
|
|
private var containerClipped: Bool?
|
|
/// The bar's side is read from the root view controller, whose traits can settle after this
|
|
/// view's own during a fold; with no size change after that, nothing else would recheck.
|
|
private weak var observedWindow: UIWindow?
|
|
private var windowTraitRegistration: (any UITraitChangeRegistration)?
|
|
|
|
required init(appContext: AppContext? = nil) {
|
|
super.init(appContext: appContext)
|
|
#if canImport(UIKit, _version: 9127.0.85)
|
|
if #available(iOS 27.1, *) {
|
|
registerForTraitChanges(UITraitCollection.systemTraitsAffectingVerticalBarEdge) { (view: HanzoScrollEdgeBleedView, _: UITraitCollection) in
|
|
view.setNeedsLayout()
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
deinit {
|
|
MainActor.assumeIsolated { detach() }
|
|
}
|
|
|
|
override func didMoveToWindow() {
|
|
super.didMoveToWindow()
|
|
observeWindowTraits()
|
|
if window == nil { detach() } else { setNeedsLayout() }
|
|
}
|
|
|
|
override func safeAreaInsetsDidChange() {
|
|
super.safeAreaInsetsDidChange()
|
|
setNeedsLayout()
|
|
}
|
|
|
|
private func observeWindowTraits() {
|
|
guard observedWindow !== window else { return }
|
|
if let observedWindow, let windowTraitRegistration {
|
|
observedWindow.unregisterForTraitChanges(windowTraitRegistration)
|
|
}
|
|
observedWindow = window
|
|
windowTraitRegistration = nil
|
|
#if canImport(UIKit, _version: 9127.0.85)
|
|
if #available(iOS 27.1, *), let window {
|
|
windowTraitRegistration = window.registerForTraitChanges(
|
|
UITraitCollection.systemTraitsAffectingVerticalBarEdge
|
|
) { [weak self] (_: UIWindow, _: UITraitCollection) in
|
|
self?.setNeedsLayout()
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
override func didAddSubview(_ subview: UIView) {
|
|
super.didAddSubview(subview)
|
|
setNeedsLayout()
|
|
}
|
|
|
|
override func willRemoveSubview(_ subview: UIView) {
|
|
if let scrollView, scrollView.isDescendant(of: subview) { detach() }
|
|
super.willRemoveSubview(subview)
|
|
}
|
|
|
|
override func layoutSubviews() {
|
|
super.layoutSubviews()
|
|
guard window != nil, let found = findScrollView(), let parent = found.superview else { return }
|
|
if found !== scrollView {
|
|
detach()
|
|
scrollView = found
|
|
container = parent
|
|
// React Native adds one plain UIView to its scroll view and mounts every child into it.
|
|
content = found.subviews.first { type(of: $0) == UIView.self }
|
|
}
|
|
bleed = verticalBarBleed()
|
|
// Without the content view to shift back, bleeding left would move the rows under the bar.
|
|
if content == nil { bleed.left = 0 }
|
|
apply()
|
|
}
|
|
|
|
/// How far the vertical bar's safe area reaches past this view's edge, when this view sits flush
|
|
/// against the padding its column added for it. Nothing else is bled into: not a sidebar column
|
|
/// overlapping this one, and not a notch.
|
|
private func verticalBarBleed() -> UIEdgeInsets {
|
|
guard let side = verticalBarSide() else { return .zero }
|
|
var ancestor = superview
|
|
while let view = ancestor {
|
|
let inset = side == .left ? view.safeAreaInsets.left : view.safeAreaInsets.right
|
|
if inset > 0 {
|
|
let frame = convert(bounds, to: view)
|
|
let flush = side == .left
|
|
? abs(frame.minX - (view.bounds.minX + inset)) < 0.5
|
|
: abs(view.bounds.maxX - inset - frame.maxX) < 0.5
|
|
guard flush else { return .zero }
|
|
return side == .left
|
|
? UIEdgeInsets(top: 0, left: inset, bottom: 0, right: 0)
|
|
: UIEdgeInsets(top: 0, left: 0, bottom: 0, right: inset)
|
|
}
|
|
ancestor = view.superview
|
|
}
|
|
return .zero
|
|
}
|
|
|
|
private enum Side { case left, right }
|
|
|
|
private func verticalBarSide() -> Side? {
|
|
// The vertical-bar API ships in the iOS 27.1 SDK (UIKit 9127.0.85); see HanzoLayoutMetricsView.
|
|
#if canImport(UIKit, _version: 9127.0.85)
|
|
if #available(iOS 27.1, *) {
|
|
// UIKit leaves the trait unset in a split view's inspector column, though the bar overlaps
|
|
// it; the flush check above still decides whether this view sits at the bar.
|
|
let traits = window?.rootViewController?.traitCollection ?? traitCollection
|
|
let rtl = effectiveUserInterfaceLayoutDirection == .rightToLeft
|
|
switch traits.verticalBarEdge {
|
|
case .leading: return rtl ? .right : .left
|
|
case .trailing: return rtl ? .left : .right
|
|
default: return nil
|
|
}
|
|
}
|
|
#endif
|
|
return nil
|
|
}
|
|
|
|
/// Widening to the left would move the rows with it. Instead of a horizontal content offset,
|
|
/// which React Native rewrites on its own layout passes, the content view's bounds origin shifts
|
|
/// them back: React Native only ever sets that view's frame, which leaves its bounds origin.
|
|
/// Nothing at all is written unless this view is bleeding or undoing its bleed.
|
|
private func apply() {
|
|
guard let scrollView, let container else { return }
|
|
let bleeding = bleed != .zero
|
|
guard bleeding || applied else { return }
|
|
// React Native sizes the scroll view's component view; the UIScrollView inside follows it by
|
|
// autoresizing, so the widened frame survives React Native's own layout updates.
|
|
let frame = container.bounds.inset(
|
|
by: UIEdgeInsets(top: 0, left: -bleed.left, bottom: 0, right: -bleed.right))
|
|
if scrollView.frame != frame { scrollView.frame = frame }
|
|
if let content, content.bounds.origin.x != -bleed.left {
|
|
content.bounds.origin.x = -bleed.left
|
|
}
|
|
if !bleeding {
|
|
if let clipped = containerClipped {
|
|
containerClipped = nil
|
|
container.layer.masksToBounds = clipped
|
|
}
|
|
} else if container.layer.masksToBounds {
|
|
// The component view clips to its own bounds, which would cut the widened scroll view back.
|
|
// The scroll view itself still clips its content.
|
|
containerClipped = containerClipped ?? true
|
|
container.layer.masksToBounds = false
|
|
}
|
|
applied = bleeding
|
|
}
|
|
|
|
private func detach() {
|
|
guard scrollView != nil else { return }
|
|
bleed = .zero
|
|
apply()
|
|
scrollView = nil
|
|
container = nil
|
|
content = nil
|
|
}
|
|
|
|
/// The scroll view sits a fixed few levels down (marker, React Native's scroll view component);
|
|
/// never walk into a scroll view's content.
|
|
private func findScrollView() -> UIScrollView? {
|
|
var level: [UIView] = subviews
|
|
for _ in 0..<4 {
|
|
var next: [UIView] = []
|
|
for view in level {
|
|
if let scrollView = view as? UIScrollView { return scrollView }
|
|
next.append(contentsOf: view.subviews)
|
|
}
|
|
level = next
|
|
}
|
|
return nil
|
|
}
|
|
}
|