Size the week-number gutter to the number it seats (#213, #189)

The pinch clamped its lower bound to `ceil(fillPx)`. Rounding a fill height up
by the fraction of a pixel that 24 hours don't divide the viewport into makes
the timeline up to one pixel per hour taller than the viewport those hours are
supposed to fill — roughly 24px of leftover scroll, enough to bounce off
Android's overscroll stretch. `FitDay` resolves to the unrounded height and sits
still, so the two ways of reaching "the whole day on one screen" disagreed.
That inconsistency is what #290 is about.

Clamps to `fillPx` itself. The whole-pixel rounding exists so the hour gutter's
24 stacked boxes share a grid with the lines and blocks drawn at the fractional
height, and it still applies everywhere the pinch is free to move. The floor is
the one height where matching `FitDay` matters more — and because it is the
clamp *result* rather than a bound the gesture is merely held against, the pinch
lands on it exactly, so the next frame reads it back unchanged and the focal
anchor gets no correction to apply.

Week and Day both measure their viewport inside a `BoxWithConstraints` below the
all-day strip, so the strip appearing only changes the height both paths agree
on — that half of the report needed no change.

Tests: the two cases that encoded the old rounding are updated (the dead-space
invariant still holds, now exactly rather than by a pixel), plus one for the
reported symptom and one asserting the pinch floor equals what `FitDay`
resolves to at the same viewport.

Closes #290

Co-authored-by: Jean-Luc Makiola <business@jeanlucmakiola.de>
Reviewed-on: https://codeberg.org/jlmakiola/calendula/pulls/315

app/src/main/java/de/jeanlucmakiola/calendula/domain/Models.kt

@@ -253,13 +253,6 @@ enum class FailureReason {
     PermissionRevoked,
     NoCalendarsConfigured,
     AllCalendarsHidden,
-
-    /**
-     * Calendars exist and are switched on, but none can receive an event: every
-     * one is read-only, app-managed, or not synced to this device. Distinct from
-     * [AllCalendarsHidden], which a visibility switch fixes.
-     */
-    NoImportTarget,
     ProviderUnavailable,
     EventNotFound,
     Unknown,

app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt

@@ -550,24 +550,18 @@ fun CalendarHost(
             enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
             exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
         ) {
-            // The manager sits directly under this screen, so its failure states'
-            // "Manage calendars" way out is simply popping back to it (#304).
-            CompositionLocalProvider(
-                LocalManageCalendars provides { showBackup = false },
-            ) {
-                BackupScreen(
-                    onBack = { showBackup = false },
-                    // Restore runs the normal .ics import, and both this screen
-                    // and the manager that can have opened it are declared above
-                    // the import overlays — so both have to step aside.
-                    onImport = {
-                        importUri = it
-                        importForceMany = true
-                        showBackup = false
-                        showCalendars = false
-                    },
-                )
-            }
+            BackupScreen(
+                onBack = { showBackup = false },
+                // Restore runs the normal .ics import, and both this screen and
+                // the manager that can have opened it are declared above the
+                // import overlays — so both have to step aside.
+                onImport = {
+                    importUri = it
+                    importForceMany = true
+                    showBackup = false
+                    showCalendars = false
+                },
+            )
         }
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupScreen.kt

@@ -4,7 +4,6 @@ import android.net.Uri
 import android.text.format.DateUtils
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
@@ -19,7 +18,6 @@ import androidx.compose.material.icons.filled.Schedule
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.Checkbox
-import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
@@ -49,10 +47,9 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.isEventTarget
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
-import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.LeadingAvatar
-import de.jeanlucmakiola.calendula.ui.common.LocalManageCalendars
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
 import de.jeanlucmakiola.floret.components.DialogAmountField
 import de.jeanlucmakiola.floret.components.DialogUnitDropdown
@@ -83,13 +80,18 @@ fun BackupScreen(
     onImport: (Uri) -> Unit,
     viewModel: CalendarsViewModel = hiltViewModel(),
 ) {
-    val state by viewModel.backupState.collectAsStateWithLifecycle()
+    val calendars by viewModel.calendars.collectAsStateWithLifecycle()
     val backupResult by viewModel.backupResult.collectAsStateWithLifecycle()
     val autoBackup by viewModel.autoBackup.collectAsStateWithLifecycle()
 
     val context = LocalContext.current
     val snackbarHostState = remember { SnackbarHostState() }
 
+    // Export covers local calendars only; managed special-dates mirrors are
+    // rebuilt from contacts. Restore can target anything the import picker offers.
+    val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
+    val canImport = calendars.any { it.isEventTarget }
+
     // Exports everything eligible (null); the per-calendar selector owns its
     // own launcher.
     val createBackup = rememberLauncherForActivityResult(
@@ -133,35 +135,75 @@ fun BackupScreen(
         snackbarHost = { SnackbarHost(snackbarHostState) },
         predictiveBack = true,
     ) {
-        when (val s = state) {
-            BackupUiState.Loading -> BackupLoading()
-            is BackupUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onBack)
-            is BackupUiState.Ready -> BackupContent(
-                exportable = s.exportable,
-                canImport = s.canImport,
-                autoBackup = autoBackup,
-                viewModel = viewModel,
-                onRestore = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
-                onPickFolder = { runCatching { pickFolder.launch(null) } },
-                onExportAll = {
-                    runCatching { createBackup.launch(defaultBackupName()) }
+        HintText(stringResource(R.string.calendars_backup_hint))
+
+        if (exportable.isNotEmpty()) {
+            GroupedRow(
+                title = stringResource(R.string.calendars_backup_action),
+                position = Position.Top,
+                leading = { LeadingAvatar(Icons.Default.FileDownload) },
+                onClick = {
+                    // A single exportable calendar skips the selector.
+                    if (exportable.size == 1) {
+                        runCatching { createBackup.launch("calendula-backup-${LocalDate.now()}.ics") }
+                    } else {
+                        showExportPicker = true
+                    }
                 },
-                onExportPick = { showExportPicker = true },
-                onEditInterval = { showInterval = true },
+            )
+            GroupedRow(
+                title = stringResource(R.string.calendars_restore_action),
+                summary = stringResource(R.string.calendars_restore_hint),
+                position = Position.Middle,
+                leading = { LeadingAvatar(Icons.Default.FileUpload) },
+                onClick = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
+            )
+            GroupedRow(
+                title = stringResource(R.string.calendars_auto_backup),
+                summary = stringResource(R.string.calendars_auto_backup_hint),
+                position = if (autoBackup.enabled) Position.Middle else Position.Bottom,
+                leading = { LeadingAvatar(Icons.Default.Schedule) },
+                trailing = {
+                    Switch(checked = autoBackup.enabled, onCheckedChange = viewModel::setAutoBackupEnabled)
+                },
+                onClick = { viewModel.setAutoBackupEnabled(!autoBackup.enabled) },
+            )
+            if (autoBackup.enabled) {
+                GroupedRow(
+                    title = stringResource(R.string.calendars_auto_backup_folder),
+                    summary = rememberFolderName(autoBackup.folderUri)
+                        ?: stringResource(R.string.calendars_auto_backup_folder_unset),
+                    position = Position.Middle,
+                    onClick = { runCatching { pickFolder.launch(null) } },
+                )
+                GroupedRow(
+                    title = stringResource(R.string.calendars_auto_backup_interval),
+                    summary = backupIntervalLabel(autoBackup.intervalMinutes),
+                    position = Position.Bottom,
+                    onClick = { showInterval = true },
+                )
+                HintText(backupStatusText(autoBackup.status))
+            }
+        } else if (canImport) {
+            // Nothing to back up, but restore is still possible — don't hide
+            // it behind export eligibility.
+            SectionHeader(stringResource(R.string.calendars_restore_header))
+            HintText(stringResource(R.string.calendars_restore_hint))
+            GroupedRow(
+                title = stringResource(R.string.calendars_restore_action),
+                position = Position.Alone,
+                leading = { LeadingAvatar(Icons.Default.FileUpload) },
+                onClick = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
             )
         }
     }
 
-    // Gated on Ready rather than resetting the flag when the state leaves it:
-    // flipping it here would be a write during composition.
-    (state as? BackupUiState.Ready)?.let { ready ->
-        if (showExportPicker) {
-            ExportCalendarPicker(
-                calendars = ready.exportable,
-                onExport = viewModel::exportBackup,
-                onDismiss = { showExportPicker = false },
-            )
-        }
+    if (showExportPicker) {
+        ExportCalendarPicker(
+            calendars = exportable,
+            onExport = viewModel::exportBackup,
+            onDismiss = { showExportPicker = false },
+        )
     }
     if (showInterval) {
         BackupIntervalDialog(
@@ -172,105 +214,6 @@ fun BackupScreen(
     }
 }
 
-/** The screen's one-line loading state, in the scaffold's content column. */
-@Composable
-private fun BackupLoading() {
-    Box(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(vertical = 48.dp),
-        contentAlignment = Alignment.Center,
-    ) {
-        CircularProgressIndicator()
-    }
-}
-
-/** Default file name for a one-shot export. */
-private fun defaultBackupName(): String = "calendula-backup-${LocalDate.now()}.ics"
-
-/**
- * The working screen: export (when there are local calendars to export), restore,
- * and the automatic-backup block. Restore is always on screen — when nothing can
- * receive the events it says so and routes to the calendar manager rather than
- * disappearing, which is what #304 reported as an invisible button.
- */
-@Composable
-private fun BackupContent(
-    exportable: List<CalendarSource>,
-    canImport: Boolean,
-    autoBackup: AutoBackupUiState,
-    viewModel: CalendarsViewModel,
-    onRestore: () -> Unit,
-    onPickFolder: () -> Unit,
-    onExportAll: () -> Unit,
-    onExportPick: () -> Unit,
-    onEditInterval: () -> Unit,
-) {
-    val manageCalendars = LocalManageCalendars.current
-    // Restore never depends on export eligibility, and never disappears: when no
-    // calendar can receive events it explains that and offers the way to fix it.
-    val restoreSummary = if (canImport) {
-        stringResource(R.string.calendars_restore_hint)
-    } else {
-        stringResource(R.string.calendars_restore_unavailable)
-    }
-    val onRestoreClick = if (canImport) onRestore else (manageCalendars ?: onRestore)
-
-    if (exportable.isEmpty()) {
-        SectionHeader(stringResource(R.string.calendars_restore_header))
-        HintText(restoreSummary)
-        GroupedRow(
-            title = stringResource(R.string.calendars_restore_action),
-            position = Position.Alone,
-            leading = { LeadingAvatar(Icons.Default.FileUpload) },
-            onClick = onRestoreClick,
-        )
-        return
-    }
-
-    HintText(stringResource(R.string.calendars_backup_hint))
-    GroupedRow(
-        title = stringResource(R.string.calendars_backup_action),
-        position = Position.Top,
-        leading = { LeadingAvatar(Icons.Default.FileDownload) },
-        // A single exportable calendar skips the selector.
-        onClick = if (exportable.size == 1) onExportAll else onExportPick,
-    )
-    GroupedRow(
-        title = stringResource(R.string.calendars_restore_action),
-        summary = restoreSummary,
-        position = Position.Middle,
-        leading = { LeadingAvatar(Icons.Default.FileUpload) },
-        onClick = onRestoreClick,
-    )
-    GroupedRow(
-        title = stringResource(R.string.calendars_auto_backup),
-        summary = stringResource(R.string.calendars_auto_backup_hint),
-        position = if (autoBackup.enabled) Position.Middle else Position.Bottom,
-        leading = { LeadingAvatar(Icons.Default.Schedule) },
-        trailing = {
-            Switch(checked = autoBackup.enabled, onCheckedChange = viewModel::setAutoBackupEnabled)
-        },
-        onClick = { viewModel.setAutoBackupEnabled(!autoBackup.enabled) },
-    )
-    if (autoBackup.enabled) {
-        GroupedRow(
-            title = stringResource(R.string.calendars_auto_backup_folder),
-            summary = rememberFolderName(autoBackup.folderUri)
-                ?: stringResource(R.string.calendars_auto_backup_folder_unset),
-            position = Position.Middle,
-            onClick = onPickFolder,
-        )
-        GroupedRow(
-            title = stringResource(R.string.calendars_auto_backup_interval),
-            summary = backupIntervalLabel(autoBackup.intervalMinutes),
-            position = Position.Bottom,
-            onClick = onEditInterval,
-        )
-        HintText(backupStatusText(autoBackup.status))
-    }
-}
-
 /**
  * Choose which local calendars to include in a one-time `.ics` export. Defaults
  * to all selected; the Export action opens the SAF save dialog and hands back

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiState.kt

@@ -1,53 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.calendars
-
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.domain.calendarListFailure
-import de.jeanlucmakiola.calendula.domain.isEventTarget
-
-/**
- * State of the Backup & restore screen (#69). Three states, because the calendar
- * list it is derived from has all three: it arrives empty, it can throw, and
- * "loaded but nothing to offer" is a real outcome the screen used to render as a
- * blank page (#304).
- */
-sealed interface BackupUiState {
-    data object Loading : BackupUiState
-    data class Failure(val reason: FailureReason) : BackupUiState
-
-    /**
-     * At least one half of the screen works. [exportable] may be empty (restore
-     * only) and [canImport] may be false (export only), but never both — that is
-     * a [Failure].
-     */
-    data class Ready(
-        val exportable: List<CalendarSource>,
-        val canImport: Boolean,
-    ) : BackupUiState
-}
-
-/**
- * What the screen can offer for this calendar list.
- *
- * Export covers the app's own local calendars; managed special-dates mirrors are
- * rebuilt from contacts, so they are excluded. Restore can target anything the
- * import picker offers ([isEventTarget]).
- *
- * A failure is raised only when *neither* is possible — deliberately not
- * [calendarListFailure] on its own, which would call an all-hidden device a
- * failure while its local calendars are still perfectly exportable. When both
- * halves are dead the list itself usually says why (no calendars, everything
- * switched off); [FailureReason.NoImportTarget] covers the remaining case, where
- * calendars exist and are visible but every one of them is read-only, managed or
- * not synced to the device.
- */
-fun backupUiState(calendars: List<CalendarSource>): BackupUiState {
-    val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
-    val canImport = calendars.any { it.isEventTarget }
-    if (exportable.isEmpty() && !canImport) {
-        return BackupUiState.Failure(
-            calendarListFailure(calendars) ?: FailureReason.NoImportTarget,
-        )
-    }
-    return BackupUiState.Ready(exportable = exportable, canImport = canImport)
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt

@@ -14,7 +14,6 @@ import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -25,7 +24,6 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -58,22 +56,6 @@ class CalendarsViewModel @Inject constructor(
                 initialValue = emptyList(),
             )
 
-    /**
-     * The Backup & restore screen's own view of that list, with the loading and
-     * failure states [calendars] flattens away — it starts empty and catches to
-     * empty, which that screen used to render as a blank page (#304).
-     */
-    val backupState: StateFlow<BackupUiState> =
-        repository.calendars()
-            .map { backupUiState(it) }
-            .catch { emit(BackupUiState.Failure(FailureReason.ProviderUnavailable)) }
-            .flowOn(io)
-            .stateIn(
-                scope = viewModelScope,
-                started = SharingStarted.WhileSubscribed(5_000L),
-                initialValue = BackupUiState.Loading,
-            )
-
     /** Automatic-backup settings + last-run status, for the Backup section UI. */
     val autoBackup: StateFlow<AutoBackupUiState> = combine(
         settingsPrefs.autoBackupEnabled,

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

@@ -36,7 +36,6 @@ fun CalendarFailure(reason: FailureReason, onRetry: () -> Unit) {
         FailureReason.PermissionRevoked -> R.string.state_failure_permission
         FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars
         FailureReason.AllCalendarsHidden -> R.string.state_failure_all_hidden
-        FailureReason.NoImportTarget -> R.string.state_failure_no_import_target
         FailureReason.ProviderUnavailable -> R.string.state_failure_provider
         FailureReason.Unknown,
         FailureReason.EventNotFound -> R.string.state_failure_unknown
@@ -44,7 +43,6 @@ fun CalendarFailure(reason: FailureReason, onRetry: () -> Unit) {
     val actionRes = when (reason) {
         FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars_action
         FailureReason.AllCalendarsHidden -> R.string.state_failure_all_hidden_action
-        FailureReason.NoImportTarget -> R.string.state_failure_all_hidden_action
         FailureReason.PermissionRevoked -> R.string.state_failure_permission_action
         else -> R.string.state_retry
     }
@@ -52,9 +50,7 @@ fun CalendarFailure(reason: FailureReason, onRetry: () -> Unit) {
         FailureReason.NoCalendarsConfigured -> {
             { context.startCalendarSetup() }
         }
-        FailureReason.AllCalendarsHidden,
-        FailureReason.NoImportTarget,
-        -> manageCalendars ?: onRetry
+        FailureReason.AllCalendarsHidden -> manageCalendars ?: onRetry
         else -> onRetry
     }
     Column(

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

@@ -19,7 +19,6 @@ import androidx.compose.ui.input.pointer.PointerEventPass
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.unit.Dp
 import kotlin.math.abs
-import kotlin.math.ceil
 import kotlin.math.floor
 import kotlin.math.roundToInt
 
@@ -197,18 +196,26 @@ fun rememberTimelinePinchZoom(
  * names, jumping the whole column as a pinch drifts across each half pixel.
  * Pinning the hour to whole pixels keeps every part of the timeline on one grid.
  *
- * The bounds themselves are pulled onto that grid too, each in the direction
- * that keeps its own promise — up for the fill floor, so no dead space opens
- * under midnight, down for the ceiling. A fractional bound would be a height the
- * pinch can be held against but never actually land on, and the difference feeds
- * the focal anchor a scroll correction on every frame the fingers sit still.
+ * The ceiling is pulled onto that grid too, downwards, so it stays a height the
+ * pinch can actually land on.
+ *
+ * [fillPx] is deliberately *not* rounded (#290). It is the one height the whole
+ * day exactly fills the viewport at, and it is the same value
+ * [TimelineScale.FitDay] resolves to — rounding it up by the fraction of a pixel
+ * that 24 hours don't divide the viewport into leaves the timeline a pixel per
+ * hour taller than its own viewport, so a pinched-all-the-way-out day still
+ * scrolls a hair and bounces off Android's overscroll stretch, while the
+ * identical FitDay preset sits still. Being the clamp result rather than a bound
+ * the gesture is merely held against, it is a height the pinch does land on: the
+ * next frame reads it back unchanged and the focal anchor is handed nothing to
+ * correct.
  */
 internal fun pinchedHourHeightPx(target: Float, fillPx: Float, maxPx: Float): Float =
     // Filling the viewport wins over the ceiling: on a screen tall enough for
     // the two to disagree, dead space is the worse of the two failures.
     target.roundToInt().toFloat()
         .coerceAtMost(floor(maxPx))
-        .coerceAtLeast(ceil(fillPx))
+        .coerceAtLeast(fillPx)
 
 /**
  * The scroll offset that keeps the moment under [centroidY] under it after the

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

@@ -123,6 +123,7 @@ import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.rememberTextMeasurer
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
@@ -744,7 +745,7 @@ internal fun WeekdayHeader(weekStart: DayOfWeek, showWeekNumbers: Boolean) {
             .padding(horizontal = AppBarSpacing.Inset, vertical = 4.dp),
     ) {
         // Reserve the gutter so the weekday labels stay over their day columns.
-        if (showWeekNumbers) Spacer(Modifier.width(WEEK_NUMBER_GUTTER))
+        if (showWeekNumbers) Spacer(Modifier.width(rememberWeekNumberGutter()))
         days.forEach { dow ->
             val isWeekend = dow == DayOfWeek.SATURDAY || dow == DayOfWeek.SUNDAY
             val javaDow = java.time.DayOfWeek.of(dow.ordinal + 1)
@@ -762,9 +763,34 @@ internal fun WeekdayHeader(weekStart: DayOfWeek, showWeekNumbers: Boolean) {
 
 private val EVENT_ROW_HEIGHT = 20.dp
 private val DAY_NUMBER_HEIGHT = 22.dp
-/** Width of the optional left calendar-week gutter (#25); narrow, since it only
- *  seats a one- or two-digit week number in a full-height tonal pill. */
-private val WEEK_NUMBER_GUTTER = 40.dp
+/** Padding between the week-number pill's edge and the number inside it. */
+private val WEEK_NUMBER_PADDING = 6.dp
+
+/** The widest week number an ISO year reaches; digits are tabular, so one
+ *  measurement of it prices every week in the grid. */
+private const val WEEK_NUMBER_SAMPLE = "53"
+
+/**
+ * Width of the optional left calendar-week gutter (#25), measured rather than
+ * fixed: it is sized to the number it seats at the style the pill draws it in,
+ * so it follows the font scale instead of reserving slack for it, and spends
+ * nothing more on a column the grid would rather hand to the seven days (#213).
+ */
+@Composable
+private fun rememberWeekNumberGutter(): Dp {
+    val measurer = rememberTextMeasurer()
+    val density = LocalDensity.current
+    val style = weekNumberStyle()
+    return remember(style, density, measurer) {
+        val text = with(density) { measurer.measure(WEEK_NUMBER_SAMPLE, style).size.width.toDp() }
+        text + (WEEK_NUMBER_PADDING + CELL_GAP) * 2
+    }
+}
+
+/** The week number's own style — a step down from the day numbers beside it. */
+@Composable
+private fun weekNumberStyle() =
+    MaterialTheme.typography.labelMedium.copy(fontWeight = FontWeight.Bold)
 private val DAY_NUMBER_GAP = 4.dp
 private val CELL_TOP_PADDING = 6.dp
 /** Named separately because the split style's selection outline draws its own
@@ -1486,7 +1512,7 @@ internal fun SplitMonthGrid(
                     WeekNumberGutter(
                         weekStart = week.days.first(),
                         modifier = Modifier
-                            .width(WEEK_NUMBER_GUTTER)
+                            .width(rememberWeekNumberGutter())
                             .fillMaxHeight(),
                     )
                 }
@@ -2007,7 +2033,7 @@ private fun MonthWeekRow(
             WeekNumberGutter(
                 weekStart = week.days.first(),
                 modifier = Modifier
-                    .width(WEEK_NUMBER_GUTTER)
+                    .width(rememberWeekNumberGutter())
                     .fillMaxHeight(),
             )
         }
@@ -2422,8 +2448,7 @@ private fun WeekNumberGutter(weekStart: LocalDate, modifier: Modifier = Modifier
     ) {
         Text(
             text = weekNumber.toString(),
-            style = MaterialTheme.typography.titleSmall,
-            fontWeight = FontWeight.Bold,
+            style = weekNumberStyle(),
             color = MaterialTheme.colorScheme.onSecondaryContainer,
         )
     }

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

@@ -571,7 +571,7 @@ private fun WeekDayHeader(
 }
 
 /** Calendar-week badge shown in the header gutter, deliberately set apart with a
- *  filled box and bold number. */
+ *  filled box and bold number — at the month grid's size, so the two agree (#213). */
 @Composable
 private fun WeekNumberBadge(weekNumber: Int, modifier: Modifier = Modifier) {
     val label = stringResource(R.string.week_number_label)
@@ -583,9 +583,9 @@ private fun WeekNumberBadge(weekNumber: Int, modifier: Modifier = Modifier) {
     ) {
         Text(
             text = weekNumber.toString(),
-            style = MaterialTheme.typography.titleSmall,
+            style = MaterialTheme.typography.labelMedium,
             fontWeight = FontWeight.Bold,
-            modifier = Modifier.padding(horizontal = 8.dp, vertical = 3.dp),
+            modifier = Modifier.padding(horizontal = 6.dp, vertical = 3.dp),
         )
     }
 }

app/src/main/res/values/strings.xml

@@ -16,7 +16,6 @@
     <string name="state_failure_no_calendars_action">Open system calendar settings</string>
     <string name="state_failure_all_hidden">All your calendars are switched off.</string>
     <string name="state_failure_all_hidden_action">Manage calendars</string>
-    <string name="state_failure_no_import_target">None of your calendars can take new events. They are read-only, managed by another app, or not synced to this device.</string>
     <string name="state_failure_provider">Could not read the calendar.</string>
 
     <!-- Long-press a field to copy it (#195) -->
@@ -680,7 +679,6 @@
     <string name="calendars_restore_header">Restore</string>
     <string name="calendars_restore_action">Restore from .ics file</string>
     <string name="calendars_restore_hint">Import events from a backup or another calendar app.</string>
-    <string name="calendars_restore_unavailable">No calendar can take the imported events yet.</string>
     <string name="calendars_auto_backup">Automatic backup</string>
     <string name="calendars_auto_backup_hint">Periodically export your local calendars to a folder as an .ics file.</string>
     <string name="calendars_auto_backup_folder">Backup folder</string>

app/src/test/java/de/jeanlucmakiola/calendula/domain/ModelsTest.kt

@@ -36,13 +36,12 @@ class ModelsTest {
     }
 
     @Test
-    fun `FailureReason enum has all seven variants`() {
+    fun `FailureReason enum has all six variants`() {
         assertThat(FailureReason.values().toSet()).isEqualTo(
             setOf(
                 FailureReason.PermissionRevoked,
                 FailureReason.NoCalendarsConfigured,
                 FailureReason.AllCalendarsHidden,
-                FailureReason.NoImportTarget,
                 FailureReason.ProviderUnavailable,
                 FailureReason.EventNotFound,
                 FailureReason.Unknown,

app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsGoogleImportTest.kt

@@ -1,116 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.Availability
-import kotlinx.datetime.TimeZone
-import org.junit.jupiter.api.Test
-
-/**
- * Reading a Google Calendar export (Codeberg #304), whose dialect the parser had
- * never been held to: `VTIMEZONE` blocks with `X-LIC-LOCATION`, `TZID`-qualified
- * `DTSTART`/`EXDATE`, folded `DESCRIPTION` and `ATTENDEE` lines, `RECURRENCE-ID`
- * overrides written as separate `VEVENT`s, and `@google.com` UIDs.
- *
- * The fixture is a trimmed copy of what "Settings → Import & export → Export"
- * produces, CRLF and all. Note that Google hands that export out as a **zip**
- * containing one `.ics` per calendar — the file here is one member of it.
- */
-class IcsGoogleImportTest {
-
-    private val parser = IcsParser(TimeZone.of("Europe/Berlin"))
-
-    private val result: IcsParseResult = parser.parse(
-        checkNotNull(
-            javaClass.classLoader?.getResourceAsStream("ics/google-calendar-export.ics"),
-        ).use { it.readBytes().toString(Charsets.UTF_8) },
-    )
-
-    private fun event(summary: String) = result.events.single { it.summary == summary }
-
-    @Test
-    fun `every master event imports and the VTIMEZONE block is not mistaken for one`() {
-        assertThat(result.events.map { it.summary })
-            .containsExactly("Team standup", "Day off", "Christmas break")
-    }
-
-    @Test
-    fun `X-WR-CALNAME names the calendar for all of them`() {
-        assertThat(result.events.map { it.calendarName }.distinct())
-            .containsExactly("jane@example.com")
-    }
-
-    @Test
-    fun `a TZID-qualified start resolves against the device tz database`() {
-        val standup = event("Team standup")
-        assertThat(standup.isAllDay).isFalse()
-        assertThat(standup.zoneId).isEqualTo("Europe/Berlin")
-        // 10:00 CEST is 08:00 UTC.
-        assertThat(standup.start.toString()).isEqualTo("2026-09-15T08:00:00Z")
-        assertThat((standup.end - standup.start).inWholeMinutes).isEqualTo(90)
-    }
-
-    @Test
-    fun `the recurrence rule and its TZID-qualified EXDATE survive`() {
-        val standup = event("Team standup")
-        assertThat(standup.recurrenceRule).isEqualTo("FREQ=WEEKLY;BYDAY=TU")
-        assertThat(standup.exDates).containsExactly("20260929T080000Z")
-    }
-
-    @Test
-    fun `the moved occurrence is skipped rather than imported as a duplicate`() {
-        // Google writes a RECURRENCE-ID override as its own VEVENT carrying the
-        // master's UID. Importing it would put a second "standup" in the
-        // calendar; Calendula models no overrides, so it is reported instead.
-        assertThat(result.events.map { it.summary }).doesNotContain("Team standup (moved)")
-        assertThat(result.warnings).contains(IcsParseWarning.ModifiedOccurrenceSkipped)
-    }
-
-    @Test
-    fun `a folded DESCRIPTION is unfolded and unescaped`() {
-        assertThat(event("Team standup").description).isEqualTo(
-            "Weekly sync with the team.\nAgenda lives in the shared doc, see the link below.",
-        )
-    }
-
-    @Test
-    fun `an escaped comma in LOCATION comes back as a comma`() {
-        assertThat(event("Team standup").location).isEqualTo("Meeting room 2, 3rd floor")
-    }
-
-    @Test
-    fun `attendees are reported rather than silently dropped`() {
-        assertThat(result.warnings).contains(IcsParseWarning.AttendeesIgnored)
-    }
-
-    @Test
-    fun `a timed VALARM becomes its lead time in minutes`() {
-        assertThat(event("Team standup").semanticReminderMinutes()).containsExactly(30)
-    }
-
-    @Test
-    fun `an all-day event keeps the single day the file gives it`() {
-        val dayOff = event("Day off")
-        assertThat(dayOff.isAllDay).isTrue()
-        assertThat((dayOff.end - dayOff.start).inWholeDays).isEqualTo(1)
-        assertThat(dayOff.availability).isEqualTo(Availability.Free)
-    }
-
-    @Test
-    fun `an all-day alarm comes back as whole days before`() {
-        // Google writes an all-day reminder as a whole-day offset from the
-        // event's UTC midnight; a day has to survive as a day.
-        assertThat(event("Day off").semanticReminderMinutes()).containsExactly(1440)
-    }
-
-    @Test
-    fun `a multi-day all-day event keeps its exclusive DTEND span`() {
-        val christmas = event("Christmas break")
-        assertThat(christmas.isAllDay).isTrue()
-        assertThat((christmas.end - christmas.start).inWholeDays).isEqualTo(3)
-    }
-
-    @Test
-    fun `no recurrence rule is repaired - Google writes them well-formed`() {
-        assertThat(result.warnings).doesNotContain(IcsParseWarning.RecurrenceRuleRepaired)
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiStateTest.kt

@@ -1,90 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.calendars
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
-import org.junit.jupiter.api.Test
-
-/** What the Backup & restore screen offers for a given calendar list (#304). */
-class BackupUiStateTest {
-
-    private fun cal(
-        id: Long,
-        local: Boolean = false,
-        writable: Boolean = true,
-        visible: Boolean = true,
-        managed: Boolean = false,
-        syncs: Boolean = true,
-    ) = CalendarSource(
-        id = id,
-        displayName = "Calendar $id",
-        accountName = "acc@example.com",
-        accountType = if (local) "LOCAL" else "com.google",
-        color = 0,
-        isVisibleInSystem = visible,
-        canModifyContents = writable,
-        isLocal = local,
-        isManaged = managed,
-        syncsEvents = syncs,
-    )
-
-    private fun failure(state: BackupUiState) = (state as BackupUiState.Failure).reason
-
-    private fun ready(state: BackupUiState) = state as BackupUiState.Ready
-
-    @Test
-    fun `no calendars at all reports the empty device`() {
-        assertThat(failure(backupUiState(emptyList())))
-            .isEqualTo(FailureReason.NoCalendarsConfigured)
-    }
-
-    @Test
-    fun `a synced writable calendar can receive a restore`() {
-        val state = ready(backupUiState(listOf(cal(1L))))
-        assertThat(state.canImport).isTrue()
-        assertThat(state.exportable).isEmpty()
-    }
-
-    @Test
-    fun `the reported case - only a calendar that cannot take events`() {
-        // #304: a Google account with calendar sync switched off leaves nothing
-        // exportable and nothing importable, which used to render a blank screen.
-        assertThat(failure(backupUiState(listOf(cal(1L, syncs = false)))))
-            .isEqualTo(FailureReason.NoImportTarget)
-    }
-
-    @Test
-    fun `a read-only subscription is no import target either`() {
-        assertThat(failure(backupUiState(listOf(cal(1L, writable = false)))))
-            .isEqualTo(FailureReason.NoImportTarget)
-    }
-
-    @Test
-    fun `everything switched off is reported as hidden, not as a missing target`() {
-        // The remedy differs: a visibility switch fixes this one.
-        assertThat(failure(backupUiState(listOf(cal(1L, visible = false)))))
-            .isEqualTo(FailureReason.AllCalendarsHidden)
-    }
-
-    @Test
-    fun `a hidden local calendar still exports`() {
-        // Export reads the provider directly, so system visibility is irrelevant
-        // to it — calling this a failure would hide a working action.
-        val state = ready(backupUiState(listOf(cal(1L, local = true, visible = false))))
-        assertThat(state.exportable).hasSize(1)
-        assertThat(state.canImport).isFalse()
-    }
-
-    @Test
-    fun `a managed special-dates mirror is neither exportable nor a target`() {
-        assertThat(failure(backupUiState(listOf(cal(1L, local = true, managed = true)))))
-            .isEqualTo(FailureReason.NoImportTarget)
-    }
-
-    @Test
-    fun `a local calendar alongside a synced one offers both halves`() {
-        val state = ready(backupUiState(listOf(cal(1L, local = true), cal(2L))))
-        assertThat(state.exportable.map { it.id }).containsExactly(1L)
-        assertThat(state.canImport).isTrue()
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/TimelineZoomTest.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.dp
 import com.google.common.truth.Truth.assertThat
 import org.junit.jupiter.api.Test
@@ -75,17 +76,16 @@ class TimelineZoomTest {
     }
 
     @Test
-    fun `a pinch held against a fractional bound stays put`() {
-        // A bound that is not a whole pixel is a height the pinch can be pushed
-        // against but never land on, so every frame of a held gesture would look
-        // like a scale change and hand the focal anchor a scroll correction.
+    fun `a pinch held against either bound stays put`() {
         val fillPx = 62.083f
         val maxPx = 616.5f
 
         val floor = pinchedHourHeightPx(target = 1f, fillPx, maxPx)
         val ceiling = pinchedHourHeightPx(target = 9_000f, fillPx, maxPx)
 
-        assertThat(floor).isEqualTo(63f)
+        // The ceiling is pulled onto the pixel grid so it stays landable; the
+        // fill floor is landable as it is, being the clamp result itself.
+        assertThat(floor).isEqualTo(fillPx)
         assertThat(ceiling).isEqualTo(616f)
         // Landing there and being pushed further must not move them again.
         assertThat(pinchedHourHeightPx(floor * 0.9f, fillPx, maxPx)).isEqualTo(floor)
@@ -100,6 +100,35 @@ class TimelineZoomTest {
         assertThat(floor * 24).isAtLeast(viewport)
     }
 
+    @Test
+    fun `pinching all the way out leaves nothing to scroll`() {
+        // #290: rounding the fill floor up to a whole pixel made the day one
+        // pixel per hour taller than the viewport it was supposed to fill, so a
+        // fully zoomed-out timeline still scrolled a hair and bounced off
+        // Android's overscroll stretch -- while FitDay, at the same zoom, sat
+        // still. 1490 is deliberately not divisible by 24.
+        val viewport = 1490f
+        val floor = pinchedHourHeightPx(target = 1f, fillPx = viewport / 24f, maxPx = 616f)
+        assertThat(floor * 24).isWithin(0.01f).of(viewport)
+    }
+
+    @Test
+    fun `the pinch floor is the height FitDay resolves to`() {
+        // The inconsistency the issue is about: the two ways to reach "the whole
+        // day on one screen" have to arrive at the same height.
+        val density = Density(2.5f)
+        val viewport = 596.dp
+        with(density) {
+            val fitDay = TimelineScale.FitDay.hourHeight(viewport).toPx()
+            val pinched = pinchedHourHeightPx(
+                target = 1f,
+                fillPx = fillHourHeight(viewport).toPx(),
+                maxPx = MAX_PINCH_HOUR_HEIGHT.toPx(),
+            )
+            assertThat(pinched).isWithin(0.01f).of(fitDay)
+        }
+    }
+
     @Test
     fun `a settled pinch is what gets persisted`() {
         var persisted: TimelineScale? = null

app/src/test/resources/ics/google-calendar-export.ics

@@ -1,91 +0,0 @@
-BEGIN:VCALENDAR
-PRODID:-//Google Inc//Google Calendar 70.9054//EN
-VERSION:2.0
-CALSCALE:GREGORIAN
-METHOD:PUBLISH
-X-WR-CALNAME:jane@example.com
-X-WR-TIMEZONE:Europe/Berlin
-BEGIN:VTIMEZONE
-TZID:Europe/Berlin
-X-LIC-LOCATION:Europe/Berlin
-BEGIN:DAYLIGHT
-TZOFFSETFROM:+0100
-TZOFFSETTO:+0200
-TZNAME:CEST
-DTSTART:19700329T020000
-RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU
-END:DAYLIGHT
-BEGIN:STANDARD
-TZOFFSETFROM:+0200
-TZOFFSETTO:+0100
-TZNAME:CET
-DTSTART:19701025T030000
-RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU
-END:STANDARD
-END:VTIMEZONE
-BEGIN:VEVENT
-DTSTART;TZID=Europe/Berlin:20260915T100000
-DTEND;TZID=Europe/Berlin:20260915T113000
-RRULE:FREQ=WEEKLY;BYDAY=TU
-EXDATE;TZID=Europe/Berlin:20260929T100000
-DTSTAMP:20260912T183000Z
-UID:0abcdef1234567890abcdef12345@google.com
-CREATED:20260901T120000Z
-DESCRIPTION:Weekly sync with the team.\nAgenda lives in the shared doc\, see
-  the link below.
-LAST-MODIFIED:20260902T081500Z
-LOCATION:Meeting room 2\, 3rd floor
-SEQUENCE:0
-STATUS:CONFIRMED
-SUMMARY:Team standup
-TRANSP:OPAQUE
-ORGANIZER;CN=Jane Doe:mailto:jane@example.com
-ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;CN=John:m
- ailto:john@example.com
-BEGIN:VALARM
-ACTION:DISPLAY
-DESCRIPTION:This is an event reminder
-TRIGGER:-PT30M
-END:VALARM
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;TZID=Europe/Berlin:20260929T140000
-DTEND;TZID=Europe/Berlin:20260929T153000
-DTSTAMP:20260912T183000Z
-UID:0abcdef1234567890abcdef12345@google.com
-RECURRENCE-ID;TZID=Europe/Berlin:20260929T100000
-CREATED:20260901T120000Z
-LAST-MODIFIED:20260910T091500Z
-SEQUENCE:1
-STATUS:CONFIRMED
-SUMMARY:Team standup (moved)
-TRANSP:OPAQUE
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;VALUE=DATE:20261024
-DTEND;VALUE=DATE:20261025
-DTSTAMP:20260912T183000Z
-UID:1bcdef01234567890abcdef23456@google.com
-CREATED:20260820T101500Z
-LAST-MODIFIED:20260820T101500Z
-SEQUENCE:0
-STATUS:CONFIRMED
-SUMMARY:Day off
-TRANSP:TRANSPARENT
-BEGIN:VALARM
-ACTION:DISPLAY
-DESCRIPTION:This is an event reminder
-TRIGGER:-P1D
-END:VALARM
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;VALUE=DATE:20261224
-DTEND;VALUE=DATE:20261227
-DTSTAMP:20260912T183000Z
-UID:2cdef012345678901abcdef34567@google.com
-SEQUENCE:0
-STATUS:CONFIRMED
-SUMMARY:Christmas break
-TRANSP:TRANSPARENT
-END:VEVENT
-END:VCALENDAR