Improve scanning-menu grid fit on small and short screens

- Keep navigation on one row whenever four cells meet the 52dp touch minimum
- Size the page-dot slot for dots rather than a text line
- Drop the title row when the highlight HUD reserves no top space, since it floats over that row
- Treat mid-word line breaks as a label-fit failure so narrow phones fall back to fewer columns
- Allow up to five columns where width permits, so landscape and tablets use rows less
- Budget and clamp the menu against the navigation-bar-inset window area

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: OwenMcGirr

app/src/main/java/com/enaboapps/switchify/screens/settings/menu/MenuCustomizationScreen.kt

@@ -169,7 +169,7 @@ fun MenuCustomizationContent(screenModel: MenuCustomizationScreenModel, menuId:
                     context = context,
                     items = menuItems.filter { visibilityMap[it.id] ?: true },
                     contextualCount = 0,
-                    hasTitle = MenuConstants.getTitleResource(menuId) != null,
+                    hasTitle = MenuGridMeasurer.showsTitle(context, menuId),
                     hasNavigation = true
                 ).grid.pageCapacity
                 val visibleIndexById = remember(menuItems, visibilityMap) {

app/src/main/java/com/enaboapps/switchify/service/menu/MenuGridLayout.kt

@@ -18,6 +18,13 @@ internal data class MenuGridLayout(
 }
 
 internal object MenuGridLayoutPolicy {
+    /**
+     * Upper bound on content columns. Width-limited screens land well below
+     * this; it only engages on landscape phones and tablets, where rows are
+     * the scarce dimension.
+     */
+    const val MAX_COLUMNS = 5
+
     fun calculate(
         widthPx: Int,
         heightPx: Int,
@@ -29,7 +36,7 @@ internal object MenuGridLayoutPolicy {
     ): MenuGridLayout {
         val width = widthPx.coerceAtLeast(1)
         val minimumWidth = maxOf(minimumCellWidthPx, minimumTouchPx, 1)
-        var columns = minOf(3, itemCount.coerceAtLeast(1), (width / minimumWidth).coerceAtLeast(1))
+        var columns = minOf(MAX_COLUMNS, itemCount.coerceAtLeast(1), (width / minimumWidth).coerceAtLeast(1))
         while (columns > 1 && !labelsFit(width / columns)) columns--
         val cellHeight = preferredCellHeightPx.coerceAtLeast(minimumTouchPx)
             .coerceAtMost(heightPx.coerceAtLeast(minimumTouchPx))
@@ -38,6 +45,34 @@ internal object MenuGridLayoutPolicy {
     }
 }
 
+internal object MenuLabelBreaks {
+    /**
+     * True when a line break placed at [end] splits a word in two, i.e. there
+     * is a word character on both sides of the break. Breaks at whitespace,
+     * punctuation, hyphens, or between characters of scripts that legitimately
+     * break anywhere (CJK, Thai, and similar) are not mid-word.
+     */
+    fun isMidWordBreak(text: CharSequence, end: Int): Boolean {
+        if (end <= 0 || end >= text.length) return false
+        return isWordChar(text[end - 1]) && isWordChar(text[end])
+    }
+
+    private fun isWordChar(c: Char): Boolean {
+        if (!c.isLetterOrDigit()) return false
+        return when (Character.UnicodeScript.of(c.code)) {
+            Character.UnicodeScript.HAN,
+            Character.UnicodeScript.HIRAGANA,
+            Character.UnicodeScript.KATAKANA,
+            Character.UnicodeScript.HANGUL,
+            Character.UnicodeScript.THAI,
+            Character.UnicodeScript.LAO,
+            Character.UnicodeScript.KHMER,
+            Character.UnicodeScript.MYANMAR -> false
+            else -> true
+        }
+    }
+}
+
 internal data class MenuPageSections<T>(
     val contextual: List<T>,
     val content: List<T>,

app/src/main/java/com/enaboapps/switchify/service/menu/MenuGridMetrics.kt

@@ -6,6 +6,8 @@ import android.graphics.Typeface
 import android.text.StaticLayout
 import android.text.TextPaint
 import android.util.TypedValue
+import com.enaboapps.switchify.service.menu.structure.MenuConstants
+import com.enaboapps.switchify.service.window.MenuHighlightHud
 import kotlin.math.ceil
 
 internal data class MenuGridMetrics(
@@ -34,8 +36,12 @@ internal object MenuGridMeasurer {
         val width = MenuSurfaceBudget.contentMaxWidthPx(context).coerceAtLeast(1)
         val minimumTouch = dp(52f)
         val titleHeight = if (hasTitle) sp(24f) + dp(12f) else 0
-        val pageCountHeight = sp(20f) + dp(8f)
-        val navigationColumns = if (width >= 4 * maxOf(minimumTouch, dp(64f))) 4 else 2
+        // Page indicator is a row of dots, not text: 8 dp dots plus breathing room.
+        val pageCountHeight = dp(16f)
+        // Keep navigation on one row whenever four cells can each meet the
+        // touch minimum; a second nav row costs more height than a content row
+        // on narrow phones.
+        val navigationColumns = if (width >= 4 * minimumTouch) 4 else 2
         val navHeight = maxOf(minimumTouch, dp(28f) + sp(size.labelTextSize.value * 2.6f) + dp(12f))
         val contextualHeight = maxOf(minimumTouch, sp(size.labelTextSize.value * 2.6f) + dp(16f))
         val chrome = titleHeight + contextualCount * contextualHeight +
@@ -56,10 +62,21 @@ internal object MenuGridMeasurer {
                 val layout = StaticLayout.Builder.obtain(text, 0, text.length, paint,
                     (cellWidth - dp(16f)).coerceAtLeast(1))
                     .setIncludePad(false).setMaxLines(4).build()
-                layout.lineCount <= 3
+                layout.lineCount <= 3 && (0 until layout.lineCount).none { line ->
+                    MenuLabelBreaks.isMidWordBreak(text, layout.getLineEnd(line))
+                }
             }
         }
         return MenuGridMetrics(grid, width, titleHeight, contextualHeight,
             navigationColumns, navHeight, pageCountHeight)
     }
+
+    /**
+     * Whether the menu should render its title row. On short screens the
+     * highlight HUD reserves no top space and floats over the top of the menu,
+     * exactly where the title sits, so the row is dropped to give that height
+     * back to content.
+     */
+    fun showsTitle(context: Context, menuId: String?): Boolean =
+        MenuConstants.getTitleResource(menuId) != null && MenuHighlightHud.reservedTopPx(context) > 0
 }

app/src/main/java/com/enaboapps/switchify/service/menu/MenuSurfaceBudget.kt

@@ -29,7 +29,7 @@ object MenuSurfaceBudget {
      * the device edge.
      */
     fun surfaceMaxWidthPx(context: Context): Int {
-        val screenWidthPx = ScreenUtils.getWidth(context)
+        val screenWidthPx = usableWidthPx(context)
         val marginPx = ScreenUtils.dpToPx(context, SCREEN_HORIZONTAL_MARGIN_DP)
         return (screenWidthPx - marginPx).coerceAtLeast(0)
     }
@@ -40,12 +40,30 @@ object MenuSurfaceBudget {
      * margin.
      */
     fun surfaceMaxHeightPx(context: Context): Int {
-        val screenHeightPx = ScreenUtils.getHeight(context)
+        val screenHeightPx = usableHeightPx(context)
         val hudReservedPx = MenuHighlightHud.reservedTopPx(context)
         val marginPx = ScreenUtils.dpToPx(context, SCREEN_VERTICAL_MARGIN_DP)
         return (screenHeightPx - hudReservedPx - marginPx).coerceAtLeast(0)
     }
 
+    /**
+     * Window width the overlay can actually draw into: full bounds minus any
+     * side-mounted navigation bar (landscape three-button nav).
+     */
+    fun usableWidthPx(context: Context): Int {
+        val insets = ScreenUtils.getNavigationBarInsets(context)
+        return (ScreenUtils.getWidth(context) - insets.left - insets.right).coerceAtLeast(0)
+    }
+
+    /**
+     * Window height the overlay can actually draw into: full bounds minus the
+     * bottom navigation bar, which the overlay window is inset by.
+     */
+    fun usableHeightPx(context: Context): Int {
+        val insets = ScreenUtils.getNavigationBarInsets(context)
+        return (ScreenUtils.getHeight(context) - insets.bottom).coerceAtLeast(0)
+    }
+
     /**
      * Max width for the *content area* inside the surface (after subtracting
      * the surface's own horizontal padding). This is the width the list

app/src/main/java/com/enaboapps/switchify/service/menu/MenuView.kt

@@ -91,6 +91,7 @@ class MenuView(val context: Context, private val menu: BaseMenu) {
         val content = items.filterNot { it.id in contextualIds || it === back }
         val close = if (menu.shouldShowNavMenuItems()) menu.buildCloseItem() else null
         val title = MenuConstants.getTitleResource(menu.menuId)
+            ?.takeIf { MenuGridMeasurer.showsTitle(context, menu.menuId) }
         var metrics = MenuGridMeasurer.measure(context, content, contextual.size,
             title != null, close != null || back != null)
         if (metrics.grid.pages(content).size > 1 && close == null && back == null) {
@@ -167,8 +168,10 @@ class MenuView(val context: Context, private val menu: BaseMenu) {
     }
 
     private fun resizeAndRepositionMenu() {
-        val screenWidth = ScreenUtils.getWidth(context)
-        val screenHeight = ScreenUtils.getHeight(context)
+        // Clamp within the area the overlay window can draw into, which
+        // excludes the navigation bar.
+        val screenWidth = MenuSurfaceBudget.usableWidthPx(context)
+        val screenHeight = MenuSurfaceBudget.usableHeightPx(context)
         val menuWidth = baseLayout.width
         val menuHeight = baseLayout.height
 

app/src/main/java/com/enaboapps/switchify/service/utils/ScreenUtils.kt

@@ -4,9 +4,17 @@ import android.content.Context
 import android.content.res.Configuration
 import android.os.Build
 import android.util.DisplayMetrics
+import android.view.WindowInsets
 import android.view.WindowManager
 import android.view.WindowMetrics
 
+/** Pixel insets of a system bar on each window edge. */
+data class SystemBarInsets(val left: Int, val top: Int, val right: Int, val bottom: Int) {
+    companion object {
+        val NONE = SystemBarInsets(0, 0, 0, 0)
+    }
+}
+
 /**
  * This class provides utility functions to get screen dimensions.
  */
@@ -41,6 +49,25 @@ class ScreenUtils {
             }
         }
 
+        /**
+         * Pixels the navigation bar occupies on each edge of the current window.
+         *
+         * Overlay windows added without FLAG_LAYOUT_NO_LIMITS are inset by the
+         * system bars, so anything budgeted from [getWidth] / [getHeight] (which
+         * report full window bounds on API 30+) must subtract these to stay
+         * visible. Below API 30 the display metrics already exclude the bar.
+         */
+        fun getNavigationBarInsets(context: Context): SystemBarInsets {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) return SystemBarInsets.NONE
+            return try {
+                val insets = getWindowMetrics(context).windowInsets
+                    .getInsets(WindowInsets.Type.navigationBars())
+                SystemBarInsets(insets.left, insets.top, insets.right, insets.bottom)
+            } catch (e: Exception) {
+                SystemBarInsets.NONE
+            }
+        }
+
         /**
          * Converts dp to pixels.
          *

app/src/test/java/com/enaboapps/switchify/service/menu/MenuGridLayoutTest.kt

@@ -15,7 +15,7 @@ class MenuGridLayoutTest {
         fits: (Int) -> Boolean = { true }
     ) = MenuGridLayoutPolicy.calculate(width, height, count, minimumWidth, cellHeight, 52, fits)
 
-    @Test fun usesAtMostThreeColumnsAndFitsRows() {
+    @Test fun columnsFollowMinimumWidthAndFitRows() {
         val grid = layout()
         assertEquals(3, grid.columns)
         assertEquals(3, grid.rows)
@@ -29,6 +29,13 @@ class MenuGridLayoutTest {
         assertEquals(1, layout(count = 0).columns)
     }
 
+    @Test fun wideScreensUseUpToFiveColumns() {
+        assertEquals(4, layout(width = 350).columns)
+        assertEquals(5, layout(width = 400).columns)
+        assertEquals(5, layout(width = 800).columns)
+        assertEquals(4, layout(width = 800, count = 4).columns)
+    }
+
     @Test fun narrowOrScaledMenusReduceColumns() {
         assertEquals(2, layout(width = 200).columns)
         assertEquals(1, layout(width = 140).columns)

app/src/test/java/com/enaboapps/switchify/service/menu/MenuLabelBreaksTest.kt

@@ -0,0 +1,37 @@
+package com.enaboapps.switchify.service.menu
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class MenuLabelBreaksTest {
+    @Test fun breakInsideAWordIsMidWord() {
+        assertTrue(MenuLabelBreaks.isMidWordBreak("Accessibility", 7))
+        assertTrue(MenuLabelBreaks.isMidWordBreak("Tap and Hold", 6))
+        assertTrue(MenuLabelBreaks.isMidWordBreak("Page 12", 6))
+    }
+
+    @Test fun breakAtWhitespaceIsNotMidWord() {
+        // StaticLayout keeps trailing whitespace on the preceding line.
+        assertFalse(MenuLabelBreaks.isMidWordBreak("Tap and Hold", 4))
+        assertFalse(MenuLabelBreaks.isMidWordBreak("Tap and Hold", 3))
+    }
+
+    @Test fun breakAtPunctuationIsNotMidWord() {
+        assertFalse(MenuLabelBreaks.isMidWordBreak("Wi-Fi", 3))
+        assertFalse(MenuLabelBreaks.isMidWordBreak("Wi-Fi", 2))
+        assertFalse(MenuLabelBreaks.isMidWordBreak("Volume/Media", 7))
+    }
+
+    @Test fun textEdgesAreNeverMidWord() {
+        assertFalse(MenuLabelBreaks.isMidWordBreak("Settings", 0))
+        assertFalse(MenuLabelBreaks.isMidWordBreak("Settings", 8))
+        assertFalse(MenuLabelBreaks.isMidWordBreak("", 0))
+    }
+
+    @Test fun scriptsThatBreakBetweenCharactersAreNotMidWord() {
+        assertFalse(MenuLabelBreaks.isMidWordBreak("設定項目", 2))
+        assertFalse(MenuLabelBreaks.isMidWordBreak("ひらがな", 2))
+        assertFalse(MenuLabelBreaks.isMidWordBreak("การตั้ง", 3))
+    }
+}