@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/parent/ParentController.kt

@@ -0,0 +1,218 @@
+package dev.apexnative.navigation.viewcontrollers.parent
+
+import android.app.Activity
+import android.view.ViewGroup
+import dev.apexnative.navigation.options.BottomTabsEnterExitAnimationOptions
+import dev.apexnative.navigation.options.Options
+import dev.apexnative.navigation.react.CommandListener
+import dev.apexnative.navigation.viewcontrollers.bottomtabs.TabBarMotion
+import dev.apexnative.navigation.viewcontrollers.child.ChildController
+import dev.apexnative.navigation.viewcontrollers.child.ChildControllersRegistry
+import dev.apexnative.navigation.viewcontrollers.stack.fab.FabPlacement
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+
+/**
+ * A layout of nodes: a stack, tabs, a side menu, or a container module (the split view, the pair). It tells the core
+ * its children and its current child, which the options resolve along and the visible screen is found through; applies
+ * and merges the options of a child through itself; gives its children their room at the top and the bottom. Where the
+ * core needs a container's own behavior, it asks the node's capabilities (`Capabilities.kt`), never its class.
+ */
+abstract class ParentController<V : ViewGroup>(
+    activity: Activity,
+    childRegistry: ChildControllersRegistry,
+    id: String,
+    presenter: Presenter,
+    initialOptions: Options,
+) : ChildController<V>(activity, childRegistry, id, presenter, initialOptions) {
+    /** Every child of the layout, shown or not. */
+    abstract fun getChildControllers(): Collection<ViewController<*>>
+
+    /** The child the layout shows now, whose options are its own; none for a layout without children (a new stack). */
+    abstract fun getCurrentChild(): ViewController<*>?
+
+    /** Every child of the layout, shown or not. */
+    val childControllers: Collection<ViewController<*>>
+        @JvmName("childControllersProperty") get() = getChildControllers()
+
+    /** The child the layout shows now; none for a layout without children. */
+    val currentChild: ViewController<*>?
+        @JvmName("currentChildProperty") get() = getCurrentChild()
+
+    /**
+     * The options a child takes from this layout: the layout's own over those of the layouts around it. A new object
+     * at each call, which the child changes.
+     */
+    open fun resolveChildOptions(child: ViewController<*>): Options = resolveCurrentOptions()
+
+    /**
+     * What the layout shows with: the shown options of the screen its options come from (`OptionsScreen`, a pair's
+     * primary), or else of its current child, down to the end of the chain; its own resolved options while it has no
+     * child. A layout whose options come from elsewhere (a side menu's center) overrides it.
+     */
+    override fun resolveShownOptions(defaultOptions: Options): Options {
+        val shown = (this as? OptionsScreen)?.optionsScreen?.takeIf { it !== this } ?: getCurrentChild()
+        return shown?.resolveShownOptions(defaultOptions) ?: resolveCurrentOptions(defaultOptions)
+    }
+
+    /** A child shows with [options], resolved: what concerns this layout (its bar, its tabs) applies here. */
+    open fun applyChildOptions(options: Options, child: ViewController<*>) = Unit
+
+    /**
+     * `mergeOptions` of a child (`mergeOptions` step 3): what concerns this layout applies here, when [child] is its
+     * current child; then a container passes it on to its own parent (`performOnParentController`), as the pair does.
+     * The default does nothing.
+     */
+    open fun mergeChildOptions(options: Options, child: ViewController<*>) = Unit
+
+    /** A child was destroyed: what the layout kept for it goes. */
+    open fun onChildDestroyed(child: ViewController<*>) = Unit
+
+    /** The room [child] keeps at its top for this layout and the layouts around it. */
+    open fun getTopInset(child: ViewController<*>): Int = parentController?.getTopInset(this) ?: 0
+
+    /**
+     * The room [child] keeps at its bottom for this layout and the layouts around it; [screen] is the screen that
+     * asks, whose options say whether it is under the tabs: [child] itself, or a screen under it.
+     */
+    open fun getBottomInset(child: ViewController<*>, screen: ViewController<*> = child): Int =
+        parentController?.getBottomInset(this, screen) ?: 0
+
+    // The answers a screen's safe area and room take from the layouts around it. Each layout passes the question on to
+    // the one around it; the stack, its bar and the tabs answer for their children. At the top of the tree the answer
+    // is "none".
+
+    /**
+     * Whether a layout around [child] keeps the room of the status bar for it: its bar is drawn under the status bar
+     * and [child] is under that bar, so the screen keeps no room of its own for the status bar.
+     */
+    open fun keepsStatusBarRoomOf(child: ViewController<*>): Boolean =
+        parentController?.keepsStatusBarRoomOf(this) ?: false
+
+    /**
+     * Where the bottom of the header over [child] is in the window, in pixels, when that header covers its content:
+     * shown and not hidden by the child's options, at the place it has in the layout; none without one.
+     */
+    open fun headerBottomOf(child: ViewController<*>): Int? = parentController?.headerBottomOf(this)
+
+    /**
+     * Where the top of the tabs under [child] is in the window, in pixels, when the tabs cover its content: shown and
+     * not hidden by the options of [screen], the screen that asks; none without them.
+     */
+    open fun tabsTopOf(child: ViewController<*>, screen: ViewController<*> = child): Int? =
+        parentController?.tabsTopOf(this, screen)
+
+    /**
+     * Whether [child] is the top of its stack: a screen under another doesn't compute its safe area again, once it has
+     * one. Out of a stack, yes.
+     */
+    open fun isTopOfStack(child: ViewController<*>): Boolean = parentController?.isTopOfStack(this) ?: true
+
+    /**
+     * Whether [child] is in a side of a side menu (`ViewController.isInSideMenu`): as this layout is, by default; a
+     * side menu answers yes for its left and right menus.
+     */
+    open fun isInSideMenu(child: ViewController<*>): Boolean = isInSideMenu
+
+    /**
+     * Whether [child] measures its safe area though its view doesn't show: a screen prepared for a push lays out
+     * hidden in its stack as if it were the top, a made tab that isn't selected lays out invisible, so does a closed
+     * menu of a side menu. No by default.
+     */
+    open fun measuresThoughNotShown(child: ViewController<*>): Boolean = false
+
+    /**
+     * Whether the safe area of [child] leaves its top edge free by default: its stack shows the header with
+     * `topBar.hideOnScroll` or the search with `hideOnScroll`, or a large title shows.
+     */
+    open fun leavesTopEdgeFree(child: ViewController<*>): Boolean =
+        parentController?.leavesTopEdgeFree(this) ?: false
+
+    /**
+     * Whether the safe area of [child] leaves its bottom edge free by default: the tabs show with
+     * `bottomTabs.hideOnScroll` of [screen], the screen that asks.
+     */
+    open fun leavesBottomEdgeFree(child: ViewController<*>, screen: ViewController<*> = child): Boolean =
+        parentController?.leavesBottomEdgeFree(this, screen) ?: false
+
+    /**
+     * The tab bar at rest under [child]: where a stack's FAB keeps clear of it, by the options of [screen], the stack's
+     * screen on top; none out of tabs.
+     */
+    internal open fun tabsAtRestOf(
+        child: ViewController<*>,
+        screen: ViewController<*> = child,
+    ): FabPlacement.Tabs? = parentController?.tabsAtRestOf(this, screen)
+
+    /**
+     * A stack under this layout ([child], or a layout on the way to it) changes its top with [move]: the tab bar of the
+     * tabs around goes with the transition, right before the new top starts to appear; [side] is the transition's
+     * `bottomTabs` with a slide of its own.
+     */
+    internal open fun tabBarTransition(
+        child: ViewController<*>,
+        move: TabBarMotion.Move,
+        side: BottomTabsEnterExitAnimationOptions? = null,
+    ) {
+        parentController?.tabBarTransition(this, move, side)
+    }
+
+    /** The transition of a stack under this layout ([child]) brought its top to rest: the tab bar rests too. */
+    internal open fun tabBarSettled(child: ViewController<*>) {
+        parentController?.tabBarSettled(this)
+    }
+
+    /**
+     * The children that show while the layout shows: they appear with it. The current child by default; a layout that
+     * shows several at once (an open side menu over its center, columns side by side) gives them all.
+     */
+    open fun visibleChildren(): List<ViewController<*>> = listOfNotNull(getCurrentChild())
+
+    /**
+     * The children whose screens a wait for the layout to render waits for (the root's, a modal's): those it shows
+     * when it shows ([visibleChildren]) by default. A layout that shows other children first, or more of them, gives
+     * those (the tabs).
+     */
+    open fun waitedChildren(): List<ViewController<*>> = visibleChildren()
+
+    /**
+     * The children made with the layout that don't show when it shows, whose screens a wait counts only within its
+     * first 0.5 s: the unselected tabs of `together`. None by default.
+     */
+    open fun waitedUnseenChildren(): List<ViewController<*>> = emptyList()
+
+    override fun onViewWillAppear() {
+        super.onViewWillAppear()
+        visibleChildren().forEach { it.onViewWillAppear() }
+    }
+
+    override fun onViewDidAppear() {
+        visibleChildren().forEach { it.onViewDidAppear() }
+        super.onViewDidAppear()
+    }
+
+    // Every child hears it: those that didn't appear tell nothing.
+    override fun onViewDisappear() {
+        getChildControllers().forEach { it.onViewDisappear() }
+        super.onViewDisappear()
+    }
+
+    // Every child starts to leave with the layout.
+    override fun onLeaveStarted() {
+        getChildControllers().forEach { it.onLeaveStarted() }
+    }
+
+    override fun sendOnNavigationButtonPressed(buttonId: String) {
+        getCurrentChild()?.sendOnNavigationButtonPressed(buttonId)
+    }
+
+    override fun handleBack(listener: CommandListener): Boolean = getCurrentChild()?.handleBack(listener) == true
+
+    override fun canHandleBack(): Boolean = getCurrentChild()?.canHandleBack() == true
+
+    override fun destroy() {
+        if (isDestroyed) return
+        getChildControllers().forEach { it.destroy() }
+        super.destroy()
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/parent/ShownChildren.kt

@@ -0,0 +1,82 @@
+package dev.apexnative.navigation.viewcontrollers.parent
+
+import dev.apexnative.navigation.react.events.AppearanceDispatcher
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+
+/**
+ * The children a container told they appeared, for a container whose children come into view and leave it without a
+ * command (the split view's panes, the pair's screens): its moves go through the dispatcher's order of a transition:
+ * `ComponentWillAppear` of what comes at the start of the move ([moveStarted]), and at its end ([moved])
+ * `ComponentDidDisappear` of what left, then `ComponentDidAppear` of what came. [shownNow] is what the container shows
+ * now (`visibleChildren`). The container's own appearance tells the children it shows (`ParentController`) and reports
+ * here. Main thread only.
+ */
+internal class ShownChildren(private val shownNow: () -> List<ViewController<*>>) {
+    /** The container appeared (its show ended), until it disappears: only then do its moves tell its children. */
+    var isShown = false
+        private set
+
+    // The children told they appeared, until they leave, in the order they came.
+    private val appeared = LinkedHashSet<ViewController<*>>()
+    // The children whose WillAppear the move on its way sent.
+    private val coming = LinkedHashSet<ViewController<*>>()
+
+    /** The container starts to appear: the children it shows are told by its own appearance. */
+    fun containerWillAppear() {
+        appeared += shownNow()
+    }
+
+    /** The container has appeared: from now on its moves tell its children. */
+    fun containerDidAppear() {
+        isShown = true
+        appeared += shownNow()
+    }
+
+    /** The container disappeared, with every child (`ParentController.onViewDisappear`), or goes. */
+    fun containerDisappeared() {
+        isShown = false
+        appeared.clear()
+        coming.clear()
+    }
+
+    /**
+     * A move starts (a pane starts to slide in): those of [candidates] that aren't shown start to appear now. A move
+     * that ends with them out of view ([moved]) makes them disappear.
+     */
+    fun moveStarted(candidates: List<ViewController<*>>) {
+        if (!isShown) return
+        val came = candidates.filter { it !in appeared && it !in coming }
+        if (came.isEmpty()) return
+        coming += came
+        AppearanceDispatcher.beginTransition(came)
+    }
+
+    /**
+     * The move ended, or what the container shows changed at once (a rotation, a resize): what came starts to appear
+     * if it hadn't, what left disappears, then what came appears, and one update of the navigation state is asked for
+     * this pass of the main loop; nothing when nothing changed.
+     */
+    fun moved() {
+        if (!isShown) return
+        val now = shownNow()
+        val left = (appeared + coming).filter { it !in now }
+        val came = now.filter { it !in appeared }
+        val starting = came.filter { it !in coming }
+        appeared.clear()
+        appeared += now
+        coming.clear()
+        if (left.isEmpty() && came.isEmpty()) return
+        AppearanceDispatcher.beginTransition(starting)
+        // The state stays one posted update of this pass, which a `setRoot`'s hold holds and which comes after a tab
+        // switch's `ANN.BottomTabSelected`.
+        AppearanceDispatcher.endTransition(
+            hiding = left,
+            showing = came,
+            events = null,
+            answer = null,
+            value = null,
+            reportsState = false,
+        )
+        AppearanceDispatcher.state.setNeedsUpdate()
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/sidemenu/SideMenuController.kt

@@ -0,0 +1,283 @@
+package dev.apexnative.navigation.viewcontrollers.sidemenu
+
+import android.app.Activity
+import android.util.Log
+import dev.apexnative.navigation.NavigationActivity
+import dev.apexnative.navigation.options.BottomTabsEnterExitAnimationOptions
+import dev.apexnative.navigation.options.DefaultOptions
+import dev.apexnative.navigation.options.Options
+import dev.apexnative.navigation.react.CommandListener
+import dev.apexnative.navigation.react.events.AppearanceDispatcher
+import dev.apexnative.navigation.utils.NavigationLog
+import dev.apexnative.navigation.viewcontrollers.bottomtabs.TabBarMotion
+import dev.apexnative.navigation.viewcontrollers.child.ChildControllersRegistry
+import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
+import dev.apexnative.navigation.viewcontrollers.navigator.Navigator
+import dev.apexnative.navigation.viewcontrollers.parent.ChildOffsetFromRest
+import dev.apexnative.navigation.viewcontrollers.parent.ParentController
+import dev.apexnative.navigation.viewcontrollers.sidemenu.SideMenuMotion.Side
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.sidemenu.SideMenuView
+
+/**
+ * A side menu on Android: a center and up to one menu on each side, the Material drawer ([SideMenuView]) the menus
+ * slide over the center in. The sides are places, not nodes: the nodes in them are this node's children, and only this
+ * node is found by its id. It works as a root, in a tab and as a modal's content.
+ *
+ * - The current child is the open menu's node, else the center ([SideMenuMotion.openSide]: from the end of the
+ *  opening to the end of the closing); the state, the options and back follow it.
+ * - The center and the open menu show with the side menu ([visibleChildren]); a wait for the side menu to render
+ *   waits for the center ([waitedChildren]); the menus' views are made with the side menu's.
+ * - Its options ([SideMenuPresenter]): from the resolution of [resolveShownOptions] at creation, at every appearance
+ *   of a screen inside, and for the fields a merge names; `sideMenu.<side>.visible` acts once, from a merge or from the
+ *  layout at the first show. What goes on up goes without `sideMenu`: the nearest side menu acts.
+ * - Back closes an open menu first, else goes to the center.
+ *
+ * Main thread only.
+ */
+internal class SideMenuController(
+    activity: Activity,
+    childRegistry: ChildControllersRegistry,
+    id: String,
+    presenter: Presenter,
+    initialOptions: Options,
+    private val center: ViewController<*>,
+    private val left: ViewController<*>?,
+    private val right: ViewController<*>?,
+) : ParentController<SideMenuView>(activity, childRegistry, id, presenter, initialOptions), ChildOffsetFromRest {
+    private val menus: SideMenuPresenter = presenter as? SideMenuPresenter ?: SideMenuPresenter(activity)
+
+    /** The drawer the motion drives: the view's, once it is made; the unit tests give their own. */
+    internal var drawer: SideMenuMotion.Drawer = ViewlessDrawer()
+
+    /** The rules of the drawer's motion, its locks and its commands. */
+    internal val motion = SideMenuMotion({ drawer }, MotionHost())
+
+    /**
+     * Whether the side menu shows: in the window and not in a layer that waits, so a menu moves with animation. The
+     * unit tests give their own.
+     */
+    internal var shows: () -> Boolean = { isViewShown && navigator?.isInWaitingLayer(this) != true }
+
+    // From the end of its appearance's start until it disappears: the drawer's motion tells the menu screens then.
+    private var appeared = false
+    private var firstShown = false
+    // Its children go first as it is destroyed: nothing reacts to them, nor to the drawer, from the start.
+    private var destroying = false
+
+    private val navigator: Navigator?
+        get() = (activity as? NavigationActivity)?.navigator
+
+    init {
+        getChildControllers().forEach { it.parentController = this }
+    }
+
+    override fun getChildControllers(): List<ViewController<*>> = listOfNotNull(center, left, right)
+
+    override fun getCurrentChild(): ViewController<*> = openChild() ?: center
+
+    // The center stays visible under an open menu.
+    override fun visibleChildren(): List<ViewController<*>> = listOfNotNull(center, openChild())
+
+    // The menus render with the side menu; a wait waits for the center only.
+    override fun waitedChildren(): List<ViewController<*>> = listOf(center)
+
+    private fun openChild(): ViewController<*>? = motion.openSide?.let(::childOf)
+
+    private fun childOf(side: Side): ViewController<*>? = if (side == Side.Left) left else right
+
+    // The drawer and its parts, each node's view in its part; the creation's options. An open menu recorded before the
+    // view existed is open in it from the start; the drawer is silent before its first layout.
+    override fun createView(): SideMenuView {
+        val view = SideMenuView(activity)
+        view.setCenter(center.view)
+        left?.let { view.addPart(Side.Left, it.view) }
+        right?.let { view.addPart(Side.Right, it.view) }
+        menus.applyOnCreation(view, resolveShownOptions(DefaultOptions.current))
+        motion.openSide?.let { view.open(it, false) }
+        view.follow(motion)
+        drawer = view
+        motion.applyLocks()
+        return view
+    }
+
+    // Options.
+
+    /**
+     * What the side menu shows with: the options of the open menu's screen with the `sideMenu` of the center's screen
+     * over them — an open menu doesn't undo what the center's screen said —, else the center's. A new object while a
+     * menu is open.
+     */
+    override fun resolveShownOptions(defaultOptions: Options): Options {
+        val shownCenter = center.resolveShownOptions(defaultOptions)
+        val open = openChild() ?: return shownCenter
+        val shown = open.resolveShownOptions(defaultOptions).copy()
+        shown.sideMenu.mergeWith(shownCenter.sideMenu)
+        return shown
+    }
+
+    // A screen in the side menu appears: everything of the side menu applies again but the heights, as it resolves
+    // now; what isn't the side menu's goes on up, only from the part that is current.
+    override fun applyChildOptions(options: Options, child: ViewController<*>) {
+        if (destroying || isDestroyed) return
+        menus.applyOptions(this, resolveShownOptions(DefaultOptions.current))
+        motion.applyLocks()
+        if (child === currentChild) {
+            performOnParentController { it.applyChildOptions(SideMenuRules.withoutSideMenu(options), this) }
+        }
+    }
+
+    // `mergeOptions` with the side menu's id: its own options, then what a merge does, then the layouts around.
+    override fun mergeOptions(options: Options) {
+        this.options = this.options.copy().mergeWith(options)
+        applyMerge(options)
+        performOnParentController { it.mergeChildOptions(SideMenuRules.withoutSideMenu(options), this) }
+    }
+
+    // `mergeOptions` of a screen inside, the center's or a menu's, shown or not.
+    override fun mergeChildOptions(options: Options, child: ViewController<*>) {
+        applyMerge(options)
+        performOnParentController { it.mergeChildOptions(SideMenuRules.withoutSideMenu(options), this) }
+    }
+
+    // The fields the merge names while the side menu shows, the locks, then `visible` last, left before right; the
+    // command acts also while the side menu doesn't show.
+    private fun applyMerge(options: Options) {
+        if (destroying || isDestroyed) return
+        if (isViewShown) menus.mergeOptions(this, options)
+        if (SideMenuRules.touchesEnabled(options.sideMenu)) motion.applyLocks()
+        val commands = SideMenuRules.commands(options.sideMenu)
+        if (commands.isEmpty()) return
+        val shown = shows()
+        commands.forEach { motion.command(it.side, it.visible, it.animate, shown) }
+    }
+
+    // Appearance: the center and the open menu appear with the side menu, every child disappears with it; the open menu
+    // stays open.
+
+    // The layout's own `visible` opens its menu once, as the side menu first starts to appear, without animation and
+    // before its children hear it: the open menu appears with the center then.
+    override fun onViewWillAppear() {
+        if (destroying || isDestroyed) return
+        if (!firstShown) {
+            firstShown = true
+            SideMenuRules.firstShow(initialOptions.sideMenu).forEach {
+                motion.command(it, visible = true, animate = false, shown = false)
+            }
+        }
+        super.onViewWillAppear()
+        appeared = true
+        motion.containerAppeared()
+    }
+
+    override fun onViewDisappear() {
+        appeared = false
+        motion.containerDisappeared()
+        super.onViewDisappear()
+    }
+
+    // Back: an open menu closes; else the center.
+
+    override fun handleBack(listener: CommandListener): Boolean = motion.back() || center.handleBack(listener)
+
+    override fun canHandleBack(): Boolean = motion.canGoBack || center.canHandleBack()
+
+    // A button's press addressed to the side menu goes to the center.
+    override fun sendOnNavigationButtonPressed(buttonId: String) = center.sendOnNavigationButtonPressed(buttonId)
+
+    // Room and place.
+
+    // The menus go the whole height under the status bar; the center's screens are as anywhere else.
+    override fun isInSideMenu(child: ViewController<*>): Boolean = child === left || child === right || isInSideMenu
+
+    // A closed menu lies invisible, laid out: its screens measure their safe area where it opens.
+    override fun measuresThoughNotShown(child: ViewController<*>): Boolean =
+        child === left || child === right || parentController?.measuresThoughNotShown(this) == true
+
+    override fun childOffsetFromRest(child: ViewController<*>): Int {
+        val view = peekView() ?: return 0
+        return when {
+            left != null && child === left -> view.offsetFromRest(Side.Left)
+            right != null && child === right -> view.offsetFromRest(Side.Right)
+            else -> 0
+        }
+    }
+
+    // The tab bar of the tabs around goes with the stack of the part that is current only.
+
+    override fun tabBarTransition(
+        child: ViewController<*>,
+        move: TabBarMotion.Move,
+        side: BottomTabsEnterExitAnimationOptions?,
+    ) {
+        if (child === currentChild) super.tabBarTransition(child, move, side)
+    }
+
+    override fun tabBarSettled(child: ViewController<*>) {
+        if (child === currentChild) super.tabBarSettled(child)
+    }
+
+    /** Destroys the side menu once: the drawer's callbacks stop first, then the children go. */
+    override fun destroy() {
+        if (isDestroyed) return
+        destroying = true
+        motion.destroy()
+        peekView()?.unfollow()
+        super.destroy()
+    }
+
+    // What the motion asks of the side menu.
+    private inner class MotionHost : SideMenuMotion.Host {
+        override val appeared: Boolean
+            get() = this@SideMenuController.appeared && !destroying
+
+        override fun child(side: Side): ViewController<*>? = childOf(side)
+
+        override fun isEnabled(side: Side): Boolean =
+            SideMenuRules.isEnabled(resolveShownOptions(DefaultOptions.current).sideMenu, side)
+
+        override fun missingSide(side: Side) {
+            Log.w(NavigationLog.TAG, "the side menu '$id' has no ${side.jsName} menu: its `visible` does nothing")
+        }
+
+        override fun stateChanged() = AppearanceDispatcher.state.setNeedsUpdate()
+
+        override fun backChanged() {
+            navigator?.let(BackCallbackState::update)
+        }
+
+        // The tabs around follow the center's screen again: they heard nothing of it while the menu was current.
+        override fun centerCurrentAgain() {
+            if (destroying) return
+            val options = SideMenuRules.withoutSideMenu(center.resolveShownOptions(DefaultOptions.current))
+            performOnParentController { it.applyChildOptions(options, this@SideMenuController) }
+        }
+
+        // The system UI follows the screen the user sees now, at rest: the open menu's, the center's once a close
+        // ends. The owner reads it before the next frame, when a menu that closed is hidden already. An open without
+        // animation runs this inside `AppearanceDispatcher.withoutWillAppear`: what starts to appear from here would
+        // send no WillAppear.
+        override fun shownChanged() {
+            navigator?.shownScreensChanged(this@SideMenuController)
+            navigator?.systemUi?.invalidate()
+        }
+    }
+
+    // The drawer before the view is made: it calls nothing back, so the motion records what is asked.
+    private inner class ViewlessDrawer : SideMenuMotion.Drawer {
+        override fun has(side: Side): Boolean = childOf(side) != null
+
+        override val callsBack: Boolean = false
+
+        override fun open(side: Side, animate: Boolean) = Unit
+
+        override fun close(side: Side, animate: Boolean) = Unit
+
+        override fun lock(side: Side, locked: Boolean) = Unit
+
+        override fun isVisible(side: Side): Boolean = false
+
+        override fun hide(side: Side) = Unit
+    }
+}