@apexnative/navigation 1.0.0-alpha.1 → 1.0.0-alpha.10

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/topbar/BarRowTransition.kt

@@ -7,14 +7,15 @@ import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay.BarMotion
  * row and the large title lies over them and the real row turns transparent; then the picture goes with the old screen
  * and the row comes with the new one ([RowTimeline]). Each change of the stack's current child owns the bar: a newer
  * one takes it over (the older picture goes, its animator stops), and only the end of the transition that owns it puts
- * the row back at rest. Without a picture (a `HARDWARE` bitmap in the bar) the old row just hides. Main thread only.
+ * the row back at rest. Without a picture (a `HARDWARE` bitmap in the bar on Android 8) the old row just hides. Main
+ * thread only.
  */
 internal class BarRowTransition(private val target: Target) {
     /** What the transition moves: the bar's views, or the unit tests' fake. */
     interface Target {
         /**
          * Lays a picture of the row and the large title over them, laid out at once and taking the touches; false when
-         * the bar can't be drawn in software (a `HARDWARE` bitmap): no picture then.
+         * the bar can't be recorded (a `HARDWARE` bitmap on Android 8): no picture then.
          */
         fun takeSnapshot(): Boolean
 

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/topbar/ButtonPlaces.kt

@@ -1,11 +1,11 @@
 package dev.apexnative.navigation.viewcontrollers.stack.topbar
 
 /**
- * Where the right buttons of the bar go: the bar has as many places as AppCompat gives a toolbar for the window now
- * ([maxActionButtons]), one less for "⋮" when it shows; the pinned buttons take theirs first, then the buttons with the
- * highest `priority` (ties by the list's order); the rest go into "⋮". The core counts it, not AppCompat: AppCompat
- * would share the places in the menu's order, where the first button of the list is the last, and keep the count of the
- * orientation before a rotation. A pure function.
+ * Where the buttons of the bar go. The right ones: the bar has as many places as AppCompat gives a toolbar for the
+ * window now ([maxActionButtons]), one less for "⋮" when it shows; the pinned buttons take theirs first, then the
+ * buttons with the highest `priority` (ties by the list's order); the rest go into "⋮". In the line ([line]) the left
+ * buttons stand from its start in the list's order, and the right ones toward its end, the first one last. A pure
+ * function.
  */
 internal object ButtonPlaces {
     /** A right button as the count sees it: its `priority` ([HIGH], [STANDARD], [LOW]) and `pinned`. */
@@ -36,6 +36,12 @@ internal object ButtonPlaces {
         else -> 2
     }
 
+    /**
+     * The buttons of a side in the bar, [inBar] in the list's order, in the line's order from its start: the left ones
+     * as they are, the right ones the other way round, so the first right button stands at the end of the line.
+     */
+    fun <T> line(inBar: List<T>, left: Boolean): List<T> = if (left) inBar else inBar.reversed()
+
     /**
      * The plan for [buttons] with [maxPlaces] places, [taken] of them already used by what the core always puts in the
      * bar (the search's magnifier), and [overflowItems] items of `overflowMenu`, which put "⋮" in the bar whatever

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/topbar/MenuChecks.kt

@@ -1,16 +1,14 @@
 package dev.apexnative.navigation.viewcontrollers.stack.topbar
 
-import dev.apexnative.navigation.options.ButtonMenuOptions
-import dev.apexnative.navigation.options.ButtonOptions
 import dev.apexnative.navigation.options.Options
-import dev.apexnative.navigation.options.copyMenu
+import dev.apexnative.navigation.options.UserChoices
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 
 /**
- * The check of a single-selection menu the user picked: written through [ViewController.changeOptions] into the
- * screen's own menu, never into a menu other screens share (the stack's, the defaults'). A menu that came from
- * elsewhere is copied into the screen's own options first — for a button, its whole side, as lists of buttons replace
- * whole. The check stays with the screen until new options give the menu. Main thread only.
+ * The check of a single-selection menu the user picked: written into the screen's user layer
+ * ([ViewController.changeChoices]), never into its own options nor into a menu other screens share (the stack's, the
+ * defaults'). It goes over the menu as the screen's options resolve, by the button's id and the item's id, and stays
+ * until the app changes that menu's checks or takes the item away. Main thread only.
  */
 internal object MenuChecks {
     /**
@@ -19,54 +17,13 @@ internal object MenuChecks {
      */
     fun write(screen: ViewController<*>, resolved: Options, buttonId: String?, itemId: String) {
         val topBar = resolved.topBar
-        if (buttonId == null) {
-            val menu = topBar.overflowMenu ?: return
-            if (!checks(menu, itemId)) return
-            screen.changeOptions { own ->
-                val copy = (own.topBar.overflowMenu ?: menu).copyMenu()
-                check(copy, itemId)
-                own.topBar.overflowMenu = copy
-            }
-            return
-        }
-        val left = topBar.buttons.left?.any { it.id.get(null) == buttonId } == true
-        val list = (if (left) topBar.buttons.left else topBar.buttons.right) ?: return
-        val menu = list.firstOrNull { it.id.get(null) == buttonId }?.menu ?: return
-        if (!checks(menu, itemId)) return
-        screen.changeOptions { own ->
-            val ownList = (if (left) own.topBar.buttons.left else own.topBar.buttons.right)
-                ?: list.map(ButtonOptions::copyWithMenu)
-            val button = ownList.firstOrNull { it.id.get(null) == buttonId } ?: return@changeOptions
-            val copy = (button.menu ?: menu).copyMenu()
-            check(copy, itemId)
-            button.menu = copy
-            if (left) own.topBar.buttons.left = ownList else own.topBar.buttons.right = ownList
-        }
-    }
-
-    /** Whether picking [itemId] moves a check: its level has `singleSelection`. */
-    fun checks(menu: ButtonMenuOptions, itemId: String): Boolean = levelOf(menu.items, menu.singleSelection, itemId) == true
-
-    /** Moves the check of [itemId]'s level to it, in [menu] itself. */
-    fun check(menu: ButtonMenuOptions, itemId: String) {
-        mark(menu.items, menu.singleSelection, itemId)
-    }
-
-    // Whether the level holding [itemId] has single selection; null when [itemId] isn't in [elements].
-    private fun levelOf(elements: List<ButtonMenuOptions.Element>, single: Boolean, itemId: String): Boolean? {
-        if (elements.any { it is ButtonMenuOptions.Item && it.id == itemId }) return single
-        for (element in elements) {
-            if (element !is ButtonMenuOptions.Submenu) continue
-            levelOf(element.items, element.singleSelection, itemId)?.let { return it }
-        }
-        return null
-    }
-
-    private fun mark(elements: List<ButtonMenuOptions.Element>, single: Boolean, itemId: String): Boolean {
-        if (elements.any { it is ButtonMenuOptions.Item && it.id == itemId }) {
-            if (single) elements.forEach { if (it is ButtonMenuOptions.Item) it.checked = it.id == itemId }
-            return true
-        }
-        return elements.any { it is ButtonMenuOptions.Submenu && mark(it.items, it.singleSelection, itemId) }
+        val menu = if (buttonId == null) {
+            topBar.overflowMenu
+        } else {
+            (topBar.buttons.left.orEmpty() + topBar.buttons.right.orEmpty()).firstOrNull { it.id.get(null) == buttonId }
+                ?.menu
+        } ?: return
+        if (!UserChoices.checks(menu, itemId)) return
+        screen.changeChoices { it.check(buttonId, menu, itemId) }
     }
 }