Give the day and week timelines an end inset (#192) (#207)

Reviewed-on: https://codeberg.org/jlmakiola/calendula/pulls/207

app/build.gradle.kts

@@ -28,8 +28,8 @@ android {
         // which builds this version and then creates the matching vX.Y.Z tag +
         // release itself (versionCode is pinned to MAJOR*10000 + MINOR*100 +
         // PATCH from versionName, e.g. 2.7.2 -> 20702). See docs/RELEASING.md.
-        versionCode = 21901
+        versionCode = 21902
-        versionName = "2.19.1"
+        versionName = "2.19.2"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/HourGutter.kt

@@ -36,6 +36,14 @@ val GUTTER_WIDTH = 48.dp
  */
 val GUTTER_CONTENT_START_INSET = 8.dp
 
+/**
+ * End inset for everything that lines up with the day columns — the week's day
+ * header, the all-day strip and the timeline itself. Without it the last column
+ * runs flush into the screen edge while the gutter gives the other side room
+ * (#192); 8dp mirrors [GUTTER_CONTENT_START_INSET].
+ */
+val TIMELINE_CONTENT_END_INSET = 8.dp
+
 private val BADGE_HEIGHT = 20.dp
 
 /** How far the fixed hour labels recede while a block is being dragged. */

app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayScreen.kt

@@ -118,6 +118,7 @@ import de.jeanlucmakiola.calendula.ui.common.rememberTimelinePinchZoom
 import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.GUTTER_WIDTH
 import de.jeanlucmakiola.calendula.ui.common.HourGutter
+import de.jeanlucmakiola.calendula.ui.common.TIMELINE_CONTENT_END_INSET
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
 import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
@@ -471,7 +472,11 @@ private fun AllDayStrip(
             // Height is hoisted + animated so it resizes smoothly; padding sits
             // inside it so the content area is lanes * row height.
             .height(height)
-            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
+            .padding(
+                top = ALL_DAY_VERTICAL_PADDING,
+                bottom = ALL_DAY_VERTICAL_PADDING,
+                end = TIMELINE_CONTENT_END_INSET,
+            ),
     ) {
         // Keep the gutter-width offset so the bars line up with the day column.
         Spacer(Modifier.width(GUTTER_WIDTH))
@@ -570,6 +575,7 @@ private fun Timeline(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
                     .clip(RoundedCornerShape(16.dp))
                     .verticalScroll(scrollState)
                     .onGloballyPositioned { dragController.geometry.viewport = it },
@@ -792,7 +798,12 @@ private fun DayLoading() {
         // Same scale resolution as the loaded timeline, so the skeleton's column
         // doesn't resize the moment the real day arrives.
         val totalHeight = scale.hourHeight(maxHeight) * 24
-        Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
+        Row(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(end = TIMELINE_CONTENT_END_INSET)
+                .verticalScroll(scrollState),
+        ) {
             Spacer(Modifier.width(GUTTER_WIDTH))
             Box(
                 modifier = Modifier

app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthScreen.kt

@@ -19,6 +19,8 @@ import androidx.compose.animation.togetherWith
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
 import androidx.compose.foundation.gestures.detectDragGestures
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
@@ -111,6 +113,7 @@ import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.input.pointer.PointerEventPass
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
@@ -439,6 +442,7 @@ fun MonthScreen(
                             showWeekNumbers = showWeekNumbers,
                             onRetry = jumpToToday,
                             onOpenDay = onOpenDay,
+                            onEventClick = onEventClick,
                         )
                     } else if (viewStyle == MonthViewStyle.Split) {
                         SplitMonthContent(
@@ -463,6 +467,7 @@ fun MonthScreen(
                             onSwipePrev = goPrev,
                             onRetry = jumpToToday,
                             onOpenDay = onOpenDay,
+                            onEventClick = onEventClick,
                         )
                     }
                 }
@@ -573,6 +578,7 @@ private fun MonthContent(
     onSwipePrev: () -> Unit,
     onRetry: () -> Unit,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
 ) {
     val slideSpec = rememberCalendarSlideSpec()
     val fadeSpec = rememberCalendarFadeSpec()
@@ -599,6 +605,7 @@ private fun MonthContent(
                 state = s,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
             )
         }
     }
@@ -617,6 +624,7 @@ private fun ContinuousMonthContent(
     showWeekNumbers: Boolean,
     onRetry: () -> Unit,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
 ) {
     when (state) {
         // The scrolling styles get their own skeleton rather than the paged
@@ -631,6 +639,7 @@ private fun ContinuousMonthContent(
                 listState = listState,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
             )
         } else {
             ContinuousMonthGrid(
@@ -638,6 +647,7 @@ private fun ContinuousMonthContent(
                 listState = listState,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
             )
         }
     }
@@ -736,7 +746,8 @@ private val CELL_SHAPE = RoundedCornerShape(CELL_CORNER)
 
 /** Width of the split style's selected-day outline. */
 private val SPLIT_SELECTION_STROKE = 1.5.dp
-private const val MAX_EVENT_ROWS = 3
+/** Lanes of bars/pills a day cell draws before the rest become overflow dots. */
+internal const val MAX_EVENT_ROWS = 3
 
 /**
  * Row height in the continuous grid. The paged grid divides the viewport between
@@ -754,11 +765,15 @@ private val CONTINUOUS_ROW_HEIGHT = 112.dp
  */
 private val CONTINUOUS_MONTH_GAP = 20.dp
 
+/** Gap between the weekday header and the seamless stream's first week row. */
+private val DENSE_HEADER_GAP = 4.dp
+
 @Composable
 internal fun MonthGrid(
     state: MonthUiState.Success,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     /** See [MonthWeekRow]'s `selected`: an anchor for the morph, never a mark. */
     selected: LocalDate? = null,
 ) {
@@ -779,6 +794,7 @@ internal fun MonthGrid(
                 inMonth = { it.month == month.month && it.year == month.year },
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
                 selected = selected,
                 modifier = Modifier
                     .fillMaxWidth()
@@ -809,6 +825,7 @@ internal fun ContinuousMonthGrid(
     listState: LazyListState,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val monthCount = remember { continuousMonthCount() }
@@ -836,6 +853,7 @@ internal fun ContinuousMonthGrid(
                     today = state.today,
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
+                    onEventClick = onEventClick,
                 )
             }
         }
@@ -855,6 +873,7 @@ private fun ContinuousMonthBlock(
     today: LocalDate,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
 ) {
     val rowCount = remember(month, weekStart) { weekRowsInMonth(month, weekStart) }
     Column(
@@ -877,6 +896,7 @@ private fun ContinuousMonthBlock(
                     blankOutside = true,
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
+                    onEventClick = onEventClick,
                     modifier = Modifier
                         .fillMaxWidth()
                         .height(CONTINUOUS_ROW_HEIGHT),
@@ -935,6 +955,7 @@ internal fun DenseMonthGrid(
     listState: LazyListState,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val weekCount = remember(state.weekStart) { continuousWeekCount(state.weekStart) }
@@ -942,10 +963,15 @@ internal fun DenseMonthGrid(
         state = listState,
         modifier = modifier
             .fillMaxSize()
-            .padding(horizontal = 8.dp),
+            // The gap under the weekday header is a real margin, not content
+            // padding: a lazy list scrolls its rows *through* the before-content
+            // padding, so scrolling to a week landed its row that far down with
+            // the tail of the previous one showing above it (#191).
+            .padding(horizontal = 8.dp)
+            .padding(top = DENSE_HEADER_GAP),
         verticalArrangement = Arrangement.spacedBy(2.dp),
         // Bottom inset clears the FAB stack so the last row stays tappable.
-        contentPadding = PaddingValues(top = 4.dp, bottom = 96.dp),
+        contentPadding = PaddingValues(bottom = 96.dp),
     ) {
         items(count = weekCount, key = { it }) { index ->
             val week = state.weeksByIndex[index]
@@ -960,6 +986,7 @@ internal fun DenseMonthGrid(
                     inMonth = { true },
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
+                    onEventClick = onEventClick,
                     labelMonthOnFirst = true,
                     modifier = Modifier
                         .fillMaxWidth()
@@ -1187,6 +1214,9 @@ private fun SplitMonthBody(
                 onSelectDay(it)
                 onSetExpanded(false)
             },
+            // A tapped chip is asking for that event, not for its day, so it
+            // opens the detail from here too rather than collapsing (#187).
+            onEventClick = onEventClick,
             onCollapse = { onSetExpanded(false) },
         )
     } else {
@@ -1287,6 +1317,7 @@ private fun SplitMonthExpanded(
     showWeekNumbers: Boolean,
     swipeModifier: Modifier,
     onPickDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     onCollapse: () -> Unit,
 ) {
     val slideSpec = rememberCalendarSlideSpec()
@@ -1309,6 +1340,7 @@ private fun SplitMonthExpanded(
                 state = s,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onPickDay,
+                onEventClick = onEventClick,
                 selected = sel,
             )
         }
@@ -1789,7 +1821,7 @@ private fun ContinuousMonthSkeleton(dense: Boolean) {
                 modifier = Modifier.padding(bottom = 8.dp),
             )
         } else {
-            Spacer(Modifier.height(4.dp))
+            Spacer(Modifier.height(DENSE_HEADER_GAP))
         }
         // More rows than a viewport holds; the clip takes the overflow.
         repeat(6) {
@@ -1837,6 +1869,7 @@ private fun MonthWeekRow(
     inMonth: (LocalDate) -> Boolean,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
     blankOutside: Boolean = false,
     labelMonthOnFirst: Boolean = false,
@@ -2135,11 +2168,17 @@ private fun MonthWeekRow(
                 }
             }
 
-            // Tap layer: in month view a tap on any day opens that day. Padded and
+            // Tap layer: a tap on a chip opens that event, anything else opens the
+            // day (#187). The chips take no pointer input of their own — this
+            // layer covers them — so the lane under the finger is resolved
+            // geometrically, exactly as the drag pickup above does it; the down
+            // position is read on the initial pass, which consumes nothing and so
+            // leaves both the click and a pickup in flight untouched. Padded and
             // clipped to the background pill so the ripple matches it. A blanked
             // cell isn't part of this month, so it takes no taps either.
+            val downY = remember(week.days.size) { FloatArray(week.days.size) }
             Row(Modifier.matchParentSize()) {
-                week.days.forEach { d ->
+                week.days.forEachIndexed { col, d ->
                     if (blankOutside && !inMonth(d)) {
                         Spacer(Modifier.weight(1f).fillMaxHeight())
                     } else {
@@ -2147,9 +2186,28 @@ private fun MonthWeekRow(
                             Modifier
                                 .weight(1f)
                                 .fillMaxHeight()
+                                .pointerInput(col) {
+                                    awaitEachGesture {
+                                        downY[col] = awaitFirstDown(
+                                            requireUnconsumed = false,
+                                            pass = PointerEventPass.Initial,
+                                        ).position.y
+                                    }
+                                }
                                 .padding(horizontal = CELL_GAP, vertical = 1.dp)
                                 .clip(CELL_SHAPE)
-                                .clickable { onOpenDay(d) },
+                                .clickable {
+                                    val chip = week.chipAtCellY(
+                                        col = col,
+                                        cellY = downY[col],
+                                        bandTopInCell = bandTopInCell(
+                                            cellCoordinates,
+                                            bandCoordinates,
+                                        ),
+                                        rowHeightPx = rowHeightPx,
+                                    )
+                                    if (chip != null) onEventClick(chip) else onOpenDay(d)
+                                },
                         )
                     }
                 }
@@ -2158,6 +2216,38 @@ private fun MonthWeekRow(
     }
 }
 
+/**
+ * How far the event band sits below the top of the row's day-column box, or null
+ * while either is unmeasured. Read off the live coordinates rather than summed
+ * from the padding constants, so it can't drift from what the row actually drew.
+ */
+private fun bandTopInCell(
+    cell: Array<LayoutCoordinates?>,
+    band: Array<LayoutCoordinates?>,
+): Float? {
+    val cellTop = cell[0]?.takeIf { it.isAttached }?.positionInRoot()?.y ?: return null
+    val bandTop = band[0]?.takeIf { it.isAttached }?.positionInRoot()?.y ?: return null
+    return bandTop - cellTop
+}
+
+/**
+ * The chip at [cellY] in column [col], where [cellY] is measured from the top of
+ * the row's day-column box. Null for a tap above the band (the day number), on an
+ * empty lane, or on the overflow dots — all of which mean "open the day", the
+ * dots included: their point is that the day holds more than fits.
+ */
+internal fun MonthWeek.chipAtCellY(
+    col: Int,
+    cellY: Float,
+    bandTopInCell: Float?,
+    rowHeightPx: Float,
+): EventInstance? {
+    if (bandTopInCell == null || rowHeightPx <= 0f) return null
+    val bandY = cellY - bandTopInCell
+    if (bandY < 0f) return null
+    return chipAt(col, (bandY / rowHeightPx).toInt(), MAX_EVENT_ROWS)
+}
+
 /**
  * The row-level pickup for month chips: resolves which chip the press landed on
  * from the geometry the row just laid out, and abandons the gesture on empty

app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthStylePreview.kt

@@ -45,6 +45,7 @@ internal fun MonthStylePreview(
                 state = sample.month,
                 showWeekNumbers = false,
                 onOpenDay = {},
+                onEventClick = {},
             )
             MonthViewStyle.Continuous -> ContinuousMonthGrid(
                 state = sample.continuous,
@@ -55,6 +56,7 @@ internal fun MonthStylePreview(
                 ),
                 showWeekNumbers = false,
                 onOpenDay = {},
+                onEventClick = {},
             )
             MonthViewStyle.Dense -> DenseMonthGrid(
                 state = sample.continuous,
@@ -66,6 +68,7 @@ internal fun MonthStylePreview(
                 ),
                 showWeekNumbers = false,
                 onOpenDay = {},
+                onEventClick = {},
             )
             MonthViewStyle.Split -> {
                 SplitMonthGrid(

app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekScreen.kt

@@ -129,6 +129,7 @@ import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.GUTTER_CONTENT_START_INSET
 import de.jeanlucmakiola.calendula.ui.common.GUTTER_WIDTH
 import de.jeanlucmakiola.calendula.ui.common.HourGutter
+import de.jeanlucmakiola.calendula.ui.common.TIMELINE_CONTENT_END_INSET
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
 import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
@@ -506,7 +507,7 @@ private fun WeekDayHeader(
     Row(
         modifier = Modifier
             .fillMaxWidth()
-            .padding(top = 4.dp, bottom = 8.dp),
+            .padding(top = 4.dp, bottom = 8.dp, end = TIMELINE_CONTENT_END_INSET),
     ) {
         // Mirror the day-column layout (empty weekday line + spacer) so the
         // badge lines up vertically with the date numbers. The start inset centres
@@ -602,7 +603,11 @@ private fun AllDayStrip(
             // Height is hoisted + animated so it slides and resizes smoothly;
             // padding sits inside it so the content area is lanes * row height.
             .height(height)
-            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
+            .padding(
+                top = ALL_DAY_VERTICAL_PADDING,
+                bottom = ALL_DAY_VERTICAL_PADDING,
+                end = TIMELINE_CONTENT_END_INSET,
+            ),
     ) {
         // Keep the gutter-width offset so the bars line up with the day columns.
         Spacer(Modifier.width(GUTTER_WIDTH))
@@ -708,6 +713,7 @@ private fun Timeline(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
                     .clip(RoundedCornerShape(16.dp))
                     .verticalScroll(scrollState)
                     .onGloballyPositioned { dragController.geometry.viewport = it },
@@ -977,7 +983,12 @@ private fun WeekLoading() {
             // Same scale resolution as the loaded timeline, so the skeleton's
             // columns don't resize the moment the real week arrives.
             val totalHeight = scale.hourHeight(maxHeight) * 24
-            Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
+            Row(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
+                    .verticalScroll(scrollState),
+            ) {
                 Spacer(Modifier.width(GUTTER_WIDTH))
                 repeat(7) {
                     Box(

app/src/main/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaWidget.kt

@@ -24,7 +24,6 @@ import androidx.glance.appwidget.cornerRadius
 import androidx.glance.appwidget.lazy.LazyColumn
 import androidx.glance.appwidget.lazy.items
 import androidx.glance.appwidget.provideContent
-import androidx.glance.appwidget.updateAll
 import androidx.glance.background
 import androidx.glance.currentState
 import androidx.glance.state.PreferencesGlanceStateDefinition
@@ -135,10 +134,14 @@ class AgendaWidget : GlanceAppWidget() {
     }
 }
 
-/** Re-reads the calendar and redraws the widget (header refresh button). */
+/**
+ * Re-reads the calendar and redraws the widget (header refresh button). Targets
+ * the tapped widget's own id rather than `updateAll`, whose provider-name lookup
+ * is empty in a process a tap woke from cold — see `ShiftMonthAction` (#18).
+ */
 class RefreshAgendaAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
-        AgendaWidget().updateAll(context.applicationContext)
+        AgendaWidget().update(context.applicationContext, glanceId)
     }
 }
 

app/src/main/java/de/jeanlucmakiola/calendula/widget/month/MonthWidget.kt

@@ -25,7 +25,6 @@ import androidx.glance.appwidget.action.actionStartActivity
 import androidx.glance.appwidget.cornerRadius
 import androidx.glance.appwidget.provideContent
 import androidx.glance.appwidget.state.updateAppWidgetState
-import androidx.glance.appwidget.updateAll
 import androidx.glance.background
 import androidx.glance.currentState
 import androidx.glance.layout.Alignment
@@ -118,7 +117,17 @@ class MonthWidget : GlanceAppWidget() {
     }
 }
 
-/** Step the displayed month by the `delta` action parameter (±1). */
+/**
+ * Step the displayed month by the `delta` action parameter (±1).
+ *
+ * Redrawn through [GlanceAppWidget.update] with the id the callback was handed,
+ * never `updateAll`. `updateAll` resolves its targets through the provider-name
+ * -> app-widget-id map Glance persists for the *receiver*, and in a process that
+ * has done nothing else yet — the one a tap wakes after a reboot — that lookup
+ * comes back empty and the redraw is dropped: the state write lands, nothing
+ * recomposes, and the arrows read as dead until something else opens the app and
+ * starts a session (#18). The tapped widget's own id needs no lookup.
+ */
 class ShiftMonthAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
         val delta = parameters[deltaKey] ?: 0
@@ -126,7 +135,7 @@ class ShiftMonthAction : ActionCallback {
             val cur = prefs[MONTH_INDEX_KEY] ?: currentMonthIndex(systemZone())
             prefs[MONTH_INDEX_KEY] = cur + delta
         }
-        MonthWidget().updateAll(context.applicationContext)
+        MonthWidget().update(context.applicationContext, glanceId)
     }
 
     companion object {
@@ -134,11 +143,11 @@ class ShiftMonthAction : ActionCallback {
     }
 }
 
-/** Jump the displayed month back to the current month. */
+/** Jump the displayed month back to the current month. See [ShiftMonthAction]. */
 class ResetMonthAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
         updateAppWidgetState(context, glanceId) { prefs -> prefs.remove(MONTH_INDEX_KEY) }
-        MonthWidget().updateAll(context.applicationContext)
+        MonthWidget().update(context.applicationContext, glanceId)
     }
 }
 

app/src/test/java/de/jeanlucmakiola/calendula/ui/month/ChipAtCellYTest.kt

@@ -0,0 +1,122 @@
+package de.jeanlucmakiola.calendula.ui.month
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.Month
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.YearMonth
+import kotlinx.datetime.atTime
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import org.junit.jupiter.api.Test
+
+/**
+ * Which chip a tap in a month cell lands on (#187) — the geometry the tap layer
+ * uses to tell "open this event" from "open this day", given that the chips take
+ * no pointer input of their own.
+ */
+class ChipAtCellYTest {
+
+    private val zone = TimeZone.UTC
+    private val jul26 = YearMonth(2026, Month.JULY)
+
+    /** Band starts 40px down the cell; each lane is 20px tall. */
+    private val bandTop = 40f
+    private val laneHeight = 20f
+
+    /** July 2026 starts on a Wednesday, so this row — Jul 6–12 — sits wholly inside it. */
+    private fun rowOfJuly6(events: List<EventInstance>) =
+        layoutMonthWeeks(jul26, DayOfWeek.MONDAY, events, zone)[1]
+
+    private fun allDay(from: LocalDate, toInclusive: LocalDate, id: Long) = EventInstance(
+        instanceId = id,
+        eventId = id,
+        calendarId = 1L,
+        title = "A$id",
+        start = from.atTime(0, 0).toInstant(zone),
+        end = toInclusive.plus(1, DateTimeUnit.DAY).atTime(0, 0).toInstant(zone),
+        isAllDay = true,
+        color = 0xFF2196F3.toInt(),
+        location = null,
+    )
+
+    private fun timed(date: LocalDate, hour: Int, id: Long) = EventInstance(
+        instanceId = id,
+        eventId = id,
+        calendarId = 1L,
+        title = "T$id",
+        start = date.atTime(hour, 0).toInstant(zone),
+        end = date.atTime(hour + 1, 0).toInstant(zone),
+        isAllDay = false,
+        color = 0xFFF44336.toInt(),
+        location = null,
+    )
+
+    private fun MonthWeek.chipAt(col: Int, cellY: Float) =
+        chipAtCellY(col = col, cellY = cellY, bandTopInCell = bandTop, rowHeightPx = laneHeight)
+
+    @Test
+    fun `a tap on a lane resolves to the chip seated there`() {
+        val bar = allDay(LocalDate(2026, 7, 7), LocalDate(2026, 7, 9), id = 1L)
+        val meeting = timed(LocalDate(2026, 7, 7), hour = 9, id = 2L)
+        val week = rowOfJuly6(listOf(bar, meeting))
+
+        // Jul 7 is column 1 of a Monday-anchored row starting Jul 6.
+        assertThat(week.chipAt(col = 1, cellY = bandTop + 5f)?.eventId).isEqualTo(1L)
+        assertThat(week.chipAt(col = 1, cellY = bandTop + laneHeight + 5f)?.eventId).isEqualTo(2L)
+    }
+
+    @Test
+    fun `a multi-day bar answers on every column it covers`() {
+        val bar = allDay(LocalDate(2026, 7, 7), LocalDate(2026, 7, 9), id = 1L)
+        val week = rowOfJuly6(listOf(bar))
+
+        (1..3).forEach { col ->
+            assertThat(week.chipAt(col = col, cellY = bandTop + 5f)?.eventId).isEqualTo(1L)
+        }
+        // Jul 10 is past the bar's last day.
+        assertThat(week.chipAt(col = 4, cellY = bandTop + 5f)).isNull()
+    }
+
+    @Test
+    fun `a tap above the band is the day number, not a chip`() {
+        val week = rowOfJuly6(listOf(timed(LocalDate(2026, 7, 7), hour = 9, id = 2L)))
+
+        assertThat(week.chipAt(col = 1, cellY = bandTop - 1f)).isNull()
+        assertThat(week.chipAt(col = 1, cellY = 0f)).isNull()
+    }
+
+    @Test
+    fun `a tap on an empty lane of a day that has chips falls through to the day`() {
+        val week = rowOfJuly6(listOf(timed(LocalDate(2026, 7, 7), hour = 9, id = 2L)))
+
+        assertThat(week.chipAt(col = 1, cellY = bandTop + laneHeight * 2 + 5f)).isNull()
+    }
+
+    @Test
+    fun `a tap on the overflow row opens the day rather than a hidden event`() {
+        val events = (1..MAX_EVENT_ROWS + 2).map {
+            timed(LocalDate(2026, 7, 7), hour = it, id = it.toLong())
+        }
+        val week = rowOfJuly6(events)
+
+        // The dots sit one lane below the last one the row draws.
+        val overflowY = bandTop + laneHeight * MAX_EVENT_ROWS + 2f
+        assertThat(week.chipAt(col = 1, cellY = overflowY)).isNull()
+    }
+
+    @Test
+    fun `unmeasured geometry resolves to no chip`() {
+        val week = rowOfJuly6(listOf(timed(LocalDate(2026, 7, 7), hour = 9, id = 2L)))
+
+        assertThat(
+            week.chipAtCellY(col = 1, cellY = 45f, bandTopInCell = null, rowHeightPx = laneHeight),
+        ).isNull()
+        assertThat(
+            week.chipAtCellY(col = 1, cellY = 45f, bandTopInCell = bandTop, rowHeightPx = 0f),
+        ).isNull()
+    }
+}