Translated using Weblate (French)

Currently translated at 52.8% (231 of 437 strings)

Translation: Calendula/Strings
Translate-URL: https://weblate.dev.jeanlucmakiola.de/projects/calendula/strings/fr/

CHANGELOG.md

@@ -5,82 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
-
-### Added
-- Choose how the month view is laid out. A new **Month view style** setting
-  (Settings → Views) offers three ways to read a month, each shown with a
-  preview of the layout it produces:
-  - **Pages** — what you have today: one month at a time, swiped sideways.
-  - **Continuous** — scroll up and down through the weeks without a break
-    between months. Because the weeks run on unbroken, no month is cut off and
-    no day appears twice, where paging repeats a boundary week at the end of one
-    month and the start of the next. The 1st of each month names itself so you
-    always know where you are, and the title bar keeps up as you scroll ([#38]).
-  - **Split** — a compact grid showing coloured dots for the days that have
-    something on them, with the day you tap listed in full underneath. Tap the
-    date above the list to open the whole day ([#53]).
-
-  The Agenda view is untouched by this and stays available in all three styles —
-  the split layout lists a single day, while Agenda remains a rolling multi-day
-  window with its own range settings.
-
-### Fixed
-- The "Upcoming" agenda widget now scales its text and rows to the size you give
-  it. Previously it was laid out once for the smallest size and simply stretched
-  when enlarged, so the text stayed small no matter how big you made the widget.
-  Now a bigger widget gets bigger, more readable type and roomier rows, while the
-  default size looks exactly as before — no new setting; it follows the size you
-  already chose ([#51]).
-
-## [2.16.0] — 2026-07-17
-
-### Added
-- Give an event its own time zone. A new **Time zone** field (under "more
-  fields" in the event form) pins an event to a specific zone, so a call set for
-  8:00 AM in New York stays 8:00 AM in New York wherever you open it — and keeps
-  tracking that zone across daylight-saving changes instead of drifting an hour.
-  The form edits the event in its own zone and shows the local equivalent under
-  the times ("2:00 PM – 3:00 PM your time"); the event's details keep your local
-  time first and note the original beneath it, so both are always clear. Pick a
-  zone from a full-screen picker with your device zone and recent choices on top,
-  searching by city ("new york"), IANA id ("europe/berlin"), or abbreviation
-  ("CEST") to gather every matching zone at once. All-day events stay
-  date-anchored and carry no zone, as before ([#31]).
-- Put the "jump to today" button in the toolbar. A new **Today button in
-  toolbar** setting (Settings → Appearance, off by default) swaps the floating
-  button that fades into the corner while you're away from today for a permanent
-  today icon in the top bar — always there, on today or not, matching the
-  familiar calendar-app pattern. Leave it off to keep the floating button as
-  before ([#60]).
-
-### Changed
-- Dates in the Month, Week and Day title bars now follow your language and
-  region instead of one hardcoded layout. Every date was rendered in a fixed
-  German-style order with a trailing dot on the day number, whatever your
-  settings: US English showed "Fri, 17. Jul 2026" where it should read
-  "Fri, Jul 17". The Agenda view already formatted correctly, so the two
-  disagreed about the same date. All four views now share one formatter, and the
-  day/month order, the separators and the ordinal all come from your locale —
-  so English-in-Germany reads "Fri, 17 Jul" and English-in-the-US "Fri, Jul 17",
-  each correct for where you are ([#60]).
-- The title bar drops the year while you're in the current one — "July" rather
-  than "July 2026". The year reappears the moment you page out of the current
-  year, which is when it tells you something you didn't already know.
-- The Week view's title now names the month instead of spelling out the day range.
-  "24. Jun – 31. Jun" restated the day numbers already printed in the column
-  headers right below it, in the widest string in the bar. A week that straddles
-  two months keeps the outgoing month until it is fully gone ([#60]).
-
-### Fixed
-- An all-day event no longer shows up again the day after it happened. In time
-  zones east of UTC, an all-day event — a birthday, say — set for one day also
-  appeared under the *next* day's heading in the Agenda (and the agenda widget),
-  because all-day events are anchored to UTC midnight and the following day's
-  window reached back across that boundary and pulled the event forward onto
-  "today". Each all-day event now lists only on the day it actually falls on
-  ([#65]).
-
 ## [2.15.0] — 2026-07-15
 
 ### Added
@@ -1060,7 +984,6 @@ automatically, with zero telemetry and no internet permission.
 [#29]: https://codeberg.org/jlmakiola/calendula/issues/29
 [#21]: https://codeberg.org/jlmakiola/calendula/issues/21
 [#30]: https://codeberg.org/jlmakiola/calendula/issues/30
-[#31]: https://codeberg.org/jlmakiola/calendula/issues/31
 [#32]: https://codeberg.org/jlmakiola/calendula/issues/32
 [#33]: https://codeberg.org/jlmakiola/calendula/issues/33
 [#34]: https://codeberg.org/jlmakiola/calendula/issues/34
@@ -1073,9 +996,4 @@ automatically, with zero telemetry and no internet permission.
 [#47]: https://codeberg.org/jlmakiola/calendula/issues/47
 [#48]: https://codeberg.org/jlmakiola/calendula/issues/48
 [#49]: https://codeberg.org/jlmakiola/calendula/issues/49
-[#51]: https://codeberg.org/jlmakiola/calendula/issues/51
 [#52]: https://codeberg.org/jlmakiola/calendula/issues/52
-[#38]: https://codeberg.org/jlmakiola/calendula/issues/38
-[#53]: https://codeberg.org/jlmakiola/calendula/issues/53
-[#60]: https://codeberg.org/jlmakiola/calendula/issues/60
-[#65]: https://codeberg.org/jlmakiola/calendula/issues/65

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 = 21600
-        versionName = "2.16.0"
+        versionCode = 21500
+        versionName = "2.15.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/androidTest/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositorySmokeTest.kt

@@ -9,7 +9,6 @@ import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.rule.GrantPermissionRule
 import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
-import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.runBlocking
@@ -32,12 +31,7 @@ class CalendarRepositorySmokeTest {
         val store: DataStore<Preferences> = PreferenceDataStoreFactory.create(
             produceFile = { context.cacheDir.resolve("smoke_test_prefs.preferences_pb") },
         )
-        return CalendarRepositoryImpl(
-            dataSource,
-            CalendarPrefs(store),
-            SettingsPrefs(store),
-            Dispatchers.IO,
-        )
+        return CalendarRepositoryImpl(dataSource, CalendarPrefs(store), Dispatchers.IO)
     }
 
     @Test

app/src/main/AndroidManifest.xml

@@ -63,9 +63,10 @@
             android:exported="true"
             android:launchMode="singleTop"
             android:windowSoftInputMode="adjustResize">
-            <!-- The MAIN/LAUNCHER entry (the launcher icon + its label) lives on
-                 the two <activity-alias> below, so the app name can be switched at
-                 runtime (issue #44). MainActivity keeps every other filter. -->
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
 
             <!-- Be selectable as the system calendar app. Android has no API for
                  an app to make itself the default, so registering the filters
@@ -164,48 +165,12 @@
                 <data android:mimeType="vnd.android.cursor.item/event" />
             </intent-filter>
 
+            <!-- Launcher long-press shortcuts (e.g. "New event"). -->
+            <meta-data
+                android:name="android.app.shortcuts"
+                android:resource="@xml/shortcuts" />
         </activity>
 
-        <!-- Launcher entry for MainActivity, split into two aliases so the app's
-             launcher name can be switched at runtime between "Calendula" and
-             "Calendar" (issue #44). Exactly one is enabled at a time; the app
-             flips them via PackageManager.setComponentEnabledSetting
-             (LauncherNameManager). The shortcuts meta-data lives here, not on
-             MainActivity, because static shortcuts are published by whichever
-             component owns the MAIN/LAUNCHER filter. -->
-        <activity-alias
-            android:name=".DefaultNameAlias"
-            android:enabled="true"
-            android:exported="true"
-            android:icon="@mipmap/ic_launcher"
-            android:label="@string/app_name"
-            android:roundIcon="@mipmap/ic_launcher_round"
-            android:targetActivity=".MainActivity">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-            <meta-data
-                android:name="android.app.shortcuts"
-                android:resource="@xml/shortcuts" />
-        </activity-alias>
-        <activity-alias
-            android:name=".CalendarNameAlias"
-            android:enabled="false"
-            android:exported="true"
-            android:icon="@mipmap/ic_launcher"
-            android:label="@string/app_name_calendar_alias"
-            android:roundIcon="@mipmap/ic_launcher_round"
-            android:targetActivity=".MainActivity">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-            <meta-data
-                android:name="android.app.shortcuts"
-                android:resource="@xml/shortcuts" />
-        </activity-alias>
-
         <!-- Standalone surface for a captured crash report. MainActivity routes
              here on a startup crash-loop, so it stays clear of the app's Hilt
              graph and Compose content. Not exported: launched only by us. -->

app/src/main/java/de/jeanlucmakiola/calendula/data/appname/LauncherNameManager.kt

@@ -1,109 +0,0 @@
-package de.jeanlucmakiola.calendula.data.appname
-
-import android.content.ComponentName
-import android.content.Context
-import android.content.pm.PackageManager
-import dagger.hilt.android.qualifiers.ApplicationContext
-import javax.inject.Inject
-import javax.inject.Singleton
-
-/** The launcher label the app shows for itself (issue #44). */
-enum class LauncherName { CALENDULA, CALENDAR }
-
-/** The two launcher aliases declared in the manifest. */
-enum class LauncherAlias { DEFAULT, CALENDAR }
-
-/** One component-enable change in a [aliasWritePlan]. */
-data class AliasStateChange(val alias: LauncherAlias, val enabled: Boolean)
-
-/**
- * Interpret the `CalendarNameAlias` component-enabled state as a [LauncherName].
- * Only [PackageManager.COMPONENT_ENABLED_STATE_ENABLED] means the "Calendar"
- * name is active; `DEFAULT` (never toggled) and `DISABLED` both resolve to the
- * manifest default, "Calendula".
- */
-fun launcherNameFor(calendarAliasState: Int): LauncherName =
-    if (calendarAliasState == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
-        LauncherName.CALENDAR
-    } else {
-        LauncherName.CALENDULA
-    }
-
-/**
- * The ordered enable/disable steps to switch the launcher name to [target].
- * Always **enables the target alias first, then disables the other** — the two
- * `setComponentEnabledSetting` calls are not atomic, and this ordering means the
- * only transient the launcher can observe is a harmless two-entry state, never a
- * zero-entry one (which would briefly drop the app from the launcher).
- */
-fun aliasWritePlan(target: LauncherName): List<AliasStateChange> = when (target) {
-    LauncherName.CALENDAR -> listOf(
-        AliasStateChange(LauncherAlias.CALENDAR, enabled = true),
-        AliasStateChange(LauncherAlias.DEFAULT, enabled = false),
-    )
-    LauncherName.CALENDULA -> listOf(
-        AliasStateChange(LauncherAlias.DEFAULT, enabled = true),
-        AliasStateChange(LauncherAlias.CALENDAR, enabled = false),
-    )
-}
-
-/**
- * Switches the app's launcher label between "Calendula" and "Calendar" by
- * enabling/disabling the two `<activity-alias>` components (issue #44). The
- * component-enabled state is the single source of truth — there is no persisted
- * preference — so [current] reads it straight from [PackageManager] and the two
- * always agree.
- *
- * The decision logic lives in the pure [launcherNameFor] / [aliasWritePlan]
- * functions above (JVM-tested); this class is only the thin framework seam.
- */
-@Singleton
-class LauncherNameManager @Inject constructor(
-    @ApplicationContext private val context: Context,
-) {
-    private val packageManager: PackageManager get() = context.packageManager
-
-    // The class portion is namespace-qualified (suffix-free), the package portion
-    // is the applicationId (which carries the .debug / .releasetest suffix). The
-    // manifest's ".CalendarNameAlias" resolves its class against the namespace, so
-    // the real component is <namespace>.CalendarNameAlias registered under the
-    // suffixed applicationId. Do NOT use ComponentName(context, ".CalendarNameAlias")
-    // — its leading-dot form prepends the applicationId to the class too, producing
-    // "<appId>.CalendarNameAlias" and failing on every debug / releaseTest build.
-    private fun component(alias: LauncherAlias): ComponentName {
-        val simpleName = when (alias) {
-            LauncherAlias.DEFAULT -> "DefaultNameAlias"
-            LauncherAlias.CALENDAR -> "CalendarNameAlias"
-        }
-        return ComponentName(context.packageName, "$NAMESPACE.$simpleName")
-    }
-
-    /** The launcher name currently in effect. */
-    fun current(): LauncherName =
-        launcherNameFor(packageManager.getComponentEnabledSetting(component(LauncherAlias.CALENDAR)))
-
-    /** Switch the launcher name to [name] (no-op cost if already active). */
-    fun set(name: LauncherName) {
-        for (change in aliasWritePlan(name)) {
-            val state = if (change.enabled) {
-                PackageManager.COMPONENT_ENABLED_STATE_ENABLED
-            } else {
-                PackageManager.COMPONENT_ENABLED_STATE_DISABLED
-            }
-            packageManager.setComponentEnabledSetting(
-                component(change.alias),
-                state,
-                PackageManager.DONT_KILL_APP,
-            )
-        }
-    }
-
-    private companion object {
-        /**
-         * The app's namespace (R-class package) — NOT `applicationId`, which
-         * carries the build-type suffix. Kept in sync with `namespace` in
-         * `app/build.gradle.kts`.
-         */
-        const val NAMESPACE = "de.jeanlucmakiola.calendula"
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt

@@ -6,11 +6,9 @@ import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventForm
 import kotlinx.datetime.toJavaLocalDate
 import kotlinx.datetime.toJavaLocalDateTime
-import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
 import java.time.ZoneOffset
-import java.time.LocalDateTime as JavaLocalDateTime
 
 /** Provider-ready DTSTART / DTEND / EVENT_TIMEZONE for an event write. */
 internal data class EventWriteTimes(
@@ -22,11 +20,7 @@ internal data class EventWriteTimes(
 /**
  * All-day events live at UTC midnights with an exclusive DTEND (the
  * CalendarContract convention — a one-day event ends at the next midnight);
- * timed events resolve their wall-clock values in the form's own
- * [EventForm.timezone], falling back to [zone] (the device) when it doesn't pin
- * one. Passing the device zone is therefore still correct for an unpinned form —
- * but it no longer overrides a pinned event's zone, which is what used to
- * silently re-anchor a foreign-zone event to the device on any time edit.
+ * timed events resolve their wall-clock values in [zone].
  */
 internal fun EventForm.toWriteTimes(zone: ZoneId): EventWriteTimes = if (isAllDay) {
     EventWriteTimes(
@@ -37,38 +31,13 @@ internal fun EventForm.toWriteTimes(zone: ZoneId): EventWriteTimes = if (isAllDa
         timezone = "UTC",
     )
 } else {
-    val writeZone = writeZone(zone)
     EventWriteTimes(
-        dtStartMillis = start.toJavaLocalDateTime().atZone(writeZone).toInstant().toEpochMilli(),
-        dtEndMillis = end.toJavaLocalDateTime().atZone(writeZone).toInstant().toEpochMilli(),
-        timezone = writeZone.id,
+        dtStartMillis = start.toJavaLocalDateTime().atZone(zone).toInstant().toEpochMilli(),
+        dtEndMillis = end.toJavaLocalDateTime().atZone(zone).toInstant().toEpochMilli(),
+        timezone = zone.id,
     )
 }
 
-/**
- * The zone this form's DTSTART is expressed in: UTC for an all-day event (the
- * provider's date anchor), otherwise the form's own pinned zone, falling back to
- * [deviceZone] when it doesn't pin one or pins something the tz database can't
- * parse.
- */
-private fun EventForm.writeZone(deviceZone: ZoneId): ZoneId = if (isAllDay) {
-    ZoneOffset.UTC
-} else {
-    timezone?.let { runCatching { ZoneId.of(it) }.getOrNull() } ?: deviceZone
-}
-
-/**
- * The form's start as a bare wall-clock value — what the user sees on the form,
- * stripped of any zone. All-day events use their date's midnight rather than
- * [EventForm.start]'s placeholder time-of-day, which exists only so switching the
- * event back to timed has something to show.
- */
-private fun EventForm.anchorLocal(): JavaLocalDateTime = if (isAllDay) {
-    start.date.toJavaLocalDate().atStartOfDay()
-} else {
-    start.toJavaLocalDateTime()
-}
-
 /**
  * RFC 2445 duration for a recurring event's row (the provider requires
  * DURATION instead of DTEND when an RRULE is set): whole days for all-day
@@ -135,12 +104,10 @@ internal fun buildEventInsertValues(
  * Time fields travel together (the provider validates them as a unit):
  * - unchanged times, all-day flag and rrule → no time columns at all;
  * - non-recurring result → DTSTART/DTEND, DURATION and RRULE cleared;
- * - recurring result → the *series* DTSTART moves by the same **wall-clock**
- *   shift the user applied to the displayed occurrence and is re-resolved in the
- *   event's zone ([seriesDtStartMillis] is the row's current DTSTART), DURATION
- *   replaces DTEND, RRULE is written. This keeps past occurrences intact when
- *   someone edits a later occurrence's time, and keeps the anchor's time-of-day
- *   stable across a DST boundary or a zone change between the two.
+ * - recurring result → the *series* DTSTART moves by the same delta the user
+ *   applied to the displayed occurrence ([seriesDtStartMillis] is the row's
+ *   current DTSTART), DURATION replaces DTEND, RRULE is written. This keeps
+ *   past occurrences intact when someone edits a later occurrence's time.
  */
 internal fun buildEventUpdateValues(
     original: EventForm,
@@ -167,14 +134,10 @@ internal fun buildEventUpdateValues(
         putAll(eventColorColumns(updated.colorKey, updated.color))
     }
 
-    // A zone change counts as a time change even when the wall-clock is
-    // untouched: the same 09:00 in another zone is a different instant, so
-    // DTSTART has to move with it.
     val timesChanged = updated.start != original.start ||
         updated.end != original.end ||
         updated.isAllDay != original.isAllDay ||
-        updated.rrule != original.rrule ||
-        updated.timezone != original.timezone
+        updated.rrule != original.rrule
     if (!timesChanged) return@buildMap
 
     val newTimes = updated.toWriteTimes(zone)
@@ -186,23 +149,8 @@ internal fun buildEventUpdateValues(
         put(CalendarContract.Events.RRULE, null)
         put(CalendarContract.Events.DURATION, null)
     } else {
-        // Move the series anchor by the *wall-clock* shift the user applied to the
-        // displayed occurrence, then re-resolve it in the event's (possibly new)
-        // zone — never by a millisecond delta. An instant delta silently bakes in
-        // the offset that happened to apply on the edited occurrence's date, which
-        // is a different offset from the series anchor's whenever a DST boundary
-        // sits between them, or whenever the zone itself changed. Working in wall
-        // clock keeps "09:00" meaning 09:00 at both ends.
-        val seriesLocal = Instant.ofEpochMilli(seriesDtStartMillis)
-            .atZone(original.writeZone(zone)).toLocalDateTime()
-        val wallClockShift = Duration.between(original.anchorLocal(), updated.anchorLocal())
-        val shifted = seriesLocal.plus(wallClockShift)
-        // An all-day series anchor must sit on a UTC midnight. A pure day move
-        // already lands there (both ends are midnights), but *switching* a
-        // recurring event to all-day shifts by a time-of-day too, so snap.
-        val newSeriesLocal = if (updated.isAllDay) shifted.toLocalDate().atStartOfDay() else shifted
-        val newSeriesStart = newSeriesLocal.atZone(updated.writeZone(zone))
-        put(CalendarContract.Events.DTSTART, newSeriesStart.toInstant().toEpochMilli())
+        val startDelta = newTimes.dtStartMillis - original.toWriteTimes(zone).dtStartMillis
+        put(CalendarContract.Events.DTSTART, seriesDtStartMillis + startDelta)
         put(CalendarContract.Events.DTEND, null)
         put(CalendarContract.Events.RRULE, updated.rrule)
         put(CalendarContract.Events.DURATION, newTimes.toRfc2445Duration(updated.isAllDay))

app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt

@@ -21,15 +21,9 @@ import de.jeanlucmakiola.calendula.ui.agenda.storageValue
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.calendula.ui.theme.FONT_SYSTEM_TOKEN
-import java.time.ZoneId
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.DayOfWeek
 import java.time.temporal.WeekFields
 import java.util.Locale
@@ -87,24 +81,6 @@ fun WeekStartPref.resolveFirstDay(locale: Locale): DayOfWeek = when (this) {
     WeekStartPref.Auto -> DayOfWeek(WeekFields.of(locale).firstDayOfWeek.value)
 }
 
-/**
- * The resolved first day of the week as a hot [StateFlow] — the one shape every
- * screen that orders or lays out weekdays should use (the month grid, the agenda
- * "this week" range, the recurrence weekday toggles). Sharing it keeps the
- * initial-frame value identical everywhere; hand-rolled copies had drifted onto
- * different `initialValue`s, so two surfaces could disagree for a frame.
- */
-fun SettingsPrefs.firstDayOfWeek(scope: CoroutineScope): StateFlow<DayOfWeek> =
-    weekStart
-        .map { it.resolveFirstDay(Locale.getDefault()) }
-        .stateIn(
-            scope = scope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            // Seed with the locale convention rather than a hardcoded weekday, so
-            // the first frame is already right for everyone still on Auto.
-            initialValue = WeekStartPref.Auto.resolveFirstDay(Locale.getDefault()),
-        )
-
 /**
  * Display settings (M4) persisted app-side: theme override, Material You
  * dynamic colour, and week start. Language is handled separately through
@@ -257,33 +233,6 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[SHOW_WEEK_NUMBERS_KEY] = enabled }
     }
 
-    /**
-     * How the Month view lays itself out (#38, #53). Defaults to [MonthViewStyle.Paged]
-     * — the historical behaviour, so existing installs see no change until they opt in.
-     */
-    val monthViewStyle: Flow<MonthViewStyle> = store.data.map { prefs ->
-        prefs[MONTH_VIEW_STYLE_KEY].toEnum(MonthViewStyle.Paged)
-    }
-
-    suspend fun setMonthViewStyle(style: MonthViewStyle) {
-        store.edit { it[MONTH_VIEW_STYLE_KEY] = style.name }
-    }
-
-    /**
-     * Where the jump-to-today control lives (issue #60). Default OFF — the
-     * historical layout, where it's an extended FAB that fades in above the "+"
-     * only while the view is off today. Turning it ON moves it to a persistent
-     * icon button in each calendar view's top bar (always shown, on today or
-     * not) and drops the FAB pill.
-     */
-    val todayButtonInToolbar: Flow<Boolean> = store.data.map { prefs ->
-        prefs[TODAY_BUTTON_IN_TOOLBAR_KEY] ?: false
-    }
-
-    suspend fun setTodayButtonInToolbar(enabled: Boolean) {
-        store.edit { it[TODAY_BUTTON_IN_TOOLBAR_KEY] = enabled }
-    }
-
     /**
      * How far ahead the in-app Agenda screen shows events (v2.11). Defaults to
      * [AgendaRange.Month] — a month of upcoming events. Independent of the
@@ -405,26 +354,6 @@ class SettingsPrefs @Inject constructor(
         }
     }
 
-    /**
-     * Zones the user picked recently, most recent first — the timezone picker's
-     * default list, since scrolling ~600 zones to re-find the two you actually
-     * use is the whole problem. Stored comma-joined (IANA ids never contain a
-     * comma); unparseable ids are dropped on read, so a zone the tz database
-     * later retires can't wedge the list.
-     */
-    val recentTimeZones: Flow<List<String>> = store.data.map { prefs ->
-        parseRecentTimeZones(prefs[RECENT_TIMEZONES_KEY])
-    }
-
-    suspend fun addRecentTimeZone(zoneId: String) {
-        store.edit { prefs ->
-            val updated = (listOf(zoneId) + parseRecentTimeZones(prefs[RECENT_TIMEZONES_KEY]))
-                .distinct()
-                .take(MAX_RECENT_TIME_ZONES)
-            prefs[RECENT_TIMEZONES_KEY] = updated.joinToString(",")
-        }
-    }
-
     /**
      * Whether opening the new-event form focuses the title field and raises the
      * keyboard straight away (issue #10). Default ON — a new event almost always
@@ -721,13 +650,6 @@ class SettingsPrefs @Inject constructor(
     private fun titleTemplateKey(type: SpecialDateType) =
         stringPreferencesKey("special_dates_title_${type.name}")
 
-    private fun parseRecentTimeZones(stored: String?): List<String> =
-        stored?.split(',').orEmpty()
-            .map { it.trim() }
-            .filter { it.isNotEmpty() && runCatching { ZoneId.of(it) }.isSuccess }
-            .distinct()
-            .take(MAX_RECENT_TIME_ZONES)
-
     private fun parseFormFields(stored: String?): Set<EventFormField> = when (stored) {
         null -> DEFAULT_FORM_FIELDS
         else -> stored.split(',')
@@ -788,8 +710,6 @@ class SettingsPrefs @Inject constructor(
         internal val PAST_EVENT_DISPLAY_KEY = stringPreferencesKey("agenda_past_event_display")
         internal val DIM_COMPLETED_EVENTS_KEY = booleanPreferencesKey("dim_completed_events")
         internal val SHOW_WEEK_NUMBERS_KEY = booleanPreferencesKey("show_week_numbers")
-        internal val MONTH_VIEW_STYLE_KEY = stringPreferencesKey("month_view_style")
-        internal val TODAY_BUTTON_IN_TOOLBAR_KEY = booleanPreferencesKey("today_button_in_toolbar")
         internal val DEFAULT_VIEW_KEY = stringPreferencesKey("default_view")
         internal val QUICK_SWITCH_VIEWS_KEY = stringPreferencesKey("quick_switch_views")
         internal val DRAWER_VIEW_ORDER_KEY = stringPreferencesKey("drawer_view_order")
@@ -816,10 +736,6 @@ class SettingsPrefs @Inject constructor(
             stringPreferencesKey("per_calendar_allday_reminder_override")
         internal val DEFAULT_FORM_FIELDS =
             setOf(EventFormField.Location, EventFormField.Description)
-        internal val RECENT_TIMEZONES_KEY = stringPreferencesKey("recent_time_zones")
-
-        /** Enough to cover the zones a user actually recurs to, without a wall of rows. */
-        internal const val MAX_RECENT_TIME_ZONES = 5
         internal val AUTO_BACKUP_ENABLED_KEY = booleanPreferencesKey("auto_backup_enabled")
         internal val AUTO_BACKUP_INTERVAL_KEY = longPreferencesKey("auto_backup_interval_minutes")
         internal val AUTO_BACKUP_FOLDER_KEY = stringPreferencesKey("auto_backup_folder_uri")

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

@@ -4,14 +4,13 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
 
 /**
  * User input for creating an event (and, from v1.3, editing one). Times are
- * wall-clock values in [timezone]; the data layer translates them to provider
- * millis (all-day events normalise to UTC midnights there).
+ * wall-clock values in the device zone; the data layer translates them to
+ * provider millis (all-day events normalise to UTC midnights there).
  */
 data class EventForm(
     val calendarId: Long?,
@@ -19,23 +18,6 @@ data class EventForm(
     val isAllDay: Boolean = false,
     val start: LocalDateTime,
     val end: LocalDateTime,
-    /**
-     * The zone [start]/[end] are wall-clock values in, or null to follow the
-     * device — null is not "no zone", it is "whichever zone the device is in
-     * when this is saved", which is what an event authored and lived in one
-     * place wants. The data layer resolves it at write time and always stamps a
-     * concrete `EVENT_TIMEZONE`.
-     *
-     * A non-null value pins the event to a zone regardless of where the device
-     * is, so it keeps tracking that zone's offset across DST. [toEditForm] only
-     * sets it when the stored zone differs from the device's, so merely opening
-     * a local event never reveals the field — and re-opening a pinned one in
-     * another zone round-trips it rather than silently re-anchoring it.
-     *
-     * Always null for all-day events: those are date-anchored, not zone-anchored
-     * (see [EventFormField.Timezone] and the data layer's UTC-midnight rule).
-     */
-    val timezone: String? = null,
     val location: String = "",
     val description: String = "",
     /** Reminder lead times in minutes before the start, deduplicated. */
@@ -84,19 +66,11 @@ data class EventAttendee(
 
 /**
  * The form's optional sections. Which ones show by default is a user setting;
- * the rest unfold behind a "more fields" button. Declaration order is the order
- * they're offered in, so a new constant goes where it belongs on the form, not
- * at the end.
+ * the rest unfold behind a "more fields" button.
  */
 enum class EventFormField {
     Location,
     Description,
-    /**
-     * Pins the event's wall-clock times to a zone. Offered right after the time
-     * fields it qualifies, and suppressed entirely for all-day events, whose
-     * dates are deliberately zone-free.
-     */
-    Timezone,
     Reminders,
     Recurrence,
     Availability,
@@ -126,25 +100,8 @@ enum class EventFormProblem {
  * All-day provider times are UTC midnights with an exclusive end; the form
  * shows the last covered day and keeps placeholder wall-clock times in case
  * the user switches the event to timed.
- *
- * A timed event stored in a zone other than [zone] is prefilled *in its own
- * zone* and keeps it pinned, so the wall-clock the form shows is the one the
- * event means ("the New York 09:00 call") and a later save re-anchors it to the
- * same zone rather than the device's.
  */
 fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone): EventForm {
-    // All-day events are date-anchored and carry a nominal "UTC" that is an
-    // anchor, not a location, so they never pin a zone.
-    val pinnedZone = if (instance.isAllDay) {
-        null
-    } else {
-        eventTimezone
-            ?.takeIf { it != zone.id }
-            // An unparseable id (a malformed sync row) can't be honoured or
-            // shown; fall back to the device zone rather than failing the open.
-            ?.takeIf { runCatching { TimeZone.of(it) }.isSuccess }
-    }
-    val formZone = pinnedZone?.let { TimeZone.of(it) } ?: zone
     val (start, end) = if (instance.isAllDay) {
         val startDate = Instant.fromEpochMilliseconds(beginMillis)
             .toLocalDateTime(TimeZone.UTC).date
@@ -153,8 +110,8 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
         val endDate = maxOf(startDate, LocalDate.fromEpochDays(endExclusive.toEpochDays() - 1))
         LocalDateTime(startDate, LocalTime(9, 0)) to LocalDateTime(endDate, LocalTime(10, 0))
     } else {
-        Instant.fromEpochMilliseconds(beginMillis).toLocalDateTime(formZone) to
-            Instant.fromEpochMilliseconds(endMillis).toLocalDateTime(formZone)
+        Instant.fromEpochMilliseconds(beginMillis).toLocalDateTime(zone) to
+            Instant.fromEpochMilliseconds(endMillis).toLocalDateTime(zone)
     }
     return EventForm(
         calendarId = instance.calendarId,
@@ -162,7 +119,6 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
         isAllDay = instance.isAllDay,
         start = start,
         end = end,
-        timezone = pinnedZone,
         location = instance.location.orEmpty(),
         description = description.orEmpty(),
         reminders = reminders.map { it.minutes }.distinct().sorted(),
@@ -220,23 +176,6 @@ fun EventDetail.toEditSnapshot(beginMillis: Long, endMillis: Long, zone: TimeZon
         rowEnd = instance.end,
     )
 
-/**
- * The form's times as they land in [target] — what a pinned event's wall-clock
- * actually means where the user is standing. Null when there's nothing to
- * disambiguate: an unpinned event (already in [target]), one pinned to [target]
- * itself, an all-day event (no zone), or an unparseable pinned zone.
- *
- * The form edits a pinned event in its own zone, so this is what lets the UI
- * show the other side of the pair rather than making the user do the arithmetic.
- */
-fun EventForm.timesIn(target: TimeZone): Pair<LocalDateTime, LocalDateTime>? {
-    if (isAllDay) return null
-    val pinned = timezone?.let { runCatching { TimeZone.of(it) }.getOrNull() } ?: return null
-    if (pinned.id == target.id) return null
-    return start.toInstant(pinned).toLocalDateTime(target) to
-        end.toInstant(pinned).toLocalDateTime(target)
-}
-
 /**
  * The optional sections that hold a value in [form] — when editing, these
  * must be visible regardless of the user's default-fields setting, or the
@@ -245,7 +184,6 @@ fun EventForm.timesIn(target: TimeZone): Pair<LocalDateTime, LocalDateTime>? {
 fun EventForm.populatedFields(): Set<EventFormField> = buildSet {
     if (location.isNotBlank()) add(EventFormField.Location)
     if (description.isNotBlank()) add(EventFormField.Description)
-    if (timezone != null) add(EventFormField.Timezone)
     if (reminders.isNotEmpty()) add(EventFormField.Reminders)
     if (rrule != null) add(EventFormField.Recurrence)
     if (availability != Availability.Busy) add(EventFormField.Availability)

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

@@ -1,225 +0,0 @@
-package de.jeanlucmakiola.calendula.domain
-
-import java.text.Normalizer
-import java.time.Instant
-import java.time.ZoneId
-import java.time.format.TextStyle
-import java.util.Locale
-
-/**
- * One selectable zone, resolved for display at a given instant. [id] is the IANA
- * id we store in `EVENT_TIMEZONE` and show as the primary label (via [label]);
- * [shortName] its abbreviation ("CET", "WET", "UTC", or a "GMT+05:30" fallback);
- * [offsetMinutes] its offset. Both the abbreviation and the offset shift with
- * DST, so they're only meaningful next to the moment they were resolved for.
- *
- * [displayName] is the long localized name ("Central European Time"). It's kept
- * for search only — matching on it lets someone type "pacific" — and is *not*
- * displayed: spelled out next to the id it made the field too wide to fit.
- */
-data class TimeZoneOption(
-    val id: String,
-    val displayName: String,
-    val shortName: String,
-    val offsetMinutes: Int,
-) {
-    /** The id as the primary label, underscores undone ("America/New York"). */
-    val label: String get() = id.replace('_', ' ')
-
-    /** The trailing segment of the id ("Europe/Berlin" -> "Berlin"), underscores undone. */
-    val city: String get() = id.substringAfterLast('/').replace('_', ' ')
-
-    /** The leading segment ("Europe/Berlin" -> "Europe"); empty for bare ids like "UTC". */
-    val region: String get() = id.substringBeforeLast('/', missingDelimiterValue = "")
-
-    /**
-     * The four fields [filterTimeZones] matches on, normalized once here rather
-     * than per query. Normalizing is not cheap — NFD decomposition plus a combining-
-     * mark strip — and a search re-examines every option on every keystroke, so
-     * doing it at construction turns ~2400 normalizations per character into a few
-     * hundred plain `startsWith`/`contains` calls.
-     *
-     * Declared in the class body, so it stays out of `equals`/`hashCode`/`copy`:
-     * it is derived state, and two options with the same id are the same option.
-     */
-    internal val searchKeys: TimeZoneSearchKeys = TimeZoneSearchKeys(
-        city = city.normalizeForSearch(),
-        id = id.normalizeForSearch(),
-        displayName = displayName.normalizeForSearch(),
-        shortName = shortName.normalizeForSearch(),
-    )
-}
-
-/** Pre-normalized match targets for one [TimeZoneOption]. */
-internal data class TimeZoneSearchKeys(
-    val city: String,
-    val id: String,
-    val displayName: String,
-    val shortName: String,
-)
-
-private fun optionFor(
-    zone: ZoneId,
-    locale: Locale,
-    at: Instant,
-    regionOf: (String) -> String?,
-): TimeZoneOption = TimeZoneOption(
-    id = zone.id,
-    displayName = zone.getDisplayName(TextStyle.FULL, locale),
-    shortName = resolveAbbreviation(zone.id, zone.rules.isDaylightSavings(at), locale, regionOf),
-    offsetMinutes = zone.rules.getOffset(at).totalSeconds / 60,
-)
-
-/**
- * The zone abbreviation ("EDT", "CEST"), DST-correct at the resolved instant, or
- * a "GMT+05:30" form when no name exists.
- *
- * Two things make this fiddlier than it looks. First, it goes through
- * java.util.TimeZone, NOT java.time's "zzz" formatter: on Android the latter has
- * no short specific-zone names and degrades every zone to a "GMT-4" form (it
- * agrees with java.util only on desktop, which is why desktop can't catch it).
- * Second, ICU only surfaces the short name *commonly used in the display
- * locale's region* — a German-region English phone (en-DE) is shown "CEST" but
- * not "EDT", and an en-US phone the reverse. So ask in the display *language*
- * but the *zone's* region ("America/New_York" in en-US, "Europe/Berlin" in
- * en-DE) via [regionOf]. That covers almost everything; where a region still
- * yields no name (Athens in en-GR) the plain device locale sometimes does, so
- * try that next; failing both, the caller shows the offset.
- *
- * [regionOf] maps an IANA id to an ISO 3166 region and is injected because it
- * needs `android.icu`, which this pure-JVM module can't import. The default
- * (no region) leaves only the device-locale path — which is all a JVM test has
- * anyway, and enough there since desktop ICU isn't region-gated the same way.
- */
-private fun resolveAbbreviation(
-    id: String,
-    dst: Boolean,
-    locale: Locale,
-    regionOf: (String) -> String?,
-): String {
-    fun shortIn(loc: Locale): String =
-        java.util.TimeZone.getTimeZone(id).getDisplayName(dst, java.util.TimeZone.SHORT, loc)
-    val regional = regionOf(id)
-        ?.takeIf { it.length == 2 }
-        ?.let { shortIn(Locale(locale.language, it)) }
-    if (regional != null && !regional.looksLikeOffset()) return regional
-    // Either no region, or the region has no name for this zone: the device
-    // locale is the next-best shot, and the offset the last resort.
-    return shortIn(locale)
-}
-
-/** True for the offset-style names ICU returns when a zone has no abbreviation. */
-private fun String.looksLikeOffset(): Boolean = this == "UTC" || startsWith("GMT")
-
-/**
- * Every zone the JVM knows, resolved at [at]. [regionOf] (see
- * [resolveAbbreviation]) supplies the zone's region for the abbreviation.
- *
- * This is ~600 entries, each costing a localized display name plus up to two ICU
- * short-name lookups, so it is **not** cheap enough for the main thread — build
- * it off-thread once and filter the result with [filterTimeZones] rather than
- * rebuilding per keystroke.
- *
- * Bare three-letter ids ("EST", "CST6CDT") and the legacy SystemV tree are
- * dropped: they're aliases the tz database keeps for compatibility, they'd
- * double up the real zones in the list, and none of them is what a user means
- * when they pick a place.
- */
-fun timeZoneOptions(
-    locale: Locale = Locale.getDefault(),
-    at: Instant = Instant.now(),
-    regionOf: (String) -> String? = { null },
-): List<TimeZoneOption> = ZoneId.getAvailableZoneIds()
-    .asSequence()
-    .filter { it.contains('/') && !it.startsWith("SystemV/") }
-    .map { optionFor(ZoneId.of(it), locale, at, regionOf) }
-    .sortedWith(compareBy({ it.region }, { it.city }))
-    .toList()
-
-/**
- * Resolve a single [id] the same way [timeZoneOptions] would, or null if the tz
- * database doesn't know it — for labelling one known zone without paying to
- * build the whole catalogue.
- */
-fun timeZoneOptionOf(
-    id: String,
-    locale: Locale = Locale.getDefault(),
-    at: Instant = Instant.now(),
-    regionOf: (String) -> String? = { null },
-): TimeZoneOption? {
-    val zone = runCatching { ZoneId.of(id) }.getOrNull() ?: return null
-    return optionFor(zone, locale, at, regionOf)
-}
-
-/**
- * The short descriptor shown beneath the id, e.g. "CET · GMT+01:00". "UTC" reads
- * fine alone; any other offset-shaped name is normalised to our own GMT form so
- * the offset isn't stated twice in ICU's spelling and ours.
- */
-fun zoneDescriptor(option: TimeZoneOption): String {
-    val abbrev = option.shortName
-    return when {
-        abbrev == "UTC" -> "UTC"
-        abbrev.startsWith("GMT") -> formatGmtOffset(option.offsetMinutes)
-        else -> "$abbrev · ${formatGmtOffset(option.offsetMinutes)}"
-    }
-}
-
-/**
- * [options] matching [query], best matches first; a blank query returns the list
- * unchanged. Matching is accent- and case-insensitive and treats underscores as
- * spaces, so "sao paulo" finds "America/Sao_Paulo".
- *
- * Ranking puts a city that *starts with* the query above one that merely
- * contains it — typing "col" should reach Colombo before Turks_and_Caicos —
- * and the id is matched ahead of the localized name so a user who knows the
- * IANA id gets it first. An exact abbreviation hit ("CEST") ranks just under a
- * city prefix, so typing an abbreviation surfaces every zone that shows it
- * (all the CEST zones together); the abbreviation is the one resolved for the
- * display region, i.e. what the row actually shows.
- */
-fun filterTimeZones(options: List<TimeZoneOption>, query: String): List<TimeZoneOption> {
-    val needle = query.normalizeForSearch()
-    if (needle.isEmpty()) return options
-    return options
-        .mapNotNull { option ->
-            val keys = option.searchKeys
-            val rank = when {
-                keys.city.startsWith(needle) -> 0
-                keys.shortName == needle -> 1
-                keys.displayName.startsWith(needle) -> 2
-                keys.shortName.startsWith(needle) -> 3
-                keys.city.contains(needle) -> 4
-                keys.id.contains(needle) -> 5
-                keys.displayName.contains(needle) -> 6
-                else -> return@mapNotNull null
-            }
-            rank to option
-        }
-        .sortedWith(compareBy({ it.first }, { it.second.city }))
-        .map { it.second }
-}
-
-/** Unicode combining marks — what NFD decomposition leaves an accent as. */
-private val COMBINING_MARKS = Regex("\\p{Mn}+")
-
-/**
- * Lowercased, accent-stripped, underscores and slashes flattened to spaces, so
- * a query types the way a place is spoken rather than the way the tz database
- * spells it.
- */
-private fun String.normalizeForSearch(): String =
-    Normalizer.normalize(this, Normalizer.Form.NFD)
-        .replace(COMBINING_MARKS, "")
-        .replace('_', ' ')
-        .replace('/', ' ')
-        .lowercase(Locale.ROOT)
-        .trim()
-
-/** "GMT+02:00" / "GMT-05:30" / "GMT" — the offset as shown next to a zone. */
-fun formatGmtOffset(offsetMinutes: Int): String {
-    if (offsetMinutes == 0) return "GMT"
-    val sign = if (offsetMinutes < 0) '-' else '+'
-    val abs = kotlin.math.abs(offsetMinutes)
-    return "GMT%c%02d:%02d".format(sign, abs / 60, abs % 60)
-}

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

@@ -88,8 +88,6 @@ fun CalendarHost(
     // sensible non-empty initial values, so they're ready before the first frame.
     val quickSwitchViews = viewModel.quickSwitchViews.collectAsStateWithLifecycle().value
     val drawerViewOrder = viewModel.drawerViewOrder.collectAsStateWithLifecycle().value
-    // Whether the jump-to-today control sits in each view's top bar or the FAB (#60).
-    val todayInToolbar = viewModel.todayButtonInToolbar.collectAsStateWithLifecycle().value
 
     var viewStack by rememberSaveable(stateSaver = viewStackSaver) {
         mutableStateOf(listOf(defaultView))
@@ -320,7 +318,6 @@ fun CalendarHost(
                     onCreateEvent = onCreateEvent,
                     quickSwitchViews = quickSwitchViews,
                     drawerViewOrder = drawerViewOrder,
-                    todayInToolbar = todayInToolbar,
                 )
                 CalendarView.Day -> DayScreen(
                     selectedView = currentView,
@@ -332,19 +329,16 @@ fun CalendarHost(
                     initialDateIso = pendingDayIso,
                     quickSwitchViews = quickSwitchViews,
                     drawerViewOrder = drawerViewOrder,
-                    todayInToolbar = todayInToolbar,
                 )
                 CalendarView.Month -> MonthScreen(
                     selectedView = currentView,
                     onSelectView = onSelectView,
                     onOpenDay = onOpenDay,
-                    onEventClick = onEventClick,
                     onOpenSettings = onOpenSettings,
                     onOpenSearch = onOpenSearch,
                     onCreateEvent = onCreateEvent,
                     quickSwitchViews = quickSwitchViews,
                     drawerViewOrder = drawerViewOrder,
-                    todayInToolbar = todayInToolbar,
                 )
                 CalendarView.Agenda -> AgendaScreen(
                     selectedView = currentView,
@@ -356,7 +350,6 @@ fun CalendarHost(
                     onCreateEvent = onCreateEvent,
                     quickSwitchViews = quickSwitchViews,
                     drawerViewOrder = drawerViewOrder,
-                    todayInToolbar = todayInToolbar,
                 )
             }
         }

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

@@ -45,12 +45,4 @@ class CalendarHostViewModel @Inject constructor(
             started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = IMPLEMENTED_VIEWS,
         )
-
-    /** Whether each view's jump-to-today control lives in the top bar, not the FAB (#60). */
-    val todayButtonInToolbar: StateFlow<Boolean> = prefs.todayButtonInToolbar
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = false,
-        )
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaRange.kt

@@ -1,6 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.agenda
 
-import de.jeanlucmakiola.floret.locale.localizedDateFormatter
+import de.jeanlucmakiola.calendula.ui.common.localizedDateFormatter
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import java.time.YearMonth

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaRows.kt

@@ -1,206 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.agenda
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Coffee
-import androidx.compose.material3.Card
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
-import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
-import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
-import de.jeanlucmakiola.calendula.ui.common.eventFill
-import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
-import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.floret.locale.currentLocale
-import de.jeanlucmakiola.floret.locale.localizedDateFormatter
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.plus
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Instant
-import java.util.Locale
-
-// The agenda's row vocabulary, split out of AgendaScreen so the month view's
-// split style can list a day with exactly the same visual language instead of
-// growing a parallel set of event rows.
-
-@Composable
-internal fun AgendaDayHeader(
-    date: LocalDate,
-    today: LocalDate,
-    onOpenDay: (LocalDate) -> Unit,
-) {
-    Surface(
-        color = MaterialTheme.colorScheme.surface,
-        modifier = Modifier
-            .fillMaxWidth()
-            .clickable { onOpenDay(date) },
-    ) {
-        Text(
-            text = agendaDayLabel(date, today),
-            style = MaterialTheme.typography.titleSmall,
-            color = if (date == today) {
-                MaterialTheme.colorScheme.primary
-            } else {
-                MaterialTheme.colorScheme.onSurfaceVariant
-            },
-            modifier = Modifier.padding(start = 28.dp, end = 28.dp, top = 16.dp, bottom = 8.dp),
-        )
-    }
-}
-
-/**
- * A card standing in for a day with no events — the same coffee-cup motif as the
- * agenda's full-screen empty state, boxed into a card so the day keeps a visible slot
- * rather than a bare header. Used for an anchored, event-less today (#35) and for
- * an empty selected day in the month view's split style.
- */
-@Composable
-internal fun AgendaEmptyDayRow(text: String, onClick: () -> Unit) {
-    Card(
-        // Match a single event row's resting corner radius (floret groupedShape).
-        shape = RoundedCornerShape(22.dp),
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 16.dp, vertical = 4.dp)
-            .clickable(onClick = onClick),
-    ) {
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(vertical = 18.dp, horizontal = 16.dp),
-            horizontalAlignment = Alignment.CenterHorizontally,
-        ) {
-            Icon(
-                imageVector = Icons.Filled.Coffee,
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                modifier = Modifier.size(36.dp),
-            )
-            Spacer(Modifier.height(8.dp))
-            Text(
-                text = text,
-                style = MaterialTheme.typography.bodyLarge,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center,
-            )
-        }
-    }
-}
-
-@Composable
-internal fun AgendaEventRow(
-    event: EventInstance,
-    day: LocalDate,
-    zone: TimeZone,
-    position: Position,
-    dimmed: Boolean,
-    modifier: Modifier = Modifier,
-    onClick: () -> Unit,
-) {
-    val dark = isSystemInDarkTheme()
-    val soften = LocalSoftenColors.current
-    val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
-    GroupedRow(
-        modifier = if (dimmed) modifier.alpha(EventDimAlpha) else modifier,
-        title = title,
-        summary = agendaTimeSummary(event, day, zone),
-        position = position,
-        minHeight = 64.dp,
-        leading = {
-            Box(
-                modifier = Modifier
-                    .size(width = 6.dp, height = 36.dp)
-                    .clip(RoundedCornerShape(3.dp))
-                    .background(eventFill(event.color, dark, soften)),
-            )
-        },
-        onClick = onClick,
-    )
-}
-
-/** "Today · Wed, 17. Jun 2026" — relative word for today/tomorrow, else the date. */
-@Composable
-internal fun agendaDayLabel(date: LocalDate, today: LocalDate): String {
-    val relative = when (date) {
-        today -> stringResource(R.string.agenda_header_today)
-        today.plus(1, DateTimeUnit.DAY) -> stringResource(R.string.agenda_header_tomorrow)
-        else -> null
-    }
-    val formatted = formatAgendaDate(date)
-    return if (relative != null) "$relative · $formatted" else formatted
-}
-
-/**
- * Time line under the title: "09:00 – 10:00 · Location", "All day", etc.
- *
- * A multi-day event shows only the part relevant to [day], spelled out so each
- * day reads on its own: its first day names the start ("Starts 14:00"), its last
- * day the end ("Ends 10:00"), and any whole day in between reads as "All day".
- * An all-day multi-day event is simply "All day" on every day it covers.
- */
-@Composable
-internal fun agendaTimeSummary(event: EventInstance, day: LocalDate, zone: TimeZone): String {
-    val is24Hour = LocalUse24HourFormat.current
-    val locale = currentLocale()
-
-    val time = when (val label = agendaTimeLabel(event, day, zone)) {
-        AgendaTimeLabel.AllDay -> stringResource(R.string.event_detail_all_day)
-        is AgendaTimeLabel.Starts -> stringResource(
-            R.string.agenda_span_starts,
-            formatTime(label.start, zone, is24Hour, locale),
-        )
-        is AgendaTimeLabel.Ends -> stringResource(
-            R.string.agenda_span_ends,
-            formatTime(label.end, zone, is24Hour, locale),
-        )
-        is AgendaTimeLabel.Range -> "${formatTime(label.start, zone, is24Hour, locale)} – " +
-            formatTime(label.end, zone, is24Hour, locale)
-    }
-
-    val location = event.location?.takeIf { it.isNotBlank() }
-    return if (location != null) "$time · $location" else time
-}
-
-private fun formatTime(
-    instant: Instant,
-    zone: TimeZone,
-    is24Hour: Boolean,
-    locale: Locale,
-): String {
-    val t = instant.toLocalDateTime(zone).time
-    return formatTimeOfDay(t.hour, t.minute, is24Hour, locale)
-}
-
-private fun formatAgendaDate(date: LocalDate): String {
-    val locale = Locale.getDefault()
-    val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
-    // Weekday + date in the locale's own field order (e.g. "Wed, Jun 17, 2026"
-    // vs "Mi., 17. Juni 2026") rather than a hardcoded day-month-year layout.
-    return localizedDateFormatter(locale, "EEEdMMMy").format(java)
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaScreen.kt

@@ -1,6 +1,9 @@
 package de.jeanlucmakiola.calendula.ui.agenda
 
 import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -14,11 +17,13 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Coffee
 import androidx.compose.material.icons.filled.Menu
 import androidx.compose.material.icons.filled.Search
 import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Card
 import androidx.compose.material3.DrawerValue
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -27,6 +32,7 @@ import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ModalNavigationDrawer
 import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
@@ -40,6 +46,8 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
@@ -51,27 +59,36 @@ import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.hasEnded
 import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
+import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
+import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
 import de.jeanlucmakiola.floret.identity.animateItemMotion
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
-import de.jeanlucmakiola.calendula.ui.common.TodayAction
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
+import de.jeanlucmakiola.calendula.ui.common.localizedDateFormatter
+import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
+import de.jeanlucmakiola.floret.components.GroupedRow
+import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
-import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
 import kotlinx.coroutines.launch
+import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
+import java.util.Locale
 
-// No file-level zone constant here on purpose: it would be fixed for the process
-// lifetime and drift from the zone AgendaViewModel groups in after a device
-// time-zone change. The zone travels on AgendaUiState.Success instead.
+private val zone = TimeZone.currentSystemDefault()
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -85,7 +102,6 @@ fun AgendaScreen(
     onCreateEvent: (LocalDate, Int?) -> Unit,
     quickSwitchViews: List<CalendarView> = IMPLEMENTED_VIEWS,
     drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
-    todayInToolbar: Boolean = false,
     modifier: Modifier = Modifier,
     viewModel: AgendaViewModel = hiltViewModel(),
 ) {
@@ -135,14 +151,12 @@ fun AgendaScreen(
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
-                    showTodayButton = todayInToolbar,
-                    onToday = viewModel::goToToday,
                     scrollBehavior = scrollBehavior,
                 )
             },
             floatingActionButton = {
                 CalendarFabColumn(
-                    todayVisible = !isOnToday && !todayInToolbar,
+                    todayVisible = !isOnToday,
                     todayText = stringResource(R.string.agenda_today_action),
                     onToday = viewModel::goToToday,
                     onCreate = { onCreateEvent(anchor, null) },
@@ -314,7 +328,6 @@ private fun AgendaContent(
                 AgendaList(
                     days = days,
                     today = state.today,
-                    zone = state.zone,
                     dimPast = pastDisplay == PastEventDisplay.DIM,
                     now = now,
                     onEventClick = onEventClick,
@@ -331,7 +344,6 @@ private fun AgendaContent(
 private fun AgendaList(
     days: List<AgendaDay>,
     today: LocalDate,
-    zone: TimeZone,
     dimPast: Boolean,
     now: Instant,
     onEventClick: (EventInstance) -> Unit,
@@ -350,23 +362,15 @@ private fun AgendaList(
             if (day.events.isEmpty()) {
                 // An anchored, event-less today (#35) — "nothing left today".
                 item(key = "placeholder-${day.date}") {
-                    AgendaEmptyDayRow(
-                        text = stringResource(R.string.agenda_no_more_today),
-                        onClick = { onOpenDay(day.date) },
-                    )
+                    AgendaEmptyDayRow(onClick = { onOpenDay(day.date) })
                 }
             } else {
                 itemsIndexed(
                     items = day.events,
-                    // Scope the key by day: a multi-day event appears under every
-                    // day it spans, so its instanceId alone is not unique across
-                    // the list (LazyColumn requires unique keys).
-                    key = { _, event -> "${day.date}-${event.instanceId}" },
+                    key = { _, event -> event.instanceId },
                 ) { index, event ->
                     AgendaEventRow(
                         event = event,
-                        day = day.date,
-                        zone = zone,
                         position = positionOf(index, day.events.size),
                         dimmed = dimPast && event.hasEnded(now),
                         modifier = animateItemMotion(),
@@ -379,6 +383,98 @@ private fun AgendaList(
     }
 }
 
+@Composable
+private fun AgendaDayHeader(
+    date: LocalDate,
+    today: LocalDate,
+    onOpenDay: (LocalDate) -> Unit,
+) {
+    Surface(
+        color = MaterialTheme.colorScheme.surface,
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable { onOpenDay(date) },
+    ) {
+        Text(
+            text = agendaDayLabel(date, today),
+            style = MaterialTheme.typography.titleSmall,
+            color = if (date == today) {
+                MaterialTheme.colorScheme.primary
+            } else {
+                MaterialTheme.colorScheme.onSurfaceVariant
+            },
+            modifier = Modifier.padding(start = 28.dp, end = 28.dp, top = 16.dp, bottom = 8.dp),
+        )
+    }
+}
+
+/**
+ * A card under an anchored, event-less today (#35) — the same coffee-cup motif
+ * as the full-screen [AgendaEmpty] state, boxed into a card so today keeps a
+ * visible slot when nothing is left rather than a bare header.
+ */
+@Composable
+private fun AgendaEmptyDayRow(onClick: () -> Unit) {
+    Card(
+        // Match a single event row's resting corner radius (floret groupedShape).
+        shape = RoundedCornerShape(22.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp, vertical = 4.dp)
+            .clickable(onClick = onClick),
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(vertical = 18.dp, horizontal = 16.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Icon(
+                imageVector = Icons.Filled.Coffee,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.size(36.dp),
+            )
+            Spacer(Modifier.height(8.dp))
+            Text(
+                text = stringResource(R.string.agenda_no_more_today),
+                style = MaterialTheme.typography.bodyLarge,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                textAlign = TextAlign.Center,
+            )
+        }
+    }
+}
+
+@Composable
+private fun AgendaEventRow(
+    event: EventInstance,
+    position: Position,
+    dimmed: Boolean,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit,
+) {
+    val dark = isSystemInDarkTheme()
+    val soften = LocalSoftenColors.current
+    val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
+    GroupedRow(
+        modifier = if (dimmed) modifier.alpha(EventDimAlpha) else modifier,
+        title = title,
+        summary = agendaTimeSummary(event),
+        position = position,
+        minHeight = 64.dp,
+        leading = {
+            Box(
+                modifier = Modifier
+                    .size(width = 6.dp, height = 36.dp)
+                    .clip(RoundedCornerShape(3.dp))
+                    .background(eventFill(event.color, dark, soften)),
+            )
+        },
+        onClick = onClick,
+    )
+}
+
 @Composable
 private fun AgendaEmpty(modifier: Modifier = Modifier) {
     Column(
@@ -408,8 +504,6 @@ private fun AgendaTopBar(
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
-    showTodayButton: Boolean,
-    onToday: () -> Unit,
     scrollBehavior: TopAppBarScrollBehavior,
 ) {
     TopAppBar(
@@ -428,7 +522,6 @@ private fun AgendaTopBar(
             }
         },
         actions = {
-            TodayAction(show = showTodayButton, onToday = onToday)
             IconButton(onClick = onOpenSearch) {
                 Icon(
                     imageVector = Icons.Default.Search,
@@ -448,3 +541,42 @@ private fun AgendaTopBar(
         scrollBehavior = scrollBehavior,
     )
 }
+
+/** "Today · Wed, 17. Jun 2026" — relative word for today/tomorrow, else the date. */
+@Composable
+private fun agendaDayLabel(date: LocalDate, today: LocalDate): String {
+    val relative = when (date) {
+        today -> stringResource(R.string.agenda_header_today)
+        today.plus(1, DateTimeUnit.DAY) -> stringResource(R.string.agenda_header_tomorrow)
+        else -> null
+    }
+    val formatted = formatAgendaDate(date)
+    return if (relative != null) "$relative · $formatted" else formatted
+}
+
+/** Time line under the title: "09:00 – 10:00 · Location", "All day", etc. */
+@Composable
+private fun agendaTimeSummary(event: EventInstance): String {
+    val time = if (event.isAllDay) {
+        stringResource(R.string.event_detail_all_day)
+    } else {
+        val is24Hour = LocalUse24HourFormat.current
+        val locale = currentLocale()
+        "${formatTime(event.start, is24Hour, locale)} – ${formatTime(event.end, is24Hour, locale)}"
+    }
+    val location = event.location?.takeIf { it.isNotBlank() }
+    return if (location != null) "$time · $location" else time
+}
+
+private fun formatTime(instant: Instant, is24Hour: Boolean, locale: Locale): String {
+    val t = instant.toLocalDateTime(zone).time
+    return formatTimeOfDay(t.hour, t.minute, is24Hour, locale)
+}
+
+private fun formatAgendaDate(date: LocalDate): String {
+    val locale = Locale.getDefault()
+    val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
+    // Weekday + date in the locale's own field order (e.g. "Wed, Jun 17, 2026"
+    // vs "Mi., 17. Juni 2026") rather than a hardcoded day-month-year layout.
+    return localizedDateFormatter(locale, "EEEdMMMy").format(java)
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaUiState.kt

@@ -2,70 +2,9 @@ package de.jeanlucmakiola.calendula.ui.agenda
 
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
-import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.plus
 import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.Instant
-
-/**
- * The zone the event's calendar dates live in. Timed events are resolved in the
- * device [zone]; all-day events live at UTC midnights with an exclusive end, so
- * resolving them anywhere but UTC shifts the boundaries — east of UTC that leaks
- * a one-day event onto its next day. Matches the Week view and detail card.
- */
-private fun EventInstance.dateZone(zone: TimeZone): TimeZone =
-    if (isAllDay) TimeZone.UTC else zone
-
-/** The first calendar day this event occupies. */
-fun EventInstance.spanFirstDay(zone: TimeZone): LocalDate =
-    start.toLocalDateTime(dateZone(zone)).date
-
-/**
- * The last calendar day this event actually occupies. An event ending exactly at
- * midnight (all-day events end at the exclusive next-midnight) does not reach
- * into that boundary day, so resolve the instant just before [end].
- */
-fun EventInstance.spanLastDay(zone: TimeZone): LocalDate {
-    val lastInstant = if (end > start) end - 1.milliseconds else start
-    return lastInstant.toLocalDateTime(dateZone(zone)).date
-}
-
-/** Whether this event occupies more than one calendar day in [zone]. */
-fun EventInstance.spansMultipleDays(zone: TimeZone): Boolean =
-    spanFirstDay(zone) != spanLastDay(zone)
-
-/**
- * What an agenda row's time line should convey for an event on a given day —
- * the part of a multi-day span that [day] falls in. Pure and shared so the
- * agenda screen and the agenda widget label multi-day events identically; each
- * surface only formats the instants into its own locale/24h string.
- */
-sealed interface AgendaTimeLabel {
-    /** An all-day event, or a whole in-between day of a multi-day span. */
-    data object AllDay : AgendaTimeLabel
-    /** The first day of a multi-day timed event: when it begins. */
-    data class Starts(val start: Instant) : AgendaTimeLabel
-    /** The last day of a multi-day timed event: when it ends. */
-    data class Ends(val end: Instant) : AgendaTimeLabel
-    /** A single-day timed event: its start–end range. */
-    data class Range(val start: Instant, val end: Instant) : AgendaTimeLabel
-}
-
-/** The [AgendaTimeLabel] for [event] as it appears on [day], resolved in [zone]. */
-fun agendaTimeLabel(event: EventInstance, day: LocalDate, zone: TimeZone): AgendaTimeLabel {
-    if (event.isAllDay) return AgendaTimeLabel.AllDay
-    val firstDay = event.spanFirstDay(zone)
-    val lastDay = event.spanLastDay(zone)
-    return when {
-        firstDay == lastDay -> AgendaTimeLabel.Range(event.start, event.end)
-        day <= firstDay -> AgendaTimeLabel.Starts(event.start)
-        day >= lastDay -> AgendaTimeLabel.Ends(event.end)
-        else -> AgendaTimeLabel.AllDay // a full in-between day
-    }
-}
 
 /** One calendar day with at least one event, for the agenda list. */
 data class AgendaDay(
@@ -76,51 +15,31 @@ data class AgendaDay(
 
 /**
  * Group flat [instances] into forward-looking [AgendaDay]s (only days that
- * actually carry events). A multi-day event surfaces on *every* day it spans,
- * not just its first — clamped to [[anchor], [windowEnd]] so an event that began
- * before the window (ongoing) still lists from the anchor day, and one running
- * past the window stops at the last visible day. Within a day, all-day events
- * sort first, then ascending by start time, then title.
+ * actually carry events). An event that began before [anchor] (ongoing or
+ * multi-day) is clamped to the anchor day so it still surfaces on top. Within a
+ * day, all-day events sort first, then ascending by start time, then title.
  *
  * Shared by the Agenda screen and the agenda home-screen widget so both group
  * and order identically.
  */
 fun groupAgendaDays(
     anchor: LocalDate,
-    windowEnd: LocalDate,
     instances: List<EventInstance>,
     zone: TimeZone,
-): List<AgendaDay> {
-    val byDay = sortedMapOf<LocalDate, MutableList<EventInstance>>()
-    for (instance in instances) {
-        val firstDay = instance.spanFirstDay(zone).coerceAtLeast(anchor)
-        val lastDay = instance.spanLastDay(zone).coerceAtMost(windowEnd)
-        // Skip instances that don't actually occupy any day in [[anchor], [windowEnd]].
-        // The provider returns an event whenever its instant span overlaps the query
-        // window, but all-day events live at UTC midnights with an exclusive end: east
-        // of UTC that end dips just past local midnight, so *yesterday's* all-day event
-        // overlaps today's window start and comes back even though its true last day
-        // (resolved in UTC) is before the anchor. Clamping it up to the anchor would
-        // surface it under "today" (issue #65); drop it instead. The symmetric case —
-        // a next-day all-day event overlapping the window's last instant — drops too.
-        if (lastDay < firstDay) continue
-        var day = firstDay
-        while (day <= lastDay) {
-            byDay.getOrPut(day) { mutableListOf() }.add(instance)
-            day = day.plus(1, DateTimeUnit.DAY)
+): List<AgendaDay> =
+    instances
+        .groupBy { it.start.toLocalDateTime(zone).date.coerceAtLeast(anchor) }
+        .toSortedMap()
+        .map { (date, dayEvents) ->
+            AgendaDay(
+                date = date,
+                events = dayEvents.sortedWith(
+                    compareByDescending<EventInstance> { it.isAllDay }
+                        .thenBy { it.start }
+                        .thenBy { it.title },
+                ),
+            )
         }
-    }
-    return byDay.map { (date, dayEvents) ->
-        AgendaDay(
-            date = date,
-            events = dayEvents.sortedWith(
-                compareByDescending<EventInstance> { it.isAllDay }
-                    .thenBy { it.start }
-                    .thenBy { it.title },
-            ),
-        )
-    }
-}
 
 /**
  * Ensure [today] surfaces as the first agenda day even when it carries no
@@ -160,12 +79,5 @@ sealed interface AgendaUiState {
         val rangeEnd: LocalDate,
         /** Whether to show the top range bar — header + switcher (toggle, on by default). */
         val showRangeBar: Boolean,
-        /**
-         * The zone [days] were grouped in. Carried in the state rather than
-         * re-read by the screen so labelling and grouping cannot disagree: an
-         * event's "Starts …/Ends …/All day" line is only correct relative to the
-         * same zone that decided which day it was filed under.
-         */
-        val zone: TimeZone,
     ) : AgendaUiState
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaViewModel.kt

@@ -7,7 +7,7 @@ import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.data.prefs.firstDayOfWeek
+import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
@@ -20,11 +20,13 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
+import java.util.Locale
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.atTime
 import kotlinx.datetime.plus
@@ -49,7 +51,8 @@ class AgendaViewModel @Inject constructor(
     ) { range, showBar -> AgendaSettings(range, showBar) }
 
     // First day of the week, for the calendar-aligned "this week" range.
-    private val weekStartDay = settingsPrefs.firstDayOfWeek(viewModelScope)
+    private val weekStartDay = settingsPrefs.weekStart
+        .map { it.resolveFirstDay(Locale.getDefault()) }
 
     /**
      * How to treat events that already ended today (show / dim / hide). A display
@@ -156,11 +159,11 @@ class AgendaViewModel @Inject constructor(
             return AgendaUiState.Failure(FailureReason.NoCalendarsConfigured)
         }
         val anchor = params.anchor
+        val days = groupAgendaDays(anchor, instances, zone)
         val rangeEnd = anchor.plus(
             params.range.dayCount(anchor, params.weekStart) - 1,
             DateTimeUnit.DAY,
         )
-        val days = groupAgendaDays(anchor, rangeEnd, instances, zone)
         return AgendaUiState.Success(
             anchor = anchor,
             today = todayDate,
@@ -169,7 +172,6 @@ class AgendaViewModel @Inject constructor(
             rangeIsOverride = params.rangeIsOverride,
             rangeEnd = rangeEnd,
             showRangeBar = params.showRangeBar,
-            zone = zone,
         )
     }
 }

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

@@ -11,6 +11,7 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.Cloud
 import androidx.compose.material.icons.filled.PhoneAndroid
 import androidx.compose.material3.Icon
@@ -32,7 +33,6 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.floret.components.SelectedCheck
 
 /**
  * The app's single "which calendar" selection list, shared by the event editor
@@ -99,7 +99,13 @@ private fun CalendarPickerGroup(
             selected = isSelected,
             leading = { CalendarColorChip(calendar.color) },
             trailing = if (isSelected) {
-                { SelectedCheck() }
+                {
+                    Icon(
+                        imageVector = Icons.Default.Check,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.primary,
+                    )
+                }
             } else {
                 null
             },

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

@@ -1,79 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.foundation.gestures.detectHorizontalDragGestures
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.unit.dp
-
-/**
- * Drag distance that turns a calendar page, shared by the month, week and day
- * views so all three answer a swipe at the same point.
- *
- * It was 6dp once, which is inside the distance a tap wanders: brushing the grid
- * changed the month, and a page that turns on an unintended gesture reads as the
- * animation misfiring rather than as the gesture being over-eager.
- */
-val CALENDAR_SWIPE_THRESHOLD = 24.dp
-
-/**
- * The whole-page horizontal swipe: one page per gesture, committed **the moment
- * the drag clears [CALENDAR_SWIPE_THRESHOLD]** rather than when the finger lifts.
- *
- * Waiting for the lift meant the page sat still under a finger that had already
- * travelled far enough to ask for it, and the answer only arrived once you let
- * go — which reads as the view being slow rather than as a deliberate commit.
- * Firing on the threshold is what makes the gesture feel like it is being
- * followed. The trade is that a drag can no longer be taken back by dragging the
- * other way; in practice, once you have moved 24dp deliberately you meant it, and
- * the page you land on is one swipe back.
- *
- * Deliberately **horizontal-only**. The week and day timelines scroll vertically
- * underneath this, and a two-dimensional detector here would claim those drags
- * before the inner scroll ever saw them. As it is, a horizontal drag crosses this
- * detector's slop while a vertical one is consumed below, and the two coexist.
- * (The month view's split style needs a vertical axis as well, so it keeps its
- * own axis-locking detector rather than using this.)
- */
-@Composable
-fun rememberCalendarPageSwipe(
-    onSwipeNext: () -> Unit,
-    onSwipePrev: () -> Unit,
-): Modifier {
-    val threshold = with(LocalDensity.current) { CALENDAR_SWIPE_THRESHOLD.toPx() }
-    return Modifier.pointerInput(onSwipeNext, onSwipePrev) {
-        var accum = 0f
-        // One page per gesture: without this a long drag would keep re-firing
-        // every time the accumulator crossed the threshold again.
-        var fired = false
-        detectHorizontalDragGestures(
-            onDragStart = {
-                accum = 0f
-                fired = false
-            },
-            onDragEnd = {
-                accum = 0f
-                fired = false
-            },
-            onDragCancel = {
-                accum = 0f
-                fired = false
-            },
-            onHorizontalDrag = { _, drag ->
-                accum += drag
-                if (!fired) {
-                    val commit = when {
-                        accum < -threshold -> onSwipeNext
-                        accum > threshold -> onSwipePrev
-                        else -> null
-                    }
-                    if (commit != null) {
-                        fired = true
-                        commit()
-                    }
-                }
-            },
-        )
-    }
-}

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

@@ -1,34 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import de.jeanlucmakiola.floret.locale.localizedDateFormatter
-import java.util.Locale
-
-/**
- * Formats a calendar title (top bar or widget header): [skeleton]'s fields laid
- * out in [locale]'s own order, with the year shown only when [date] falls outside
- * [currentYear].
- *
- * Pass [skeleton] *without* a year field — "LLLL" for a month, "EEEdMMM" for a
- * day. A skeleton is a field list, so wanting the year is just asking for one
- * more field; the locale still decides where it lands ("July 2026" vs "2026年7月").
- *
- * Dropping the year in the current year is the one bit of policy here: the title
- * sits directly above a grid that already says which year it is, and the year's
- * *absence* is itself the signal that you're in the current one — it appears the
- * moment you page out of it, which is when it starts carrying information.
- *
- * [forceYear] overrides that for titles whose [date] does not tell the whole
- * story — a week view's title names only the month its *first* day falls in, so
- * a week straddling New Year must still show the year even though [date] is in
- * [currentYear].
- */
-fun formatCalendarTitle(
-    date: java.time.LocalDate,
-    locale: Locale,
-    currentYear: Int,
-    skeleton: String,
-    forceYear: Boolean = false,
-): String {
-    val fields = if (date.year == currentYear && !forceYear) skeleton else skeleton + "y"
-    return localizedDateFormatter(locale, fields).format(date)
-}

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

@@ -1,7 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.animation.ContentTransform
-import androidx.compose.animation.SizeTransform
 import androidx.compose.animation.core.FiniteAnimationSpec
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
@@ -24,13 +23,9 @@ import androidx.compose.ui.unit.IntOffset
  */
 
 /**
- * The M3 Expressive spatial spring used for the month/week/day slide: the
- * *default* spring-physics spec from the active motion scheme, rather than a
- * fixed easing curve.
- *
- * Default rather than fast: `fastSpatialSpec` is tuned for small, incidental
- * movement, and driving a whole calendar page with it made the settle read as a
- * twitch instead of a glide.
+ * The M3 Expressive spatial spring used for the month/week slide: the *fast*
+ * spring-physics spec from the active motion scheme — snappy with a subtle
+ * springy settle, rather than a fixed easing curve.
  *
  * Read it in a composable scope (this helper) so it can be captured by the
  * non-composable `AnimatedContent` transitionSpec lambda.
@@ -38,34 +33,27 @@ import androidx.compose.ui.unit.IntOffset
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun rememberCalendarSlideSpec(): FiniteAnimationSpec<IntOffset> =
-    MaterialTheme.motionScheme.defaultSpatialSpec()
+    MaterialTheme.motionScheme.fastSpatialSpec()
 
 /**
- * The effects spec from the active motion scheme, for the opacity half of the
- * transition. Captured in composable scope alongside [rememberCalendarSlideSpec]
- * for use in non-composable transition lambdas, and reused on its own as the
- * reduced-motion fallback.
- *
- * Opacity gets its own spec on purpose: M3 Expressive springs *position* and
- * eases *opacity*, and a fade that bounced with the slide would shimmer.
+ * The fast effects spec from the active motion scheme, for opacity (fade)
+ * transitions. Captured in composable scope alongside [rememberCalendarSlideSpec]
+ * for use in non-composable transition lambdas and as the reduced-motion fallback.
  */
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun rememberCalendarFadeSpec(): FiniteAnimationSpec<Float> =
-    MaterialTheme.motionScheme.defaultEffectsSpec()
+    MaterialTheme.motionScheme.fastEffectsSpec()
 
 /**
- * Navigating between adjacent months/weeks/days, as M3's shared-axis X: the
- * outgoing page slides and fades one way while the incoming one arrives from the
- * other, position on a spring and opacity on an easing curve.
+ * Horizontal slide for navigating between adjacent months/weeks/days.
  *
  * @param slideDir     +1 = forward (incoming from the right), -1 = back, 0 = jump
  *                     (e.g. "today"); a jump reuses the forward direction.
  * @param spec         spatial animation spec, typically [rememberCalendarSlideSpec].
- * @param fadeSpec     effects spec for the opacity half, and for the whole
- *                     transition under reduced motion; typically
+ * @param fadeSpec     effects spec for the reduced-motion fade, typically
  *                     [rememberCalendarFadeSpec].
- * @param reduceMotion when true, drop the movement and cross-fade alone.
+ * @param reduceMotion when true, swap the directional slide for a plain cross-fade.
  */
 fun calendarSlideTransition(
     slideDir: Int,
@@ -77,26 +65,6 @@ fun calendarSlideTransition(
         return fadeIn(fadeSpec).togetherWith(fadeOut(fadeSpec))
     }
     val dir = if (slideDir == 0) 1 else slideDir
-    return ContentTransform(
-        targetContentEnter =
-            slideInHorizontally(spec) { w -> dir * w / SLIDE_TRAVEL_DIVISOR } + fadeIn(fadeSpec),
-        initialContentExit =
-            slideOutHorizontally(spec) { w -> -dir * w / SLIDE_TRAVEL_DIVISOR } + fadeOut(fadeSpec),
-        // AnimatedContent clips to the animating container by default, which
-        // shears the pages against the viewport edge as they pass. There is no
-        // size change here to contain — both pages are the same grid.
-        sizeTransform = SizeTransform(clip = false),
-    )
+    return slideInHorizontally(spec) { w -> dir * w }
+        .togetherWith(slideOutHorizontally(spec) { w -> -dir * w })
 }
-
-/**
- * How far a page travels, as a fraction of the container width.
- *
- * A full width was the obvious reading of "paging", but the two pages are
- * stacked and both opaque, so a full-width slide showed one grid racing across
- * another — the movement carried the whole transition and had a long way to go.
- * Under M3's shared-axis pattern the offset only has to *hint* the direction
- * while the cross-fade does the swapping, so a fifth of the width is plenty and
- * leaves nothing skating past.
- */
-private const val SLIDE_TRAVEL_DIVISOR = 5

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

@@ -9,7 +9,6 @@ import androidx.compose.material.icons.filled.Notifications
 import androidx.compose.material.icons.filled.Palette
 import androidx.compose.material.icons.filled.People
 import androidx.compose.material.icons.filled.Place
-import androidx.compose.material.icons.filled.Public
 import androidx.compose.material.icons.filled.Repeat
 import androidx.compose.ui.graphics.vector.ImageVector
 import de.jeanlucmakiola.calendula.R
@@ -25,7 +24,6 @@ import de.jeanlucmakiola.calendula.domain.EventFormField
 fun eventFormFieldLabel(field: EventFormField): Int = when (field) {
     EventFormField.Location -> R.string.event_detail_location
     EventFormField.Description -> R.string.event_detail_description
-    EventFormField.Timezone -> R.string.event_detail_timezone
     EventFormField.Reminders -> R.string.event_detail_reminders
     EventFormField.Recurrence -> R.string.event_detail_recurrence
     EventFormField.Availability -> R.string.event_edit_availability
@@ -37,7 +35,6 @@ fun eventFormFieldLabel(field: EventFormField): Int = when (field) {
 fun eventFormFieldIcon(field: EventFormField): ImageVector = when (field) {
     EventFormField.Location -> Icons.Default.Place
     EventFormField.Description -> Icons.AutoMirrored.Filled.Notes
-    EventFormField.Timezone -> Icons.Default.Public
     EventFormField.Reminders -> Icons.Default.Notifications
     EventFormField.Recurrence -> Icons.Default.Repeat
     EventFormField.Availability -> Icons.Default.EventAvailable

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

@@ -0,0 +1,33 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.core.os.ConfigurationCompat
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+
+/**
+ * Current display [Locale], read observably from [LocalConfiguration] so the UI
+ * recomposes after a locale change (lint: NonObservableLocale). Used for
+ * weekday/month name formatting.
+ */
+@Composable
+fun currentLocale(): Locale {
+    val configuration = LocalConfiguration.current
+    return remember(configuration) {
+        ConfigurationCompat.getLocales(configuration).get(0) ?: Locale.getDefault()
+    }
+}
+
+/**
+ * A [DateTimeFormatter] for [skeleton]'s fields laid out in [locale]'s own order
+ * (via Android's best-pattern matching), so dates read naturally per locale
+ * instead of a hardcoded day-month-year order. [skeleton] lists the wanted
+ * fields, e.g. "dMMMy" (day, abbreviated month, year) or "EEEdMMM" (weekday too).
+ */
+fun localizedDateFormatter(locale: Locale, skeleton: String): DateTimeFormatter =
+    DateTimeFormatter.ofPattern(
+        android.text.format.DateFormat.getBestDateTimePattern(locale, skeleton),
+        locale,
+    )

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

@@ -5,6 +5,7 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
 import androidx.compose.material3.Checkbox
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
@@ -25,7 +26,6 @@ import de.jeanlucmakiola.floret.components.CustomAmountEditor
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.floret.identity.collapseExit
 import de.jeanlucmakiola.floret.identity.expandEnter
@@ -198,7 +198,7 @@ private fun CustomReminderEditor(
 
 /** A short explanatory paragraph shown under a picker's title, above the rows. */
 @Composable
-internal fun PickerDescription(text: String) {
+private fun PickerDescription(text: String) {
     Text(
         text = text,
         style = MaterialTheme.typography.bodyMedium,
@@ -207,6 +207,14 @@ internal fun PickerDescription(text: String) {
     )
 }
 
+@Composable
+private fun SelectedCheck() {
+    Icon(
+        imageVector = Icons.Default.Check,
+        contentDescription = null,
+        tint = MaterialTheme.colorScheme.primary,
+    )
+}
 
 /**
  * Agenda-range picker, full-screen. Two grouped lists — the calendar-aligned

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

@@ -9,10 +9,6 @@ import androidx.compose.ui.text.buildAnnotatedString
 import androidx.compose.ui.text.font.FontStyle
 import de.jeanlucmakiola.calendula.R
 import java.time.DayOfWeek
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.ZoneId
-import java.time.ZoneOffset
 import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
 import java.time.format.TextStyle as JavaTextStyle
@@ -115,36 +111,16 @@ private fun rruleDayName(token: String, locale: Locale): String? {
 
 /** Parse an RRULE UNTIL value ("20261231" or "20261231T235959Z") to a localized date. */
 private fun parseUntilDate(raw: String, locale: Locale): String? {
-    val date = untilLocalDate(raw) ?: return null
-    return DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale).format(date)
-}
-
-private val UNTIL_UTC_FORMAT: DateTimeFormatter =
-    DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'", Locale.ROOT)
-
-/**
- * The calendar day an RRULE UNTIL value denotes, *in the device's zone*.
- *
- * The UTC form ("20261231T225959Z") must be converted back before its date is
- * read: `SimpleRecurrence.toRRule` writes the end of the chosen **local** day
- * expressed in UTC, so for zones behind UTC that instant already falls on the
- * following UTC date. Taking the leading digits straight off would then show
- * the day after the one the user picked. Date-only and floating forms are
- * already local and pass through unchanged.
- */
-internal fun untilLocalDate(raw: String, zone: ZoneId = ZoneId.systemDefault()): LocalDate? {
-    val value = raw.trim()
-    return runCatching {
-        LocalDateTime.parse(value, UNTIL_UTC_FORMAT)
-            .atOffset(ZoneOffset.UTC)
-            .atZoneSameInstant(zone)
-            .toLocalDate()
-    }.recoverCatching {
-        val digits = value.takeWhile { it.isDigit() }
-        LocalDate.of(
+    val digits = raw.takeWhile { it.isDigit() }
+    if (digits.length < 8) return null
+    return try {
+        val date = java.time.LocalDate.of(
             digits.substring(0, 4).toInt(),
             digits.substring(4, 6).toInt(),
             digits.substring(6, 8).toInt(),
         )
-    }.getOrNull()
+        DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale).format(date)
+    } catch (e: Exception) {
+        null
+    }
 }

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

@@ -1,267 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.itemsIndexed
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Close
-import androidx.compose.material.icons.filled.Public
-import androidx.compose.material.icons.filled.Search
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.produceState
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalSoftwareKeyboardController
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.domain.TimeZoneOption
-import de.jeanlucmakiola.calendula.domain.filterTimeZones
-import de.jeanlucmakiola.calendula.domain.timeZoneOptionOf
-import de.jeanlucmakiola.calendula.domain.timeZoneOptions
-import de.jeanlucmakiola.calendula.domain.zoneDescriptor
-import de.jeanlucmakiola.floret.components.FullScreenPicker
-import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.InlineTextField
-import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.floret.components.SelectedCheck
-import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.locale.currentLocale
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-
-/**
- * Full-screen zone picker: a query field over every zone the JVM knows, with the
- * device zone and recently-picked ones pinned on top so the common case needs no
- * typing. [selected] is the pinned zone id, or null when the event follows the
- * device — picking the device row reports null back, which is what keeps an
- * unpinned event unpinned rather than freezing it to today's zone.
- *
- * Unlike the kit's [de.jeanlucmakiola.floret.components.OptionPicker], this
- * drives its own [LazyColumn] (hence `scrollable = false`): ~600 options is far
- * past what an eagerly composed column can carry.
- */
-@Composable
-fun TimeZonePickerDialog(
-    selected: String?,
-    deviceZoneId: String,
-    recents: List<String>,
-    onSelect: (String?) -> Unit,
-    onDismiss: () -> Unit,
-) {
-    var query by rememberSaveable { mutableStateOf("") }
-    val locale = currentLocale()
-    // ~600 zones, each resolving a localized name and up to two ICU short names:
-    // far too much to run inside composition, so build it on a worker and let the
-    // list fill in a frame later. Filtering the built catalogue is cheap (its
-    // search keys are pre-normalized), so that stays here.
-    val allZones by produceState(initialValue = emptyList<TimeZoneOption>(), locale) {
-        value = withContext(Dispatchers.Default) {
-            timeZoneOptions(locale, regionOf = ::icuTimeZoneRegion)
-        }
-    }
-    val matches = remember(allZones, query) { filterTimeZones(allZones, query) }
-    val recentZones = remember(allZones, recents) {
-        recents.mapNotNull { id -> allZones.firstOrNull { it.id == id } }
-    }
-    // Resolved on its own rather than looked up in the catalogue: it's one zone,
-    // so it costs nothing, and the device row can then render complete on the
-    // first frame instead of showing a bare id until the catalogue lands.
-    val deviceSummary = remember(deviceZoneId, locale) {
-        timeZoneOptionOf(deviceZoneId, locale, regionOf = ::icuTimeZoneRegion)
-            ?.let { zoneDescriptor(it) }
-            ?: deviceZoneId
-    }
-    val searching = query.isNotBlank()
-
-    fun choose(zoneId: String?) {
-        onSelect(zoneId)
-        onDismiss()
-    }
-
-    FullScreenPicker(
-        title = stringResource(R.string.event_detail_timezone),
-        onDismiss = onDismiss,
-        scrollable = false,
-    ) {
-        SearchField(
-            query = query,
-            onQueryChange = { query = it },
-            modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
-        )
-        LazyColumn(contentPadding = PaddingValues(top = 8.dp, bottom = 24.dp)) {
-            if (!searching) {
-                // The device row is the "unpinned" choice, so it reads as a mode
-                // rather than as a zone among zones — it stays out of the big
-                // list and never carries an offset.
-                item(key = "device") {
-                    GroupedRow(
-                        title = stringResource(R.string.event_edit_timezone_device),
-                        summary = deviceSummary,
-                        position = Position.Alone,
-                        selected = selected == null,
-                        leading = { Icon(Icons.Default.Public, contentDescription = null) },
-                        trailing = if (selected == null) {
-                            { SelectedCheck() }
-                        } else {
-                            null
-                        },
-                        onClick = { choose(null) },
-                    )
-                }
-                if (recentZones.isNotEmpty()) {
-                    item(key = "recent_header") {
-                        SectionHeader(stringResource(R.string.event_edit_timezone_recent))
-                    }
-                    itemsIndexed(
-                        items = recentZones,
-                        key = { _, zone -> "recent_${zone.id}" },
-                    ) { index, zone ->
-                        ZoneRow(
-                            zone = zone,
-                            position = positionOf(index, recentZones.size),
-                            selected = zone.id == selected,
-                            onClick = { choose(zone.id) },
-                        )
-                    }
-                }
-                item(key = "all_header") {
-                    SectionHeader(stringResource(R.string.event_edit_timezone_all))
-                }
-            }
-
-            // allZones.isNotEmpty() gates this: until the catalogue lands there is
-            // simply nothing to match yet, and claiming "no time zone matches"
-            // for that frame would be wrong.
-            if (searching && matches.isEmpty() && allZones.isNotEmpty()) {
-                item(key = "empty") {
-                    Text(
-                        text = stringResource(R.string.event_edit_timezone_none, query),
-                        style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                        textAlign = TextAlign.Center,
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 32.dp, vertical = 48.dp),
-                    )
-                }
-            }
-
-            itemsIndexed(
-                items = matches,
-                key = { _, zone -> "zone_${zone.id}" },
-            ) { index, zone ->
-                ZoneRow(
-                    zone = zone,
-                    position = positionOf(index, matches.size),
-                    selected = zone.id == selected,
-                    onClick = { choose(zone.id) },
-                )
-            }
-        }
-    }
-}
-
-/**
- * The query box: the family's borderless [InlineTextField] over a tonal surface,
- * so it reads like the rest of the app's inputs rather than a boxed Material
- * field. The clear button rides inside the surface (unlike the search screen,
- * which has a top bar to put it in) because the picker's bar is the title.
- */
-@Composable
-private fun SearchField(
-    query: String,
-    onQueryChange: (String) -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    val keyboard = LocalSoftwareKeyboardController.current
-    // surfaceContainerHighest — the picker sits on surfaceContainerHigh, so
-    // anything lower vanishes into it.
-    Surface(
-        color = MaterialTheme.colorScheme.surfaceContainerHighest,
-        shape = RoundedCornerShape(28.dp),
-        modifier = modifier.fillMaxWidth(),
-    ) {
-        Row(
-            verticalAlignment = Alignment.CenterVertically,
-            modifier = Modifier.padding(horizontal = 16.dp),
-        ) {
-            Icon(
-                imageVector = Icons.Default.Search,
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-            InlineTextField(
-                value = query,
-                onValueChange = onQueryChange,
-                placeholder = stringResource(R.string.event_edit_timezone_search),
-                capitalization = KeyboardCapitalization.None,
-                imeAction = ImeAction.Search,
-                onImeAction = { keyboard?.hide() },
-                modifier = Modifier
-                    .weight(1f)
-                    .padding(horizontal = 12.dp, vertical = 14.dp),
-            )
-            if (query.isNotEmpty()) {
-                IconButton(onClick = { onQueryChange("") }) {
-                    Icon(
-                        imageVector = Icons.Default.Close,
-                        contentDescription = stringResource(R.string.search_clear),
-                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                    )
-                }
-            }
-        }
-    }
-}
-
-/** A small primary-coloured group label, matching the settings screens. */
-@Composable
-private fun SectionHeader(text: String) {
-    Text(
-        text = text,
-        style = MaterialTheme.typography.labelLarge,
-        color = MaterialTheme.colorScheme.primary,
-        modifier = Modifier.padding(start = 24.dp, end = 24.dp, top = 16.dp, bottom = 4.dp),
-    )
-}
-
-
-@Composable
-private fun ZoneRow(
-    zone: TimeZoneOption,
-    position: Position,
-    selected: Boolean,
-    onClick: () -> Unit,
-) {
-    GroupedRow(
-        title = zone.label,
-        summary = zoneDescriptor(zone),
-        position = position,
-        selected = selected,
-        trailing = if (selected) {
-            { SelectedCheck() }
-        } else {
-            null
-        },
-        onClick = onClick,
-    )
-}

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

@@ -1,16 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import android.icu.util.TimeZone as IcuTimeZone
-
-/**
- * The ISO 3166 region an IANA zone belongs to ("America/New_York" -> "US"), or
- * null when ICU has none or maps it to the multi-country "001" ("Etc/UTC").
- *
- * This is the `android.icu`-backed bridge the pure-JVM
- * [de.jeanlucmakiola.calendula.domain.timeZoneOptions] takes as `regionOf`, so
- * it can ask ICU for a zone's abbreviation in that zone's own region — the only
- * region for which ICU will surface it (see `resolveAbbreviation`). Lives here,
- * not in `domain/`, precisely because it needs an Android import.
- */
-fun icuTimeZoneRegion(id: String): String? =
-    runCatching { IcuTimeZone.getRegion(id) }.getOrNull()?.takeIf { it.length == 2 }

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

@@ -1,26 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Today
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.res.stringResource
-import de.jeanlucmakiola.calendula.R
-
-/**
- * The top-bar "jump to today" icon button, shared by every calendar view's app
- * bar (#60). Shown in place of the fade-in FAB pill when the user moves the
- * today control into the toolbar; renders nothing when [show] is false, so it
- * drops straight into an app bar's `actions` slot without a wrapping condition.
- */
-@Composable
-fun TodayAction(show: Boolean, onToday: () -> Unit) {
-    if (!show) return
-    IconButton(onClick = onToday) {
-        Icon(
-            imageVector = Icons.Default.Today,
-            contentDescription = stringResource(R.string.today_jump_action),
-        )
-    }
-}

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

@@ -5,6 +5,7 @@ import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.detectHorizontalDragGestures
 import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
@@ -42,6 +43,7 @@ import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
@@ -66,10 +68,8 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
-import de.jeanlucmakiola.calendula.ui.common.TodayAction
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
@@ -77,14 +77,13 @@ import de.jeanlucmakiola.calendula.ui.common.NowLine
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
-import de.jeanlucmakiola.calendula.ui.common.rememberCalendarPageSwipe
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.eventInk
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
-import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
 import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
@@ -94,9 +93,7 @@ import de.jeanlucmakiola.calendula.ui.week.TimedBlock
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Clock
+import java.time.format.TextStyle as JavaTextStyle
 import java.util.Locale
 import kotlin.math.roundToInt
 
@@ -128,7 +125,6 @@ fun DayScreen(
     onCreateEvent: (LocalDate, Int?) -> Unit,
     quickSwitchViews: List<CalendarView> = IMPLEMENTED_VIEWS,
     drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
-    todayInToolbar: Boolean = false,
     modifier: Modifier = Modifier,
     initialDateIso: String? = null,
     viewModel: DayViewModel = hiltViewModel(),
@@ -161,13 +157,6 @@ fun DayScreen(
         else -> true
     }
 
-    // Drives whether the title carries the year. Falls back to the clock only
-    // while the first load is in flight, when there is no state to read today from.
-    val currentYear = when (val s = state) {
-        is DayUiState.Success -> s.today.year
-        else -> Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date.year
-    }
-
     // Slide direction for the day transition: +1 = next, -1 = prev, 0 = jump.
     var slideDir by remember { mutableIntStateOf(0) }
     val goNext = { slideDir = 1; viewModel.goToNext() }
@@ -216,19 +205,16 @@ fun DayScreen(
             topBar = {
                 DayTopBar(
                     date = date,
-                    currentYear = currentYear,
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
-                    showTodayButton = todayInToolbar,
-                    onToday = jumpToToday,
                     scrollBehavior = scrollBehavior,
                 )
             },
             floatingActionButton = {
                 CalendarFabColumn(
-                    todayVisible = !isOnToday && !todayInToolbar,
+                    todayVisible = !isOnToday,
                     todayText = stringResource(R.string.day_today_action),
                     onToday = jumpToToday,
                     onCreate = { onCreateEvent(date, null) },
@@ -265,6 +251,8 @@ private fun DayContent(
     modifier: Modifier = Modifier,
 ) {
     val density = LocalDensity.current
+    val threshold = with(density) { 24.dp.toPx() }
+    var dragAccum by remember { mutableFloatStateOf(0f) }
     val slideSpec = rememberCalendarSlideSpec()
     val fadeSpec = rememberCalendarFadeSpec()
     val reduceMotion = rememberReduceMotion()
@@ -293,7 +281,20 @@ private fun DayContent(
     // Whole-page horizontal swipe, one level above the timeline's vertical
     // scroll: a horizontal drag crosses this detector's slop, while a vertical
     // drag is consumed by the inner scroll first — the two gestures coexist.
-    val swipeModifier = rememberCalendarPageSwipe(onSwipeNext, onSwipePrev)
+    val swipeModifier = Modifier.pointerInput(Unit) {
+        detectHorizontalDragGestures(
+            onDragStart = { dragAccum = 0f },
+            onDragEnd = {
+                when {
+                    dragAccum < -threshold -> onSwipeNext()
+                    dragAccum > threshold -> onSwipePrev()
+                }
+                dragAccum = 0f
+            },
+            onDragCancel = { dragAccum = 0f },
+            onHorizontalDrag = { _, drag -> dragAccum += drag },
+        )
+    }
 
     AnimatedContent(
         targetState = state,
@@ -359,20 +360,16 @@ private fun DaySuccess(
 @Composable
 private fun DayTopBar(
     date: LocalDate,
-    currentYear: Int,
     selectedView: CalendarView,
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
-    showTodayButton: Boolean,
-    onToday: () -> Unit,
     scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
-    val locale = currentLocale()
     TopAppBar(
         title = {
             Text(
-                text = formatDayTitle(date, locale, currentYear),
+                text = formatDayTitle(date),
                 style = MaterialTheme.typography.titleLarge,
             )
         },
@@ -385,7 +382,6 @@ private fun DayTopBar(
             }
         },
         actions = {
-            TodayAction(show = showTodayButton, onToday = onToday)
             IconButton(onClick = onOpenSearch) {
                 Icon(
                     imageVector = Icons.Default.Search,
@@ -673,10 +669,10 @@ private fun DayLoading() {
 private fun minToHm(min: Int, is24Hour: Boolean, locale: Locale): String =
     formatMinuteOfDay(min, is24Hour, locale)
 
-private fun formatDayTitle(date: LocalDate, locale: Locale, currentYear: Int): String =
-    formatCalendarTitle(
-        date = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day),
-        locale = locale,
-        currentYear = currentYear,
-        skeleton = "EEEdMMM",
-    )
+private fun formatDayTitle(date: LocalDate): String {
+    val locale = Locale.getDefault()
+    val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
+    val weekday = java.dayOfWeek.getDisplayName(JavaTextStyle.SHORT, locale)
+    val monthName = java.month.getDisplayName(JavaTextStyle.SHORT, locale)
+    return "$weekday, ${date.day}. $monthName ${date.year}"
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailScreen.kt

@@ -93,26 +93,22 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import de.jeanlucmakiola.calendula.domain.Reminder
-import de.jeanlucmakiola.calendula.domain.TimeZoneOption
-import de.jeanlucmakiola.calendula.domain.timeZoneOptionOf
-import de.jeanlucmakiola.calendula.domain.zoneDescriptor
 import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
-import de.jeanlucmakiola.calendula.ui.common.icuTimeZoneRegion
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.floret.components.OptionCard
-import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.recurrenceText
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
 import kotlinx.coroutines.launch
 import kotlinx.datetime.TimeZone
-import kotlin.time.toJavaInstant
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
+import java.time.format.TextStyle as JavaTextStyle
 import java.util.Locale
 import kotlin.time.Duration.Companion.seconds
 import kotlin.time.Instant
@@ -457,44 +453,14 @@ private fun EventDetailContent(state: EventDetailUiState.Success, modifier: Modi
         }
 
         // Time zone — only when the event is timed and pinned to a zone other
-        // than the device's, so cross-zone events read unambiguously. It answers
-        // "when was it set", which the zone's name alone never did: an 8 AM New
-        // York call showing as 2 PM here should still say 8 AM somewhere.
-        //
-        // Same hierarchy as the When card above — the label carries the card,
-        // the time sits small beneath it. The local time is the one the reader
-        // acts on, so the original must stay quieter than it, not compete.
-        val foreignZone = remember(detail.eventTimezone, instance.isAllDay, instance.start, locale) {
-            foreignTimeZone(detail.eventTimezone, instance.isAllDay, locale, instance.start)
-        }
-        foreignZone?.let { zoneOption ->
+        // than the device's, so cross-zone events read unambiguously.
+        foreignTimeZoneLabel(detail.eventTimezone, instance.isAllDay, locale)?.let { tzLabel ->
             Spacer(Modifier.height(gap))
             DetailCard(
                 icon = Icons.Default.Public,
                 iconContentDescription = stringResource(R.string.event_detail_timezone),
             ) {
-                // The id is the primary label ("Europe/Berlin"); the long
-                // localized name spelled next to it made the field too wide.
-                Text(text = zoneOption.label, style = MaterialTheme.typography.titleMedium)
-                // Beneath, small: the abbreviation plus the event's own-zone time,
-                // e.g. "CET · 8:00 AM – 9:00 AM". formatWhen puts the range in the
-                // secondary half only for a same-day event; one spanning midnight
-                // — which a cross-zone event easily does — carries the whole span
-                // in the primary instead, so fall back to it. If the zone can't be
-                // read back at all, drop to just the abbreviation + offset.
-                val originalTime = runCatching { TimeZone.of(zoneOption.id) }.getOrNull()
-                    ?.let { formatWhen(instance, it, locale) }
-                    ?.let { (primary, secondary) -> secondary ?: primary }
-                Spacer(Modifier.height(2.dp))
-                Text(
-                    text = if (originalTime != null) {
-                        "${zoneOption.shortName} · $originalTime"
-                    } else {
-                        zoneDescriptor(zoneOption)
-                    },
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                )
+                Text(text = tzLabel, style = MaterialTheme.typography.titleMedium)
             }
         }
 
@@ -786,30 +752,21 @@ private fun attendeeRoleLabel(attendee: Attendee): Int? = when {
 private fun reminderLeadText(reminder: Reminder): String = reminderLeadTimeLabel(reminder.minutes)
 
 /**
- * [tz] resolved as a [TimeZoneOption], but only when the event is timed and
- * pinned to a zone different from the device's — the cases where showing it
- * removes ambiguity. Null otherwise (all-day, device-zone, blank, or an id the
- * tz database doesn't know).
- *
- * Resolved *at [at]*, the event's own start, not at "now": the abbreviation and
- * offset both move with DST, and the card prints them next to the event's time.
- * Resolving at now would label a July event "CET · 10:00 AM" when read in
- * January — an abbreviation that contradicts the time beside it.
+ * A localized label for [tz] (e.g. "Central European Time (Europe/Berlin)"),
+ * but only when the event is timed and pinned to a zone different from the
+ * device's. Returns null when there's nothing worth showing.
  */
-private fun foreignTimeZone(
-    tz: String?,
-    isAllDay: Boolean,
-    locale: Locale,
-    at: Instant,
-): TimeZoneOption? {
+private fun foreignTimeZoneLabel(tz: String?, isAllDay: Boolean, locale: Locale): String? {
     if (isAllDay || tz.isNullOrBlank()) return null
-    if (tz == ZoneId.systemDefault().id) return null
-    return timeZoneOptionOf(
-        tz,
-        locale,
-        at = at.toJavaInstant(),
-        regionOf = ::icuTimeZoneRegion,
-    )
+    val deviceZone = ZoneId.systemDefault().id
+    if (tz == deviceZone) return null
+    return try {
+        val zone = ZoneId.of(tz)
+        val name = zone.getDisplayName(JavaTextStyle.FULL, locale)
+        if (name == tz) tz else "$name ($tz)"
+    } catch (e: Exception) {
+        tz
+    }
 }
 
 /** Wrap http(s) URLs in [text] as tappable links tinted [linkColor]. */

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt

@@ -98,6 +98,7 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat
 import androidx.hilt.navigation.compose.hiltViewModel
@@ -110,9 +111,6 @@ import de.jeanlucmakiola.calendula.domain.EventAttendee
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventFormField
-import de.jeanlucmakiola.calendula.domain.zoneDescriptor
-import de.jeanlucmakiola.calendula.domain.timeZoneOptionOf
-import de.jeanlucmakiola.calendula.domain.timesIn
 import de.jeanlucmakiola.calendula.domain.EventFormProblem
 import de.jeanlucmakiola.calendula.domain.RecurrenceEnd
 import de.jeanlucmakiola.calendula.domain.RecurrenceFreq
@@ -128,8 +126,6 @@ import de.jeanlucmakiola.calendula.data.calendar.CalendarColorPalette
 import de.jeanlucmakiola.calendula.ui.common.CalendarPickerGroups
 import de.jeanlucmakiola.calendula.ui.common.CalendarDatePickerDialog
 import de.jeanlucmakiola.calendula.ui.common.ColorSwatchRow
-import de.jeanlucmakiola.calendula.ui.common.TimeZonePickerDialog
-import de.jeanlucmakiola.calendula.ui.common.icuTimeZoneRegion
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.floret.components.DialogAmountField
@@ -138,19 +134,16 @@ import de.jeanlucmakiola.calendula.ui.common.eventFormFieldIcon
 import de.jeanlucmakiola.calendula.ui.common.eventFormFieldLabel
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.GroupedSurface
 import de.jeanlucmakiola.calendula.ui.common.MILLIS_PER_DAY
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.OptionCard
 import de.jeanlucmakiola.floret.components.OptionPicker
 import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.floret.components.SelectedCheck
-import de.jeanlucmakiola.floret.components.groupedShape as floretGroupedShape
 import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS
 import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.floret.reminders.ReminderUnit
-import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
@@ -164,14 +157,13 @@ import kotlinx.datetime.TimeZone
 import kotlinx.datetime.isoDayNumber
 import kotlinx.datetime.toJavaDayOfWeek
 import kotlinx.datetime.toJavaLocalDate
-import kotlinx.datetime.toInstant
+import kotlinx.datetime.toKotlinDayOfWeek
 import kotlinx.datetime.toJavaLocalTime
 import kotlinx.datetime.toLocalDateTime
-import kotlin.time.toJavaInstant
-import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
 import java.time.format.TextStyle as JavaTextStyle
+import java.time.temporal.WeekFields
 import java.util.Locale
 import kotlin.time.Clock
 
@@ -503,7 +495,6 @@ private fun EventEditContent(
 ) {
     val form = state.form
     val locale = currentLocale()
-    val firstDayOfWeek by viewModel.firstDayOfWeek.collectAsStateWithLifecycle()
     val dark = isSystemInDarkTheme()
     // The title, date and recurrence are managed by the special-dates sync, so
     // they're locked here; everything else (reminders, location, notes) is the
@@ -515,7 +506,6 @@ private fun EventEditContent(
     var showRecurrencePicker by rememberSaveable { mutableStateOf(false) }
     var showVisibilityPicker by rememberSaveable { mutableStateOf(false) }
     var showColorPicker by rememberSaveable { mutableStateOf(false) }
-    var showTimezonePicker by rememberSaveable { mutableStateOf(false) }
     var showFieldPicker by rememberSaveable { mutableStateOf(false) }
 
     // Pick a guest from contacts: a one-shot system picker returning the chosen
@@ -680,28 +670,6 @@ private fun EventEditContent(
                     color = MaterialTheme.colorScheme.error,
                 )
             }
-            // The rows above edit a pinned event in *its own* zone, which is the
-            // time it was set at — but that says nothing about when it lands for
-            // whoever is reading it. Spell the local equivalent out rather than
-            // leaving the user to do the offset arithmetic. Absent (null) unless
-            // the event is pinned somewhere other than here.
-            // Keyed rather than recomputed: this sits in the same Column as the
-            // title field, so it would otherwise re-parse the zone on every
-            // keystroke.
-            val localTimes = remember(form.timezone, form.start, form.end, form.isAllDay) {
-                form.timesIn(TimeZone.currentSystemDefault())
-            }
-            localTimes?.let { (localStart, localEnd) ->
-                Spacer(Modifier.height(2.dp))
-                Text(
-                    text = stringResource(
-                        R.string.event_edit_timezone_local_time,
-                        formatTimeRange(localStart, localEnd, locale),
-                    ),
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                )
-            }
         }
 
         Spacer(Modifier.height(gap))
@@ -738,54 +706,6 @@ private fun EventEditContent(
 
         // Optional sections: which ones render by default is a setting; the
         // rest unfold behind the "more fields" button below.
-        OptionalFormSection(visible = EventFormField.Timezone in state.visibleFields) {
-            Spacer(Modifier.height(gap))
-            EditCard(
-                icon = Icons.Default.Public,
-                iconContentDescription = null,
-                onClick = { showTimezonePicker = true },
-            ) {
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier.fillMaxWidth(),
-                ) {
-                    // Resolved at the event's own start, not at "now": the
-                    // abbreviation and offset shown ("CEST · GMT+02:00") must be
-                    // the ones that apply when the event actually happens.
-                    val pinned = remember(form.timezone, form.start, locale) {
-                        form.timezone
-                            ?.let { id -> runCatching { id to TimeZone.of(id) }.getOrNull() }
-                            ?.let { (id, zone) ->
-                                timeZoneOptionOf(
-                                    id,
-                                    locale,
-                                    at = form.start.toInstant(zone).toJavaInstant(),
-                                    regionOf = ::icuTimeZoneRegion,
-                                )
-                            }
-                    }
-                    Column(modifier = Modifier.weight(1f)) {
-                        Text(
-                            text = pinned?.label
-                                ?: stringResource(R.string.event_edit_timezone_device),
-                            style = MaterialTheme.typography.titleMedium,
-                        )
-                        Text(
-                            text = pinned?.let { zoneDescriptor(it) }
-                                ?: stringResource(R.string.event_edit_timezone_device_summary),
-                            style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant,
-                        )
-                    }
-                    Icon(
-                        imageVector = Icons.Default.ArrowDropDown,
-                        contentDescription = null,
-                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                    )
-                }
-            }
-        }
-
         OptionalFormSection(visible = EventFormField.Location in state.visibleFields) {
             Spacer(Modifier.height(gap))
             EditCard(
@@ -1142,7 +1062,6 @@ private fun EventEditContent(
         RecurrencePickerDialog(
             current = form.rrule,
             startDay = form.start.date.dayOfWeek,
-            firstDayOfWeek = firstDayOfWeek,
             onSelect = { rrule ->
                 viewModel.setRecurrence(rrule)
                 showRecurrencePicker = false
@@ -1162,16 +1081,6 @@ private fun EventEditContent(
         )
     }
 
-    if (showTimezonePicker) {
-        TimeZonePickerDialog(
-            selected = form.timezone,
-            deviceZoneId = ZoneId.systemDefault().id,
-            recents = state.recentTimeZones,
-            onSelect = viewModel::setTimezone,
-            onDismiss = { showTimezonePicker = false },
-        )
-    }
-
     if (showColorPicker) {
         ColorPickerDialog(
             palette = state.colorPalette,
@@ -1314,7 +1223,6 @@ private enum class RecurrenceEndMode { Never, Until, Count }
 private fun RecurrencePickerDialog(
     current: String?,
     startDay: DayOfWeek,
-    firstDayOfWeek: DayOfWeek,
     onSelect: (String?) -> Unit,
     onDismiss: () -> Unit,
 ) {
@@ -1349,21 +1257,8 @@ private fun RecurrencePickerDialog(
 
     val locale = currentLocale()
     val untilDate = untilIso?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
-    // remember() must not sit behind the ?. — a slot that appears and disappears
-    // as a date is picked breaks Compose's positional memoisation. Format
-    // unconditionally and let the null fall through to a null summary.
-    val untilSummary = remember(untilDate, locale) {
-        untilDate?.let {
-            DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)
-                .withLocale(locale).format(it.toJavaLocalDate())
-        }
-    }
-    // A blank amount field shows its placeholder ("1" / "10") greyed out, so read
-    // blank as that default rather than as an error — otherwise simply clearing
-    // the field silently greys out OK. Only a real out-of-range value (0) is
-    // invalid, and that's the one case the read-out below reports.
-    val interval = if (intervalText.isBlank()) 1 else intervalText.toIntOrNull()?.takeIf { it in 1..999 }
-    val count = if (countText.isBlank()) 10 else countText.toIntOrNull()?.takeIf { it in 1..999 }
+    val interval = intervalText.toIntOrNull()?.takeIf { it in 1..999 }
+    val count = countText.toIntOrNull()?.takeIf { it in 1..999 }
     val customEnd: RecurrenceEnd? = when (endMode) {
         RecurrenceEndMode.Never -> RecurrenceEnd.Never
         RecurrenceEndMode.Until -> untilDate?.let { RecurrenceEnd.Until(it) }
@@ -1399,11 +1294,6 @@ private fun RecurrencePickerDialog(
                 title = stringResource(R.string.event_edit_recurrence_none),
                 position = positionOf(0, rowCount),
                 selected = current == null,
-                trailing = if (current == null) {
-                    { SelectedCheck() }
-                } else {
-                    null
-                },
                 onClick = { onSelect(null) },
             )
             RecurrenceFreq.entries.forEachIndexed { index, entry ->
@@ -1411,11 +1301,6 @@ private fun RecurrencePickerDialog(
                     title = stringResource(recurrencePresetLabel(entry)),
                     position = positionOf(index + 1, rowCount),
                     selected = isPlainPreset && parsed?.freq == entry,
-                    trailing = if (isPlainPreset && parsed?.freq == entry) {
-                        { SelectedCheck() }
-                    } else {
-                        null
-                    },
                     onClick = { onSelect(SimpleRecurrence(entry).toRRule()) },
                 )
             }
@@ -1423,195 +1308,88 @@ private fun RecurrencePickerDialog(
                 title = stringResource(R.string.event_edit_recurrence_custom),
                 position = positionOf(rowCount - 1, rowCount),
                 selected = current != null && !isPlainPreset,
-                trailing = if (current != null && !isPlainPreset) {
-                    { SelectedCheck() }
-                } else {
-                    null
-                },
                 onClick = { customMode = true },
             )
         } else {
-            // Section gaps live on each block (not a parent spacedBy) so the
-            // weekday card's gap collapses *with* it under AnimatedVisibility —
-            // a parent arrangement would leave a residual gap that snaps shut.
-            Column(modifier = Modifier.fillMaxWidth()) {
-                // A live, human-readable read-out of the rule being built, so the
-                // effect of the controls below is never a guess. It renders
-                // *[customResult] itself* — the exact string OK would save — so it
-                // can never describe a different rule than the one that lands. When
-                // the form can't produce a rule, it says why instead of falling
-                // back to defaults and quietly disagreeing with the controls.
-                // minLines reserves the second line up front: without it the whole
-                // stack below shifts a line as the phrase grows with each weekday.
-                Text(
-                    text = customResult?.let { recurrenceText(it, locale) }
-                        ?: AnnotatedString(
-                            stringResource(R.string.event_edit_recurrence_incomplete),
-                        ),
-                    style = MaterialTheme.typography.titleMedium,
-                    color = if (customResult != null) {
-                        MaterialTheme.colorScheme.onSurface
-                    } else {
-                        MaterialTheme.colorScheme.error
-                    },
-                    minLines = 2,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 16.dp),
-                )
-
-                // How often: an interval amount plus a frequency segmented row —
-                // all four units on show, no unit hidden behind a dropdown.
-                GroupedSurface(
-                    position = Position.Alone,
-                    modifier = Modifier
-                        .padding(top = 16.dp)
-                        .padding(horizontal = 16.dp),
-                ) {
-                    Column(
-                        modifier = Modifier.padding(16.dp),
-                        verticalArrangement = Arrangement.spacedBy(16.dp),
-                    ) {
-                        Row(verticalAlignment = Alignment.CenterVertically) {
-                            Text(
-                                text = stringResource(R.string.event_edit_recurrence_every),
-                                style = MaterialTheme.typography.titleMedium,
-                            )
-                            Spacer(Modifier.width(12.dp))
-                            DialogAmountField(
-                                value = intervalText,
-                                onValueChange = { intervalText = it },
-                                placeholder = "1",
-                            )
-                        }
-                        SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
-                            RecurrenceFreq.entries.forEachIndexed { index, entry ->
-                                SegmentedButton(
-                                    selected = freq == entry,
-                                    onClick = { freq = entry },
-                                    shape = SegmentedButtonDefaults.itemShape(
-                                        index, RecurrenceFreq.entries.size,
-                                    ),
-                                    // Drop the default check-icon slot: four segments
-                                    // share one row, and its reserved width is what
-                                    // pushes longer labels ("Monate", "Wochen") into
-                                    // an ellipsis on a compact screen. Selection is
-                                    // already carried by the segment's fill.
-                                    icon = {},
-                                    label = {
-                                        Text(
-                                            text = stringResource(recurrenceUnitLabel(entry)),
-                                            maxLines = 1,
-                                        )
-                                    },
-                                )
-                            }
-                        }
-                    }
-                }
-
-                // Weekday picks — only meaningful on a weekly rule. The 16dp gap
-                // sits inside the animated block so it grows/shrinks with the card.
-                AnimatedVisibility(
-                    visible = freq == RecurrenceFreq.Weekly,
-                    enter = expandEnter(),
-                    exit = collapseExit(),
-                ) {
-                    GroupedSurface(
-                        position = Position.Alone,
-                        modifier = Modifier
-                            .padding(top = 16.dp)
-                            .padding(horizontal = 16.dp),
-                    ) {
-                        WeekdayToggleRow(
-                            selected = daysMask.toDaySet(),
-                            onToggle = { day -> daysMask = daysMask xor day.toMaskBit() },
-                            locale = locale,
-                            firstDay = firstDayOfWeek,
-                            modifier = Modifier.padding(16.dp),
-                        )
-                    }
-                }
-
-                // Ends: a connected never / on-a-date / after-N group, the count
-                // field folding into the bottom of the run when chosen.
-                Column(modifier = Modifier.padding(top = 16.dp)) {
+            Column(
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+                modifier = Modifier.padding(horizontal = 24.dp),
+            ) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
                     Text(
-                        text = stringResource(R.string.event_edit_recurrence_ends),
-                        style = MaterialTheme.typography.labelLarge,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                        modifier = Modifier.padding(start = 16.dp, bottom = 8.dp),
+                        text = stringResource(R.string.event_edit_recurrence_every),
+                        style = MaterialTheme.typography.titleMedium,
                     )
-                    GroupedRow(
-                        title = stringResource(R.string.event_edit_recurrence_end_never),
-                        position = Position.Top,
-                        selected = endMode == RecurrenceEndMode.Never,
-                        trailing = if (endMode == RecurrenceEndMode.Never) {
-                            { SelectedCheck() }
-                        } else {
-                            null
-                        },
-                        onClick = { endMode = RecurrenceEndMode.Never },
+                    Spacer(Modifier.width(12.dp))
+                    DialogAmountField(
+                        value = intervalText,
+                        onValueChange = { intervalText = it },
+                        placeholder = "1",
                     )
-                    GroupedRow(
-                        title = stringResource(R.string.event_edit_recurrence_end_until),
-                        summary = untilSummary,
-                        position = Position.Middle,
-                        selected = endMode == RecurrenceEndMode.Until,
-                        trailing = if (endMode == RecurrenceEndMode.Until) {
-                            { SelectedCheck() }
-                        } else {
-                            null
-                        },
-                        onClick = {
-                            endMode = RecurrenceEndMode.Until
-                            showUntilPicker = true
+                    Spacer(Modifier.width(12.dp))
+                    DialogUnitDropdown(
+                        label = stringResource(recurrenceUnitLabel(freq)),
+                        entries = RecurrenceFreq.entries.map {
+                            stringResource(recurrenceUnitLabel(it))
                         },
+                        onPick = { freq = RecurrenceFreq.entries[it] },
                     )
-                    GroupedRow(
-                        title = stringResource(R.string.event_edit_recurrence_end_count),
-                        position = if (endMode == RecurrenceEndMode.Count) {
-                            Position.Middle
-                        } else {
-                            Position.Bottom
-                        },
-                        selected = endMode == RecurrenceEndMode.Count,
-                        trailing = if (endMode == RecurrenceEndMode.Count) {
-                            { SelectedCheck() }
-                        } else {
-                            null
-                        },
-                        onClick = { endMode = RecurrenceEndMode.Count },
+                }
+                if (freq == RecurrenceFreq.Weekly) {
+                    WeekdayToggleRow(
+                        selected = daysMask.toDaySet(),
+                        onToggle = { day -> daysMask = daysMask xor day.toMaskBit() },
+                        locale = locale,
                     )
-                    // Animated for the same reason the weekday card is: this is the
-                    // picker's other collapsible block, and a bare `if` here made
-                    // the ends group snap while the card above it glided.
-                    AnimatedVisibility(
-                        visible = endMode == RecurrenceEndMode.Count,
-                        enter = expandEnter(),
-                        exit = collapseExit(),
-                    ) {
-                        GroupedSurface(
-                            position = Position.Bottom,
-                            modifier = Modifier.padding(horizontal = 16.dp),
-                        ) {
-                            Row(
-                                verticalAlignment = Alignment.CenterVertically,
-                                modifier = Modifier.padding(16.dp),
-                            ) {
-                                DialogAmountField(
-                                    value = countText,
-                                    onValueChange = { countText = it },
-                                    placeholder = "10",
-                                )
-                                Spacer(Modifier.width(12.dp))
-                                Text(
-                                    text = stringResource(R.string.event_edit_recurrence_times),
-                                    style = MaterialTheme.typography.titleMedium,
-                                )
-                            }
-                        }
+                }
+                Text(
+                    text = stringResource(R.string.event_edit_recurrence_ends),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+            GroupedRow(
+                title = stringResource(R.string.event_edit_recurrence_end_never),
+                position = positionOf(0, 3),
+                selected = endMode == RecurrenceEndMode.Never,
+                onClick = { endMode = RecurrenceEndMode.Never },
+            )
+            GroupedRow(
+                title = stringResource(R.string.event_edit_recurrence_end_until),
+                summary = untilDate?.let {
+                    remember(it, locale) {
+                        DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)
+                            .withLocale(locale).format(it.toJavaLocalDate())
                     }
+                },
+                position = positionOf(1, 3),
+                selected = endMode == RecurrenceEndMode.Until,
+                onClick = {
+                    endMode = RecurrenceEndMode.Until
+                    showUntilPicker = true
+                },
+            )
+            GroupedRow(
+                title = stringResource(R.string.event_edit_recurrence_end_count),
+                position = positionOf(2, 3),
+                selected = endMode == RecurrenceEndMode.Count,
+                onClick = { endMode = RecurrenceEndMode.Count },
+            )
+            if (endMode == RecurrenceEndMode.Count) {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier.padding(horizontal = 24.dp, vertical = 4.dp),
+                ) {
+                    DialogAmountField(
+                        value = countText,
+                        onValueChange = { countText = it },
+                        placeholder = "10",
+                    )
+                    Spacer(Modifier.width(12.dp))
+                    Text(
+                        text = stringResource(R.string.event_edit_recurrence_times),
+                        style = MaterialTheme.typography.titleMedium,
+                    )
                 }
             }
         }
@@ -1626,13 +1404,7 @@ private fun RecurrencePickerDialog(
                 untilIso = it.toString()
                 showUntilPicker = false
             },
-            onDismiss = {
-                showUntilPicker = false
-                // Backing out of the date picker with nothing chosen would leave
-                // "on date" selected but dateless — a state that can't be saved and
-                // greys out OK with no visible cause. Fall back to "never".
-                if (untilIso == null) endMode = RecurrenceEndMode.Never
-            },
+            onDismiss = { showUntilPicker = false },
         )
     }
 }
@@ -1647,15 +1419,14 @@ private fun WeekdayToggleRow(
     selected: Set<DayOfWeek>,
     onToggle: (DayOfWeek) -> Unit,
     locale: Locale,
-    firstDay: DayOfWeek,
-    modifier: Modifier = Modifier,
 ) {
-    val days = remember(firstDay) {
-        (0 until 7).map { DayOfWeek(((firstDay.isoDayNumber - 1 + it) % 7) + 1) }
+    val days = remember(locale) {
+        val first = WeekFields.of(locale).firstDayOfWeek.toKotlinDayOfWeek()
+        (0 until 7).map { DayOfWeek(((first.isoDayNumber - 1 + it) % 7) + 1) }
     }
     Row(
         horizontalArrangement = Arrangement.SpaceBetween,
-        modifier = modifier.fillMaxWidth(),
+        modifier = Modifier.fillMaxWidth(),
     ) {
         days.forEach { day ->
             val isSelected = day in selected
@@ -1708,14 +1479,18 @@ private fun recurrenceUnitLabel(freq: RecurrenceFreq): Int = when (freq) {
     RecurrenceFreq.Yearly -> R.string.recurrence_unit_years
 }
 
-/**
- * Corner shape for a card at [position] in a grouped run. Delegates to the
- * family primitive with the same radii [GroupedSurface] draws at rest — a local
- * copy had drifted to 20dp, so a card sharing a run with GroupedRows had
- * visibly tighter outer corners than the rows above it.
- */
-private fun groupedShape(position: Position): Shape =
-    floretGroupedShape(position, full = 22.dp, small = 6.dp)
+/** Corner shape for a card at [position] in a grouped run (mirrors GroupedRow). */
+private fun groupedShape(position: Position, full: Dp = 20.dp, small: Dp = 6.dp): Shape =
+    when (position) {
+        Position.Alone -> RoundedCornerShape(full)
+        Position.Top -> RoundedCornerShape(
+            topStart = full, topEnd = full, bottomStart = small, bottomEnd = small,
+        )
+        Position.Middle -> RoundedCornerShape(small)
+        Position.Bottom -> RoundedCornerShape(
+            topStart = small, topEnd = small, bottomStart = full, bottomEnd = full,
+        )
+    }
 
 /** The 2dp gap that visually separates grouped cards (none after the last). */
 private fun groupedGap(position: Position): Modifier = when (position) {
@@ -2158,21 +1933,6 @@ private fun EditCard(
     }
 }
 
-/**
- * "2:00 PM – 3:00 PM", honouring the user's 12/24-hour setting. Collapses to one
- * time when both land on the same minute (an instant event shouldn't read as a
- * range against itself). Dates are deliberately absent — the rows above carry
- * them.
- */
-@Composable
-private fun formatTimeRange(start: LocalDateTime, end: LocalDateTime, locale: Locale): String {
-    val use24Hour = LocalUse24HourFormat.current
-    val timeFormat = remember(locale, use24Hour) { timeOfDayFormatter(use24Hour, locale) }
-    val from = timeFormat.format(start.time.toJavaLocalTime())
-    val to = timeFormat.format(end.time.toJavaLocalTime())
-    return if (from == to) from else "$from – $to"
-}
-
 /**
  * Borderless text input used inside the cards (and as the headline title).
  * Thin wrapper over the shared [InlineTextField] so the form and the rest of

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditUiState.kt

@@ -27,8 +27,6 @@ data class EventEditUiState(
      * neither list.
      */
     val hiddenFields: List<EventFormField> = emptyList(),
-    /** Recently picked zones, most recent first — the zone picker's shortlist. */
-    val recentTimeZones: List<String> = emptyList(),
     /** True while editing an existing event (the calendar is then fixed). */
     val isEditing: Boolean = false,
     /**

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt

@@ -8,7 +8,6 @@ import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.data.prefs.firstDayOfWeek
 import de.jeanlucmakiola.calendula.data.prefs.resolveDefaultReminder
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
@@ -40,8 +39,6 @@ import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
@@ -222,8 +219,7 @@ class EventEditViewModel @Inject constructor(
         ).flowOn(io),
         colorPalette,
         allCalendars,
-        settingsPrefs.recentTimeZones.flowOn(io),
-    ) { local, external, palette, allCalendars, recentTimeZones ->
+    ) { local, external, palette, allCalendars ->
         val form = local.form ?: return@combine null
         val resolvedId = form.calendarId
             ?: external.lastUsed?.takeIf { id -> external.writable.any { it.id == id } }
@@ -239,19 +235,14 @@ class EventEditViewModel @Inject constructor(
         val pickerCalendars =
             if (isManaged && resolvedCalendar != null) external.writable + resolvedCalendar
             else external.writable
-        // An all-day event is date-anchored, so a zone is meaningless on it —
-        // the field is withheld from both lists rather than shown as a no-op.
-        val offerableFields = EventFormField.entries.toSet() -
-            if (resolved.isAllDay) setOf(EventFormField.Timezone) else emptySet()
-        val visibleFields = (external.defaultFields + local.revealed) intersect offerableFields
+        val visibleFields = external.defaultFields + local.revealed
         EventEditUiState(
             form = resolved,
             calendars = pickerCalendars,
             problems = if (local.showProblems) resolved.problems() else emptySet(),
             saveState = local.saveState,
             visibleFields = visibleFields,
-            hiddenFields = (offerableFields - visibleFields).sorted(),
-            recentTimeZones = recentTimeZones,
+            hiddenFields = (EventFormField.entries.toSet() - visibleFields).sorted(),
             isEditing = local.editTarget != null,
             isManaged = isManaged,
             autofocusTitle = external.autofocusTitle,
@@ -269,13 +260,6 @@ class EventEditViewModel @Inject constructor(
             initialValue = null,
         )
 
-    /**
-     * First day of the week for ordering the recurrence weekday toggles — the
-     * app's "week starts on" preference, matching the calendar views (Auto
-     * falls back to the locale convention).
-     */
-    val firstDayOfWeek: StateFlow<DayOfWeek> = settingsPrefs.firstDayOfWeek(viewModelScope)
-
     /**
      * Initialise a fresh form for a new event on [date]. [startMinutes] (minutes
      * from midnight) anchors the start when the form is opened by tapping a slot
@@ -469,28 +453,12 @@ class EventEditViewModel @Inject constructor(
     fun setLocation(value: String) = update { it.copy(location = value) }
     fun setDescription(value: String) = update { it.copy(description = value) }
     fun setAllDay(value: Boolean) {
-        // Going all-day drops any pinned zone: the times become bare dates that
-        // the provider stores UTC-anchored, so a zone could only misrepresent
-        // them. Coming back out of all-day leaves the event on the device zone,
-        // which is the same thing a fresh event gets.
-        update { it.copy(isAllDay = value, timezone = if (value) null else it.timezone) }
+        update { it.copy(isAllDay = value) }
         // The default reminder differs for all-day vs timed; re-apply the
         // type-appropriate default unless the user has hand-edited it (guarded).
         applyDefaultReminder()
     }
 
-    /**
-     * Pin the event to [zoneId], or pass null to follow the device. The zone
-     * rides along as a recent so the picker can offer it without a search next
-     * time — only real picks are remembered, not the device fallback.
-     */
-    fun setTimezone(zoneId: String?) {
-        update { it.copy(timezone = zoneId) }
-        if (zoneId != null) {
-            viewModelScope.launch { withContext(io) { settingsPrefs.addRecentTimeZone(zoneId) } }
-        }
-    }
-
     /**
      * Switching calendars drops any chosen colour: a palette key is
      * account-scoped, and a raw colour may be invalid on the new calendar.

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

@@ -1,154 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.month
-
-import androidx.compose.animation.AnimatedVisibilityScope
-import androidx.compose.animation.ExperimentalSharedTransitionApi
-import androidx.compose.animation.SharedTransitionScope
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.compositionLocalOf
-import androidx.compose.ui.Modifier
-import kotlinx.datetime.LocalDate
-
-/**
- * What lets the split style's compact grid *become* the full month rather than be
- * swapped for it (#53).
- *
- * The two grids are separate composables — the compact one draws dots, the
- * expanded one draws the paged style's bars and pills — so nothing about them is
- * shared by construction. Tagging the pieces that mean the same thing on both
- * sides with the same [MonthMorphKey] hands Compose enough to animate one into
- * the other: a day's cell grows, its number rides along, and each dot travels out
- * to the bar it stood for.
- *
- * It travels as a composition local rather than as parameters because the pieces
- * sit five levels below where the scopes exist, and because a null default is
- * exactly the right meaning for everyone else: the paged, continuous, and dense
- * styles share the same row and cell composables, provide nothing, and pay
- * nothing. Reduced motion provides nothing either, which leaves the plain
- * cross-fade underneath.
- */
-internal sealed interface MonthMorphKey {
-    /** A day's background pill — the structural anchor the rest rides on. */
-    data class Cell(val date: LocalDate) : MonthMorphKey
-
-    data class DayNumber(val date: LocalDate) : MonthMorphKey
-
-    /**
-     * One event *on one day*. Keyed by date as well as instance because a
-     * multi-day event has a dot on every day it covers but only one bar, drawn
-     * from where it starts: the start day's dot is the one that becomes the bar,
-     * and the rest are left unmatched on purpose. They fade where they stand
-     * while the bar sweeps out over them, which is the honest reading — one of
-     * them could not become the bar without the others teleporting into it.
-     */
-    data class Event(val date: LocalDate, val instanceId: Long) : MonthMorphKey
-
-    /**
-     * A day's "+N" marker. The compact grid writes it as a count beside the dots
-     * and the expanded one as a row of small dots under the bars, but they stand
-     * for the same events and appear on exactly the same days — both sides seat
-     * three and overflow the rest — so they are a matched pair, not two unrelated
-     * bits of text. Tagged, the marker travels with its day like everything else
-     * in the cell.
-     */
-    data class Overflow(val date: LocalDate) : MonthMorphKey
-
-    /**
-     * The selected day's outline. The expanded grid draws no outline — once the
-     * cells carry real event bars it is one mark too many — so this pairs the
-     * compact grid's outline with an *invisible* stand-in over the same cell
-     * there. Without one it had nowhere to travel and could only fade in place
-     * while everything around it moved.
-     */
-    data class Selection(val date: LocalDate) : MonthMorphKey
-
-    /** The grab handle, which slides from the pane's seam to the foot of the grid. */
-    data object Handle : MonthMorphKey
-}
-
-@OptIn(ExperimentalSharedTransitionApi::class)
-internal class MonthMorphScope(
-    val shared: SharedTransitionScope,
-    val visibility: AnimatedVisibilityScope,
-)
-
-internal val LocalMonthMorph = compositionLocalOf<MonthMorphScope?> { null }
-
-/**
- * True while the grid is mid-morph, for content that has to stop clipping to let
- * the travelling pieces through.
- *
- * A mark's two homes are in *different rows*: the dot for the 20th sits a third
- * of the way down the compact grid, its bar most of the way down the expanded
- * one. Clipped to the row it is arriving at, a mark spends the first half of its
- * journey outside those bounds and is simply not drawn — so it appears from
- * nowhere, part-way through, already near its destination. Rendering in place
- * rather than in an overlay is what subjects them to that clip, and is worth
- * keeping; the clip is what has to yield, and only while pieces are in flight.
- */
-@OptIn(ExperimentalSharedTransitionApi::class)
-@Composable
-internal fun morphInFlight(): Boolean {
-    val morph = LocalMonthMorph.current ?: return false
-    return morph.shared.isTransitionActive
-}
-
-/**
- * Tag content that is *the same thing* on both sides — a background pill, a day
- * number — so it animates between its two positions and sizes.
- *
- * ### Why nothing renders in the overlay
- *
- * By default a travelling piece is painted into an overlay above the *entire*
- * regular tree, so it can fly over anything in its way. That is right for a
- * thumbnail crossing a screen, and wrong here: everything is moving inside one
- * grid, and the overlay meant every untagged neighbour — the selection outline,
- * the "+N" markers — spent the transition buried under pieces that had left the
- * tree's z-order behind. Lifting each of them out in turn fixed the burying and
- * bought a worse problem: they then floated over the grid on their own layer,
- * out of step with it.
- *
- * Rendering in place puts everything back in one z-order and one clip, which is
- * what makes the grid read as a single surface changing shape rather than a
- * stack of pieces sliding past each other. Nothing here needs to escape its
- * ancestors: the cells, marks and markers all travel within the grid.
- */
-@OptIn(ExperimentalSharedTransitionApi::class)
-@Composable
-internal fun Modifier.morphElement(key: MonthMorphKey): Modifier {
-    val morph = LocalMonthMorph.current ?: return this
-    return with(morph.shared) {
-        this@morphElement.sharedElement(
-            sharedContentState = rememberSharedContentState(key),
-            animatedVisibilityScope = morph.visibility,
-            renderInOverlayDuringTransition = false,
-        )
-    }
-}
-
-/**
- * Tag content that means the same thing but *is drawn differently* on each side —
- * a 5dp dot and a titled bar — so only the bounds are shared and the contents
- * cross-fade inside them.
- *
- * [ResizeMode.RemeasureToBounds][SharedTransitionScope.ResizeMode] rather than
- * scaling: a bar's title laid out at the dot's 5dp and then scaled up would
- * arrive as a smear. Remeasuring keeps the text at its real size throughout and
- * simply clips it while there is no room, so what grows is the pill, not the type.
- */
-@OptIn(ExperimentalSharedTransitionApi::class)
-@Composable
-internal fun Modifier.morphBounds(key: MonthMorphKey): Modifier {
-    val morph = LocalMonthMorph.current ?: return this
-    return with(morph.shared) {
-        this@morphBounds.sharedBounds(
-            sharedContentState = rememberSharedContentState(key),
-            animatedVisibilityScope = morph.visibility,
-            enter = fadeIn(),
-            exit = fadeOut(),
-            resizeMode = SharedTransitionScope.ResizeMode.RemeasureToBounds,
-            renderInOverlayDuringTransition = false,
-        )
-    }
-}

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

@@ -1,284 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.month
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clipToBounds
-import androidx.compose.ui.layout.layout
-import androidx.compose.ui.unit.Constraints
-import androidx.compose.ui.graphics.TransformOrigin
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.input.pointer.PointerEventPass
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalConfiguration
-import androidx.compose.ui.semantics.clearAndSetSemantics
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.DayOfWeek
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.YearMonth
-import kotlinx.datetime.atTime
-import kotlinx.datetime.plus
-import kotlinx.datetime.toInstant
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Clock
-import kotlin.math.roundToInt
-
-/**
- * A live, scaled-down Month view in a given [MonthViewStyle], for the settings
- * chooser.
- *
- * It renders the *real* grid composables rather than a drawing of them, so the
- * preview cannot drift from the thing it depicts: change a cell's shape or an
- * event bar's colour and every preview follows automatically. The trick is
- * [requiredSize] — it ignores the incoming constraints, so the grid lays itself
- * out at a full phone width and a plausible viewport height, and a
- * [graphicsLayer] scale shrinks the finished layout into the card.
- *
- * The month, today's position and the week start are all real; only the events
- * are stand-ins, since the settings screen has no business querying the
- * provider for a thumbnail.
- */
-@Composable
-internal fun MonthStylePreview(
-    style: MonthViewStyle,
-    weekStart: DayOfWeek,
-    height: Dp,
-    modifier: Modifier = Modifier,
-) {
-    val screenWidth = LocalConfiguration.current.screenWidthDp.dp
-    val scale = height.value / VIRTUAL_HEIGHT.value
-    val zone = remember { TimeZone.currentSystemDefault() }
-    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
-    val sample = remember(today, weekStart, zone) { sampleMonthState(today, weekStart, zone) }
-
-    Box(
-        modifier = modifier
-            .clipToBounds()
-            .background(MaterialTheme.colorScheme.surface)
-            // A preview is a picture, not a control: swallow touches before the
-            // grid's own clickables see them, and give screen readers one label
-            // instead of six weeks of day cells.
-            .pointerInput(Unit) {
-                awaitPointerEventScope {
-                    while (true) {
-                        awaitPointerEvent(PointerEventPass.Initial).changes
-                            .forEach { it.consume() }
-                    }
-                }
-            }
-            .clearAndSetSemantics { }
-            // Measure the grid at a full phone viewport but report the scaled
-            // size, so the node occupies exactly what it draws.
-            //
-            // Modifier.requiredSize would be the obvious way to force the larger
-            // measurement, but it *centres* content that overflows the incoming
-            // constraints — which pushed the grid to a negative offset and left
-            // only its bottom-right corner inside the clip.
-            .layout { measurable, _ ->
-                val fullWidth = screenWidth.roundToPx()
-                val fullHeight = VIRTUAL_HEIGHT.roundToPx()
-                val placeable = measurable.measure(Constraints.fixed(fullWidth, fullHeight))
-                layout((fullWidth * scale).roundToInt(), (fullHeight * scale).roundToInt()) {
-                    placeable.place(0, 0)
-                }
-            }
-            .graphicsLayer {
-                scaleX = scale
-                scaleY = scale
-                transformOrigin = TransformOrigin(0f, 0f)
-            },
-    ) {
-        Column(Modifier.fillMaxSize()) {
-            WeekdayHeader(weekStart = weekStart, showWeekNumbers = false)
-                when (style) {
-                    MonthViewStyle.Paged -> MonthGrid(
-                        state = sample.month,
-                        showWeekNumbers = false,
-                        onOpenDay = {},
-                    )
-                    MonthViewStyle.Continuous -> ContinuousMonthGrid(
-                        state = sample.continuous,
-                        listState = rememberLazyListState(
-                            initialFirstVisibleItemIndex = itemIndexForMonth(
-                                monthIndexOf(YearMonth(today.year, today.month)),
-                            ),
-                        ),
-                        showWeekNumbers = false,
-                        onOpenDay = {},
-                    )
-                    MonthViewStyle.Dense -> DenseMonthGrid(
-                        state = sample.continuous,
-                        listState = rememberLazyListState(
-                            // Start a week above today's, so the preview shows a
-                            // stream running past the viewport rather than one
-                            // beginning at its top edge.
-                            initialFirstVisibleItemIndex =
-                                weekIndexOf(today, weekStart) - 1,
-                        ),
-                        showWeekNumbers = false,
-                        onOpenDay = {},
-                    )
-                    MonthViewStyle.Split -> {
-                        SplitMonthGrid(
-                            state = sample.month,
-                            selected = today,
-                            showWeekNumbers = false,
-                            onSelectDay = {},
-                        )
-                        SplitDayPane(
-                            date = today,
-                            today = today,
-                            events = sample.month.instancesByDay[today].orEmpty(),
-                            zone = zone,
-                            onOpenDay = {},
-                            onEventClick = {},
-                            onCreateEvent = {},
-                            modifier = Modifier.fillMaxWidth().height(SPLIT_PANE_HEIGHT),
-                        )
-                    }
-                }
-            }
-    }
-}
-
-/**
- * The viewport the preview pretends to be: a phone's width by the height a
- * calendar view gets under the top bar. Scaling from a fixed height keeps the
- * three styles comparable — each shows the same slice of screen.
- */
-private val VIRTUAL_HEIGHT = 440.dp
-private val SPLIT_PANE_HEIGHT = 170.dp
-
-private class SampleMonth(
-    val month: MonthUiState.Success,
-    val continuous: ContinuousMonthUiState.Success,
-)
-
-/**
- * A month's worth of stand-in events, laid out through the same
- * [layoutMonthWeeks] / [clipWeekToMonth] the live views use — so the preview
- * exercises the real span, lane and overflow logic rather than approximating it.
- *
- * Colours are raw ARGB on purpose: that is what the provider hands out for an
- * event, so a token here would misrepresent what the grid actually renders.
- */
-private fun sampleMonthState(
-    today: LocalDate,
-    weekStart: DayOfWeek,
-    zone: TimeZone,
-): SampleMonth {
-    val ym = YearMonth(today.year, today.month)
-    val first = LocalDate(ym.year, ym.month, 1)
-    val events = sampleEvents(first, today, zone)
-
-    val weeks = layoutMonthWeeks(ym, weekStart, events, zone)
-    val month = MonthUiState.Success(
-        month = ym,
-        today = today,
-        weeks = weeks,
-        instancesByDay = instancesByDay(weeks.flatMap { it.days }, events, zone),
-        zone = zone,
-    )
-
-    // The month either side of this one: enough for Continuous to show a block,
-    // the whitespace under it and the next month's header coming up, and for
-    // Dense to have somewhere to scroll in both directions.
-    val centre = monthIndexOf(ym)
-    val window = (centre - 1)..(centre + 1)
-    val continuous = ContinuousMonthUiState.Success(
-        today = today,
-        monthsByIndex = window.associateWith { index ->
-            val m = yearMonthForIndex(index)
-            layoutMonthWeeks(m, weekStart, events, zone).map { clipWeekToMonth(it, m) }
-        },
-        weeksByIndex = weekWindowFor(window, weekStart).associateWith { index ->
-            val days = (0 until 7).map {
-                weekStartForIndex(index, weekStart).plus(it, DateTimeUnit.DAY)
-            }
-            layoutCalendarWeek(days, events, zone)
-        },
-        weekStart = weekStart,
-    )
-    return SampleMonth(month, continuous)
-}
-
-private val SAMPLE_COLORS = listOf(
-    0xFF3F7BD4.toInt(),
-    0xFFCE5B4C.toInt(),
-    0xFF4E9A6A.toInt(),
-    0xFF8A63C7.toInt(),
-)
-
-private fun sampleEvents(
-    firstOfMonth: LocalDate,
-    today: LocalDate,
-    zone: TimeZone,
-): List<EventInstance> {
-    var id = 0L
-    fun next() = ++id
-
-    fun timed(day: LocalDate, hour: Int, length: Int, colorIndex: Int) = EventInstance(
-        instanceId = next(),
-        eventId = id,
-        calendarId = 1L,
-        title = SAMPLE_TITLES[(id.toInt() - 1) % SAMPLE_TITLES.size],
-        start = day.atTime(hour, 0).toInstant(zone),
-        end = day.atTime(hour + length, 0).toInstant(zone),
-        isAllDay = false,
-        color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
-        location = null,
-    )
-
-    fun allDay(from: LocalDate, days: Int, colorIndex: Int) = EventInstance(
-        instanceId = next(),
-        eventId = id,
-        calendarId = 1L,
-        title = SAMPLE_TITLES[(id.toInt() - 1) % SAMPLE_TITLES.size],
-        // All-day events sit at UTC midnights with an exclusive end.
-        start = from.atTime(0, 0).toInstant(TimeZone.UTC),
-        end = from.plus(days, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
-        isAllDay = true,
-        color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
-        location = null,
-    )
-
-    // Spread across the month so most weeks carry something, with one multi-day
-    // bar to show a span bridging cells and a busy today for the split pane.
-    return buildList {
-        add(allDay(firstOfMonth.plus(9, DateTimeUnit.DAY), days = 3, colorIndex = 2))
-        add(timed(firstOfMonth.plus(1, DateTimeUnit.DAY), 9, 1, 0))
-        add(timed(firstOfMonth.plus(4, DateTimeUnit.DAY), 14, 2, 1))
-        add(timed(firstOfMonth.plus(7, DateTimeUnit.DAY), 11, 1, 3))
-        add(timed(firstOfMonth.plus(15, DateTimeUnit.DAY), 10, 1, 0))
-        add(timed(firstOfMonth.plus(18, DateTimeUnit.DAY), 16, 1, 2))
-        add(timed(firstOfMonth.plus(22, DateTimeUnit.DAY), 8, 2, 1))
-        add(timed(firstOfMonth.plus(25, DateTimeUnit.DAY), 13, 1, 3))
-        // Today, so the split pane's list and the grid's dots both have content.
-        add(timed(today, 9, 1, 0))
-        add(timed(today, 12, 1, 1))
-        add(timed(today, 15, 2, 3))
-    }
-}
-
-private val SAMPLE_TITLES = listOf(
-    "Standup",
-    "Lunch",
-    "Review",
-    "Gym",
-    "Call",
-    "Workshop",
-    "Dentist",
-    "Trip",
-)

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

@@ -2,9 +2,7 @@ package de.jeanlucmakiola.calendula.ui.month
 
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
-import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
 import kotlinx.datetime.YearMonth
 
 /**
@@ -39,85 +37,12 @@ data class MonthWeek(
     val countByDay: Map<LocalDate, Int>,
 )
 
-/**
- * The events occupying each lane of [day] — column [col] of this week — in lane
- * order, capped at [laneCap] lanes.
- *
- * This is the same seating [spans]/[timedByDay] get when the paged grid draws a
- * week: bars keep the lane the row layout gave them, and the day's timed events
- * fill whatever slots are left, top-most first. Reading it here means the split
- * style's dots and the paged style's bars describe a day in the *same order*, so
- * dot _i_ and lane _i_ are the same event and one can morph into the other (#53).
- *
- * Deriving the dots independently — by distinct colour, as they first were —
- * left dot _i_ standing for no particular event, and quietly merged two events
- * that shared a calendar into a single dot.
- */
-fun MonthWeek.laneEvents(col: Int, day: LocalDate, laneCap: Int): List<EventInstance> {
-    val byLane = arrayOfNulls<EventInstance>(laneCap)
-    spans.forEach { span ->
-        if (span.lane < laneCap && col in span.startCol..span.endCol) {
-            byLane[span.lane] = span.event
-        }
-    }
-    val free = (0 until laneCap).filter { byLane[it] == null }
-    timedByDay[day].orEmpty().take(free.size).forEachIndexed { i, event ->
-        byLane[free[i]] = event
-    }
-    return byLane.filterNotNull()
-}
-
-/**
- * State for the continuous style (#38): a vertical stream of *self-contained*
- * months rather than one undifferentiated run of weeks. Each month is keyed by
- * absolute month index and carries only its own days — the boundary week keeps
- * its seven columns so the grid geometry never shifts, but the neighbour month's
- * dates are clipped out of it (see `clipWeekToMonth`) and render as blanks.
- *
- * The same loaded window is served two ways, because the Dense style is the same
- * scroll with the seams taken out and it would be wasteful to query the provider
- * twice for one range:
- *
- *  - [monthsByIndex] — the block layout, keyed by absolute month index, each week
- *    clipped to its own month.
- *  - [weeksByIndex] — the flowing layout, keyed by absolute week index, boundary
- *    weeks left carrying both months.
- *
- * Both hold only the loaded window; indices outside it render as placeholders
- * until the window catches up.
- */
-sealed interface ContinuousMonthUiState {
-    data object Loading : ContinuousMonthUiState
-    data class Failure(val reason: FailureReason) : ContinuousMonthUiState
-    data class Success(
-        val today: LocalDate,
-        val monthsByIndex: Map<Int, List<MonthWeek>>,
-        val weeksByIndex: Map<Int, MonthWeek>,
-        val weekStart: DayOfWeek,
-    ) : ContinuousMonthUiState
-}
-
 sealed interface MonthUiState {
     data object Loading : MonthUiState
     data class Failure(val reason: FailureReason) : MonthUiState
-
-    /**
-     * [weeks] is what the grid draws; [instancesByDay] is the same events keyed by
-     * date and *uncapped*, so the split style's day pane can list everything on a
-     * date without a second provider query — the month grid range already covers
-     * it. All-day events sort first, then by start.
-     */
     data class Success(
         val month: YearMonth,
         val today: LocalDate,
         val weeks: List<MonthWeek>,
-        val instancesByDay: Map<LocalDate, List<EventInstance>> = emptyMap(),
-        /**
-         * Travels on the state rather than being read at the call site, for the
-         * same reason the agenda does it: a file-level constant would be fixed
-         * for the process lifetime and drift from the zone the events were laid
-         * out in after a device time-zone change.
-         */
-        val zone: TimeZone = TimeZone.currentSystemDefault(),
     ) : MonthUiState
 }

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

@@ -6,7 +6,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.data.prefs.firstDayOfWeek
+import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
@@ -20,23 +20,21 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 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.atStartOfDayIn
 import kotlinx.datetime.atTime
-import kotlinx.datetime.daysUntil
 import kotlinx.datetime.minus
 import kotlinx.datetime.plus
 import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
+import java.util.Locale
 import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject
@@ -50,9 +48,16 @@ class MonthViewModel @Inject constructor(
 ) : ViewModel() {
 
     private val zone = TimeZone.currentSystemDefault()
+    private val locale: Locale = Locale.getDefault()
 
     /** First day of the week, from the Settings preference (AUTO → locale). */
-    val weekStart: StateFlow<DayOfWeek> = settingsPrefs.firstDayOfWeek(viewModelScope)
+    val weekStart: StateFlow<DayOfWeek> = settingsPrefs.weekStart
+        .map { it.resolveFirstDay(locale) }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = DayOfWeek.MONDAY,
+        )
 
     /** Whether to fade events that have already finished (display concern only). */
     val dimCompletedEvents: StateFlow<Boolean> = settingsPrefs.dimCompletedEvents
@@ -70,14 +75,6 @@ class MonthViewModel @Inject constructor(
             initialValue = false,
         )
 
-    /** How the grid is laid out and navigated (#38, #53). */
-    val viewStyle: StateFlow<MonthViewStyle> = settingsPrefs.monthViewStyle
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = MonthViewStyle.Paged,
-        )
-
     private val todayDate: LocalDate
         get() = Clock.System.now().toLocalDateTime(zone).date
 
@@ -85,12 +82,8 @@ class MonthViewModel @Inject constructor(
     val month: StateFlow<YearMonth> = _month
 
     val state: StateFlow<MonthUiState> =
-        combine(_month, weekStart, viewStyle) { ym, ws, style -> Triple(ym, ws, style) }
-            .flatMapLatest { (ym, ws, style) ->
-                // The mirror of the gate below: the paged grid is what Paged and
-                // Split draw, so under a scrolling style this query is a month
-                // of provider work for a view that isn't on screen.
-                if (style.isScrolling) return@flatMapLatest flowOf(MonthUiState.Loading)
+        combine(_month, weekStart) { ym, ws -> ym to ws }
+            .flatMapLatest { (ym, ws) ->
                 val range = monthGridRange(ym, ws, zone)
                 combine(
                     repository.calendars(),
@@ -107,202 +100,21 @@ class MonthViewModel @Inject constructor(
                 initialValue = MonthUiState.Loading,
             )
 
-    // --- Continuous + Dense styles (#38) ----------------------------------
-    //
-    // These scroll through every month there is, so they can't load "a month" —
-    // they load a sliding window of month indices around whatever is on screen.
-    // The window only moves when the visible range comes within WINDOW_EDGE
-    // months of a loaded edge, so a scroll re-queries occasionally rather than
-    // on every frame.
-    //
-    // The window also *starts small and grows*. A provider Instances query
-    // expands recurrences across its whole range, so opening straight onto a
-    // year of months made the first frame wait for eleven months of expansion
-    // when only one was about to be looked at. It now opens on INITIAL_PAD
-    // months, and each completed load widens by GROWTH_STEP in both directions
-    // until MAX_PAD — the months you can reach by scrolling arrive while you're
-    // still looking at the first one.
-
-    /** How far around the visible range we currently load; grows as loads land. */
-    @Volatile
-    private var loadPad = INITIAL_PAD
-
-    /** Last reported visible range, so a widening step can re-centre on it. */
-    @Volatile
-    private var visibleMonths = monthIndexOf(YearMonth(todayDate.year, todayDate.month))
-        .let { it..it }
-
-    private val _loadedMonths = MutableStateFlow(
-        monthIndexOf(YearMonth(todayDate.year, todayDate.month))
-            .let { clampMonthWindow(it - INITIAL_PAD..it + INITIAL_PAD) },
-    )
-
-    val continuousState: StateFlow<ContinuousMonthUiState> =
-        combine(_loadedMonths, weekStart, viewStyle) { window, ws, style ->
-            Triple(window, ws, style)
-        }
-            .flatMapLatest { (window, ws, style) ->
-                // Nothing to load for the paged and split styles — they have
-                // their own single-month flow, and querying a year of months
-                // behind them is pure waste.
-                if (!style.isScrolling) return@flatMapLatest flowOf(ContinuousMonthUiState.Loading)
-                // Widened to whole grid weeks at both ends: a month block still
-                // has to know about an event that starts in the boundary week's
-                // clipped-off days, or a bar running into the block would vanish.
-                val first = firstOfMonth(yearMonthForIndex(window.first)).startOfGridWeek(ws)
-                val last = firstOfMonth(yearMonthForIndex(window.last))
-                    .plus(1, DateTimeUnit.MONTH)
-                    .minus(1, DateTimeUnit.DAY)
-                    .startOfGridWeek(ws)
-                    .plus(6, DateTimeUnit.DAY)
-                val range = first.atStartOfDayIn(zone)..last.atTime(23, 59, 59).toInstant(zone)
-                combine(
-                    repository.calendars(),
-                    repository.instances(range),
-                ) { calendars, instances ->
-                    buildContinuousState(window, ws, style, calendars, instances)
-                }
-            }
-            // A load landing is the cue to reach further out. Widening from here
-            // rather than on a timer means each step waits for the previous one,
-            // so the ladder can never outrun the provider.
-            .onEach { if (it is ContinuousMonthUiState.Success) widenLoadedWindow() }
-            .catch { emit(ContinuousMonthUiState.Failure(FailureReason.ProviderUnavailable)) }
-            .flowOn(io)
-            .stateIn(
-                scope = viewModelScope,
-                started = SharingStarted.WhileSubscribed(5_000L),
-                initialValue = ContinuousMonthUiState.Loading,
-            )
-
-    /**
-     * Report which absolute month indices are on screen. Cheap to call on every
-     * scroll frame: it returns immediately unless the visible range has drifted
-     * close enough to a loaded edge to warrant a wider query.
-     */
-    fun onVisibleMonthsChanged(firstIndex: Int, lastIndex: Int) {
-        visibleMonths = firstIndex..lastIndex
-        nextLoadWindow(_loadedMonths.value, firstIndex, lastIndex, loadPad)
-            ?.let { _loadedMonths.value = clampMonthWindow(it) }
-    }
-
-    /**
-     * One rung up the ladder: reach [GROWTH_STEP] further in each direction,
-     * stopping at [MAX_PAD]. A no-op once there, so the provider notifications
-     * that re-emit the same window don't restart it.
-     */
-    private fun widenLoadedWindow() {
-        if (loadPad >= MAX_PAD) return
-        loadPad = (loadPad + GROWTH_STEP).coerceAtMost(MAX_PAD)
-        _loadedMonths.value = clampMonthWindow(
-            visibleMonths.first - loadPad..visibleMonths.last + loadPad,
-        )
-    }
-
-    private fun buildContinuousState(
-        window: IntRange,
-        weekStart: DayOfWeek,
-        style: MonthViewStyle,
-        calendars: List<CalendarSource>,
-        instances: List<EventInstance>,
-    ): ContinuousMonthUiState {
-        if (calendars.isEmpty()) {
-            return ContinuousMonthUiState.Failure(FailureReason.NoCalendarsConfigured)
-        }
-        // Bucketed once for the whole window: a row then takes the handful of
-        // events on its seven days instead of re-scanning a year of them.
-        val byDay = DayIndex(instances, zone)
-        // Only the style on screen is laid out. Building both doubled the work
-        // for a layout nothing was going to draw.
-        val months = if (style == MonthViewStyle.Continuous) {
-            window.associateWith { index ->
-                val ym = yearMonthForIndex(index)
-                layoutMonthWeeks(ym, weekStart, byDay, zone).map { clipWeekToMonth(it, ym) }
-            }
-        } else {
-            emptyMap()
-        }
-        val weeks = if (style == MonthViewStyle.Dense) {
-            weekWindowFor(window, weekStart).associateWith { index ->
-                val days = (0 until 7).map {
-                    weekStartForIndex(index, weekStart).plus(it, DateTimeUnit.DAY)
-                }
-                layoutCalendarWeek(days, byDay.eventsOn(days), zone)
-            }
-        } else {
-            emptyMap()
-        }
-        return ContinuousMonthUiState.Success(
-            today = todayDate,
-            monthsByIndex = months,
-            weeksByIndex = weeks,
-            weekStart = weekStart,
-        )
-    }
-
-    // --- Split style (#53) ------------------------------------------------
-    //
-    // The first selected-day concept in the app: the other views drill straight
-    // into a date, while the split style keeps one selected and lists it below
-    // the grid.
-
-    private val _selectedDate = MutableStateFlow(todayDate)
-    val selectedDate: StateFlow<LocalDate> = _selectedDate
-
-    /**
-     * Select [date], following it to its month if it sits in the grid's leading
-     * or trailing days — tapping a greyed-out day should show that day, not
-     * silently list a date the grid isn't pointing at.
-     */
-    fun selectDate(date: LocalDate) {
-        _selectedDate.value = date
-        val target = YearMonth(date.year, date.month)
-        if (target != _month.value) _month.value = target
-    }
-
-    /**
-     * Move the selection with the month: today if the new month holds it, else
-     * its 1st. Leaving the old date selected would list a day the grid no longer
-     * shows.
-     */
-    private fun realignSelection() {
-        _selectedDate.value = selectionForMonth(_month.value, todayDate)
-    }
-
     fun goToPrev() {
         _month.value = _month.value.minus(1, DateTimeUnit.MONTH)
-        realignSelection()
     }
 
     fun goToNext() {
         _month.value = _month.value.plus(1, DateTimeUnit.MONTH)
-        realignSelection()
     }
 
     fun goToToday() {
         _month.value = YearMonth(todayDate.year, todayDate.month)
-        _selectedDate.value = todayDate
-    }
-
-    /**
-     * Track [_month] to the month a scrolling style is showing. Those styles
-     * navigate by scroll position and never set [_month] themselves, so it would
-     * otherwise sit wherever paged navigation last left it (today's month, on a
-     * fresh open) — and a switch to a paged style, or a reseed of the other
-     * scrolling style's list, would jump there instead of holding position. The
-     * selection is realigned alongside it so that landing on the Split style
-     * shows a live day in the month on screen rather than a stale, off-month one.
-     */
-    fun syncScrollMonth(ym: YearMonth) {
-        if (_month.value == ym) return
-        _month.value = ym
-        _selectedDate.value = selectionForMonth(ym, todayDate)
     }
 
     /** Jump to the month containing [date] (drawer jump-to-date). */
     fun goToDate(date: LocalDate) {
         _month.value = YearMonth(date.year, date.month)
-        _selectedDate.value = date
     }
 
     private fun buildState(
@@ -314,13 +126,10 @@ class MonthViewModel @Inject constructor(
         if (calendars.isEmpty()) {
             return MonthUiState.Failure(FailureReason.NoCalendarsConfigured)
         }
-        val weeks = layoutMonthWeeks(ym, weekStart, instances, zone)
         return MonthUiState.Success(
             month = ym,
             today = todayDate,
-            weeks = weeks,
-            instancesByDay = instancesByDay(weeks.flatMap { it.days }, instances, zone),
-            zone = zone,
+            weeks = layoutMonthWeeks(ym, weekStart, instances, zone),
         )
     }
 }
@@ -339,124 +148,41 @@ internal fun layoutMonthWeeks(
     weekStart: DayOfWeek,
     instances: List<EventInstance>,
     zone: TimeZone,
-): List<MonthWeek> = layoutMonthWeeks(ym, weekStart, DayIndex(instances, zone), zone)
-
-/**
- * As above, but reusing a [DayIndex] already built for a wider range — what the
- * scrolling styles need, since they lay out many months from one query and
- * rebuilding the index per month would put the cost straight back.
- */
-internal fun layoutMonthWeeks(
-    ym: YearMonth,
-    weekStart: DayOfWeek,
-    byDay: DayIndex,
-    zone: TimeZone,
 ): List<MonthWeek> {
-    val gridStart = firstOfMonth(ym).startOfGridWeek(weekStart)
-    val weekCount = weekRowsInMonth(ym, weekStart)
+    val firstOfMonth = LocalDate(ym.year, ym.month, 1)
+    val gridStart = firstOfMonth.startOfGridWeek(weekStart)
+    val leadOffset = ((firstOfMonth.dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7
+    val daysInMonth =
+        java.time.YearMonth.of(ym.year, ym.month.ordinal + 1).lengthOfMonth()
+    val weekCount = (leadOffset + daysInMonth + 6) / 7
 
     return (0 until weekCount).map { row ->
         val days = (0 until 7).map { gridStart.plus(row * 7 + it, DateTimeUnit.DAY) }
-        layoutCalendarWeek(days, byDay.eventsOn(days), zone)
-    }
-}
-
-/**
- * Events bucketed by the dates they cover, built once per load.
- *
- * [layoutCalendarWeek] opens by filtering the instances it was handed down to
- * the ones touching its seven days. That is fine for a single month's grid, but
- * the scrolling styles lay out a hundred-odd rows from one query, and scanning
- * *every* instance in an eleven-month window for each of them made the work grow
- * with the number of enabled calendars until opening the view stalled.
- *
- * Membership is decided by [coversDay] itself rather than by re-deriving the
- * rule from the timestamps: the all-day and timed cases have enough edge cases
- * between them (UTC anchoring, exclusive ends, zero-length events at midnight)
- * that a second implementation would drift. The walk only visits an event's own
- * candidate days, so the check runs a couple of times per event rather than once
- * per event per row.
- */
-internal class DayIndex(instances: List<EventInstance>, private val zone: TimeZone) {
-
-    private val byDay: Map<LocalDate, List<EventInstance>> = buildMap<LocalDate, MutableList<EventInstance>> {
-        instances.forEach { event ->
-            // All-day events are anchored to UTC midnights; timed ones to the
-            // device zone. Either way the candidate span is the event's own
-            // dates, which is one or two days for almost everything.
-            val anchor = if (event.isAllDay) TimeZone.UTC else zone
-            var day = event.start.toLocalDateTime(anchor).date
-            val lastCandidate = event.end.toLocalDateTime(anchor).date
-            while (day <= lastCandidate) {
-                if (event.coversDay(day, zone)) getOrPut(day) { mutableListOf() }.add(event)
-                day = day.plus(1, DateTimeUnit.DAY)
-            }
+        val weekEvents = instances.filter { ev -> days.any { ev.coversDay(it, zone) } }
+        val (bars, singles) = weekEvents.partition { ev ->
+            ev.isAllDay || days.count { ev.coversDay(it, zone) } > 1
         }
-    }
-
-    /** Every event touching any of [days], each listed once, in input order. */
-    fun eventsOn(days: List<LocalDate>): List<EventInstance> {
-        if (days.isEmpty()) return emptyList()
-        val hits = days.flatMap { byDay[it].orEmpty() }
-        // A multi-day event is bucketed on each date it covers, so a row that
-        // holds several of its days would otherwise list it several times.
-        return if (hits.size < 2) hits else hits.distinctBy { it.instanceId }
-    }
-}
-
-/**
- * Resolve one week row's events for rendering. Split out of [layoutMonthWeeks] so
- * the continuous style — which streams weeks rather than months and so has no
- * enclosing [YearMonth] to slice by — lays each row out identically.
- *
- * [days] must be the row's seven consecutive dates, in display order.
- */
-internal fun layoutCalendarWeek(
-    days: List<LocalDate>,
-    instances: List<EventInstance>,
-    zone: TimeZone,
-): MonthWeek {
-    val weekEvents = instances.filter { ev -> days.any { ev.coversDay(it, zone) } }
-    val (bars, singles) = weekEvents.partition { ev ->
-        ev.isAllDay || days.count { ev.coversDay(it, zone) } > 1
-    }
-    val spans = layoutAllDay(bars, days, zone).map { s ->
-        MonthSpan(
-            event = s.event,
-            startCol = s.startCol,
-            endCol = s.endCol,
-            lane = s.lane,
-            continuesLeft = s.event.coversDay(days.first().minus(1, DateTimeUnit.DAY), zone),
-            continuesRight = s.event.coversDay(days.last().plus(1, DateTimeUnit.DAY), zone),
+        val spans = layoutAllDay(bars, days, zone).map { s ->
+            MonthSpan(
+                event = s.event,
+                startCol = s.startCol,
+                endCol = s.endCol,
+                lane = s.lane,
+                continuesLeft = s.event.coversDay(days.first().minus(1, DateTimeUnit.DAY), zone),
+                continuesRight = s.event.coversDay(days.last().plus(1, DateTimeUnit.DAY), zone),
+            )
+        }
+        MonthWeek(
+            days = days,
+            spans = spans,
+            timedByDay = days.associateWith { d ->
+                singles.filter { it.coversDay(d, zone) }.sortedBy { it.start }
+            },
+            countByDay = days.associateWith { d -> weekEvents.count { it.coversDay(d, zone) } },
         )
     }
-    return MonthWeek(
-        days = days,
-        spans = spans,
-        timedByDay = days.associateWith { d ->
-            singles.filter { it.coversDay(d, zone) }.sortedBy { it.start }
-        },
-        countByDay = days.associateWith { d -> weekEvents.count { it.coversDay(d, zone) } },
-    )
 }
 
-/**
- * Every event touching each of [days], all-day first then by start time. Unlike
- * [MonthWeek.timedByDay] this keeps multi-day and all-day events on every date
- * they cover and applies no display cap, so the split style's day pane can list a
- * date in full without querying the provider again.
- */
-internal fun instancesByDay(
-    days: List<LocalDate>,
-    instances: List<EventInstance>,
-    zone: TimeZone,
-): Map<LocalDate, List<EventInstance>> =
-    days.associateWith { day ->
-        instances
-            .filter { it.coversDay(day, zone) }
-            .sortedWith(compareByDescending<EventInstance> { it.isAllDay }.thenBy { it.start })
-    }
-
 /**
  * The on-screen grid spans 6 weeks anchored on [weekStart]. Includes the
  * trailing days of the previous month and the leading days of the next month.
@@ -474,198 +200,6 @@ internal fun monthGridRange(
     return start..end
 }
 
-/**
- * The sliding window's shape.
- *
- * [INITIAL_PAD] is what the first frame waits for — one month either side of the
- * visible one, so opening the view costs about what the paged style costs. Each
- * completed load then reaches [GROWTH_STEP] further out until [MAX_PAD], filling
- * in the months a scroll could reach while the first ones are already on screen.
- *
- * [WINDOW_EDGE] is how close the visible range may drift to a loaded edge before
- * it reloads. It is always kept below the current pad — a trigger at or beyond
- * the pad would re-fire the moment its own reload landed.
- */
-private const val INITIAL_PAD = 1
-private const val GROWTH_STEP = 2
-private const val MAX_PAD = 5
-private const val WINDOW_EDGE = 2
-
-/** The reload trigger for a given pad, held strictly inside it. */
-internal fun edgeForPad(pad: Int): Int = minOf(WINDOW_EDGE, pad - 1).coerceAtLeast(0)
-
-/**
- * Which day the split style should select when the grid lands on [month]:
- * [today] when the month holds it, otherwise the 1st. Pure so the rule can be
- * tested without standing up a view model and a provider behind it.
- */
-internal fun selectionForMonth(month: YearMonth, today: LocalDate): LocalDate =
-    if (YearMonth(today.year, today.month) == month) {
-        today
-    } else {
-        LocalDate(month.year, month.month, 1)
-    }
-
-/**
- * The window to load for a visible range, or null to keep the current one.
- *
- * Kept pure and separate from the view model so the hysteresis — the reason a
- * scroll doesn't re-query the provider on every frame — is testable on its own.
- */
-internal fun nextLoadWindow(
-    loaded: IntRange,
-    firstVisible: Int,
-    lastVisible: Int,
-    pad: Int = MAX_PAD,
-): IntRange? {
-    val edge = edgeForPad(pad)
-    val comfortablyInside =
-        firstVisible - edge >= loaded.first && lastVisible + edge <= loaded.last
-    if (comfortablyInside) return null
-    return (firstVisible - pad)..(lastVisible + pad)
-}
-
-/**
- * The continuous grid addresses months by an absolute index, so the list has one
- * stable, gap-free coordinate space to scroll through and key its items by.
- * Index 0 is January 1900; the list runs to [continuousMonthCount].
- *
- * Unlike the week indexing this replaced, the coordinate space doesn't depend on
- * the week-start preference — changing it reflows the rows *inside* a month
- * block but never moves the block, so a scroll position stays put.
- */
-private const val MONTH_INDEX_EPOCH_YEAR = 1900
-private const val MONTH_INDEX_END_YEAR = 2100
-
-internal fun monthIndexOf(ym: YearMonth): Int =
-    (ym.year - MONTH_INDEX_EPOCH_YEAR) * 12 + ym.month.ordinal
-
-internal fun yearMonthForIndex(index: Int): YearMonth = YearMonth(
-    MONTH_INDEX_EPOCH_YEAR + index / 12,
-    Month.entries[index % 12],
-)
-
-/** Total months the continuous grid scrolls through (1900 → 2100). */
-internal fun continuousMonthCount(): Int =
-    (MONTH_INDEX_END_YEAR - MONTH_INDEX_EPOCH_YEAR + 1) * 12
-
-/**
- * Each month occupies two LazyColumn items — its sticky header and the block of
- * week rows under it — so the two coordinate spaces differ by a factor of two.
- * Scrolling to a month means scrolling to its header.
- */
-internal fun itemIndexForMonth(monthIndex: Int): Int = monthIndex * 2
-
-internal fun monthIndexForItem(itemIndex: Int): Int = itemIndex / 2
-
-/**
- * Hold a load window inside the months that actually exist. The pad
- * [nextLoadWindow] adds can otherwise push an index past either end of the
- * 1900–2100 span, and [yearMonthForIndex] has no month to hand back for one.
- */
-internal fun clampMonthWindow(window: IntRange): IntRange {
-    val last = continuousMonthCount() - 1
-    return window.first.coerceIn(0, last)..window.last.coerceIn(0, last)
-}
-
-internal fun firstOfMonth(ym: YearMonth): LocalDate = LocalDate(ym.year, ym.month, 1)
-
-/**
- * The Dense style addresses *weeks* by absolute index instead: it has no month
- * blocks to key by, and a row's identity has to survive the months around it
- * scrolling past. Index 0 is the first week of 1900 under the active week-start,
- * so — like the month space — every index is non-negative and the LazyColumn's
- * item indices and week indices are the same number.
- *
- * Unlike month indices these *do* shift with the week-start preference, which is
- * why the list state is keyed on it.
- */
-private val WEEK_INDEX_EPOCH = LocalDate(1900, 1, 1)
-private val WEEK_INDEX_END = LocalDate(2100, 12, 31)
-
-internal fun weekIndexOf(date: LocalDate, weekStart: DayOfWeek): Int {
-    val base = WEEK_INDEX_EPOCH.startOfGridWeek(weekStart)
-    return base.daysUntil(date.startOfGridWeek(weekStart)) / 7
-}
-
-internal fun weekStartForIndex(index: Int, weekStart: DayOfWeek): LocalDate =
-    WEEK_INDEX_EPOCH.startOfGridWeek(weekStart).plus(index * 7, DateTimeUnit.DAY)
-
-/** Total weeks the Dense grid scrolls through (1900 → 2100). */
-internal fun continuousWeekCount(weekStart: DayOfWeek): Int =
-    weekIndexOf(WEEK_INDEX_END, weekStart) + 1
-
-/** Which month a Dense row belongs to, for reporting the visible range. */
-internal fun monthIndexForWeek(weekIndex: Int, weekStart: DayOfWeek): Int {
-    // The row's midweek day: a boundary week is reported as whichever month owns
-    // most of it, the same rule the title uses.
-    val midweek = weekStartForIndex(weekIndex, weekStart).plus(3, DateTimeUnit.DAY)
-    return monthIndexOf(YearMonth(midweek.year, midweek.month))
-}
-
-/**
- * Every week index the months in [window] touch — the Dense rows one month-window
- * load covers. Widened by a week at each end so the boundary rows either side are
- * laid out too, rather than flickering as placeholders.
- */
-internal fun weekWindowFor(window: IntRange, weekStart: DayOfWeek): IntRange {
-    val first = weekIndexOf(firstOfMonth(yearMonthForIndex(window.first)), weekStart) - 1
-    val lastMonthEnd = firstOfMonth(yearMonthForIndex(window.last))
-        .plus(1, DateTimeUnit.MONTH)
-        .minus(1, DateTimeUnit.DAY)
-    return first..(weekIndexOf(lastMonthEnd, weekStart) + 1)
-}
-
-/** How many week rows [ym] needs under [weekStart] — 4 (a non-leap February), 5 or 6. */
-internal fun weekRowsInMonth(ym: YearMonth, weekStart: DayOfWeek): Int {
-    val first = firstOfMonth(ym)
-    val leadOffset = ((first.dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7
-    val daysInMonth = java.time.YearMonth.of(ym.year, ym.month.ordinal + 1).lengthOfMonth()
-    return (leadOffset + daysInMonth + 6) / 7
-}
-
-/**
- * Strip everything outside [month] from a boundary week row, for the continuous
- * style's self-contained month blocks.
- *
- * The seven [MonthWeek.days] stay put — the row keeps its column geometry, and
- * the grid decides which cells to draw blank — but the neighbour month's events
- * are removed: its pills and counts go, and a bar reaching in from (or out into)
- * it is cut back to the month's own columns. A bar cut this way keeps a flat
- * cap, which is what says "this continues past the block" rather than "it ends
- * here".
- */
-internal fun clipWeekToMonth(week: MonthWeek, month: YearMonth): MonthWeek {
-    val inMonth = week.days.map { it.year == month.year && it.month == month.month }
-    val firstCol = inMonth.indexOfFirst { it }
-    val lastCol = inMonth.indexOfLast { it }
-    // Can't happen for a row of the month's own grid, but a caller-proof no-op
-    // beats an out-of-range crash.
-    if (firstCol == -1) {
-        return week.copy(spans = emptyList(), timedByDay = emptyMap(), countByDay = emptyMap())
-    }
-    val spans = week.spans.mapNotNull { span ->
-        val start = maxOf(span.startCol, firstCol)
-        val end = minOf(span.endCol, lastCol)
-        if (start > end) {
-            null
-        } else {
-            span.copy(
-                startCol = start,
-                endCol = end,
-                continuesLeft = span.continuesLeft || start > span.startCol,
-                continuesRight = span.continuesRight || end < span.endCol,
-            )
-        }
-    }
-    val own = week.days.filterIndexed { col, _ -> inMonth[col] }
-    return week.copy(
-        spans = spans,
-        timedByDay = week.timedByDay.filterKeys { it in own },
-        countByDay = week.countByDay.filterKeys { it in own },
-    )
-}
-
 internal fun LocalDate.startOfGridWeek(weekStart: DayOfWeek): LocalDate {
     // DayOfWeek.ordinal: MONDAY=0..SUNDAY=6 → identical to ISO ordering.
     val offset = ((dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7

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

@@ -1,60 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.month
-
-import androidx.annotation.StringRes
-import de.jeanlucmakiola.calendula.R
-
-/**
- * How the Month view lays itself out (#38, #53).
- *
- * One setting rather than two independent toggles: "vertical scrolling" and
- * "month plus agenda" would otherwise multiply into four combinations to build
- * and test, most of which nobody asked for.
- *
- * [Split] does **not** replace or disable the Agenda view — that stays a forward
- * multi-day window with its own range model, while the split pane lists a single
- * selected day.
- */
-enum class MonthViewStyle {
-    /** Month pages, swiped left/right. Full event bars and pills per day. */
-    Paged,
-
-    /**
-     * Months stacked into one vertical scroll, each a self-contained block under
-     * its own sticky header: a block shows only its own days, and whitespace
-     * separates it from the next (#38).
-     */
-    Continuous,
-
-    /**
-     * [Continuous] with the seams taken out: one uninterrupted stream of weeks
-     * where months flow into each other. Each date appears exactly once — paging
-     * repeats a boundary week at both ends — and the 1st names its month, the
-     * only marker of where one ends.
-     */
-    Dense,
-
-    /** Compact dots-only grid over a list of the selected day's events (#53). */
-    Split,
-}
-
-/** Both vertically scrolling styles, which share a data window and a list state. */
-val MonthViewStyle.isScrolling: Boolean
-    get() = this == MonthViewStyle.Continuous || this == MonthViewStyle.Dense
-
-@get:StringRes
-val MonthViewStyle.labelRes: Int
-    get() = when (this) {
-        MonthViewStyle.Paged -> R.string.month_style_paged
-        MonthViewStyle.Continuous -> R.string.month_style_continuous
-        MonthViewStyle.Dense -> R.string.month_style_dense
-        MonthViewStyle.Split -> R.string.month_style_split
-    }
-
-@get:StringRes
-val MonthViewStyle.descriptionRes: Int
-    get() = when (this) {
-        MonthViewStyle.Paged -> R.string.month_style_paged_summary
-        MonthViewStyle.Continuous -> R.string.month_style_continuous_summary
-        MonthViewStyle.Dense -> R.string.month_style_dense_summary
-        MonthViewStyle.Split -> R.string.month_style_split_summary
-    }

app/src/main/java/de/jeanlucmakiola/calendula/ui/search/SearchScreen.kt

@@ -54,7 +54,7 @@ import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/MonthViewStylePicker.kt

@@ -1,112 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.settings
-
-import androidx.compose.animation.Crossfade
-import androidx.compose.animation.core.snap
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.clipToBounds
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.ui.common.PickerDescription
-import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
-import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
-import de.jeanlucmakiola.calendula.ui.month.descriptionRes
-import de.jeanlucmakiola.calendula.ui.month.labelRes
-import de.jeanlucmakiola.floret.components.FullScreenPicker
-import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.SelectedCheck
-import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.identity.rememberReduceMotion
-import kotlinx.datetime.DayOfWeek
-
-/**
- * The Month view style chooser (#38, #53).
- *
- * A live, scaled-down Month view sits above the options and changes as you pick
- * one, so the choice is made by looking rather than by reading "Continuous" and
- * guessing. Selecting therefore applies immediately and leaves the picker open —
- * closing on tap would hide the very thing the screen is for. Back exits, the
- * same as the App name picker, which stays open for the same reason.
- *
- * Under the preview sits the selected style's own one-line blurb, then the
- * family's standard picker shape: connected single-line grouped rows with a
- * tonal highlight and [SelectedCheck] on the current one.
- */
-@Composable
-internal fun MonthViewStylePicker(
-    selected: MonthViewStyle,
-    weekStart: DayOfWeek,
-    onSelect: (MonthViewStyle) -> Unit,
-    onDismiss: () -> Unit,
-) {
-    val options = MonthViewStyle.entries
-    val reduceMotion = rememberReduceMotion()
-    FullScreenPicker(
-        title = stringResource(R.string.settings_month_view_style),
-        onDismiss = onDismiss,
-        predictiveBack = true,
-    ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 12.dp, vertical = 8.dp)
-                .height(PREVIEW_HEIGHT),
-            contentAlignment = Alignment.Center,
-        ) {
-            Crossfade(
-                targetState = selected,
-                animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
-                label = "month-style-preview",
-            ) { shown ->
-                // The preview renders the real grid at phone size and scales it
-                // down, so its own corners are square — the frame rounds it.
-                Box(
-                    modifier = Modifier
-                        .clip(PREVIEW_SHAPE)
-                        .background(MaterialTheme.colorScheme.surface)
-                        .clipToBounds(),
-                ) {
-                    MonthStylePreview(
-                        style = shown,
-                        weekStart = weekStart,
-                        height = PREVIEW_HEIGHT,
-                    )
-                }
-            }
-        }
-        // The selected style's own blurb lives here, under its preview, rather
-        // than on every row — the rows stay single-line and dense, and the words
-        // describe exactly what is being shown above.
-        PickerDescription(stringResource(selected.descriptionRes))
-        options.forEachIndexed { index, style ->
-            val isSelected = style == selected
-            GroupedRow(
-                title = stringResource(style.labelRes),
-                position = positionOf(index, options.size),
-                selected = isSelected,
-                trailing = if (isSelected) {
-                    { SelectedCheck() }
-                } else {
-                    null
-                },
-                // Applies straight away; the preview above is the confirmation,
-                // so there is nothing to dismiss for.
-                onClick = { onSelect(style) },
-            )
-        }
-    }
-}
-
-private val PREVIEW_HEIGHT = 280.dp
-private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt

@@ -23,8 +23,6 @@ import androidx.compose.animation.slideInHorizontally
 import androidx.compose.animation.slideOutHorizontally
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -44,8 +42,8 @@ import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
 import androidx.compose.material.icons.filled.BugReport
 import androidx.compose.material.icons.filled.Cake
 import androidx.compose.material.icons.filled.CalendarMonth
-import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.Dashboard
+import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.DragHandle
 import androidx.compose.material.icons.filled.SwapVert
 import androidx.compose.material.icons.filled.ExpandLess
@@ -77,7 +75,6 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.colorResource
@@ -96,7 +93,6 @@ import androidx.lifecycle.LifecycleEventObserver
 import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.data.appname.LauncherName
 import de.jeanlucmakiola.calendula.data.contacts.hasContactsPermission
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.floret.reminders.ReminderOverride
@@ -104,7 +100,6 @@ import de.jeanlucmakiola.floret.reminders.reminderOverrideFor
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
-import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
 import de.jeanlucmakiola.calendula.qs.NewEventTileService
@@ -126,7 +121,6 @@ import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.month.labelRes
 import de.jeanlucmakiola.floret.components.ReorderableColumn
 import de.jeanlucmakiola.floret.components.ReorderableRowHeight
 import de.jeanlucmakiola.calendula.ui.common.icon
@@ -137,12 +131,11 @@ import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS
 import de.jeanlucmakiola.calendula.ui.common.ReminderDefaultPicker
 import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
-import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.SnoozeDurationPicker
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
-import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.eventFormFieldIcon
 import de.jeanlucmakiola.calendula.ui.common.eventFormFieldLabel
 import de.jeanlucmakiola.calendula.ui.theme.BundledFont
@@ -494,10 +487,8 @@ private fun AppearanceScreen(
     var showPastEvents by remember { mutableStateOf(false) }
     var showBrandFont by remember { mutableStateOf(false) }
     var showPlainFont by remember { mutableStateOf(false) }
-    var showAppName by remember { mutableStateOf(false) }
 
     val fonts by viewModel.fontState.collectAsStateWithLifecycle()
-    val launcherName by viewModel.launcherName.collectAsStateWithLifecycle()
     // A picked file that didn't parse as a font: tell the user and keep the old choice.
     val context = LocalContext.current
     val importFailedMessage = stringResource(R.string.settings_font_import_failed)
@@ -580,18 +571,6 @@ private fun AppearanceScreen(
             position = Position.Top,
             onClick = { showDefaultView = true },
         )
-        GroupedRow(
-            title = stringResource(R.string.settings_today_toolbar),
-            summary = stringResource(R.string.settings_today_toolbar_summary),
-            position = Position.Middle,
-            trailing = {
-                Switch(
-                    checked = state.todayButtonInToolbar,
-                    onCheckedChange = viewModel::setTodayButtonInToolbar,
-                )
-            },
-            onClick = { viewModel.setTodayButtonInToolbar(!state.todayButtonInToolbar) },
-        )
         GroupedRow(
             title = stringResource(R.string.settings_week_start),
             summary = weekStartLabel(state.weekStart),
@@ -688,58 +667,8 @@ private fun AppearanceScreen(
             },
             onClick = { viewModel.setAgendaShowRangeBar(!state.agendaShowRangeBar) },
         )
-
-        Spacer(Modifier.height(16.dp))
-
-        // App name — chooses the launcher label between "Calendula" and "Calendar"
-        // (issue #44). Own group: it's a launcher/system concern, not calendar
-        // formatting. A sub-page chooser (not a switch), matching the app's other
-        // "choose one" settings and leaving room for more names later.
-        GroupedRow(
-            title = stringResource(R.string.settings_app_name),
-            summary = launcherNameLabel(launcherName),
-            position = Position.Alone,
-            onClick = { showAppName = true },
-        )
     }
 
-    if (showAppName) {
-        FullScreenPicker(
-            title = stringResource(R.string.settings_app_name),
-            onDismiss = { showAppName = false },
-            predictiveBack = true,
-        ) {
-            // Show both names as launcher-mark previews so the user sees what
-            // they'd switch to, not just the current state. Tapping applies
-            // immediately and highlights — the picker stays open so the change is
-            // visible; back exits.
-            Text(
-                text = stringResource(R.string.settings_app_name_summary),
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center,
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 24.dp),
-            )
-            Spacer(Modifier.height(24.dp))
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 16.dp),
-                horizontalArrangement = Arrangement.spacedBy(16.dp),
-            ) {
-                LauncherName.entries.forEach { option ->
-                    AppNameOptionCard(
-                        name = option,
-                        selected = launcherName == option,
-                        onClick = { viewModel.setLauncherName(option) },
-                        modifier = Modifier.weight(1f),
-                    )
-                }
-            }
-        }
-    }
     if (showTheme) {
         OptionPicker(
             title = stringResource(R.string.settings_theme),
@@ -849,24 +778,12 @@ private fun ViewsScreen(
     viewModel: SettingsViewModel,
     onBack: () -> Unit,
 ) {
-    var showMonthStyle by remember { mutableStateOf(false) }
-
     CollapsingScaffold(
         title = stringResource(R.string.settings_section_views),
         onBack = onBack,
     ) {
         val config = state.quickSwitchConfig
 
-        // Per-view layout, above the cross-view switcher/order settings below.
-        SectionHeader(stringResource(R.string.settings_month_header))
-        GroupedRow(
-            title = stringResource(R.string.settings_month_view_style),
-            summary = stringResource(state.monthViewStyle.labelRes),
-            position = Position.Alone,
-            onClick = { showMonthStyle = true },
-        )
-
-        Spacer(Modifier.height(24.dp))
         SectionHeader(stringResource(R.string.settings_quick_switch_header))
         SettingsHint(stringResource(R.string.settings_quick_switch_hint))
         Spacer(Modifier.height(8.dp))
@@ -912,16 +829,6 @@ private fun ViewsScreen(
             )
         }
     }
-
-    if (showMonthStyle) {
-        MonthViewStylePicker(
-            selected = state.monthViewStyle,
-            // The preview is a real grid, so it uses the real week start too.
-            weekStart = state.weekStart.resolveFirstDay(currentLocale()),
-            onSelect = viewModel::setMonthViewStyle,
-            onDismiss = { showMonthStyle = false },
-        )
-    }
 }
 
 /** One reorderable view row: the view's icon and name, an optional [trailing]
@@ -1174,7 +1081,13 @@ private fun NotificationsScreen(
             },
             position = Position.Top,
             trailing = if (batteryExempt) {
-                { SelectedCheck() }
+                {
+                    Icon(
+                        imageVector = Icons.Default.Check,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.primary,
+                    )
+                }
             } else {
                 null
             },
@@ -1779,98 +1692,6 @@ private fun openUrl(context: Context, url: String) {
     runCatching { context.startActivity(intent) }
 }
 
-/** The display name for a launcher-label choice (issue #44). */
-@Composable
-private fun launcherNameLabel(name: LauncherName): String = stringResource(
-    when (name) {
-        LauncherName.CALENDULA -> R.string.app_name
-        LauncherName.CALENDAR -> R.string.app_name_calendar_alias
-    },
-)
-
-/**
- * One selectable launcher-name preview in the App name picker (issue #44): the
- * app's launcher mark over the name, framed as a card. The active one carries a
- * primary border, a tinted container and a check; tapping selects it. The mark
- * is the same for both — only the label changes — so the card previews exactly
- * what the home screen will read.
- */
-@Composable
-private fun AppNameOptionCard(
-    name: LauncherName,
-    selected: Boolean,
-    onClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    val shape = RoundedCornerShape(24.dp)
-    val borderColor = if (selected) {
-        MaterialTheme.colorScheme.primary
-    } else {
-        MaterialTheme.colorScheme.outlineVariant
-    }
-    val containerColor = if (selected) {
-        MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.4f)
-    } else {
-        MaterialTheme.colorScheme.surfaceContainerHigh
-    }
-    Column(
-        modifier = modifier
-            .clip(shape)
-            .background(containerColor)
-            .border(width = if (selected) 2.dp else 1.dp, color = borderColor, shape = shape)
-            .clickable(onClick = onClick)
-            .padding(vertical = 20.dp, horizontal = 16.dp),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.spacedBy(12.dp),
-    ) {
-        // The adaptive launcher mark, reconstructed as a squircle (as in the
-        // onboarding BrandHero) so it renders identically everywhere.
-        Box(
-            modifier = Modifier
-                .size(64.dp)
-                .clip(RoundedCornerShape(18.dp))
-                .background(colorResource(R.color.ic_launcher_background)),
-        ) {
-            Image(
-                painter = painterResource(R.drawable.ic_launcher_foreground),
-                contentDescription = null,
-                modifier = Modifier.fillMaxSize(),
-            )
-        }
-        Text(
-            text = launcherNameLabel(name),
-            style = MaterialTheme.typography.titleMedium,
-            color = MaterialTheme.colorScheme.onSurface,
-            textAlign = TextAlign.Center,
-            maxLines = 1,
-        )
-        // Selection indicator: a filled check when active, an empty ring otherwise.
-        Box(
-            modifier = Modifier
-                .size(24.dp)
-                .clip(CircleShape)
-                .background(if (selected) MaterialTheme.colorScheme.primary else Color.Transparent)
-                .then(
-                    if (selected) {
-                        Modifier
-                    } else {
-                        Modifier.border(1.dp, MaterialTheme.colorScheme.outlineVariant, CircleShape)
-                    },
-                ),
-            contentAlignment = Alignment.Center,
-        ) {
-            if (selected) {
-                Icon(
-                    imageVector = Icons.Filled.Check,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.onPrimary,
-                    modifier = Modifier.size(16.dp),
-                )
-            }
-        }
-    }
-}
-
 @Composable
 private fun themeLabel(mode: ThemeMode): String = stringResource(
     when (mode) {
@@ -2012,7 +1833,13 @@ private fun FontOptionRow(
             }
         },
         trailing = if (selected) {
-            { SelectedCheck() }
+            {
+                Icon(
+                    imageVector = Icons.Default.Check,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.primary,
+                )
+            }
         } else {
             null
         },

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt

@@ -13,7 +13,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 
 /**
  * Settings screen state (M4). Persisted preferences are instant to read, so
@@ -38,8 +37,6 @@ data class SettingsUiState(
     val dimCompletedEvents: Boolean = false,
     /** Whether the Month grid shows calendar-week numbers in a left gutter (#25). */
     val showWeekNumbers: Boolean = false,
-    /** Whether the jump-to-today control sits in the top bar instead of the FAB (#60). */
-    val todayButtonInToolbar: Boolean = false,
     /** How far ahead the in-app Agenda screen shows events (v2.11). */
     val agendaScreenRange: AgendaRange = AgendaRange.Month,
     /** How far ahead the agenda widget shows events (v2.11). */
@@ -52,8 +49,6 @@ data class SettingsUiState(
     val defaultView: CalendarView = CalendarView.Week,
     /** Which views the top-bar quick-switch button cycles through, and their order (#24). */
     val quickSwitchConfig: QuickSwitchConfig = QuickSwitchConfig.Default,
-    /** How the Month view lays itself out: pages, continuous scroll, or split (#38, #53). */
-    val monthViewStyle: MonthViewStyle = MonthViewStyle.Paged,
     /** Order of the views in the navigation drawer (#24); every view is always listed. */
     val drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
     /** Optional event-form fields shown by default (rest behind "more fields"). */

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt

@@ -10,8 +10,6 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.calendula.data.appname.LauncherName
-import de.jeanlucmakiola.calendula.data.appname.LauncherNameManager
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesCalendarSpec
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
@@ -35,7 +33,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.storageValue
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.calendula.ui.theme.AppFontSettings
 import de.jeanlucmakiola.calendula.ui.theme.FONT_CUSTOM_TOKEN
 import de.jeanlucmakiola.calendula.widget.agenda.AGENDA_PAST_DISPLAY_KEY
@@ -46,9 +43,7 @@ import de.jeanlucmakiola.calendula.widget.month.MonthWidget
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.catch
@@ -67,7 +62,6 @@ class SettingsViewModel @Inject constructor(
     repository: CalendarRepository,
     private val specialDatesEngine: SpecialDatesSyncEngine,
     specialDatesSpec: SpecialDatesCalendarSpec,
-    private val launcherNameManager: LauncherNameManager,
     @IoDispatcher private val io: CoroutineDispatcher,
     @ApplicationContext private val appContext: Context,
 ) : ViewModel() {
@@ -130,9 +124,8 @@ class SettingsViewModel @Inject constructor(
                     prefs.showWeekNumbers,
                     prefs.agendaShowToday,
                     prefs.softenCalendarColors,
-                    prefs.todayButtonInToolbar,
-                ) { hourLines, weekNumbers, showToday, soften, todayInToolbar ->
-                    DisplayToggles(hourLines, weekNumbers, showToday, soften, todayInToolbar)
+                ) { hourLines, weekNumbers, showToday, soften ->
+                    DisplayToggles(hourLines, weekNumbers, showToday, soften)
                 },
             ) { view, screenRange, widgetRange, timeFormat, toggles ->
                 ViewSettings(
@@ -141,7 +134,6 @@ class SettingsViewModel @Inject constructor(
                     showWeekNumbers = toggles.showWeekNumbers,
                     agendaShowToday = toggles.agendaShowToday,
                     softenColors = toggles.softenColors,
-                    todayButtonInToolbar = toggles.todayButtonInToolbar,
                 )
             },
             combine(
@@ -151,12 +143,8 @@ class SettingsViewModel @Inject constructor(
                 prefs.dimCompletedEvents,
                 // View customisation (#24) folded into one flow so it fits this
                 // group — the outer combine is already at its five-arg limit.
-                combine(
-                    prefs.quickSwitchConfig,
-                    prefs.drawerViewOrder,
-                    prefs.monthViewStyle,
-                ) { quickSwitch, drawer, monthStyle ->
-                    ViewCustomization(quickSwitch, drawer, monthStyle)
+                combine(prefs.quickSwitchConfig, prefs.drawerViewOrder) { quickSwitch, drawer ->
+                    ViewCustomization(quickSwitch, drawer)
                 },
             ) { showRangeBar, autofocus, pastEvents, dimCompleted, viewCustomization ->
                 MiscSettings(showRangeBar, autofocus, pastEvents, dimCompleted, viewCustomization)
@@ -171,14 +159,12 @@ class SettingsViewModel @Inject constructor(
                 showWeekNumbers = views.showWeekNumbers,
                 agendaShowToday = views.agendaShowToday,
                 softenColors = views.softenColors,
-                todayButtonInToolbar = views.todayButtonInToolbar,
                 agendaShowRangeBar = misc.showRangeBar,
                 autofocusEventTitle = misc.autofocusEventTitle,
                 pastEventDisplay = misc.pastEventDisplay,
                 dimCompletedEvents = misc.dimCompletedEvents,
                 quickSwitchConfig = misc.viewCustomization.quickSwitch,
                 drawerViewOrder = misc.viewCustomization.drawerOrder,
-                monthViewStyle = misc.viewCustomization.monthViewStyle,
                 allowColorOnUnsupportedCalendars = defaults.allowColor,
                 defaultReminderMinutes = defaults.defaultReminder,
                 defaultAllDayReminderMinutes = defaults.allDayReminder,
@@ -213,28 +199,6 @@ class SettingsViewModel @Inject constructor(
         initialValue = AppFontSettings(),
     )
 
-    /**
-     * The launcher-label choice (issue #44). Backed by the manifest aliases'
-     * component-enabled state rather than a stored preference, so it's read
-     * imperatively via [LauncherNameManager] and held here in its own flow — the
-     * main settings combine is already at its arity limit and this isn't a
-     * DataStore flow anyway.
-     *
-     * Seeded with the manifest default and corrected off-thread rather than read
-     * in the initializer: `getComponentEnabledSetting` is a binder round-trip to
-     * system_server, and this ViewModel is constructed on the main thread while
-     * Settings is opening. The row it feeds is well below the fold, so the
-     * one-frame correction is never visible.
-     */
-    private val _launcherName = MutableStateFlow(LauncherName.CALENDULA)
-    val launcherName: StateFlow<LauncherName> = _launcherName.asStateFlow()
-
-    init {
-        viewModelScope.launch {
-            _launcherName.value = withContext(io) { launcherNameManager.current() }
-        }
-    }
-
     // Emitted when a picked font file couldn't be read as a font; the screen
     // surfaces it and the previous selection stays put.
     private val _fontImportFailed = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
@@ -270,7 +234,6 @@ class SettingsViewModel @Inject constructor(
         val showWeekNumbers: Boolean,
         val agendaShowToday: Boolean,
         val softenColors: Boolean,
-        val todayButtonInToolbar: Boolean,
     )
 
     private data class DisplayToggles(
@@ -278,7 +241,6 @@ class SettingsViewModel @Inject constructor(
         val showWeekNumbers: Boolean,
         val agendaShowToday: Boolean,
         val softenColors: Boolean,
-        val todayButtonInToolbar: Boolean,
     )
 
     private data class MiscSettings(
@@ -292,7 +254,6 @@ class SettingsViewModel @Inject constructor(
     private data class ViewCustomization(
         val quickSwitch: QuickSwitchConfig,
         val drawerOrder: List<CalendarView>,
-        val monthViewStyle: MonthViewStyle,
     )
 
     /** Contact special-dates sub-page (issue #15); its own flow — the main state is full. */
@@ -499,26 +460,6 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setShowWeekNumbers(enabled) }
     }
 
-    fun setTodayButtonInToolbar(enabled: Boolean) {
-        viewModelScope.launch { prefs.setTodayButtonInToolbar(enabled) }
-    }
-
-    /**
-     * Switch the launcher label between "Calendula" and "Calendar" (issue #44).
-     * The card highlights immediately, then settles on whatever the component
-     * state actually reports — the two `setComponentEnabledSetting` calls are
-     * binder round-trips, so they don't belong on the main thread either.
-     */
-    fun setLauncherName(name: LauncherName) {
-        _launcherName.value = name
-        viewModelScope.launch {
-            _launcherName.value = withContext(io) {
-                launcherNameManager.set(name)
-                launcherNameManager.current()
-            }
-        }
-    }
-
     fun setPastEventDisplay(mode: PastEventDisplay) {
         viewModelScope.launch {
             prefs.setPastEventDisplay(mode)
@@ -569,10 +510,6 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.updateQuickSwitch { it.copy(order = order) } }
     }
 
-    fun setMonthViewStyle(style: MonthViewStyle) {
-        viewModelScope.launch { prefs.setMonthViewStyle(style) }
-    }
-
     fun setDrawerViewOrder(order: List<CalendarView>) {
         viewModelScope.launch { prefs.setDrawerViewOrder(order) }
     }

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

@@ -5,6 +5,7 @@ import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.detectHorizontalDragGestures
 import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
@@ -48,6 +49,7 @@ import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
@@ -75,10 +77,8 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.hasEnded
-import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
-import de.jeanlucmakiola.calendula.ui.common.TodayAction
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
@@ -92,9 +92,8 @@ import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
-import de.jeanlucmakiola.calendula.ui.common.rememberCalendarPageSwipe
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
-import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
 import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
@@ -144,7 +143,6 @@ fun WeekScreen(
     onCreateEvent: (LocalDate, Int?) -> Unit,
     quickSwitchViews: List<CalendarView> = IMPLEMENTED_VIEWS,
     drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
-    todayInToolbar: Boolean = false,
     modifier: Modifier = Modifier,
     viewModel: WeekViewModel = hiltViewModel(),
 ) {
@@ -182,13 +180,6 @@ fun WeekScreen(
         else -> true
     }
 
-    // Drives whether the title carries the year. Falls back to the clock only
-    // while the first load is in flight, when there is no state to read today from.
-    val currentYear = when (val s = state) {
-        is WeekUiState.Success -> s.today.year
-        else -> Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date.year
-    }
-
     // Slide direction for the week transition: +1 = next, -1 = prev, 0 = jump.
     var slideDir by remember { mutableIntStateOf(0) }
     val goNext = { slideDir = 1; viewModel.goToNext() }
@@ -237,19 +228,16 @@ fun WeekScreen(
             topBar = {
                 WeekTopBar(
                     weekStart = weekStart,
-                    currentYear = currentYear,
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
-                    showTodayButton = todayInToolbar,
-                    onToday = jumpToToday,
                     scrollBehavior = scrollBehavior,
                 )
             },
             floatingActionButton = {
                 CalendarFabColumn(
-                    todayVisible = !isOnCurrentWeek && !todayInToolbar,
+                    todayVisible = !isOnCurrentWeek,
                     todayText = stringResource(R.string.week_today_action),
                     onToday = jumpToToday,
                     onCreate = {
@@ -295,6 +283,8 @@ private fun WeekContent(
     modifier: Modifier = Modifier,
 ) {
     val density = LocalDensity.current
+    val threshold = with(density) { 24.dp.toPx() }
+    var dragAccum by remember { mutableFloatStateOf(0f) }
     val slideSpec = rememberCalendarSlideSpec()
     val fadeSpec = rememberCalendarFadeSpec()
     val reduceMotion = rememberReduceMotion()
@@ -326,7 +316,20 @@ private fun WeekContent(
     // vertical scroll: a horizontal drag only crosses *this* detector's slop,
     // while a vertical drag is consumed by the inner scroll first — so the two
     // gestures coexist without fighting.
-    val swipeModifier = rememberCalendarPageSwipe(onSwipeNext, onSwipePrev)
+    val swipeModifier = Modifier.pointerInput(Unit) {
+        detectHorizontalDragGestures(
+            onDragStart = { dragAccum = 0f },
+            onDragEnd = {
+                when {
+                    dragAccum < -threshold -> onSwipeNext()
+                    dragAccum > threshold -> onSwipePrev()
+                }
+                dragAccum = 0f
+            },
+            onDragCancel = { dragAccum = 0f },
+            onHorizontalDrag = { _, drag -> dragAccum += drag },
+        )
+    }
 
     AnimatedContent(
         targetState = state,
@@ -392,20 +395,16 @@ private fun WeekSuccess(
 @Composable
 private fun WeekTopBar(
     weekStart: LocalDate,
-    currentYear: Int,
     selectedView: CalendarView,
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
-    showTodayButton: Boolean,
-    onToday: () -> Unit,
     scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
-    val locale = currentLocale()
     TopAppBar(
         title = {
             Text(
-                text = formatWeekTitle(weekStart, locale, currentYear),
+                text = formatWeekRange(weekStart),
                 style = MaterialTheme.typography.titleLarge,
             )
         },
@@ -418,7 +417,6 @@ private fun WeekTopBar(
             }
         },
         actions = {
-            TodayAction(show = showTodayButton, onToday = onToday)
             IconButton(onClick = onOpenSearch) {
                 Icon(
                     imageVector = Icons.Default.Search,
@@ -856,29 +854,18 @@ private fun WeekLoading() {
 private fun minToHm(min: Int, is24Hour: Boolean, locale: java.util.Locale): String =
     formatMinuteOfDay(min, is24Hour, locale)
 
-/**
- * The week's title: just the month [weekStart] falls in.
- *
- * The day numbers are already in the column headers directly below, so spelling
- * out "13.–19. Jul" restates them in the widest string in the bar. Naming the
- * month of [weekStart] means a week straddling a boundary keeps the outgoing
- * month until it is fully gone — a week is seven contiguous days, so the earlier
- * month has a day in it exactly while [weekStart] is still inside it. That also
- * makes the *month* depend on nothing but [weekStart], so it cannot drift with
- * the direction you paged in from.
- *
- * The *year* is decided from the whole week, not just its start: a week running
- * Dec 28 – Jan 3 has four of its seven visible columns in the new year, so
- * "December" with no year would be actively misleading while the reader is
- * looking straight at January dates.
- */
-private fun formatWeekTitle(weekStart: LocalDate, locale: Locale, currentYear: Int): String {
-    val weekEnd = weekStart.plus(6, kotlinx.datetime.DateTimeUnit.DAY)
-    return formatCalendarTitle(
-        date = java.time.LocalDate.of(weekStart.year, weekStart.month.ordinal + 1, 1),
-        locale = locale,
-        currentYear = currentYear,
-        skeleton = "LLLL",
-        forceYear = weekEnd.year != weekStart.year,
-    )
+private fun formatWeekRange(weekStart: LocalDate): String {
+    val locale = Locale.getDefault()
+    val end = weekStart.plus(6, kotlinx.datetime.DateTimeUnit.DAY)
+    val monthName = { d: LocalDate ->
+        java.time.Month.of(d.month.ordinal + 1).getDisplayName(JavaTextStyle.SHORT, locale)
+    }
+    return if (weekStart.month == end.month && weekStart.year == end.year) {
+        "${weekStart.day}.–${end.day}. ${monthName(weekStart)} ${weekStart.year}"
+    } else if (weekStart.year == end.year) {
+        "${weekStart.day}. ${monthName(weekStart)} – ${end.day}. ${monthName(end)} ${end.year}"
+    } else {
+        "${weekStart.day}. ${monthName(weekStart)} ${weekStart.year} – " +
+            "${end.day}. ${monthName(end)} ${end.year}"
+    }
 }

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetData.kt

@@ -131,14 +131,13 @@ internal suspend fun Context.loadAgendaWidgetData(): AgendaWidgetData {
     // the composition from Glance state, so changing the range is a plain
     // recomposition and never depends on the widget session restarting.
     val window = agendaRange(anchor, AgendaRange.MAX_CUSTOM_DAYS - 1, zone)
-    val windowEnd = anchor.plus(AgendaRange.MAX_CUSTOM_DAYS - 1, DateTimeUnit.DAY)
     val instances = ep.calendarRepository().instances(window).first()
     val is24Hour = prefs.timeFormat.first()
         .is24Hour(android.text.format.DateFormat.is24HourFormat(this))
     val soften = prefs.softenCalendarColors.first()
     return AgendaWidgetData.Ready(
         today = anchor,
-        days = groupAgendaDays(anchor, windowEnd, instances, zone),
+        days = groupAgendaDays(anchor, instances, zone),
         is24Hour = is24Hour,
         soften = soften,
         weekStart = weekStart,

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetScale.kt

@@ -1,70 +0,0 @@
-package de.jeanlucmakiola.calendula.widget
-
-import androidx.compose.ui.unit.DpSize
-import androidx.compose.ui.unit.dp
-
-/**
- * Size tiers a widget scales its typography and metrics across (#51).
- *
- * Shared by every Glance widget so the bucketing rule can't drift between them:
- * each widget keeps its own metrics table, but they all agree on *when* a widget
- * counts as compact, regular, large or extra-large. Both widgets already declare
- * [androidx.glance.appwidget.SizeMode.Exact], so the composition sees the live
- * size via `LocalSize.current` and passes it to [scaleFor].
- *
- * Kept in a pure, Glance-free file (only `compose.ui.unit`) so the bucketing is
- * covered by plain JVM tests.
- */
-internal enum class WidgetScale { COMPACT, REGULAR, LARGE, XLARGE }
-
-/**
- * Chrome a widget spends before its first content row: outer vertical padding
- * plus a header row and its spacer. Subtracted from the raw height so the height
- * thresholds below talk about *usable* space rather than gross widget height.
- */
-private val CHROME_HEIGHT = 60.dp
-
-/**
- * Buckets a live widget size into a [WidgetScale] by **width**.
- *
- * Width is the right axis: it governs how much of a title fits on a row, so it's
- * what should drive type size. Height only decides how many rows are visible — a
- * tall, narrow widget wants *more events*, not bigger text — so it never raises
- * the tier. It does act as a **cap**, though: a genuinely squashed widget is
- * stepped back down so it can't keep oversized type in a sliver of space.
- *
- * The width thresholds are spread across the range a phone can actually produce
- * (~180dp up to roughly the screen width) rather than over a theoretical range,
- * so the tiers are reachable in practice. Calibrated on-device (Pixel / Nova): a
- * compact 222dp-wide widget stays COMPACT (the app's baseline, unchanged) and a
- * full-width 378dp one reaches LARGE. XLARGE is reserved for genuinely wide
- * surfaces — tablets, foldables, landscape — where the extra size reads well.
- *
- * The height cap is deliberately generous: it exists to catch a widget squashed
- * to one or two rows, **not** to gate ordinary placements. A full-width widget at
- * the usual three cells tall (~270dp) must still reach the tier its width earned
- * — that is exactly the resize #51 reports, and an aggressive cap would make the
- * whole feature a no-op for it.
- */
-internal fun scaleFor(size: DpSize): WidgetScale {
-    val byWidth = when {
-        size.width < 260.dp -> WidgetScale.COMPACT
-        size.width < 330.dp -> WidgetScale.REGULAR
-        size.width < 420.dp -> WidgetScale.LARGE
-        else -> WidgetScale.XLARGE
-    }
-    // Height can only ever pull the tier *down*, never push it up: a squashed
-    // widget would otherwise keep the big type its width earned and look absurd
-    // in the little space left. Keeping this a cap (rather than a second scaling
-    // axis) is what preserves "tall and narrow shows more events, not bigger
-    // text". Thresholds are usable height — roughly one, two and three rows of
-    // breathing room once the header is paid for.
-    val usable = size.height - CHROME_HEIGHT
-    val heightCap = when {
-        usable < 70.dp -> WidgetScale.COMPACT
-        usable < 130.dp -> WidgetScale.REGULAR
-        usable < 200.dp -> WidgetScale.LARGE
-        else -> WidgetScale.XLARGE
-    }
-    return minOf(byWidth, heightCap)
-}

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

@@ -1,150 +0,0 @@
-package de.jeanlucmakiola.calendula.widget.agenda
-
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.TextUnit
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import de.jeanlucmakiola.calendula.widget.WidgetScale
-
-/**
- * Horizontal layout constants for an agenda event row. These don't scale with the
- * tier — a wider stripe or gap would eat title width, which is the thing the row
- * is short of — but [TEXT_INDENT] is *derived* from them so the day header and
- * the "nothing left today" line can never drift out of alignment with the event
- * title column the way a hardcoded 19dp could.
- */
-internal val ROW_H_PAD = 4.dp
-internal val STRIPE_WIDTH = 5.dp
-internal val STRIPE_GAP = 10.dp
-
-/** Left indent that lines non-event text up with the event title column. */
-internal val TEXT_INDENT = ROW_H_PAD + STRIPE_WIDTH + STRIPE_GAP
-
-/**
- * The width band a *default* agenda placement can land in, per
- * `app/src/main/res/xml/appwidget_info_agenda.xml` (`android:minWidth="180dp"`,
- * `android:targetCellWidth="3"`). Measured at 222dp on a Pixel running Nova, but
- * launcher cell grids vary, so the whole band — not one measured point — has to
- * stay [WidgetScale.COMPACT] for the "default size is unchanged" promise of #51
- * to hold. A test pins that.
- *
- * If the provider's `targetCellWidth` ever changes, this band and the first
- * width threshold in [de.jeanlucmakiola.calendula.widget.scaleFor] must be
- * revisited together.
- */
-internal val AGENDA_DEFAULT_WIDTH_BAND = 180.dp..255.dp
-
-/**
- * Every size the agenda widget varies by tier. Values that genuinely shouldn't
- * grow (the horizontal row constants above, corner radii) stay constants rather
- * than routing through here.
- */
-internal data class AgendaMetrics(
-    val title: TextUnit,        // header "Upcoming"
-    val dayHeader: TextUnit,    // day label ("Today · …")
-    val eventTitle: TextUnit,   // event title line
-    val eventTime: TextUnit,    // time/location line
-    val placeholder: TextUnit,  // "no more events today" (#35)
-    val message: TextUnit,      // empty/permission centred message
-    val stripeH: Dp,            // coloured event stripe height
-    val iconImage: Dp,          // header action icon glyph
-    val iconBox: Dp,            // header action touch target
-    val rowVPad: Dp,            // event row vertical padding
-    val dayHeaderTopPad: Dp,    // space above a day header
-) {
-    /**
-     * Resolves the stripe height against the user's system font scale.
-     *
-     * The stripe is a [Dp] but the two text lines it sits beside are `sp`, so
-     * they scale with the accessibility font setting and the stripe does not —
-     * at "Largest" the text outgrows the stripe and it visibly under-runs the row
-     * it is supposed to mark. Multiplying by the same factor keeps them locked,
-     * and at the default scale of 1.0 reproduces the tier's value exactly.
-     */
-    fun scaledForFont(fontScale: Float): AgendaMetrics =
-        if (fontScale == 1f) this else copy(stripeH = stripeH * fontScale)
-}
-
-/*
- * Type sizes are anchored to the Material 3 type scale (see the `material-3`
- * skill's typography reference) rather than invented: 16sp is Title Medium, 14sp
- * Body Medium / Title Small, 12sp Body Small, 16sp Body Large, 22sp Title Large.
- *
- * Two documented deviations:
- *
- *  ‡ COMPACT's 13sp day header is off-scale. It is held there deliberately —
- *    COMPACT reproduces the widget's original constants verbatim so a
- *    default-sized widget looks exactly as it did (#51), and snapping it to
- *    Title Small (14sp) would break that promise for a 1sp gain.
- *
- *  † Above Title Medium the M3 scale jumps 16 → 22 → 24 with nothing in between,
- *    which is far too coarse for four widget tiers. Where a role would force a
- *    ≥1.4x step between adjacent tiers we hold an interpolated value instead and
- *    mark it. The endpoints stay on real roles.
- */
-
-private val COMPACT_METRICS = AgendaMetrics(
-    title = 16.sp,       // M3 Title Medium
-    dayHeader = 13.sp,   // ‡ off-scale, holds the #51 baseline
-    eventTitle = 14.sp,  // M3 Body Medium
-    eventTime = 12.sp,   // M3 Body Small
-    placeholder = 14.sp, // M3 Body Medium
-    message = 14.sp,     // M3 Body Medium
-    stripeH = 36.dp,
-    iconImage = 22.dp,
-    iconBox = 40.dp,
-    rowVPad = 4.dp,
-    dayHeaderTopPad = 10.dp,
-)
-
-private val REGULAR_METRICS = AgendaMetrics(
-    title = 18.sp,       // †
-    dayHeader = 14.sp,   // M3 Title Small
-    eventTitle = 16.sp,  // M3 Body Large
-    eventTime = 14.sp,   // M3 Body Medium
-    placeholder = 16.sp, // M3 Body Large
-    message = 16.sp,     // M3 Body Large
-    stripeH = 40.dp,
-    iconImage = 24.dp,
-    iconBox = 44.dp,
-    rowVPad = 5.dp,
-    dayHeaderTopPad = 11.dp,
-)
-
-private val LARGE_METRICS = AgendaMetrics(
-    title = 20.sp,       // †
-    dayHeader = 16.sp,   // M3 Title Medium
-    eventTitle = 18.sp,  // †
-    eventTime = 14.sp,   // M3 Body Medium — the secondary line steps more slowly
-    placeholder = 18.sp, // †                on purpose, so the title keeps its
-    message = 18.sp,     // †                lead and the hierarchy survives.
-    stripeH = 46.dp,
-    iconImage = 26.dp,
-    iconBox = 48.dp,
-    rowVPad = 6.dp,
-    dayHeaderTopPad = 12.dp,
-)
-
-private val XLARGE_METRICS = AgendaMetrics(
-    title = 22.sp,       // M3 Title Large
-    dayHeader = 18.sp,   // †
-    eventTitle = 20.sp,  // †
-    eventTime = 16.sp,   // M3 Body Large
-    placeholder = 20.sp, // †
-    message = 20.sp,     // †
-    stripeH = 52.dp,
-    iconImage = 28.dp,
-    iconBox = 52.dp,
-    rowVPad = 8.dp,
-    dayHeaderTopPad = 14.dp,
-)
-
-/** Indexed by [WidgetScale.ordinal] so lookup allocates nothing per recomposition. */
-private val AGENDA_METRICS = listOf(
-    COMPACT_METRICS,
-    REGULAR_METRICS,
-    LARGE_METRICS,
-    XLARGE_METRICS,
-)
-
-internal fun metricsFor(scale: WidgetScale): AgendaMetrics = AGENDA_METRICS[scale.ordinal]

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

@@ -5,6 +5,7 @@ import android.content.res.Configuration
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.glance.ColorFilter
@@ -13,11 +14,9 @@ import androidx.glance.GlanceModifier
 import androidx.glance.GlanceTheme
 import androidx.glance.Image
 import androidx.glance.ImageProvider
-import androidx.glance.LocalSize
 import androidx.glance.action.ActionParameters
 import androidx.glance.action.clickable
 import androidx.glance.appwidget.GlanceAppWidget
-import androidx.glance.appwidget.SizeMode
 import androidx.glance.appwidget.action.ActionCallback
 import androidx.glance.appwidget.action.actionRunCallback
 import androidx.glance.appwidget.action.actionStartActivity
@@ -50,19 +49,16 @@ import de.jeanlucmakiola.calendula.data.prefs.parsePastEventDisplay
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.hasEnded
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
-import de.jeanlucmakiola.calendula.ui.agenda.AgendaTimeLabel
-import de.jeanlucmakiola.calendula.ui.agenda.agendaTimeLabel
 import de.jeanlucmakiola.calendula.ui.agenda.anchorTodayIfMissing
 import de.jeanlucmakiola.calendula.ui.agenda.dayCount
 import de.jeanlucmakiola.calendula.ui.agenda.parseAgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
-import de.jeanlucmakiola.floret.locale.localizedDateFormatter
+import de.jeanlucmakiola.calendula.ui.common.localizedDateFormatter
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.widget.AgendaWidgetData
 import de.jeanlucmakiola.calendula.widget.CalendulaGlanceTheme
-import de.jeanlucmakiola.calendula.widget.scaleFor
 import de.jeanlucmakiola.calendula.widget.loadAgendaWidgetData
 import de.jeanlucmakiola.calendula.widget.systemZone
 import de.jeanlucmakiola.calendula.widget.today
@@ -109,19 +105,6 @@ class AgendaWidget : GlanceAppWidget() {
 
     override val stateDefinition = PreferencesGlanceStateDefinition
 
-    // Exact so the composition sees the widget's live size and can scale type/rows
-    // from it ([scaleFor]/[metricsFor]); at the default size that resolves to
-    // COMPACT, i.e. the layout is unchanged (#51). MonthWidget already does the
-    // same.
-    //
-    // Note Exact still asks Glance for one RemoteViews per host size (typically
-    // portrait + landscape) where the old SizeMode.Single produced exactly one —
-    // so the serialized payload roughly doubles. That is why the row list below is
-    // capped: an uncapped agenda (the range goes up to AgendaRange.MAX_CUSTOM_DAYS
-    // = 365) could otherwise push the RemoteViews past the binder transaction
-    // limit and the host would just show "Problem loading widget".
-    override val sizeMode = SizeMode.Exact
-
     override suspend fun provideGlance(context: Context, id: GlanceId) {
         val data = context.loadAgendaWidgetData()
         val dark = (context.resources.configuration.uiMode and
@@ -141,41 +124,26 @@ class RefreshAgendaAction : ActionCallback {
     }
 }
 
-/**
- * Upper bound on rows handed to the [LazyColumn], so the serialized RemoteViews
- * stays well inside the binder transaction limit regardless of range and calendar
- * size (see the [SizeMode.Exact] note above). Far more than fits on screen — a
- * user scrolling a home-screen widget past a hundred rows is not a case worth
- * risking a failed update for.
- */
-private const val MAX_AGENDA_ROWS = 100
-
 /** Flat row model so the [LazyColumn] can mix day headers and events. */
 private sealed interface AgendaRow {
     data class Header(val date: LocalDate, val today: LocalDate) : AgendaRow
-    data class Event(val date: LocalDate, val event: EventInstance) : AgendaRow
+    data class Event(val event: EventInstance) : AgendaRow
     /** "Nothing left today" line under an anchored, event-less today (#35). */
     data class Placeholder(val date: LocalDate) : AgendaRow
 }
 
 @Composable
 private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
-    // Type and row metrics scale with the widget's live size (SizeMode.Exact); a
-    // short/compact widget resolves to COMPACT, leaving the layout unchanged (#51).
-    // The stripe is then re-resolved against the system font scale so it tracks the
-    // sp-sized text beside it instead of drifting at large accessibility settings.
-    val fontScale = androidx.glance.LocalContext.current.resources.configuration.fontScale
-    val metrics = metricsFor(scaleFor(LocalSize.current)).scaledForFont(fontScale)
     Column(
         modifier = GlanceModifier
             .fillMaxSize()
             .background(GlanceTheme.colors.surface)
             .padding(horizontal = 8.dp, vertical = 6.dp),
     ) {
-        AgendaHeader(metrics)
+        AgendaHeader()
         Spacer(GlanceModifier.height(4.dp))
         when (data) {
-            AgendaWidgetData.NeedsPermission -> WidgetMessage(R.string.widget_needs_permission, metrics)
+            AgendaWidgetData.NeedsPermission -> WidgetMessage(R.string.widget_needs_permission)
             is AgendaWidgetData.Ready -> {
                 // Range read reactively from per-instance Glance state (falls back
                 // to the saved pref for a freshly placed widget), then the wide
@@ -209,7 +177,7 @@ private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
                     enabled = showToday,
                 )
                 if (visibleDays.isEmpty()) {
-                    WidgetMessage(R.string.agenda_empty_title, metrics)
+                    WidgetMessage(R.string.agenda_empty_title)
                 } else {
                     val rows = buildList {
                         visibleDays.forEach { day ->
@@ -217,28 +185,22 @@ private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
                             if (day.events.isEmpty()) {
                                 add(AgendaRow.Placeholder(day.date))
                             } else {
-                                day.events.forEach { add(AgendaRow.Event(day.date, it)) }
+                                day.events.forEach { add(AgendaRow.Event(it)) }
                             }
                         }
                     }
-                        // Bound the payload, then drop a day header the cut left
-                        // stranded with nothing under it.
-                        .take(MAX_AGENDA_ROWS)
-                        .dropLastWhile { it is AgendaRow.Header }
                     LazyColumn(modifier = GlanceModifier.fillMaxSize()) {
                         items(rows.size) { index ->
                             when (val row = rows[index]) {
-                                is AgendaRow.Header -> DayHeaderRow(row.date, row.today, metrics)
-                                is AgendaRow.Placeholder -> PlaceholderRow(row.date, metrics)
+                                is AgendaRow.Header -> DayHeaderRow(row.date, row.today)
+                                is AgendaRow.Placeholder -> PlaceholderRow(row.date)
                                 is AgendaRow.Event -> EventRow(
                                     event = row.event,
-                                    day = row.date,
                                     dark = dark,
                                     soften = data.soften,
                                     is24Hour = data.is24Hour,
                                     dimmed = pastDisplay == PastEventDisplay.DIM &&
                                         row.event.hasEnded(data.now),
-                                    metrics = metrics,
                                 )
                             }
                         }
@@ -250,7 +212,7 @@ private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
 }
 
 @Composable
-private fun AgendaHeader(metrics: AgendaMetrics) {
+private fun AgendaHeader() {
     val context = androidx.glance.LocalContext.current
     Row(
         modifier = GlanceModifier.fillMaxWidth().padding(horizontal = 4.dp),
@@ -262,7 +224,7 @@ private fun AgendaHeader(metrics: AgendaMetrics) {
             text = context.getString(R.string.widget_agenda_title),
             style = TextStyle(
                 color = GlanceTheme.colors.primary,
-                fontSize = metrics.title,
+                fontSize = 16.sp,
                 fontWeight = FontWeight.Medium,
             ),
             modifier = GlanceModifier
@@ -275,7 +237,6 @@ private fun AgendaHeader(metrics: AgendaMetrics) {
             resId = R.drawable.ic_widget_refresh,
             contentDescription = context.getString(R.string.widget_refresh),
             onClick = GlanceModifier.clickable(actionRunCallback<RefreshAgendaAction>()),
-            metrics = metrics,
         )
         IconButton(
             resId = R.drawable.ic_widget_add,
@@ -285,50 +246,39 @@ private fun AgendaHeader(metrics: AgendaMetrics) {
                     MainActivity.openCreateIntent(context, today(systemZone())),
                 ),
             ),
-            metrics = metrics,
         )
     }
 }
 
 @Composable
-private fun IconButton(
-    resId: Int,
-    contentDescription: String,
-    onClick: GlanceModifier,
-    metrics: AgendaMetrics,
-) {
+private fun IconButton(resId: Int, contentDescription: String, onClick: GlanceModifier) {
     Box(
-        modifier = GlanceModifier.size(metrics.iconBox).then(onClick),
+        modifier = GlanceModifier.size(40.dp).then(onClick),
         contentAlignment = Alignment.Center,
     ) {
         Image(
             provider = ImageProvider(resId),
             contentDescription = contentDescription,
             colorFilter = ColorFilter.tint(GlanceTheme.colors.onSurfaceVariant),
-            modifier = GlanceModifier.size(metrics.iconImage),
+            modifier = GlanceModifier.size(22.dp),
         )
     }
 }
 
 @Composable
-private fun DayHeaderRow(date: LocalDate, today: LocalDate, metrics: AgendaMetrics) {
+private fun DayHeaderRow(date: LocalDate, today: LocalDate) {
     val context = androidx.glance.LocalContext.current
     Text(
         text = agendaDayLabel(context, date, today),
         style = TextStyle(
             color = if (date == today) GlanceTheme.colors.primary
             else GlanceTheme.colors.onSurfaceVariant,
-            fontSize = metrics.dayHeader,
+            fontSize = 13.sp,
             fontWeight = FontWeight.Medium,
         ),
         modifier = GlanceModifier
             .fillMaxWidth()
-            .padding(
-                start = 8.dp,
-                end = 8.dp,
-                top = metrics.dayHeaderTopPad,
-                bottom = metrics.rowVPad,
-            )
+            .padding(start = 8.dp, end = 8.dp, top = 10.dp, bottom = 4.dp)
             .clickable(
                 actionStartActivity(
                     MainActivity.openDateIntent(context, date, CalendarView.Agenda),
@@ -343,19 +293,14 @@ private fun DayHeaderRow(date: LocalDate, today: LocalDate, metrics: AgendaMetri
  * plain too (a stripe + text, not cards), so a card here would look out of place.
  */
 @Composable
-private fun PlaceholderRow(date: LocalDate, metrics: AgendaMetrics) {
+private fun PlaceholderRow(date: LocalDate) {
     val context = androidx.glance.LocalContext.current
     Text(
         text = context.getString(R.string.agenda_no_more_today),
-        style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = metrics.placeholder),
+        style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 14.sp),
         modifier = GlanceModifier
             .fillMaxWidth()
-            .padding(
-                start = TEXT_INDENT,
-                end = 8.dp,
-                top = 2.dp,
-                bottom = metrics.rowVPad + 2.dp,
-            )
+            .padding(start = 19.dp, end = 8.dp, top = 2.dp, bottom = 6.dp)
             .clickable(
                 actionStartActivity(
                     MainActivity.openDateIntent(context, date, CalendarView.Agenda),
@@ -367,12 +312,10 @@ private fun PlaceholderRow(date: LocalDate, metrics: AgendaMetrics) {
 @Composable
 private fun EventRow(
     event: EventInstance,
-    day: LocalDate,
     dark: Boolean,
     soften: Boolean,
     is24Hour: Boolean,
     dimmed: Boolean,
-    metrics: AgendaMetrics,
 ) {
     val context = androidx.glance.LocalContext.current
     val title = event.title.ifBlank { context.getString(R.string.event_untitled) }
@@ -385,7 +328,7 @@ private fun EventRow(
     Row(
         modifier = GlanceModifier
             .fillMaxWidth()
-            .padding(horizontal = ROW_H_PAD, vertical = metrics.rowVPad)
+            .padding(horizontal = 4.dp, vertical = 4.dp)
             .clickable(
                 actionStartActivity(
                     MainActivity.openEventIntent(
@@ -401,29 +344,29 @@ private fun EventRow(
     ) {
         Box(
             modifier = GlanceModifier
-                .width(STRIPE_WIDTH)
-                .height(metrics.stripeH)
+                .width(5.dp)
+                .height(36.dp)
                 .cornerRadius(3.dp)
                 .background(stripeColor),
         ) {}
-        Spacer(GlanceModifier.width(STRIPE_GAP))
+        Spacer(GlanceModifier.width(10.dp))
         Column(modifier = GlanceModifier.defaultWeight()) {
             Text(
                 text = title,
                 maxLines = 1,
-                style = TextStyle(color = titleColor, fontSize = metrics.eventTitle),
+                style = TextStyle(color = titleColor, fontSize = 14.sp),
             )
             Text(
-                text = eventTimeSummary(context, event, day, is24Hour),
+                text = eventTimeSummary(context, event, is24Hour),
                 maxLines = 1,
-                style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = metrics.eventTime),
+                style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 12.sp),
             )
         }
     }
 }
 
 @Composable
-private fun WidgetMessage(resId: Int, metrics: AgendaMetrics) {
+private fun WidgetMessage(resId: Int) {
     val context = androidx.glance.LocalContext.current
     Box(
         modifier = GlanceModifier.fillMaxSize().padding(16.dp),
@@ -431,7 +374,7 @@ private fun WidgetMessage(resId: Int, metrics: AgendaMetrics) {
     ) {
         Text(
             text = context.getString(resId),
-            style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = metrics.message),
+            style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 14.sp),
         )
     }
 }
@@ -453,20 +396,11 @@ private fun agendaDayLabel(context: Context, date: LocalDate, today: LocalDate):
     return if (relative != null) "$relative · $formatted" else formatted
 }
 
-private fun eventTimeSummary(
-    context: Context,
-    event: EventInstance,
-    day: LocalDate,
-    is24Hour: Boolean,
-): String {
-    val time = when (val label = agendaTimeLabel(event, day, zone())) {
-        AgendaTimeLabel.AllDay -> context.getString(R.string.event_detail_all_day)
-        is AgendaTimeLabel.Starts ->
-            context.getString(R.string.agenda_span_starts, formatTime(label.start, is24Hour))
-        is AgendaTimeLabel.Ends ->
-            context.getString(R.string.agenda_span_ends, formatTime(label.end, is24Hour))
-        is AgendaTimeLabel.Range ->
-            "${formatTime(label.start, is24Hour)} – ${formatTime(label.end, is24Hour)}"
+private fun eventTimeSummary(context: Context, event: EventInstance, is24Hour: Boolean): String {
+    val time = if (event.isAllDay) {
+        context.getString(R.string.event_detail_all_day)
+    } else {
+        "${formatTime(event.start, is24Hour)} – ${formatTime(event.end, is24Hour)}"
     }
     val location = event.location?.takeIf { it.isNotBlank() }
     return if (location != null) "$time · $location" else time

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

@@ -49,7 +49,6 @@ import de.jeanlucmakiola.calendula.MainActivity
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
-import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.month.MonthWeek
 import de.jeanlucmakiola.calendula.ui.month.layoutMonthWeeks
 import de.jeanlucmakiola.calendula.ui.common.eventFill
@@ -163,7 +162,7 @@ private fun MonthWidgetBody(source: MonthWidgetSource, dark: Boolean, soften: Bo
                 val colW = (LocalSize.current.width - GRID_HPADDING * 2) / 7
                 val weeks = layoutMonthWeeks(ym, source.weekStart, source.instances, zone)
 
-                MonthHeader(label = monthLabel(ym, source.today.year))
+                MonthHeader(label = monthLabel(ym))
                 Spacer(GlanceModifier.height(2.dp))
                 WeekdayHeader(weekStart = source.weekStart, colW = colW)
                 weeks.forEach { week ->
@@ -481,13 +480,9 @@ private fun PermissionMessage() {
     }
 }
 
-// Locale.getDefault() rather than currentLocale(): Glance has no
-// LocalConfiguration, and the widget is re-rendered on a configuration change
-// anyway (same convention as AgendaWidget).
-private fun monthLabel(month: YearMonth, currentYear: Int): String =
-    formatCalendarTitle(
-        date = java.time.LocalDate.of(month.year, month.month.ordinal + 1, 1),
-        locale = Locale.getDefault(),
-        currentYear = currentYear,
-        skeleton = "LLLL",
-    )
+private fun monthLabel(month: YearMonth): String {
+    val locale = Locale.getDefault()
+    val name = java.time.Month.of(month.month.ordinal + 1)
+        .getDisplayName(JavaTextStyle.FULL, locale)
+    return "$name ${month.year}"
+}

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

@@ -10,24 +10,24 @@
     <string name="app_tagline">Un calendrier moderne.</string>
     <string name="state_loading">Chargement…</string>
     <string name="state_retry">Réessayer</string>
-    <string name="state_failure_unknown">Une erreur s\'est produit.</string>
+    <string name="state_failure_unknown">Une erreur s\'est produite.</string>
     <string name="state_failure_permission">Un accès au Calendrier est nécessaire.</string>
-    <string name="state_failure_permission_action">Autoriser l\'accès</string>
+    <string name="state_failure_permission_action">Accorder l\'accès</string>
     <string name="state_failure_no_calendars">Aucun calendrier configuré.</string>
-    <string name="state_failure_no_calendars_action">Ouvrir les paramètres du calendrier.</string>
-    <string name="state_failure_provider">Ne peut pas lire le calendrier.</string>
-    <string name="permission_rationale_title">Tous les évènements ont été trouvés.</string>
-    <string name="permission_rationale_body">Calendula a besoin d\'avoir accès à votre calendrier pour afficher et accéder aux événements. C\'est tout ce dont nous avons besoin, aucune données ne sort de votre appareil.</string>
+    <string name="state_failure_no_calendars_action">Ouvrir les paramètres systèmes du calendrier</string>
+    <string name="state_failure_provider">Impossible de lire le calendrier.</string>
+    <string name="permission_rationale_title">Accédez à tous vos évènements, en beauté</string>
+    <string name="permission_rationale_body">Calendula a besoin d\'accéder à votre calendrier pour afficher et gérer vos évènements. C\'est tout ce qu\'il demande — et rien ne quitte votre appareil.</string>
     <string name="permission_request_button">Autoriser l\'accès au calendrier</string>
-    <string name="permission_denied_title">Accès au calendrier refusé.</string>
+    <string name="permission_denied_title">Accès au calendrier refusé</string>
     <string name="permission_denied_body">Calendula ne peut pas afficher les évènements si elle ne peut pas accéder au calendrier. Vous pouvez l\'autoriser à tout moment dans les paramètres.</string>
-    <string name="permission_open_settings_button">Ouvrir les paramètres.</string>
+    <string name="permission_open_settings_button">Ouvrir les paramètres système</string>
     <string name="permission_retry_button">Essayer à nouveau</string>
-    <string name="permission_benefit_private_title">Reste sur votre appareil</string>
+    <string name="permission_benefit_private_title">Ne quitte pas votre appareil</string>
     <string name="permission_benefit_private_body">Vos calendriers sont lus localement et ne quittent jamais le téléphone.</string>
     <string name="permission_benefit_sync_title">Tous vos calendriers, réunis</string>
     <string name="permission_benefit_privacy_title">Aucun suivi, jamais</string>
-    <string name="permission_benefit_privacy_body">Aucune collecte de données, aucune analyse, pas de pubs</string>
+    <string name="permission_benefit_privacy_body">Aucune collecte de données, aucune analyse, pas de pubs.</string>
     <string name="permission_privacy_footnote">Reste sur votre appareil - Pas d\'utilisation d\'Internet</string>
     <string name="month_prev">Mois précédent</string>
     <string name="month_next">Prochain mois</string>
@@ -153,4 +153,130 @@
     <string name="event_attendee_needs_action">Aucune réponse</string>
     <string name="event_attendee_unknown">—</string>
     <string name="event_detail_reminders">Rappels</string>
+    <string name="permission_benefit_sync_body">Google, CalDAV, local - Tout ce qui est synchronisé sur l\'appareil s\'affiche tout simplement.</string>
+    <string name="event_status_cancelled">Annulé</string>
+    <plurals name="duration_minutes">
+        <item quantity="one">%d minute</item>
+        <item quantity="many">%d minutes</item>
+        <item quantity="other">%d minutes</item>
+    </plurals>
+    <string name="widget_new_event">Nouvel évènement</string>
+    <string name="widget_next_month">Mois suivant</string>
+    <string name="filter_title">Calendriers</string>
+    <string name="agenda_range_custom">Personnaliser…</string>
+    <string name="settings_section_calendars">Calendriers</string>
+    <string name="calendars_title">Calendriers</string>
+    <string name="calendars_backup_header">Sauvegarde</string>
+    <string name="calendars_auto_backup_every">Chaque %1$s</string>
+    <string name="backup_channel_name">Sauvegarde</string>
+    <string name="shortcut_new_event_short">Nouvel évènement</string>
+    <string name="qs_tile_new_event_label">Nouvel évènement</string>
+    <string name="event_detail_duplicate">Dupliquer</string>
+    <string name="event_detail_timezone">Fuseau horaire</string>
+    <string name="event_availability_free">Disponible</string>
+    <string name="event_access_private">Privé</string>
+    <string name="event_access_confidential">Confidentiel</string>
+    <string name="event_attendee_organizer">Organisateur</string>
+    <string name="event_attendee_resource">Ressource</string>
+    <string name="event_detail_self_response">Votre réponse : %1$s</string>
+    <string name="reminder_default">Rappel par défaut</string>
+    <plurals name="reminder_minutes">
+        <item quantity="one">%d minute avant</item>
+        <item quantity="many">%d minutes avant</item>
+        <item quantity="other">%d minutes avant</item>
+    </plurals>
+    <plurals name="reminder_hours">
+        <item quantity="one">%d heure avant</item>
+        <item quantity="many">%d heures avant</item>
+        <item quantity="other">%d heures avant</item>
+    </plurals>
+    <plurals name="reminder_days">
+        <item quantity="one">%d jour avant</item>
+        <item quantity="many">%d jours avant</item>
+        <item quantity="other">%d jours avant</item>
+    </plurals>
+    <plurals name="reminder_weeks">
+        <item quantity="one">%d semaine avant</item>
+        <item quantity="many">%d semaines avant</item>
+        <item quantity="other">%d semaines avant</item>
+    </plurals>
+    <plurals name="duration_hours">
+        <item quantity="one">%d heure</item>
+        <item quantity="many">%d heures</item>
+        <item quantity="other">%d heures</item>
+    </plurals>
+    <plurals name="duration_days">
+        <item quantity="one">%d jour</item>
+        <item quantity="many">%d jours</item>
+        <item quantity="other">%d jours</item>
+    </plurals>
+    <plurals name="duration_weeks">
+        <item quantity="one">%d semaine</item>
+        <item quantity="many">%d semaines</item>
+        <item quantity="other">%d semaines</item>
+    </plurals>
+    <string name="event_untitled">(Pas de titre)</string>
+    <string name="reminder_channel_name">Rappels d\'évènement</string>
+    <string name="reminder_channel_description">Notifications au moment des rappels de vos évènements</string>
+    <string name="reminder_onboarding_title">Ne manquez jamais un évènement</string>
+    <string name="reminder_benefit_delivery_title">Vos rappels, libérés</string>
+    <string name="reminder_benefit_delivery_body">Chaque rappel à vos évènements vous délivre une notification, ponctuelle.</string>
+    <string name="reminder_onboarding_enable_button">Activer les rappels</string>
+    <string name="reminder_onboarding_skip_button">Plus tard</string>
+    <string name="reminder_day_tomorrow">Demain</string>
+    <string name="reminder_day_yesterday">Hier</string>
+    <string name="view_month">Mois</string>
+    <string name="view_week">Semaine</string>
+    <string name="view_day">Jour</string>
+    <string name="view_agenda">Agenda</string>
+    <string name="view_section">Vue</string>
+    <string name="drawer_jump_to_date">Aller à...</string>
+    <string name="agenda_header_tomorrow">Demain</string>
+    <string name="agenda_empty_title">Vous êtes à jour</string>
+    <string name="agenda_no_more_today">Plus d\'évènements aujourd\'hui</string>
+    <string name="search_action">Rechercher</string>
+    <string name="search_hint">Rechercher des évènements</string>
+    <string name="search_idle_hint">Rechercher parmi vos évènements par titre, lieu, ou notes.</string>
+    <string name="search_empty">Pas d\'évènements correspondant à “%1$s”.</string>
+    <string name="widget_agenda_title">À venir</string>
+    <string name="widget_agenda_label">Agenda Calendula</string>
+    <string name="widget_month_label">Calendula Mois</string>
+    <string name="widget_refresh">Actualiser</string>
+    <string name="settings_section_appearance">Apparence</string>
+    <string name="settings_theme">Thème</string>
+    <string name="settings_theme_system">Système</string>
+    <string name="settings_theme_light">Clair</string>
+    <string name="settings_theme_dark">Sombre</string>
+    <string name="settings_default_view">Vue par défaut</string>
+    <string name="settings_dynamic_color">Couleurs dynamiques</string>
+    <string name="settings_dynamic_color_unavailable">Nécessite Android 12 ou plus récent</string>
+    <string name="settings_soften_colors">Adoucir les couleurs du calendrier</string>
+    <string name="settings_soften_colors_summary">Ajuster les couleurs du calendrier et des évènements au thème. Désactiver pour voir les couleurs brutes issues du calendrier.</string>
+    <string name="settings_font_headings">Police des titres</string>
+    <string name="settings_font_body">Police du corps</string>
+    <string name="settings_font_system">Valeur par défaut du système</string>
+    <string name="font_atkinson_hyperlegible">Atkinson Hyperlegible</string>
+    <string name="font_lora">Lora</string>
+    <string name="settings_font_choose_file">Sélectionner un fichier…</string>
+    <string name="settings_font_custom_selected">Police personnalisée</string>
+    <string name="settings_font_import_failed">Impossible d\'interpréter ce fichier comme police</string>
+    <string name="settings_week_start_auto">Automatique</string>
+    <string name="settings_week_numbers">Numéros de semaine</string>
+    <string name="settings_week_numbers_summary">Afficher les numéros de semaine dans la vue par mois</string>
+    <string name="event_attendee_optional">Optionnel</string>
+    <string name="agenda_today_action">Aujourd\'hui</string>
+    <string name="agenda_header_today">Aujourd\'hui</string>
+    <string name="search_back">Retour</string>
+    <string name="widget_prev_month">Mois précédent</string>
+    <string name="widget_today">Aujourd\'hui</string>
+    <string name="settings_title">Paramètres</string>
+    <string name="settings_back">Retour</string>
+    <string name="agenda_range_day">Aujourd\'hui</string>
+    <string name="agenda_range_this_week">Cette semaine</string>
+    <string name="back">Retour</string>
+    <string name="settings_special_dates_reminders">Rappels</string>
+    <string name="settings_special_dates_grant">Autoriser l\'accès</string>
+    <string name="dialog_save">Sauvegarder</string>
+    <string name="calendars_color_label">Couleur</string>
+    <string name="import_close">Fermer</string>
 </resources>

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

@@ -47,11 +47,11 @@
     <string name="event_share_failed">Nie udało się udostępnić tego wydarzenia.</string>
     <string name="event_delete_title">Usunąć wydarzenie?</string>
     <string name="event_delete_body">Usunięto wydarzenie z Twojego kalendarza i wszystkich zsynchronizowanych urządzeń.</string>
-    <string name="event_delete_recurring_title">Usuń powtarzające się wydarzenie</string>
+    <string name="event_delete_recurring_title">Usuń wydarzenie cykliczne</string>
     <string name="event_delete_option_occurrence">Tylko to wystąpienie</string>
     <string name="event_delete_option_following">To i wszystkie następne wystąpienia</string>
     <string name="event_delete_option_series">Wszystkie wystąpienia w serii</string>
-    <string name="event_edit_recurring_title">Edytuj powtarzające się wydarzenie</string>
+    <string name="event_edit_recurring_title">Edytuj wydarzenie cykliczne</string>
     <string name="event_delete_failed">Nie udało się usunąć tego wydarzenia</string>
     <string name="event_delete_write_denied">Calendula wymaga uprawnień do zapisu, aby móc usuwać wydarzenia</string>
     <string name="dialog_cancel">Anuluj</string>
@@ -136,7 +136,7 @@
     <string name="event_detail_description">Opis</string>
     <string name="event_detail_attendees">Uczestnicy</string>
     <string name="event_detail_recurrence">Powtarzanie</string>
-    <string name="event_detail_recurring">Powtarzające się wydarzenie</string>
+    <string name="event_detail_recurring">Wydarzenie cykliczne</string>
     <string name="recurrence_daily">Codziennie</string>
     <string name="recurrence_weekly">Co tydzień</string>
     <string name="recurrence_monthly">Co miesiąc</string>
@@ -297,4 +297,224 @@
     <string name="settings_agenda_range">Zakres agendy</string>
     <string name="settings_agenda_range_hint">Jak daleko w przód wyświetlane są wydarzenia na ekranie Agendy.</string>
     <string name="settings_agenda_widget_range">Zakres widżetu agendy</string>
+    <string name="settings_agenda_widget_range_hint">Jak daleko w przód wyświetlane są wydarzenia w widżecie agendy na ekranie domowym.</string>
+    <string name="settings_agenda_range_bar">Pasek zakresu</string>
+    <string name="settings_agenda_range_bar_hint">Wyświetl u góry agendy pasek z zakresem widocznych dat oraz przyciskiem umożliwiającym zmianę zakresu na czas trwania sesji</string>
+    <string name="agenda_range_day">Dzisiaj</string>
+    <string name="agenda_range_this_week">Bieżący tydzień</string>
+    <string name="agenda_range_this_month">Bieżący miesiąc</string>
+    <string name="agenda_range_week">Następne 7 dni</string>
+    <string name="agenda_range_month">Następne 30 dni</string>
+    <string name="agenda_range_custom">Niestandardowy…</string>
+    <string name="agenda_range_custom_hint">Dni</string>
+    <string name="agenda_range_override_hint">Ustawienie tymczasowe — po ponownym otwarciu aplikacji Calendula przywrócony zostanie zapisany zakres.</string>
+    <string name="agenda_range_showing_label">Wyświetlanie wszystkich nadchodzących wydarzeń dla</string>
+    <plurals name="agenda_range_days">
+        <item quantity="one">%d dzień</item>
+        <item quantity="few">%d dni</item>
+        <item quantity="many">%d dni</item>
+        <item quantity="other">%d dni</item>
+    </plurals>
+    <string name="settings_section_views">Widoki</string>
+    <string name="settings_quick_switch_header">Przycisk szybkiego przełączania</string>
+    <string name="settings_quick_switch_hint">Wybierz widoki, między którymi można przełączać się przyciskiem w prawym górnym rogu, i przeciągnij je, aby zmienić ich kolejność. Wyłączone widoki pozostaną dostępne w menu nawigacyjnym.</string>
+    <string name="settings_drawer_order_header">Menu nawigacyjne</string>
+    <string name="settings_drawer_order_hint">Przeciągnij aby zmienić kolejność widoków w menu nawigacyjnym.</string>
+    <string name="reorder_drag_handle">Przeciągnij by zmienić kolejność</string>
+    <string name="settings_section_event_form">Formularz nowego wydarzenia</string>
+    <string name="settings_form_fields_hint">Pola wyświetlane domyślnie — cała reszta znajduje się pod przyciskiem „Więcej pól”</string>
+    <string name="settings_autofocus_title">Ustaw kursor na tytule nowego wydarzenia</string>
+    <string name="settings_autofocus_title_hint">Kiedy tworzysz nowe wydarzenie, umieść kursor w polu tytułu i od razu otwórz klawiaturę.</string>
+    <string name="settings_color_unsupported">Zezwalaj na kolory w nieobsługiwanych kalendarzach</string>
+    <string name="settings_color_unsupported_hint">Niektóre kalendarze (np. niektóre CalDAV) nie udostępniają zestawu kolorów; niestandardowy kolor wydarzenia może zostać utracony lub nadpisany przy następnej synchronizacji. Jest to ograniczenie tych kalendarzy, a nie coś, co Calendula może naprawić.</string>
+    <string name="settings_section_notifications">Powiadomienia</string>
+    <string name="settings_reminders">Przypomnienia o wydarzeniach</string>
+    <string name="settings_reminders_hint">Widzisz podwójne przypomnienia? Inna aplikacja kalendarza również je wyświetla — wyłącz je w jednej z nich.</string>
+    <string name="settings_default_reminder">Domyślne przypomnienie</string>
+    <string name="settings_default_reminder_allday">Wydarzenia całodniowe</string>
+    <string name="settings_allday_reminder_time">Godzina przypomnienia o wydarzeniach całodniowych</string>
+    <string name="settings_allday_reminder_time_hint">Przypomnienia o wydarzeniach całodniowych zostaną pojawiają się o %1$s</string>
+    <string name="reminder_none">Brak</string>
+    <string name="reminder_use_default">Użyj domyślnego przypomnienia</string>
+    <string name="reminder_custom_amount">jednostek</string>
+    <string name="reminder_custom_set">Ustaw</string>
+    <string name="settings_calendar_reminders_title">Przypomnienia dla poszczególnych kalendarzy</string>
+    <string name="settings_calendar_reminders_hint">Zastąp ustawienia domyślne dla wybranych kalendarzy — oddzielnie dla wydarzeń terminowych i całodniowych. Kalendarz może zachować ustawienie domyślne, odrzucić je lub ustawić własne.</string>
+    <string name="settings_calendar_reminder_inherits">Domyślne (%1$s)</string>
+    <string name="settings_reliable_delivery">Niezawodne dostarczanie</string>
+    <string name="settings_reliable_delivery_hint">Android może opóźniać przypomnienia, aby oszczędzać baterię. Dodaj Calendula do wyjątków, żeby przychodziły na czas.</string>
+    <string name="settings_reliable_delivery_exempt">Wyłączono optymalizację baterii — przypomnienia przychodzą na czas.</string>
+    <string name="settings_snooze_duration">Długość drzemki</string>
+    <string name="settings_section_calendars">Kalendarze</string>
+    <string name="settings_manage_calendars">Zarządzaj kalendarzami</string>
+    <string name="settings_manage_calendars_hint">Twórz lokalne kalendarze; zarządzaj synchronizowanymi</string>
+    <string name="settings_section_language">Język</string>
+    <string name="settings_language">Język aplikacji</string>
+    <string name="settings_language_auto">Domyślny systemu</string>
+    <string name="settings_translate">Pomóż w tłumaczeniu</string>
+    <string name="settings_translate_hint">Dodaj lub ulepsz tłumaczenie w Weblate</string>
+    <string name="settings_appearance_subtitle">Motyw, domyślny widok, pierwszy dzień tygodnia</string>
+    <string name="settings_views_subtitle">Kolejność przycisku szybkiego przełączania oraz menu</string>
+    <string name="settings_event_form_subtitle">Domyślne pola dla nowych wydarzeń</string>
+    <string name="settings_notifications_subtitle">Przypomnienia o wydarzeniach</string>
+    <string name="settings_special_dates_subtitle">Urodziny i rocznice kontaktów</string>
+    <string name="settings_section_special_dates">Szczególne daty kontaktów</string>
+    <string name="settings_special_dates_enable">Pokaż daty kontaktów</string>
+    <string name="settings_special_dates_enable_hint">Zsynchronizuj urodziny i inne daty z kontaktów z lokalnymi kalendarzami. Odczytuje kontakty wyłącznie z tego urządzenia — nic nie jest przesyłane, a Twoje kontakty nigdy nie ulegają zmianie.</string>
+    <string name="settings_special_dates_type_birthday">Urodziny</string>
+    <string name="settings_special_dates_type_anniversary">Rocznice</string>
+    <string name="settings_special_dates_type_custom">Inne daty</string>
+    <string name="settings_special_dates_template">Format tytułu</string>
+    <string name="settings_special_dates_template_hint">Użyj {name} dla nazwy kontaktu i {year} dla roku (rok urodzenia lub rok rozpoczęcia rocznicy; ukryty, gdy jest nieznany).</string>
+    <string name="settings_special_dates_reminders">Przypomnienia</string>
+    <string name="settings_special_dates_show_year">Pokaż rok</string>
+    <string name="settings_special_dates_show_year_hint">Uwzględniaj {year} w tytułach, jeśli jest znany</string>
+    <string name="settings_special_dates_sync_now">Synchronizuj teraz</string>
+    <string name="settings_special_dates_never_synced">Jeszcze nie zsynchronizowano</string>
+    <string name="settings_special_dates_last_synced">Ostatnio zsynchronizowano %1$s</string>
+    <string name="settings_special_dates_calendar_hint">Ustaw kolor i widoczność każdego kalendarza w sekcji Kalendarze.</string>
+    <string name="settings_calendar_reminders_managed_hint">Ustaw w sekcji Szczególne daty kontaktów</string>
+    <string name="settings_special_dates_paused_title">Wstrzymano</string>
+    <string name="settings_special_dates_paused_hint">Aplikacja Calendula nie ma już dostępu do Twoich kontaktów, więc te kalendarze nie są aktualizowane.</string>
+    <string name="settings_special_dates_grant">Przyznaj dostęp</string>
+    <string name="settings_special_dates_disable_title">Wyłączyć daty kontaktów?</string>
+    <string name="settings_special_dates_disable_all_message">To spowoduje usunięcie kalendarzy ze szczególnymi datami kontaktów oraz ich wydarzeń. Wszelkie dodane do nich przypomnienia lub notatki zostaną utracone.</string>
+    <string name="settings_special_dates_disable_type_message">To spowoduje usunięcie kalendarza „%1$s” wraz z jego wydarzeniami. Wszelkie dodane do nich przypomnienia lub notatki zostaną utracone.</string>
+    <string name="settings_special_dates_disable_confirm">Wyłącz</string>
+    <string name="dialog_save">Zapisz</string>
+    <string name="settings_section_about">O aplikacji</string>
+    <string name="settings_license">Licencja</string>
+    <string name="settings_license_value">MIT</string>
+    <string name="settings_about_author">autorstwa Jean-Luc Makiola</string>
+    <string name="settings_about_source">Kod źródłowy</string>
+    <string name="settings_about_support">Wesprzyj rozwój</string>
+    <string name="settings_about_version">Wersja %1$s</string>
+    <string name="settings_about_logo_desc">Ikona aplikacji Calendula</string>
+    <string name="settings_report_problem">Zgłoś problem</string>
+    <string name="settings_report_problem_hint">Wyślij raport o awarii lub otwórz system zgłoszeń</string>
+    <string name="calendars_title">Kalendarze</string>
+    <string name="calendars_local_header">Twoje kalendarze</string>
+    <string name="calendars_local_empty">Brak lokalnych kalendarzy. Utwórz kalendarz, aby zapisywać wydarzenia tylko na tym urządzeniu.</string>
+    <string name="calendars_add">Dodaj kalendarz</string>
+    <string name="calendars_disable_hint">Wyłącz kalendarz, aby ukryć go w aplikacji — wraz z jego wydarzeniami, filtrami i selektorami. Nic nie zostanie usunięte, a w każdej chwili możesz go tutaj ponownie włączyć.</string>
+    <string name="calendars_show_in_app_a11y">Pokaż „%1$s” w aplikacji</string>
+    <string name="calendars_synced_header">Synchronizowane kalendarze</string>
+    <string name="calendars_synced_hint">Pochodzą z kont na Twoim urządzeniu. Możesz je tworzyć i edytować w powiązanych z nimi aplikacjach.</string>
+    <string name="calendars_manage_in_app">Zarządzaj w aplikacji</string>
+    <string name="calendars_account_menu_a11y">Więcej opcji dla %1$s</string>
+    <string name="calendars_enable_all">Włącz wszystkie</string>
+    <string name="calendars_disable_all">Wyłącz wszystkie</string>
+    <string name="calendars_add_account">Dodaj konto</string>
+    <string name="calendars_new_title">Nowy kalendarz</string>
+    <string name="calendars_edit_title">Edytuj kalendarz</string>
+    <string name="calendars_name_label">Nazwa</string>
+    <string name="calendars_color_label">Kolor</string>
+    <string name="calendars_description_hint">Dodaj opis</string>
+    <string name="calendars_delete_confirm_title">Usunąć kalendarz?</string>
+    <string name="calendars_delete_confirm_message">„%1$s” oraz wszystkie powiązane z nim wydarzenia zostaną trwale usunięte z tego urządzenia.</string>
+    <string name="calendars_write_error">Nie udało się zapisać zmiany.</string>
+    <string name="calendars_backup_header">Kopia zapasowa</string>
+    <string name="calendars_backup_hint">Kalendarze lokalne nie są nigdzie synchronizowane, więc wyeksportuj je do pliku .ics, aby zachować kopię.</string>
+    <string name="calendars_backup_action">Eksportuj jako plik .ics</string>
+    <string name="calendars_export_title">Eksportuj kalendarze</string>
+    <string name="calendars_export_hint">Wybierz kalendarze, które mają zostać uwzględnione w pliku .ics.</string>
+    <string name="calendars_export_action">Eksportuj</string>
+    <string name="calendars_restore_header">Przywróć</string>
+    <string name="calendars_restore_action">Przywróć z pliku .ics</string>
+    <string name="calendars_restore_hint">Importuj wydarzenia z kopii zapasowej lub innej aplikacji kalendarza.</string>
+    <string name="calendars_auto_backup">Automatyczna kopia zapasowa</string>
+    <string name="calendars_auto_backup_hint">Okresowo eksportuj swoje lokalne kalendarze do folderu jako plik .ics.</string>
+    <string name="calendars_auto_backup_folder">Folder kopii zapasowej</string>
+    <string name="calendars_auto_backup_folder_unset">Dotknij by wybrać folder</string>
+    <string name="calendars_auto_backup_interval">Okres</string>
+    <string name="calendars_auto_backup_every">Co %1$s</string>
+    <string name="calendars_auto_backup_interval_min">Minimum 30 minut.</string>
+    <string name="calendars_auto_backup_status_never">Nie ma jeszcze automatycznych kopii zapasowych</string>
+    <string name="calendars_auto_backup_status_ok">Ostatnia kopia zapasowa: %1$s</string>
+    <string name="calendars_auto_backup_status_failed">Ostatnia nieudana kopia zapasowa: %1$s</string>
+    <string name="backup_channel_name">Kopia zapasowa</string>
+    <string name="backup_channel_description">Ostrzega, jeśli automatyczne kopie zapasowe wielokrotnie się nie powiodą.</string>
+    <string name="backup_failed_title">Automatyczna kopia zapasowa nie powiodła się</string>
+    <string name="backup_failed_text">Calendula nie mogła zapisać pliku kopii zapasowej. Sprawdź folder kopii zapasowej w Ustawieniach.</string>
+    <string name="calendars_backup_failed">Nie udało się wyeksportować kopii zapasowej.</string>
+    <plurals name="calendars_backup_done">
+        <item quantity="one">Wyeksportowano %d wydarzenie.</item>
+        <item quantity="few">Wyeksportowano %d wydarzenia.</item>
+        <item quantity="many">Wyeksportowano %d wydarzeń.</item>
+        <item quantity="other">Wyeksportowano %d wydarzeń.</item>
+    </plurals>
+    <string name="import_title">Importuj wydarzenia</string>
+    <string name="import_target_header">Dodaj do kalendarza</string>
+    <string name="import_empty">Nie znaleziono wydarzeń w tym w pliku.</string>
+    <string name="import_failed">Nie udało się odczytać tego pliku.</string>
+    <string name="import_no_calendar">Brak kalendarza z możliwością zapisu, do którego można zaimportować dane. Najpierw utwórz kalendarz lokalny.</string>
+    <string name="import_done_title">Import zakończony</string>
+    <string name="import_done_dedup_note">Wydarzenia znajdujące się już w kalendarzu zostały pominięte.</string>
+    <string name="import_done_added_label">Dodano</string>
+    <string name="import_done_skipped_label">Duplikaty</string>
+    <string name="import_close">Zamknij</string>
+    <string name="import_warning_recurrence">Niektóre zmienione wystąpienia zdarzeń cyklicznych zostały pominięte.</string>
+    <string name="import_warning_no_start">Wydarzenie bez określonej godziny rozpoczęcia zostało pominięte.</string>
+    <string name="import_warning_attendees">Listy gości nie zostały zaimportowane.</string>
+    <string name="import_warning_timezone">Nieznana strefa czasowa została zastąpiona strefą ustawioną na Twoim urządzeniu.</string>
+    <string name="import_button">Importuj</string>
+    <plurals name="import_title_count">
+        <item quantity="one">Importowanie %d wydarzenia</item>
+        <item quantity="few">Importowanie %d wydarzeń</item>
+        <item quantity="many">Importowanie %d wydarzeń</item>
+        <item quantity="other">Importowanie %d wydarzeń</item>
+    </plurals>
+    <plurals name="import_event_count">
+        <item quantity="one">%d wydarzenie w tym pliku.</item>
+        <item quantity="few">%d wydarzenia w tym pliku.</item>
+        <item quantity="many">%d wydarzeń w tym pliku.</item>
+        <item quantity="other">%d wydarzeń w tym pliku.</item>
+    </plurals>
+    <plurals name="import_action">
+        <item quantity="one">Importuj %d wydarzenie</item>
+        <item quantity="few">Importuj %d wydarzenia</item>
+        <item quantity="many">Importuj %d wydarzeń</item>
+        <item quantity="other">Importuj %d wydarzeń</item>
+    </plurals>
+    <plurals name="import_done_imported">
+        <item quantity="one">Zaimportowano %d wydarzenie.</item>
+        <item quantity="few">Zaimportowano %d wydarzenia.</item>
+        <item quantity="many">Zaimportowano %d wydarzeń.</item>
+        <item quantity="other">Zaimportowano %d wydarzeń.</item>
+    </plurals>
+    <plurals name="import_done_skipped">
+        <item quantity="one">Pominięto %d wydarzenie znajdujące się już w tym kalendarzu.</item>
+        <item quantity="few">Pominięto %d wydarzenia znajdujące się już w tym kalendarzu.</item>
+        <item quantity="many">Pominięto %d wydarzeń znajdujących się już w tym kalendarzu.</item>
+        <item quantity="other">Pominięto %d wydarzeń znajdujących się już w tym kalendarzu.</item>
+    </plurals>
+    <string name="shortcut_new_event_short">Nowe wydarzenie</string>
+    <string name="shortcut_new_event_long">Utwórz nowe wydarzenie</string>
+    <string name="qs_tile_new_event_label">Nowe wydarzenie</string>
+    <string name="settings_qs_tile">Dodaj kafelek Szybkich ustawień</string>
+    <string name="settings_qs_tile_hint">Dodaj kafelek „Nowe wydarzenie” do panelu Szybkich ustawień.</string>
+    <string name="crash_dialog_title">Aplikacja %1$s uległa awarii</string>
+    <string name="crash_dialog_message">Aplikacja %1$s została nieoczekiwanie zamknięta przy ostatnim uruchomieniu. Możesz pomóc nam to naprawić, wysyłając zgłoszenie o błędzie. Pozostanie ono na Twoim urządzeniu, dopóki nie zdecydujesz się go udostępnić, i nie zawiera żadnych danych osobowych ani treści z kalendarza — jedynie poniższe szczegóły techniczne.</string>
+    <string name="crash_dialog_report">Zgłoś</string>
+    <string name="crash_dialog_dismiss">Nie teraz</string>
+    <string name="crash_report_issue_title">Raport o awarii</string>
+    <string name="crash_report_clip_label">Raport o awarii %1$s</string>
+    <string name="crash_report_copied">Raport skopiowany do schowka</string>
+    <string name="crash_report_open_failed">Nie udało się otworzyć systemu zgłoszeń. Raport znajduje się w Twoim schowku.</string>
+    <string name="crash_report_body_template">Dziękujemy za zgłoszenie awarii w aplikacji %1$s. Prosimy o dodanie wszelkich zapamiętanych szczegółów na temat wykonywanych czynności, a następnie przesłanie zgłoszenia.\n\n### Co się wydarzyło\n\n\n### Raport o awarii\n%2$s\n</string>
+    <string name="crash_report_body_paste">_(Raport był zbyt długi dla tego linku — wklej go tutaj ze schowka)._</string>
+    <string name="special_dates_calendar_custom">Szczególne daty</string>
+    <string name="special_dates_default_title_birthday">Urodziny {name} ({year})</string>
+    <string name="special_dates_default_title_anniversary">Rocznica {name} ({year})</string>
+    <string name="special_dates_default_title_custom">{name}</string>
+    <string name="event_detail_duplicate">Duplikuj</string>
+    <string name="reminder_day_tomorrow">Jutro</string>
+    <string name="reminder_day_yesterday">Wczoraj</string>
+    <string name="agenda_no_more_today">Brak zaplanowanych wydarzeń</string>
+    <string name="settings_soften_colors">Zredukuj intensywność kolorów kalendarza</string>
+    <string name="settings_soften_colors_summary">Dopasuj intensywność kolorów kalendarza i wydarzeń do motywu. Wyłącz tę opcję, aby wyświetlać oryginalne kolory ze źródła kalendarza.</string>
+    <string name="settings_agenda_show_today">Zawsze pokazuj dzisiejszy dzień</string>
+    <string name="settings_agenda_show_today_hint">Zachowaj dzisiejszy dzień na górze agendy i widżetu, nawet gdy nie ma już na dziś żadnych zadań.</string>
+    <string name="special_dates_calendar_birthday">Urodziny</string>
+    <string name="special_dates_calendar_anniversary">Rocznice</string>
 </resources>

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

@@ -6,4 +6,60 @@
         <item>Days</item>
         <item>Weeks</item>
     </string-array>
+    <string name="app_name">Calendula</string>
+    <string name="app_tagline">Современный календарь.</string>
+    <string name="state_loading">Загрузка…</string>
+    <string name="state_retry">Попробовать ещё раз</string>
+    <string name="state_failure_unknown">Что-то пошло не так.</string>
+    <string name="state_failure_permission">Требуется доступ к календарю.</string>
+    <string name="state_failure_permission_action">Предоставить доступ</string>
+    <string name="state_failure_no_calendars">Нет настроенных календарей.</string>
+    <string name="state_failure_no_calendars_action">Перейти в системные настройки календаря</string>
+    <string name="state_failure_provider">Не удалось просмотреть календарь.</string>
+    <string name="permission_rationale_title">Следите за всеми своими событиями. С красотой</string>
+    <string name="permission_rationale_body">Calendula требуется доступ к вашему календарю, чтобы показывать и управлять вашими событиями. Это всё, что приложение требует с самого начала – и никакая информация не покидает ваш девайс.</string>
+    <string name="permission_request_button">Дать доступ к календарю</string>
+    <string name="permission_denied_title">В доступе к календарю отказано</string>
+    <string name="permission_denied_body">Calendula не может показать события без доступа к календарю. Предоставьте его снова в настройках телефона.</string>
+    <string name="permission_open_settings_button">Открыть настройки телефона</string>
+    <string name="permission_retry_button">Попытайтесь снова</string>
+    <string name="permission_benefit_private_title">Остаётся на вашем устройстве</string>
+    <string name="permission_benefit_private_body">Ваши календари просматриваются локально и информация никогда не покидает устройство.</string>
+    <string name="permission_benefit_sync_title">Все ваши календари. Вместе</string>
+    <string name="permission_benefit_sync_body">Google, CalDAV, локальный календарь – всё синхронизированное с устройством просто подключается.</string>
+    <string name="permission_benefit_privacy_title">Никакого отслеживания. Никогда</string>
+    <string name="permission_benefit_privacy_body">Ноль телеметрии. ноль аналитики, без рекламы.</string>
+    <string name="permission_privacy_footnote">Остаётся на устройстве · не требует доступа к интернету</string>
+    <string name="month_prev">Предыдущий месяц</string>
+    <string name="month_next">Следующий месяц</string>
+    <string name="month_today_action">Сегодня</string>
+    <string name="month_more_actions">Больше действий</string>
+    <string name="month_open_menu">Открыть меню</string>
+    <string name="month_action_settings">Настройки</string>
+    <string name="month_a11y_today_prefix">Сегодня</string>
+    <string name="week_today_action">Эта неделя</string>
+    <string name="week_number_label">Нед</string>
+    <string name="day_today_action">Сегодня</string>
+    <string name="event_detail_back">Назад</string>
+    <string name="event_detail_edit">Редактировать</string>
+    <string name="event_detail_delete">Удалить</string>
+    <string name="event_detail_share">Поделиться</string>
+    <string name="event_detail_duplicate">Дублировать</string>
+    <string name="event_share_chooser_title">Поделиться событием</string>
+    <string name="event_share_failed">Не удалось поделиться этим событием.</string>
+    <string name="event_delete_title">Удалить событие?</string>
+    <string name="event_delete_body">Это событие удалено из вашего календаря и всех устройств с которыми он синхронизирован.</string>
+    <string name="event_delete_recurring_title">Удалить повторяющееся событие</string>
+    <string name="event_delete_option_occurrence">Только это событие</string>
+    <string name="event_delete_option_following">Это и все следующие события</string>
+    <string name="event_delete_option_series">Все события в последовательности</string>
+    <string name="event_edit_recurring_title">Редактировать повторяющееся событие</string>
+    <string name="event_delete_failed">Не удалось удалить событие</string>
+    <string name="event_delete_write_denied">Calendula требуется доступ для удаления событий</string>
+    <string name="dialog_cancel">Отмена</string>
+    <string name="dialog_ok">ОК</string>
+    <string name="event_edit_new_title">Новое событие</string>
+    <string name="event_edit_close">Закрыть</string>
+    <string name="event_edit_save">Сохранить</string>
+    <string name="event_edit_title_hint">Добавить имя</string>
 </resources>

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

@@ -1,10 +1,6 @@
 <resources>
     <string name="app_name">Calendula</string>
     <string name="app_tagline">A modern calendar.</string>
-    <!-- Alternative launcher label offered by the "App name" setting (issue #44).
-         translatable="false": this string becomes a launcher component's label, so
-         it must never be changed by an unreviewed community translation. -->
-    <string name="app_name_calendar_alias" translatable="false">Calendar</string>
 
     <!-- Loading / Failure / Success generic strings (used across screens) -->
     <string name="state_loading">Loading…</string>
@@ -103,18 +99,6 @@
     <string name="event_edit_availability">Availability</string>
     <string name="event_edit_visibility">Visibility</string>
 
-    <!-- Event form — time zone -->
-    <string name="event_edit_timezone_device">Device time zone</string>
-    <string name="event_edit_timezone_device_summary">Follows wherever you are</string>
-    <string name="event_edit_timezone_search">Search time zones</string>
-    <string name="event_edit_timezone_recent">Recent</string>
-    <string name="event_edit_timezone_all">All time zones</string>
-    <string name="event_edit_timezone_none">No time zone matches “%1$s”</string>
-    <!-- Shown under the time fields when the event is pinned to another zone:
-         the same event expressed where the user actually is. %1$s is a time
-         range, e.g. "2:00 PM – 3:00 PM". -->
-    <string name="event_edit_timezone_local_time">%1$s your time</string>
-
     <!-- Event form — per-event color -->
     <string name="event_edit_color">Color</string>
     <string name="event_edit_color_default">Calendar color</string>
@@ -152,9 +136,6 @@
     <string name="recurrence_unit_weeks">weeks</string>
     <string name="recurrence_unit_months">months</string>
     <string name="recurrence_unit_years">years</string>
-    <!-- Shown in place of the live rule read-out when an amount field holds a
-         value outside 1–999 (i.e. 0), so the greyed-out OK button has a reason. -->
-    <string name="event_edit_recurrence_incomplete">Enter a number from 1 to 999</string>
     <string name="event_edit_recurrence_ends">Ends</string>
     <string name="event_edit_recurrence_end_never">Never</string>
     <string name="event_edit_recurrence_end_until">On a date</string>
@@ -276,12 +257,6 @@
     <string name="agenda_header_tomorrow">Tomorrow</string>
     <string name="agenda_empty_title">You\'re all caught up</string>
     <string name="agenda_no_more_today">No more events today</string>
-    <!-- Time line for a multi-day event, on its first / last day (%1$s is a time, e.g. "14:00"). -->
-    <string name="agenda_span_starts">Starts %1$s</string>
-    <string name="agenda_span_ends">Ends %1$s</string>
-
-    <!-- Jump to today (toolbar icon button; see settings_today_toolbar) -->
-    <string name="today_jump_action">Go to today</string>
 
     <!-- Event search -->
     <string name="search_action">Search</string>
@@ -333,10 +308,6 @@
     <string name="settings_week_start_auto">Automatic</string>
     <string name="settings_week_numbers">Week numbers</string>
     <string name="settings_week_numbers_summary">Show calendar-week numbers in month view</string>
-    <string name="settings_today_toolbar">Today button in toolbar</string>
-    <string name="settings_today_toolbar_summary">Show a jump-to-today button in the toolbar instead of a floating button</string>
-    <string name="settings_app_name">App name</string>
-    <string name="settings_app_name_summary">Show Calendula as “Calendar” in your launcher. Only the launcher name changes; the icon may move to a new spot after switching.</string>
     <string name="settings_time_format">Time format</string>
     <string name="settings_time_format_auto">Automatic</string>
     <string name="settings_time_format_12h">12-hour (2:00 PM)</string>
@@ -372,20 +343,6 @@
         <item quantity="other">%d days</item>
     </plurals>
     <string name="settings_section_views">Views</string>
-    <!-- Month view style (#38, #53) -->
-    <string name="settings_month_header">Month view</string>
-    <string name="settings_month_view_style">Month view style</string>
-    <string name="month_style_paged">Pages</string>
-    <string name="month_style_paged_summary">One month fills the screen. Swipe left or right to change month.</string>
-    <string name="month_style_continuous">Scrolling months</string>
-    <string name="month_style_continuous_summary">Each month sits under its own heading, with a little space setting it apart from the next.</string>
-    <string name="month_style_dense">Seamless weeks</string>
-    <string name="month_style_dense_summary">The weeks run on without a break, each month flowing straight into the next with no gap between them.</string>
-    <string name="month_style_split">Split</string>
-    <string name="month_style_split_summary">A compact grid marks the days that have events, and the day you tap is listed underneath.</string>
-    <string name="month_split_no_events">Nothing scheduled</string>
-    <string name="month_split_expand">Show the whole month</string>
-    <string name="month_split_collapse">Show the day\'s events</string>
     <string name="settings_quick_switch_header">Quick-switch button</string>
     <string name="settings_quick_switch_hint">Choose which views the top-right button cycles through, and drag to reorder them. Turned-off views stay reachable from the navigation menu.</string>
     <string name="settings_drawer_order_header">Navigation menu</string>
@@ -425,7 +382,7 @@
     <string name="settings_translate_hint">Add or improve a language on Weblate</string>
     <!-- Hub category subtitles -->
     <string name="settings_appearance_subtitle">Theme, default view, week start</string>
-    <string name="settings_views_subtitle">Month layout, quick-switch button, menu order</string>
+    <string name="settings_views_subtitle">Quick-switch button and menu order</string>
     <string name="settings_event_form_subtitle">Default fields for new events</string>
     <string name="settings_notifications_subtitle">Event reminders</string>
     <string name="settings_special_dates_subtitle">Contact birthdays &amp; anniversaries</string>

app/src/test/java/de/jeanlucmakiola/calendula/data/appname/LauncherNameManagerTest.kt

@@ -1,51 +0,0 @@
-package de.jeanlucmakiola.calendula.data.appname
-
-import android.content.pm.PackageManager
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-
-/**
- * Pure decision logic behind the app-name toggle (issue #44). The framework seam
- * ([LauncherNameManager.set]/[current], which call `PackageManager`) is covered
- * on-device; these tests pin the read interpretation and the write ordering.
- */
-class LauncherNameManagerTest {
-
-    @Test
-    fun `enabled calendar alias reads as CALENDAR`() {
-        assertThat(launcherNameFor(PackageManager.COMPONENT_ENABLED_STATE_ENABLED))
-            .isEqualTo(LauncherName.CALENDAR)
-    }
-
-    @Test
-    fun `default and disabled calendar alias read as CALENDULA`() {
-        assertThat(launcherNameFor(PackageManager.COMPONENT_ENABLED_STATE_DEFAULT))
-            .isEqualTo(LauncherName.CALENDULA)
-        assertThat(launcherNameFor(PackageManager.COMPONENT_ENABLED_STATE_DISABLED))
-            .isEqualTo(LauncherName.CALENDULA)
-    }
-
-    @Test
-    fun `write plan enables the target alias before disabling the other`() {
-        val toCalendar = aliasWritePlan(LauncherName.CALENDAR)
-        assertThat(toCalendar).containsExactly(
-            AliasStateChange(LauncherAlias.CALENDAR, enabled = true),
-            AliasStateChange(LauncherAlias.DEFAULT, enabled = false),
-        ).inOrder()
-
-        val toCalendula = aliasWritePlan(LauncherName.CALENDULA)
-        assertThat(toCalendula).containsExactly(
-            AliasStateChange(LauncherAlias.DEFAULT, enabled = true),
-            AliasStateChange(LauncherAlias.CALENDAR, enabled = false),
-        ).inOrder()
-    }
-
-    @Test
-    fun `write plan never disables both aliases in the same step`() {
-        // The first step is always an enable, so the launcher can never observe a
-        // zero-entry transient regardless of switch direction.
-        for (target in LauncherName.entries) {
-            assertThat(aliasWritePlan(target).first().enabled).isTrue()
-        }
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapperTest.kt

@@ -19,14 +19,7 @@ class EventWriteMapperTest {
         isAllDay: Boolean = false,
         start: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)),
         end: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 30)),
-        timezone: String? = null,
-    ): EventForm = EventForm(
-        calendarId = 1L,
-        isAllDay = isAllDay,
-        start = start,
-        end = end,
-        timezone = timezone,
-    )
+    ): EventForm = EventForm(calendarId = 1L, isAllDay = isAllDay, start = start, end = end)
 
     @Test
     fun `timed event resolves wall clock in the given zone`() {
@@ -37,26 +30,6 @@ class EventWriteMapperTest {
         assertThat(times.timezone).isEqualTo("Europe/Berlin")
     }
 
-    @Test
-    fun `pinned zone wins over the device zone`() {
-        val times = form(timezone = "America/New_York").toWriteTimes(berlin)
-        // 10:00 in New York (EDT, UTC-4) == 14:00Z, not 08:00Z as Berlin would give.
-        assertThat(times.timezone).isEqualTo("America/New_York")
-        assertThat(times.dtStartMillis).isEqualTo(1_781_186_400_000L)
-    }
-
-    @Test
-    fun `an unparseable pinned zone falls back to the device zone`() {
-        val times = form(timezone = "Mars/Olympus_Mons").toWriteTimes(berlin)
-        assertThat(times.timezone).isEqualTo("Europe/Berlin")
-    }
-
-    @Test
-    fun `all-day ignores a pinned zone and stays UTC`() {
-        val times = form(isAllDay = true, timezone = "America/New_York").toWriteTimes(berlin)
-        assertThat(times.timezone).isEqualTo("UTC")
-    }
-
     @Test
     fun `all-day event lives at UTC midnights with exclusive end`() {
         val times = form(isAllDay = true).toWriteTimes(berlin)
@@ -123,18 +96,8 @@ class EventWriteMapperTest {
 
     private val seriesStart = 1_700_000_000_000L
 
-    private fun update(
-        original: EventForm,
-        updated: EventForm,
-        series: Long = seriesStart,
-    ): Map<String, Any?> = buildEventUpdateValues(original, updated, series, berlin)
-
-    /** The instant [local] names in [zoneId], as the provider would store it. */
-    private fun instantAt(local: String, zoneId: String): Long =
-        java.time.LocalDateTime.parse(local)
-            .atZone(java.time.ZoneId.of(zoneId))
-            .toInstant()
-            .toEpochMilli()
+    private fun update(original: EventForm, updated: EventForm): Map<String, Any?> =
+        buildEventUpdateValues(original, updated, seriesStart, berlin)
 
     @Test
     fun `pristine form produces no values`() {
@@ -142,42 +105,6 @@ class EventWriteMapperTest {
         assertThat(update(original, original.copy())).isEmpty()
     }
 
-    @Test
-    fun `editing the time of a pinned event keeps its zone`() {
-        // The regression this guards: the update used to stamp the device zone
-        // over the event's own, silently un-anchoring a foreign-zone event so it
-        // stopped tracking that zone across DST.
-        val original = form(timezone = "America/New_York")
-        val values = update(original, original.copy(title = "Standup", start = original.start))
-        assertThat(values).doesNotContainKey(CalendarContract.Events.EVENT_TIMEZONE)
-
-        val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30)),
-        )
-        assertThat(update(original, moved)[CalendarContract.Events.EVENT_TIMEZONE])
-            .isEqualTo("America/New_York")
-    }
-
-    @Test
-    fun `changing only the zone still moves the event`() {
-        // Same wall-clock, different zone: the instant moves, so DTSTART must be
-        // rewritten even though start/end compare equal.
-        val original = form()
-        val values = update(original, original.copy(timezone = "America/New_York"))
-        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("America/New_York")
-        // 10:00 Berlin (08:00Z) -> 10:00 New York (14:00Z): six hours later.
-        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_186_400_000L)
-    }
-
-    @Test
-    fun `unpinning back to the device zone rewrites the times`() {
-        val original = form(timezone = "America/New_York")
-        val values = update(original, original.copy(timezone = null))
-        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("Europe/Berlin")
-        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L)
-    }
-
     @Test
     fun `text-only edit writes just the changed columns`() {
         val original = form()
@@ -229,77 +156,6 @@ class EventWriteMapperTest {
         assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P5400S")
     }
 
-    @Test
-    fun `pinning a recurring event to another zone keeps the series wall clock`() {
-        // The regression this guards: the series DTSTART used to move by a
-        // millisecond delta measured at the *edited occurrence*. Here the series
-        // anchor sits in January (Berlin CET, +1) and the edited occurrence in
-        // July (Berlin CEST, +2), so the July delta is an hour off for January —
-        // the whole series would have drifted to 10:00 Tokyo.
-        val series = instantAt("2026-01-07T09:00", "Europe/Berlin")
-        val original = form(
-            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
-        ).copy(rrule = "FREQ=WEEKLY")
-
-        val values = update(original, original.copy(timezone = "Asia/Tokyo"), series)
-
-        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("Asia/Tokyo")
-        // The anchor still reads 09:00 — now 09:00 in Tokyo, not 10:00.
-        assertThat(values[CalendarContract.Events.DTSTART])
-            .isEqualTo(instantAt("2026-01-07T09:00", "Asia/Tokyo"))
-    }
-
-    @Test
-    fun `a time edit moves the series anchor in wall clock across a DST boundary`() {
-        // Anchor in winter, edited occurrence in summer: pushing the occurrence
-        // one hour later must leave the anchor at 10:00 winter time, not at an
-        // instant that re-reads as 11:00 once the offset differs.
-        val series = instantAt("2026-01-07T09:00", "Europe/Berlin")
-        val original = form(
-            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
-        ).copy(rrule = "FREQ=WEEKLY")
-        val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(11, 0)),
-        )
-
-        assertThat(update(original, moved, series)[CalendarContract.Events.DTSTART])
-            .isEqualTo(instantAt("2026-01-07T10:00", "Europe/Berlin"))
-    }
-
-    @Test
-    fun `moving a recurring occurrence to another day shifts the anchor by whole days`() {
-        val series = instantAt("2026-01-07T09:00", "Europe/Berlin")
-        val original = form(
-            start = LocalDateTime(LocalDate(2026, 1, 7), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 1, 7), LocalTime(10, 0)),
-        ).copy(rrule = "FREQ=WEEKLY")
-        val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 1, 9), LocalTime(14, 30)),
-            end = LocalDateTime(LocalDate(2026, 1, 9), LocalTime(15, 30)),
-        )
-
-        assertThat(update(original, moved, series)[CalendarContract.Events.DTSTART])
-            .isEqualTo(instantAt("2026-01-09T14:30", "Europe/Berlin"))
-    }
-
-    @Test
-    fun `switching a recurring event to all-day anchors the series on a UTC midnight`() {
-        val series = instantAt("2026-01-07T09:00", "Europe/Berlin")
-        val original = form(
-            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
-        ).copy(rrule = "FREQ=WEEKLY")
-
-        val values = update(original, original.copy(isAllDay = true), series)
-
-        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("UTC")
-        val dtStart = values[CalendarContract.Events.DTSTART] as Long
-        assertThat(dtStart % (24L * 60 * 60 * 1000)).isEqualTo(0L)
-    }
-
     @Test
     fun `adding a recurrence keeps the times and writes rule plus duration`() {
         val original = form()

app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt

@@ -13,7 +13,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
 import kotlinx.datetime.DayOfWeek
@@ -126,30 +125,6 @@ class SettingsPrefsTest {
         assertThat(prefs.agendaWidgetRange.first()).isEqualTo(AgendaRange.Week)
     }
 
-    @Test
-    fun `month view style defaults to paged and round-trips`(@TempDir tempDir: Path) = runTest {
-        val prefs = SettingsPrefs(newDataStore(tempDir))
-        assertThat(prefs.monthViewStyle.first()).isEqualTo(MonthViewStyle.Paged)
-
-        prefs.setMonthViewStyle(MonthViewStyle.Split)
-        assertThat(prefs.monthViewStyle.first()).isEqualTo(MonthViewStyle.Split)
-
-        prefs.setMonthViewStyle(MonthViewStyle.Continuous)
-        assertThat(prefs.monthViewStyle.first()).isEqualTo(MonthViewStyle.Continuous)
-    }
-
-    @Test
-    fun `garbage stored month view style falls back to paged`(@TempDir tempDir: Path) = runTest {
-        val store = newDataStore(tempDir)
-        val prefs = SettingsPrefs(store)
-        store.updateData { p ->
-            val m = p.toMutablePreferences()
-            m[SettingsPrefs.MONTH_VIEW_STYLE_KEY] = "Carousel"
-            m
-        }
-        assertThat(prefs.monthViewStyle.first()).isEqualTo(MonthViewStyle.Paged)
-    }
-
     @Test
     fun `garbage stored enum falls back to default`(@TempDir tempDir: Path) = runTest {
         val store = newDataStore(tempDir)

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

@@ -117,7 +117,6 @@ class EventFormTest {
         attendees: List<Attendee> = emptyList(),
         eventColor: Int? = null,
         eventColorKey: String? = null,
-        eventTimezone: String? = null,
     ): EventDetail = EventDetail(
         instance = EventInstance(
             instanceId = 1L,
@@ -139,7 +138,6 @@ class EventFormTest {
         accessLevel = accessLevel,
         eventColor = eventColor,
         eventColorKey = eventColorKey,
-        eventTimezone = eventTimezone,
     )
 
     @Test
@@ -159,117 +157,6 @@ class EventFormTest {
         assertThat(prefilled.description).isEqualTo("Body")
     }
 
-    @Test
-    fun `toEditForm leaves an event in the device zone unpinned`() {
-        val prefilled = detail(eventTimezone = "Europe/Berlin").toEditForm(
-            beginMillis = 1_781_164_800_000L,
-            endMillis = 1_781_164_800_000L + 3_600_000L,
-            zone = berlin,
-        )
-        // Same zone as the device: pinning it would only make the picker appear
-        // on every ordinary event.
-        assertThat(prefilled.timezone).isNull()
-        assertThat(prefilled.populatedFields()).doesNotContain(EventFormField.Timezone)
-    }
-
-    @Test
-    fun `toEditForm pins a foreign zone and shows the times in it`() {
-        val prefilled = detail(eventTimezone = "America/New_York").toEditForm(
-            beginMillis = 1_781_164_800_000L, // 08:00Z
-            endMillis = 1_781_164_800_000L + 3_600_000L,
-            zone = berlin,
-        )
-        assertThat(prefilled.timezone).isEqualTo("America/New_York")
-        // 08:00Z is 10:00 in Berlin but 04:00 in New York — the form shows the
-        // event's own wall-clock, which is what a later save re-anchors to.
-        assertThat(prefilled.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(4, 0)))
-        assertThat(prefilled.populatedFields()).contains(EventFormField.Timezone)
-    }
-
-    @Test
-    fun `toEditForm never pins a zone on an all-day event`() {
-        // All-day rows carry a nominal "UTC" that is an anchor, not a location.
-        val prefilled = detail(isAllDay = true, eventTimezone = "UTC").toEditForm(
-            beginMillis = LocalDate(2026, 6, 11).toEpochDays() * 86_400_000L,
-            endMillis = LocalDate(2026, 6, 12).toEpochDays() * 86_400_000L,
-            zone = berlin,
-        )
-        assertThat(prefilled.timezone).isNull()
-    }
-
-    @Test
-    fun `toEditForm ignores an unparseable stored zone`() {
-        val prefilled = detail(eventTimezone = "Mars/Olympus_Mons").toEditForm(
-            beginMillis = 1_781_164_800_000L,
-            endMillis = 1_781_164_800_000L + 3_600_000L,
-            zone = berlin,
-        )
-        // A malformed sync row must not be honoured, nor fail the open.
-        assertThat(prefilled.timezone).isNull()
-        assertThat(prefilled.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)))
-    }
-
-    @Test
-    fun `timesIn converts a pinned event into the target zone`() {
-        val form = EventForm(
-            calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(8, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(9, 0)),
-            timezone = "America/New_York",
-        )
-        val (start, end) = form.timesIn(berlin)!!
-        // 08:00 New York (EDT, UTC-4) is 14:00 Berlin (CEST, UTC+2).
-        assertThat(start).isEqualTo(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(14, 0)))
-        assertThat(end).isEqualTo(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(15, 0)))
-    }
-
-    @Test
-    fun `timesIn crosses the date line when the offset pushes past midnight`() {
-        val form = EventForm(
-            calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(20, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(21, 0)),
-            timezone = "America/New_York",
-        )
-        val (start, _) = form.timesIn(berlin)!!
-        // 20:00 New York is 02:00 the NEXT day in Berlin — the date has to move
-        // with it, not just the clock.
-        assertThat(start).isEqualTo(LocalDateTime(LocalDate(2026, 7, 18), LocalTime(2, 0)))
-    }
-
-    @Test
-    fun `timesIn tracks each zone's own DST rather than a fixed offset`() {
-        // In January both are on standard time: 08:00 EST is 14:00 CET — the
-        // same six hours as July, but only because both shifted. Late March,
-        // when the US has sprung forward and Europe hasn't, the gap is five.
-        val march = EventForm(
-            calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 3, 20), LocalTime(8, 0)),
-            end = LocalDateTime(LocalDate(2026, 3, 20), LocalTime(9, 0)),
-            timezone = "America/New_York",
-        )
-        assertThat(march.timesIn(berlin)!!.first)
-            .isEqualTo(LocalDateTime(LocalDate(2026, 3, 20), LocalTime(13, 0)))
-    }
-
-    @Test
-    fun `timesIn returns null when there is nothing to disambiguate`() {
-        val base = EventForm(
-            calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(8, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(9, 0)),
-        )
-        // Unpinned: the form's times already are the local times.
-        assertThat(base.timesIn(berlin)).isNull()
-        // Pinned to the target itself: same thing.
-        assertThat(base.copy(timezone = "Europe/Berlin").timesIn(berlin)).isNull()
-        // All-day: date-anchored, so there's no zone conversion to show.
-        assertThat(base.copy(isAllDay = true, timezone = "America/New_York").timesIn(berlin))
-            .isNull()
-        // Unparseable: can't convert, mustn't throw.
-        assertThat(base.copy(timezone = "Mars/Olympus_Mons").timesIn(berlin)).isNull()
-    }
-
     @Test
     fun `toEditForm turns the exclusive all-day end into the last covered day`() {
         // 11th..13th = UTC midnights of the 11th and the (exclusive) 14th.

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

@@ -1,159 +0,0 @@
-package de.jeanlucmakiola.calendula.domain
-
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-import java.time.Instant
-import java.util.Locale
-
-class TimeZoneCatalogTest {
-
-    // A fixed instant so DST-dependent offsets can't drift with the wall clock:
-    // 2026-06-11 is northern summer, i.e. Berlin on CEST and New York on EDT.
-    private val summer: Instant = Instant.parse("2026-06-11T12:00:00Z")
-    private val zones = timeZoneOptions(Locale.ENGLISH, summer)
-
-    private fun filter(query: String) = filterTimeZones(zones, query)
-
-    @Test
-    fun `catalogue holds the real zones and drops the legacy aliases`() {
-        assertThat(zones.map { it.id }).containsAtLeast("Europe/Berlin", "America/New_York")
-        // Bare aliases the tz database keeps for compatibility would double up
-        // the real zones in the picker.
-        assertThat(zones.map { it.id }).containsNoneOf("EST", "CST6CDT", "UTC")
-        assertThat(zones.none { it.id.startsWith("SystemV/") }).isTrue()
-    }
-
-    @Test
-    fun `option exposes city and region split from the id`() {
-        val ny = zones.first { it.id == "America/New_York" }
-        assertThat(ny.city).isEqualTo("New York")
-        assertThat(ny.region).isEqualTo("America")
-    }
-
-    @Test
-    fun `label is the id with underscores undone`() {
-        assertThat(zones.first { it.id == "America/New_York" }.label)
-            .isEqualTo("America/New York")
-        assertThat(zones.first { it.id == "Europe/Berlin" }.label).isEqualTo("Europe/Berlin")
-    }
-
-    @Test
-    fun `resolved abbreviation is compact, not the long name`() {
-        // Whatever CLDR gives ("CET"/"CEST" or a "GMT+.." fallback), it must be
-        // short and space-free — that's the whole point of showing it instead of
-        // "Central European Time".
-        val berlin = zones.first { it.id == "Europe/Berlin" }
-        assertThat(berlin.shortName).doesNotContain(" ")
-        assertThat(berlin.shortName.length).isLessThan(berlin.displayName.length)
-    }
-
-    @Test
-    fun `descriptor pairs a named abbreviation with the offset`() {
-        val option = TimeZoneOption(
-            id = "Europe/Berlin",
-            displayName = "Central European Time",
-            shortName = "CET",
-            offsetMinutes = 60,
-        )
-        assertThat(zoneDescriptor(option)).isEqualTo("CET · GMT+01:00")
-    }
-
-    @Test
-    fun `descriptor drops the offset when the abbreviation already is one`() {
-        // Repeating the offset after an offset-shaped abbreviation would just say
-        // the same thing twice.
-        fun descriptorFor(shortName: String, offset: Int) = zoneDescriptor(
-            TimeZoneOption(id = "X/Y", displayName = "", shortName = shortName, offsetMinutes = offset),
-        )
-        assertThat(descriptorFor("UTC", 0)).isEqualTo("UTC")
-        assertThat(descriptorFor("GMT+05:30", 330)).isEqualTo("GMT+05:30")
-    }
-
-    @Test
-    fun `offset is resolved at the given instant, not the current one`() {
-        val berlin = zones.first { it.id == "Europe/Berlin" }
-        // CEST in June, so +02:00 — a fixed +01:00 would mean we ignored DST.
-        assertThat(berlin.offsetMinutes).isEqualTo(120)
-
-        val winter = timeZoneOptions(Locale.ENGLISH, Instant.parse("2026-01-11T12:00:00Z"))
-        assertThat(winter.first { it.id == "Europe/Berlin" }.offsetMinutes).isEqualTo(60)
-    }
-
-    @Test
-    fun `blank query returns everything unchanged`() {
-        assertThat(filter("")).isEqualTo(zones)
-        assertThat(filter("   ")).isEqualTo(zones)
-    }
-
-    @Test
-    fun `query matches the city, ignoring case and underscores`() {
-        assertThat(filter("new york").map { it.id }).contains("America/New_York")
-        assertThat(filter("NEW YORK").map { it.id }).contains("America/New_York")
-        assertThat(filter("new_york").map { it.id }).contains("America/New_York")
-    }
-
-    @Test
-    fun `query matches accented cities typed plainly`() {
-        // Sao_Paulo has no accent in the id, but its localized name does — the
-        // point is that a user typing plain ASCII still finds it.
-        assertThat(filter("sao paulo").map { it.id }).contains("America/Sao_Paulo")
-        assertThat(filter("zurich").map { it.id }).contains("Europe/Zurich")
-    }
-
-    @Test
-    fun `query matches the full IANA id`() {
-        assertThat(filter("europe/berlin").map { it.id }).contains("Europe/Berlin")
-    }
-
-    @Test
-    fun `query matches the abbreviation, case-insensitively`() {
-        // "cest" isn't a city, id, or substring of "Central European Summer
-        // Time", so the only way these match is via the abbreviation.
-        val hits = filter("cest")
-        assertThat(hits).isNotEmpty()
-        assertThat(hits.map { it.id }).contains("Europe/Berlin")
-        // Every hit genuinely carries that abbreviation — nothing bled in.
-        assertThat(hits.all { it.shortName.equals("CEST", ignoreCase = true) }).isTrue()
-        // Case doesn't matter.
-        assertThat(filter("CEST").map { it.id }).isEqualTo(hits.map { it.id })
-    }
-
-    @Test
-    fun `a city starting with the query outranks one merely containing it`() {
-        val ids = filter("york").map { it.id }
-        // "New York" contains "york"; nothing starts with it, so it should still
-        // surface rather than being buried.
-        assertThat(ids).contains("America/New_York")
-
-        // "col" starts Colombo but only appears mid-string elsewhere.
-        val col = filter("col").map { it.id }
-        assertThat(col.first()).isEqualTo("Asia/Colombo")
-    }
-
-    @Test
-    fun `no match yields an empty list rather than everything`() {
-        assertThat(filter("zzzznotazone")).isEmpty()
-    }
-
-    @Test
-    fun `single zone resolves the same way the catalogue does`() {
-        val fromCatalogue = zones.first { it.id == "Europe/Berlin" }
-        assertThat(timeZoneOptionOf("Europe/Berlin", Locale.ENGLISH, summer))
-            .isEqualTo(fromCatalogue)
-    }
-
-    @Test
-    fun `an unknown zone id resolves to null`() {
-        assertThat(timeZoneOptionOf("Mars/Olympus_Mons")).isNull()
-    }
-
-    @Test
-    fun `gmt offsets format with a sign and padding`() {
-        assertThat(formatGmtOffset(0)).isEqualTo("GMT")
-        assertThat(formatGmtOffset(120)).isEqualTo("GMT+02:00")
-        assertThat(formatGmtOffset(-300)).isEqualTo("GMT-05:00")
-        // India is +05:30 — a whole-hour assumption would render this wrong.
-        assertThat(formatGmtOffset(330)).isEqualTo("GMT+05:30")
-        assertThat(formatGmtOffset(-210)).isEqualTo("GMT-03:30")
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaTimeLabelTest.kt

@@ -1,76 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.agenda
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.LocalDateTime
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toInstant
-import kotlin.time.Instant
-import org.junit.jupiter.api.Test
-
-class AgendaTimeLabelTest {
-
-    private val zone = TimeZone.UTC
-
-    private fun at(y: Int, mo: Int, d: Int, h: Int = 0, min: Int = 0): Instant =
-        LocalDateTime(y, mo, d, h, min).toInstant(zone)
-
-    private fun event(start: Instant, end: Instant, isAllDay: Boolean = false) = EventInstance(
-        instanceId = 1,
-        eventId = 1,
-        calendarId = 1,
-        title = "e",
-        start = start,
-        end = end,
-        isAllDay = isAllDay,
-        color = 0,
-        location = null,
-    )
-
-    private fun labelOn(y: Int, mo: Int, d: Int, event: EventInstance) =
-        agendaTimeLabel(event, LocalDate(y, mo, d), zone)
-
-    @Test
-    fun `a single-day timed event is a start-end range`() {
-        val e = event(at(2026, 7, 2, 12, 0), at(2026, 7, 2, 13, 0))
-
-        assertThat(labelOn(2026, 7, 2, e))
-            .isEqualTo(AgendaTimeLabel.Range(e.start, e.end))
-    }
-
-    @Test
-    fun `a single-day all-day event is all-day`() {
-        val e = event(at(2026, 7, 2), at(2026, 7, 3), isAllDay = true)
-
-        assertThat(labelOn(2026, 7, 2, e)).isEqualTo(AgendaTimeLabel.AllDay)
-    }
-
-    @Test
-    fun `a multi-day timed event names the start, middle, and end days`() {
-        val e = event(at(2026, 7, 1, 14, 0), at(2026, 7, 4, 10, 0))
-
-        assertThat(labelOn(2026, 7, 1, e)).isEqualTo(AgendaTimeLabel.Starts(e.start))
-        assertThat(labelOn(2026, 7, 2, e)).isEqualTo(AgendaTimeLabel.AllDay)
-        assertThat(labelOn(2026, 7, 3, e)).isEqualTo(AgendaTimeLabel.AllDay)
-        assertThat(labelOn(2026, 7, 4, e)).isEqualTo(AgendaTimeLabel.Ends(e.end))
-    }
-
-    @Test
-    fun `a multi-day all-day event is all-day on every day`() {
-        val e = event(at(2026, 7, 2), at(2026, 7, 5), isAllDay = true)
-
-        assertThat(labelOn(2026, 7, 2, e)).isEqualTo(AgendaTimeLabel.AllDay)
-        assertThat(labelOn(2026, 7, 3, e)).isEqualTo(AgendaTimeLabel.AllDay)
-        assertThat(labelOn(2026, 7, 4, e)).isEqualTo(AgendaTimeLabel.AllDay)
-    }
-
-    @Test
-    fun `an event begun before the shown day is not labelled as starting`() {
-        // Runs 29 Jun 09:00 → 2 Jul 09:00; on 1 Jul it is mid-span, on 2 Jul it ends.
-        val e = event(at(2026, 6, 29, 9, 0), at(2026, 7, 2, 9, 0))
-
-        assertThat(labelOn(2026, 7, 1, e)).isEqualTo(AgendaTimeLabel.AllDay)
-        assertThat(labelOn(2026, 7, 2, e)).isEqualTo(AgendaTimeLabel.Ends(e.end))
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/agenda/GroupAgendaDaysTest.kt

@@ -1,175 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.agenda
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.LocalDateTime
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toInstant
-import kotlin.time.Instant
-import org.junit.jupiter.api.Test
-
-class GroupAgendaDaysTest {
-
-    private val zone = TimeZone.UTC
-    private val anchor = LocalDate(2026, 7, 1)
-    // A wide window so clamping to the window end is out of the way unless tested.
-    private val windowEnd = LocalDate(2026, 7, 31)
-
-    private fun at(y: Int, mo: Int, d: Int, h: Int = 0, min: Int = 0): Instant =
-        LocalDateTime(y, mo, d, h, min).toInstant(zone)
-
-    private fun event(
-        id: Long,
-        title: String,
-        start: Instant,
-        end: Instant,
-        isAllDay: Boolean = false,
-    ) = EventInstance(
-        instanceId = id,
-        eventId = id,
-        calendarId = 1,
-        title = title,
-        start = start,
-        end = end,
-        isAllDay = isAllDay,
-        color = 0,
-        location = null,
-    )
-
-    private fun days(instances: List<EventInstance>) =
-        groupAgendaDays(anchor, windowEnd, instances, zone)
-
-    @Test
-    fun `a timed multi-day event lists on every day it spans`() {
-        val e = event(1, "trip", at(2026, 7, 1, 14, 0), at(2026, 7, 3, 10, 0))
-
-        val result = days(listOf(e))
-
-        assertThat(result.map { it.date }).containsExactly(
-            LocalDate(2026, 7, 1),
-            LocalDate(2026, 7, 2),
-            LocalDate(2026, 7, 3),
-        ).inOrder()
-        result.forEach { assertThat(it.events).containsExactly(e) }
-    }
-
-    @Test
-    fun `an all-day multi-day event stops before its exclusive next-midnight end`() {
-        // 1–3 July inclusive: end is the exclusive midnight opening 4 July.
-        val e = event(1, "holiday", at(2026, 7, 1), at(2026, 7, 4), isAllDay = true)
-
-        val result = days(listOf(e))
-
-        assertThat(result.map { it.date }).containsExactly(
-            LocalDate(2026, 7, 1),
-            LocalDate(2026, 7, 2),
-            LocalDate(2026, 7, 3),
-        ).inOrder()
-    }
-
-    @Test
-    fun `a single-day event lists exactly once`() {
-        val e = event(1, "lunch", at(2026, 7, 2, 12, 0), at(2026, 7, 2, 13, 0))
-
-        assertThat(days(listOf(e)).map { it.date })
-            .containsExactly(LocalDate(2026, 7, 2))
-    }
-
-    @Test
-    fun `an event ending exactly at midnight does not reach the next day`() {
-        val e = event(1, "late", at(2026, 7, 1, 22, 0), at(2026, 7, 2, 0, 0))
-
-        assertThat(days(listOf(e)).map { it.date })
-            .containsExactly(LocalDate(2026, 7, 1))
-    }
-
-    @Test
-    fun `an event begun before the anchor is clamped to the anchor day`() {
-        val e = event(1, "ongoing", at(2026, 6, 29, 9, 0), at(2026, 7, 2, 9, 0))
-
-        assertThat(days(listOf(e)).map { it.date }).containsExactly(
-            LocalDate(2026, 7, 1),
-            LocalDate(2026, 7, 2),
-        ).inOrder()
-    }
-
-    @Test
-    fun `an event running past the window is clamped to the last visible day`() {
-        val narrowEnd = LocalDate(2026, 7, 2)
-        val e = event(1, "long", at(2026, 7, 1, 9, 0), at(2026, 7, 5, 9, 0))
-
-        val result = groupAgendaDays(anchor, narrowEnd, listOf(e), zone)
-
-        assertThat(result.map { it.date }).containsExactly(
-            LocalDate(2026, 7, 1),
-            LocalDate(2026, 7, 2),
-        ).inOrder()
-    }
-
-    // All-day events are stored at UTC midnights; resolving them in a device
-    // zone east of UTC would leak them onto the following day (see spanLastDay).
-    private val berlin = TimeZone.of("Europe/Berlin")
-
-    private fun utcMidnight(y: Int, mo: Int, d: Int): Instant =
-        LocalDateTime(y, mo, d, 0, 0).toInstant(TimeZone.UTC)
-
-    @Test
-    fun `a single-day all-day event does not leak onto the next day in an eastern zone`() {
-        val e = event(1, "birthday", utcMidnight(2026, 7, 2), utcMidnight(2026, 7, 3), isAllDay = true)
-
-        val result = groupAgendaDays(anchor, windowEnd, listOf(e), berlin)
-
-        assertThat(result.map { it.date }).containsExactly(LocalDate(2026, 7, 2))
-        assertThat(e.spansMultipleDays(berlin)).isFalse()
-    }
-
-    @Test
-    fun `an all-day multi-day event spans its true days in an eastern zone`() {
-        // 2–4 July inclusive: exclusive end is the UTC midnight opening 5 July.
-        val e = event(1, "holiday", utcMidnight(2026, 7, 2), utcMidnight(2026, 7, 5), isAllDay = true)
-
-        val result = groupAgendaDays(anchor, windowEnd, listOf(e), berlin)
-
-        assertThat(result.map { it.date }).containsExactly(
-            LocalDate(2026, 7, 2),
-            LocalDate(2026, 7, 3),
-            LocalDate(2026, 7, 4),
-        ).inOrder()
-    }
-
-    @Test
-    fun `yesterday's all-day event does not surface under the anchor day in an eastern zone`() {
-        // The agenda window starts at the anchor's local midnight, which in Berlin is
-        // 22:00 UTC the day before — so an all-day event that ended yesterday (whose
-        // exclusive UTC-midnight end sits at that instant) is still returned by the
-        // provider. It must not be clamped onto the anchor's "today" section (#65).
-        val jul19 = LocalDate(2026, 7, 19)
-        val e = event(1, "birthday", utcMidnight(2026, 7, 18), utcMidnight(2026, 7, 19), isAllDay = true)
-
-        val result = groupAgendaDays(jul19, LocalDate(2026, 8, 18), listOf(e), berlin)
-
-        assertThat(result).isEmpty()
-    }
-
-    @Test
-    fun `an all-day event that falls entirely past the window end is dropped`() {
-        // The same guard, at the far edge: an instance whose true days are all beyond
-        // windowEnd occupies no visible day and must not be clamped onto the last one.
-        val e = event(1, "birthday", utcMidnight(2026, 7, 3), utcMidnight(2026, 7, 4), isAllDay = true)
-
-        val result = groupAgendaDays(anchor, LocalDate(2026, 7, 2), listOf(e), berlin)
-
-        assertThat(result).isEmpty()
-    }
-
-    @Test
-    fun `within a day all-day events sort before timed ones`() {
-        val allDay = event(1, "birthday", at(2026, 7, 1), at(2026, 7, 2), isAllDay = true)
-        val timed = event(2, "call", at(2026, 7, 1, 9, 0), at(2026, 7, 1, 10, 0))
-
-        val dayOne = days(listOf(timed, allDay)).first { it.date == anchor }
-
-        assertThat(dayOne.events).containsExactly(allDay, timed).inOrder()
-    }
-}

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

@@ -1,69 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import com.google.common.truth.Truth.assertThat
-import java.time.LocalDate
-import java.time.ZoneId
-import org.junit.jupiter.api.Test
-
-/**
- * The read side of the UNTIL round-trip. `SimpleRecurrence.toRRule` deliberately
- * writes the end of the chosen *local* day expressed in UTC (see its docs — the
- * provider applies UNTIL coarsely), so displaying it means converting back into
- * the device zone first. Reading the leading digits raw showed the wrong day for
- * zones behind UTC.
- */
-class RecurrenceTextTest {
-
-    private val berlin = ZoneId.of("Europe/Berlin")
-    private val losAngeles = ZoneId.of("America/Los_Angeles")
-    private val utc = ZoneId.of("UTC")
-
-    @Test
-    fun `UTC form converts back to the picked day west of UTC`() {
-        // toRRule("2026-12-31", America/Los_Angeles) → 23:59:59 local = 07:59:59Z
-        // on 1 Jan. Reading the digits raw would show 1 Jan 2027.
-        assertThat(untilLocalDate("20270101T075959Z", losAngeles))
-            .isEqualTo(LocalDate.of(2026, 12, 31))
-    }
-
-    @Test
-    fun `UTC form converts back to the picked day east of UTC`() {
-        // Berlin in December is UTC+1: 23:59:59 local = 22:59:59Z the same day.
-        assertThat(untilLocalDate("20261231T225959Z", berlin))
-            .isEqualTo(LocalDate.of(2026, 12, 31))
-    }
-
-    @Test
-    fun `UTC form is unchanged at UTC itself`() {
-        assertThat(untilLocalDate("20261231T235959Z", utc))
-            .isEqualTo(LocalDate.of(2026, 12, 31))
-    }
-
-    @Test
-    fun `summer offset is honoured, not a fixed one`() {
-        // Berlin in July is UTC+2, so the same local end-of-day lands at 21:59:59Z.
-        assertThat(untilLocalDate("20260801T215959Z", berlin))
-            .isEqualTo(LocalDate.of(2026, 8, 1))
-    }
-
-    @Test
-    fun `date-only form is already local and passes through`() {
-        assertThat(untilLocalDate("20261231", losAngeles))
-            .isEqualTo(LocalDate.of(2026, 12, 31))
-    }
-
-    @Test
-    fun `floating date-time form uses its date as-is`() {
-        // No trailing Z, so it isn't an instant — no conversion may be applied.
-        assertThat(untilLocalDate("20261231T235959", losAngeles))
-            .isEqualTo(LocalDate.of(2026, 12, 31))
-    }
-
-    @Test
-    fun `garbage returns null rather than throwing`() {
-        assertThat(untilLocalDate("", berlin)).isNull()
-        assertThat(untilLocalDate("nonsense", berlin)).isNull()
-        assertThat(untilLocalDate("2026", berlin)).isNull()
-        assertThat(untilLocalDate("20261340", berlin)).isNull()
-    }
-}

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

@@ -1,120 +0,0 @@
-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
-
-/**
- * What makes the continuous style's month blocks self-contained: a boundary week
- * keeps its seven columns but carries only the block's own month.
- */
-class ClipWeekToMonthTest {
-
-    private val zone = TimeZone.UTC
-    private val jul26 = YearMonth(2026, Month.JULY)
-
-    private fun allDay(from: LocalDate, toInclusive: LocalDate, id: Long = 1L) = EventInstance(
-        instanceId = id,
-        eventId = id,
-        calendarId = 1L,
-        title = "A",
-        start = from.atTime(0, 0).toInstant(TimeZone.UTC),
-        end = toInclusive.plus(1, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
-        isAllDay = true,
-        color = 0xFF445566.toInt(),
-        location = null,
-    )
-
-    private fun timed(date: LocalDate, hour: Int, id: Long = 2L) = EventInstance(
-        instanceId = id,
-        eventId = id,
-        calendarId = 1L,
-        title = "T",
-        start = date.atTime(hour, 0).toInstant(zone),
-        end = date.atTime(hour + 1, 0).toInstant(zone),
-        isAllDay = false,
-        color = 0xFF112233.toInt(),
-        location = null,
-    )
-
-    /** July 2026 starts on a Wednesday, so its first Monday-anchored row is Jun 29 – Jul 5. */
-    private fun firstRowOfJuly(events: List<EventInstance>) =
-        clipWeekToMonth(
-            layoutMonthWeeks(jul26, DayOfWeek.MONDAY, events, zone).first(),
-            jul26,
-        )
-
-    @Test
-    fun `the row keeps all seven days so the columns don't shift`() {
-        val week = firstRowOfJuly(emptyList())
-        assertThat(week.days).hasSize(7)
-        assertThat(week.days.first()).isEqualTo(LocalDate(2026, 6, 29))
-    }
-
-    @Test
-    fun `the neighbour month's events are dropped`() {
-        val june = timed(LocalDate(2026, 6, 30), 9)
-        val july = timed(LocalDate(2026, 7, 1), 9, id = 3L)
-        val week = firstRowOfJuly(listOf(june, july))
-
-        assertThat(week.timedByDay.keys).doesNotContain(LocalDate(2026, 6, 30))
-        assertThat(week.timedByDay[LocalDate(2026, 7, 1)]).containsExactly(july)
-        assertThat(week.countByDay[LocalDate(2026, 6, 30)]).isNull()
-        assertThat(week.countByDay[LocalDate(2026, 7, 1)]).isEqualTo(1)
-    }
-
-    @Test
-    fun `a bar reaching in from the previous month is cut back to the 1st`() {
-        // Jun 29 – Jul 2: columns 0..3 unclipped, 2..3 once July owns the row.
-        val week = firstRowOfJuly(listOf(allDay(LocalDate(2026, 6, 29), LocalDate(2026, 7, 2))))
-
-        val span = week.spans.single()
-        assertThat(span.startCol).isEqualTo(2) // Wednesday the 1st
-        assertThat(span.endCol).isEqualTo(3)
-        // Flat cap on the cut side: the event continues out of this block.
-        assertThat(span.continuesLeft).isTrue()
-        assertThat(span.continuesRight).isFalse()
-    }
-
-    @Test
-    fun `a bar living entirely in the neighbour month disappears`() {
-        val week = firstRowOfJuly(listOf(allDay(LocalDate(2026, 6, 29), LocalDate(2026, 6, 30))))
-        assertThat(week.spans).isEmpty()
-    }
-
-    @Test
-    fun `a bar reaching out into the next month is cut at the last day`() {
-        // Jul 29 – Aug 2 sits in July's final row (Jul 27 – Aug 2).
-        val weeks = layoutMonthWeeks(
-            jul26,
-            DayOfWeek.MONDAY,
-            listOf(allDay(LocalDate(2026, 7, 29), LocalDate(2026, 8, 2))),
-            zone,
-        )
-        val span = clipWeekToMonth(weeks.last(), jul26).spans.single()
-        assertThat(span.startCol).isEqualTo(2) // Wednesday the 29th
-        assertThat(span.endCol).isEqualTo(4) // Friday the 31st
-        assertThat(span.continuesRight).isTrue()
-        assertThat(span.continuesLeft).isFalse()
-    }
-
-    @Test
-    fun `a row wholly inside the month is untouched`() {
-        val mid = layoutMonthWeeks(
-            jul26,
-            DayOfWeek.MONDAY,
-            listOf(timed(LocalDate(2026, 7, 8), 9), allDay(LocalDate(2026, 7, 7), LocalDate(2026, 7, 9))),
-            zone,
-        )[1]
-        assertThat(clipWeekToMonth(mid, jul26)).isEqualTo(mid)
-    }
-}

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

@@ -1,238 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.month
-
-import com.google.common.truth.Truth.assertThat
-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.minus
-import kotlinx.datetime.plus
-import org.junit.jupiter.api.Test
-
-/**
- * The continuous grid's coordinate space. Every block's identity — and the
- * LazyColumn items it maps to — hangs off this arithmetic, so it gets its own
- * tests rather than being exercised only through the UI.
- */
-class ContinuousMonthIndexTest {
-
-    private val jun26 = YearMonth(2026, Month.JUNE)
-
-    @Test
-    fun `consecutive months are consecutive indices`() {
-        val jun = monthIndexOf(jun26)
-        assertThat(monthIndexOf(YearMonth(2026, Month.JULY))).isEqualTo(jun + 1)
-        assertThat(monthIndexOf(YearMonth(2026, Month.MAY))).isEqualTo(jun - 1)
-        // And across the year boundary.
-        assertThat(monthIndexOf(YearMonth(2027, Month.JANUARY)))
-            .isEqualTo(monthIndexOf(YearMonth(2026, Month.DECEMBER)) + 1)
-    }
-
-    @Test
-    fun `index round-trips back to its month`() {
-        listOf(
-            YearMonth(1900, Month.JANUARY),
-            jun26,
-            YearMonth(2026, Month.DECEMBER),
-            YearMonth(2100, Month.DECEMBER),
-        ).forEach { ym ->
-            assertThat(yearMonthForIndex(monthIndexOf(ym))).isEqualTo(ym)
-        }
-    }
-
-    @Test
-    fun `indices are non-negative and span 1900 through 2100`() {
-        assertThat(monthIndexOf(YearMonth(1900, Month.JANUARY))).isEqualTo(0)
-        assertThat(monthIndexOf(jun26)).isGreaterThan(0)
-        assertThat(monthIndexOf(YearMonth(2100, Month.DECEMBER)))
-            .isEqualTo(continuousMonthCount() - 1)
-        assertThat(continuousMonthCount()).isEqualTo(201 * 12)
-    }
-
-    @Test
-    fun `a month maps to its header item and back`() {
-        val index = monthIndexOf(jun26)
-        val item = itemIndexForMonth(index)
-        // Both of a month's items — its sticky header and the block under it —
-        // resolve back to the same month, so a title read off the first visible
-        // item is right wherever the viewport sits inside the block.
-        assertThat(monthIndexForItem(item)).isEqualTo(index)
-        assertThat(monthIndexForItem(item + 1)).isEqualTo(index)
-        assertThat(monthIndexForItem(item + 2)).isEqualTo(index + 1)
-    }
-
-    @Test
-    fun `week rows follow the month's shape and its week start`() {
-        // June 2026 starts on a Monday: 30 days → 5 rows either way.
-        assertThat(weekRowsInMonth(jun26, DayOfWeek.MONDAY)).isEqualTo(5)
-        assertThat(weekRowsInMonth(jun26, DayOfWeek.SUNDAY)).isEqualTo(5)
-        // February 2026 starts on a Sunday: a Sunday-anchored grid fits it in 4
-        // rows, a Monday-anchored one needs 5 — the block's height moves with the
-        // preference even though its position in the list doesn't.
-        val feb26 = YearMonth(2026, Month.FEBRUARY)
-        assertThat(weekRowsInMonth(feb26, DayOfWeek.SUNDAY)).isEqualTo(4)
-        assertThat(weekRowsInMonth(feb26, DayOfWeek.MONDAY)).isEqualTo(5)
-        // February 2021 starts on a Monday and is 28 days → exactly 4.
-        assertThat(weekRowsInMonth(YearMonth(2021, Month.FEBRUARY), DayOfWeek.MONDAY))
-            .isEqualTo(4)
-    }
-
-    @Test
-    fun `the placeholder block is the size the loaded one will be`() {
-        // Otherwise scrolling across an unloaded month jumps when its data lands.
-        (0 until 24).forEach { offset ->
-            val ym = yearMonthForIndex(monthIndexOf(jun26) + offset)
-            DayOfWeek.entries.forEach { ws ->
-                assertThat(weekRowsInMonth(ym, ws))
-                    .isEqualTo(layoutMonthWeeks(ym, ws, emptyList(), TimeZone.UTC).size)
-            }
-        }
-    }
-
-    @Test
-    fun `a window is clamped to the months that exist`() {
-        // The regression this guards: an empty visible-items list reported as
-        // "month 0", whose padded window ran to -4 — and yearMonthForIndex has
-        // no month for that, so the whole grid failed with "couldn't read".
-        assertThat(clampMonthWindow(-4..4)).isEqualTo(0..4)
-        val last = continuousMonthCount() - 1
-        assertThat(clampMonthWindow((last - 2)..(last + 4))).isEqualTo((last - 2)..last)
-        assertThat(clampMonthWindow(10..20)).isEqualTo(10..20)
-    }
-
-    @Test
-    fun `every index a clamped window can hold resolves to a month`() {
-        listOf(clampMonthWindow(-4..4), clampMonthWindow((continuousMonthCount() - 1)..(continuousMonthCount() + 3)))
-            .forEach { window ->
-                window.forEach { index -> yearMonthForIndex(index) }
-            }
-    }
-
-    @Test
-    fun `the dense week window covers every week its months touch`() {
-        // One month-window load has to lay out every Dense row those months
-        // appear in, boundary weeks included, or rows would flicker as
-        // placeholders while the data for them is already in hand.
-        DayOfWeek.entries.forEach { ws ->
-            val window = monthIndexOf(jun26)..monthIndexOf(YearMonth(2026, Month.AUGUST))
-            val weeks = weekWindowFor(window, ws)
-            window.forEach { index ->
-                val ym = yearMonthForIndex(index)
-                val first = weekIndexOf(firstOfMonth(ym), ws)
-                val last = weekIndexOf(firstOfMonth(yearMonthForIndex(index + 1)).minus(1, DateTimeUnit.DAY), ws)
-                assertThat(weeks.contains(first)).isTrue()
-                assertThat(weeks.contains(last)).isTrue()
-            }
-        }
-    }
-
-    @Test
-    fun `a dense row reports the month that owns most of it`() {
-        // June 29 – July 5, 2026 (Monday-anchored): four of its days are July's,
-        // so the window follows July rather than snapping back to June.
-        val boundary = weekIndexOf(LocalDate(2026, 6, 29), DayOfWeek.MONDAY)
-        assertThat(monthIndexForWeek(boundary, DayOfWeek.MONDAY))
-            .isEqualTo(monthIndexOf(YearMonth(2026, Month.JULY)))
-        // A row wholly inside June reports June.
-        assertThat(monthIndexForWeek(weekIndexOf(LocalDate(2026, 6, 15), DayOfWeek.MONDAY), DayOfWeek.MONDAY))
-            .isEqualTo(monthIndexOf(jun26))
-    }
-
-    @Test
-    fun `every day of a dense week shares one index`() {
-        val mon = LocalDate(2026, 6, 8)
-        val indices = (0..6).map { weekIndexOf(mon.plus(it, DateTimeUnit.DAY), DayOfWeek.MONDAY) }
-        assertThat(indices.toSet()).hasSize(1)
-    }
-
-    @Test
-    fun `dense week indices round-trip and stay inside the list`() {
-        val wed = LocalDate(2026, 6, 10)
-        DayOfWeek.entries.forEach { ws ->
-            val index = weekIndexOf(wed, ws)
-            assertThat(weekStartForIndex(index, ws)).isEqualTo(wed.startOfGridWeek(ws))
-            assertThat(weekIndexOf(LocalDate(1900, 1, 1), ws)).isAtLeast(0)
-            assertThat(index).isLessThan(continuousWeekCount(ws))
-            assertThat(weekIndexOf(LocalDate(2100, 12, 31), ws))
-                .isLessThan(continuousWeekCount(ws))
-        }
-    }
-
-    @Test
-    fun `firstOfMonth is the 1st`() {
-        assertThat(firstOfMonth(jun26)).isEqualTo(LocalDate(2026, 6, 1))
-    }
-
-    @Test
-    fun `a window comfortably around the visible range is kept`() {
-        assertThat(nextLoadWindow(loaded = 0..100, firstVisible = 40, lastVisible = 45)).isNull()
-    }
-
-    @Test
-    fun `nearing a loaded edge widens the window around the visible range`() {
-        // Within two months of the top edge → reload, padded on both sides.
-        assertThat(nextLoadWindow(loaded = 0..100, firstVisible = 1, lastVisible = 2))
-            .isEqualTo(-4..7)
-
-        assertThat(nextLoadWindow(loaded = 0..100, firstVisible = 98, lastVisible = 100))
-            .isEqualTo(93..105)
-    }
-
-    @Test
-    fun `a jump far outside the window reloads around the destination`() {
-        assertThat(nextLoadWindow(loaded = 0..100, firstVisible = 500, lastVisible = 501))
-            .isEqualTo(495..506)
-    }
-
-    @Test
-    fun `the reloaded window always clears the trigger it just crossed`() {
-        // Otherwise every scroll frame would re-trigger a query — and with the
-        // window growing from a pad of 1, this has to hold at every rung of the
-        // ladder, not just the widest one.
-        (1..8).forEach { pad ->
-            val loaded = (10 - pad)..(10 + pad)
-            val past = 10 + pad + 1
-            val widened = nextLoadWindow(loaded, past, past, pad)!!
-            assertThat(nextLoadWindow(widened, past, past, pad)).isNull()
-        }
-    }
-
-    @Test
-    fun `the reload trigger stays inside the pad`() {
-        // A trigger at or beyond the pad would fire again the instant its own
-        // reload landed, and the window would query forever.
-        (1..8).forEach { pad -> assertThat(edgeForPad(pad)).isLessThan(pad) }
-        // A one-month window has no room for hysteresis: reload only on contact.
-        assertThat(edgeForPad(1)).isEqualTo(0)
-        assertThat(edgeForPad(0)).isEqualTo(0)
-    }
-
-    @Test
-    fun `the smallest window reloads on crossing rather than nearing its edge`() {
-        // The first frame loads one month either side of today, which leaves no
-        // room to reload *before* the edge: at pad 1 the trigger is contact.
-        // Only momentary — the first completed load widens the pad to 3, which
-        // buys the usual head start back.
-        val initial = 10..12
-        assertThat(nextLoadWindow(initial, firstVisible = 12, lastVisible = 12, pad = 1)).isNull()
-        assertThat(nextLoadWindow(initial, firstVisible = 13, lastVisible = 13, pad = 1))
-            .isEqualTo(12..14)
-    }
-
-    @Test
-    fun `the split selection follows the month, landing on today when it's there`() {
-        val today = LocalDate(2026, 6, 10)
-        assertThat(selectionForMonth(jun26, today)).isEqualTo(today)
-    }
-
-    @Test
-    fun `the split selection falls to the 1st of any other month`() {
-        val today = LocalDate(2026, 6, 10)
-        assertThat(selectionForMonth(YearMonth(2026, Month.JULY), today))
-            .isEqualTo(LocalDate(2026, 7, 1))
-        assertThat(selectionForMonth(YearMonth(2025, Month.JUNE), today))
-            .isEqualTo(LocalDate(2025, 6, 1))
-    }
-}

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

@@ -1,121 +0,0 @@
-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.minus
-import kotlinx.datetime.plus
-import kotlinx.datetime.toInstant
-import org.junit.jupiter.api.Test
-
-/**
- * [DayIndex] exists purely to make the scrolling styles cheap, so what it owes
- * is that cheapness changes *nothing*: a row laid out from the index must be the
- * row that would have come from scanning every instance.
- *
- * Run in a zone east of UTC, where the all-day anchoring and the day boundaries
- * disagree — the case that has bitten this codebase before (#65).
- */
-class DayIndexTest {
-
-    private val zone = TimeZone.of("Europe/Berlin")
-    private val mon = LocalDate(2026, 6, 8)
-    private val week = (0..6).map { mon.plus(it, DateTimeUnit.DAY) }
-
-    private var nextId = 0L
-
-    private fun timed(from: LocalDate, startHour: Int, to: LocalDate, endHour: Int): EventInstance {
-        val id = ++nextId
-        return EventInstance(
-            instanceId = id,
-            eventId = id,
-            calendarId = 1L,
-            title = "T$id",
-            start = from.atTime(startHour, 0).toInstant(zone),
-            end = to.atTime(endHour, 0).toInstant(zone),
-            isAllDay = false,
-            color = 0xFF112233.toInt(),
-            location = null,
-        )
-    }
-
-    private fun allDay(from: LocalDate, toInclusive: LocalDate): EventInstance {
-        val id = ++nextId
-        return EventInstance(
-            instanceId = id,
-            eventId = id,
-            calendarId = 1L,
-            title = "A$id",
-            start = from.atTime(0, 0).toInstant(TimeZone.UTC),
-            end = toInclusive.plus(1, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
-            isAllDay = true,
-            color = 0xFF445566.toInt(),
-            location = null,
-        )
-    }
-
-    /** Every shape the layout distinguishes, plus the boundary cases around them. */
-    private fun awkwardEvents(): List<EventInstance> = listOf(
-        timed(mon, 9, mon, 10),
-        // Crosses midnight into the next day.
-        timed(mon.plus(1, DateTimeUnit.DAY), 23, mon.plus(2, DateTimeUnit.DAY), 1),
-        // Ends exactly at midnight: covers its own day, not the next.
-        timed(mon.plus(3, DateTimeUnit.DAY), 22, mon.plus(4, DateTimeUnit.DAY), 0),
-        // Zero length, at midnight: covers nothing at all.
-        timed(mon.plus(4, DateTimeUnit.DAY), 0, mon.plus(4, DateTimeUnit.DAY), 0),
-        allDay(mon.plus(2, DateTimeUnit.DAY), mon.plus(2, DateTimeUnit.DAY)),
-        // Runs in from before the row and out past its end.
-        allDay(mon.minus(3, DateTimeUnit.DAY), mon.plus(9, DateTimeUnit.DAY)),
-        // Wholly outside the row, both sides.
-        timed(mon.minus(10, DateTimeUnit.DAY), 9, mon.minus(10, DateTimeUnit.DAY), 10),
-        allDay(mon.plus(20, DateTimeUnit.DAY), mon.plus(21, DateTimeUnit.DAY)),
-        // Two on one day, to pin the ordering the index hands back.
-        timed(mon.plus(5, DateTimeUnit.DAY), 8, mon.plus(5, DateTimeUnit.DAY), 9),
-        timed(mon.plus(5, DateTimeUnit.DAY), 14, mon.plus(5, DateTimeUnit.DAY), 15),
-    )
-
-    @Test
-    fun `a row from the index is the row from a full scan`() {
-        val events = awkwardEvents()
-        val scanned = layoutCalendarWeek(week, events, zone)
-        val indexed = layoutCalendarWeek(week, DayIndex(events, zone).eventsOn(week), zone)
-        assertThat(indexed).isEqualTo(scanned)
-    }
-
-    @Test
-    fun `a whole month agrees, row for row`() {
-        val events = awkwardEvents()
-        val jun = YearMonth(2026, Month.JUNE)
-        DayOfWeek.entries.forEach { ws ->
-            assertThat(layoutMonthWeeks(jun, ws, DayIndex(events, zone), zone))
-                .isEqualTo(layoutMonthWeeks(jun, ws, events, zone))
-        }
-    }
-
-    @Test
-    fun `an event covering several of a row's days is listed once`() {
-        // It is bucketed on each date it covers, so the row would otherwise see
-        // it repeatedly and lay out a lane per copy.
-        val long = allDay(mon, mon.plus(4, DateTimeUnit.DAY))
-        val events = DayIndex(listOf(long), zone).eventsOn(week)
-        assertThat(events).containsExactly(long)
-    }
-
-    @Test
-    fun `days no event touches come back empty`() {
-        val index = DayIndex(listOf(timed(mon, 9, mon, 10)), zone)
-        assertThat(index.eventsOn(listOf(mon.plus(1, DateTimeUnit.DAY)))).isEmpty()
-        assertThat(index.eventsOn(emptyList())).isEmpty()
-    }
-
-    @Test
-    fun `an empty calendar indexes to nothing`() {
-        assertThat(DayIndex(emptyList(), zone).eventsOn(week)).isEmpty()
-    }
-}

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

@@ -1,129 +0,0 @@
-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
-
-/**
- * What lets the split style's dots morph into the paged style's bars (#53): both
- * read a day off the *same* lane seating, so dot _i_ and lane _i_ are one event.
- */
-class LaneEventsTest {
-
-    private val zone = TimeZone.UTC
-    private val jul26 = YearMonth(2026, Month.JULY)
-
-    /** 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, color: Int = BLUE) =
-        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 = color,
-            location = null,
-        )
-
-    private fun timed(date: LocalDate, hour: Int, id: Long, color: Int = RED) = 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 = color,
-        location = null,
-    )
-
-    @Test
-    fun `a bar keeps its lane and the day's timed events fill what's left`() {
-        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.laneEvents(col = 1, day = LocalDate(2026, 7, 7), laneCap = 3))
-            .containsExactly(bar, meeting)
-            .inOrder()
-    }
-
-    @Test
-    fun `a day the bar misses seats its own events from lane zero`() {
-        val bar = allDay(LocalDate(2026, 7, 7), LocalDate(2026, 7, 9), id = 1L)
-        val monday = timed(LocalDate(2026, 7, 6), hour = 9, id = 2L)
-        val week = rowOfJuly6(listOf(bar, monday))
-
-        assertThat(week.laneEvents(col = 0, day = LocalDate(2026, 7, 6), laneCap = 3))
-            .containsExactly(monday)
-    }
-
-    @Test
-    fun `a multi-day bar is seated on every day it covers`() {
-        val bar = allDay(LocalDate(2026, 7, 7), LocalDate(2026, 7, 9), id = 1L)
-        val week = rowOfJuly6(listOf(bar))
-
-        (1..3).forEach { col ->
-            val day = LocalDate(2026, 7, 6 + col)
-            assertThat(week.laneEvents(col, day, laneCap = 3)).containsExactly(bar)
-        }
-        assertThat(week.laneEvents(col = 4, day = LocalDate(2026, 7, 10), laneCap = 3)).isEmpty()
-    }
-
-    /** The bug the colour-gathered dots had: one dot for two events on one calendar. */
-    @Test
-    fun `events sharing a colour each keep their own lane`() {
-        val first = timed(LocalDate(2026, 7, 6), hour = 9, id = 1L, color = RED)
-        val second = timed(LocalDate(2026, 7, 6), hour = 14, id = 2L, color = RED)
-        val week = rowOfJuly6(listOf(first, second))
-
-        assertThat(week.laneEvents(col = 0, day = LocalDate(2026, 7, 6), laneCap = 3))
-            .containsExactly(first, second)
-            .inOrder()
-    }
-
-    @Test
-    fun `seating stops at the cap and leaves the rest to the overflow count`() {
-        val events = (0 until 5).map { timed(LocalDate(2026, 7, 6), hour = 8 + it, id = it + 1L) }
-        val week = rowOfJuly6(events)
-
-        val seated = week.laneEvents(col = 0, day = LocalDate(2026, 7, 6), laneCap = 3)
-        assertThat(seated).hasSize(3)
-        assertThat(seated).containsExactlyElementsIn(events.take(3)).inOrder()
-        assertThat(week.countByDay[LocalDate(2026, 7, 6)]!! - seated.size).isEqualTo(2)
-    }
-
-    /** A bar parked below the cap is out of view, so it takes no dot with it. */
-    @Test
-    fun `a bar beyond the cap is left out`() {
-        val bars = (0 until 4).map {
-            allDay(LocalDate(2026, 7, 6), LocalDate(2026, 7, 8), id = it + 1L)
-        }
-        val week = rowOfJuly6(bars)
-
-        val seated = week.laneEvents(col = 0, day = LocalDate(2026, 7, 6), laneCap = 3)
-        assertThat(seated).hasSize(3)
-        assertThat(week.spans.filter { it.lane >= 3 }.map { it.event })
-            .containsNoneIn(seated)
-    }
-
-    private companion object {
-        const val BLUE = 0xFF3366CC.toInt()
-        const val RED = 0xFFCC3333.toInt()
-    }
-}

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

@@ -1,220 +0,0 @@
-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.TimeZone
-import kotlinx.datetime.YearMonth
-import kotlinx.datetime.atTime
-import kotlinx.datetime.plus
-import kotlinx.datetime.toInstant
-import kotlin.time.Instant
-import org.junit.jupiter.api.Test
-
-class MonthLayoutTest {
-
-    private val zone = TimeZone.UTC
-
-    // 2026-06-01 is a Monday, so a Monday-anchored June grid starts on the 1st.
-    private val jun = YearMonth(2026, kotlinx.datetime.Month.JUNE)
-    private val jun1 = LocalDate(2026, 6, 1)
-    private val jun8 = LocalDate(2026, 6, 8)
-    private val weekOf8th = (0..6).map { jun8.plus(it, DateTimeUnit.DAY) }
-
-    private fun at(date: LocalDate, h: Int, m: Int = 0): Instant =
-        date.atTime(h, m).toInstant(zone)
-
-    private fun timed(
-        date: LocalDate,
-        startHour: Int,
-        endHour: Int,
-        id: Long = 1L,
-        title: String = "E",
-    ) = EventInstance(
-        instanceId = id,
-        eventId = id,
-        calendarId = 1L,
-        title = title,
-        start = at(date, startHour),
-        end = at(date, endHour),
-        isAllDay = false,
-        color = 0xFF112233.toInt(),
-        location = null,
-    )
-
-    /** All-day events live at UTC midnights with an *exclusive* end. */
-    private fun allDay(
-        from: LocalDate,
-        toInclusive: LocalDate = from,
-        id: Long = 100L,
-        title: String = "A",
-    ) = EventInstance(
-        instanceId = id,
-        eventId = id,
-        calendarId = 1L,
-        title = title,
-        start = from.atTime(0, 0).toInstant(TimeZone.UTC),
-        end = toInclusive.plus(1, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
-        isAllDay = true,
-        color = 0xFF445566.toInt(),
-        location = null,
-    )
-
-    @Test
-    fun `startOfGridWeek snaps back to the configured week start`() {
-        val wed = LocalDate(2026, 6, 10)
-        assertThat(wed.startOfGridWeek(DayOfWeek.MONDAY)).isEqualTo(jun8)
-        assertThat(jun8.startOfGridWeek(DayOfWeek.MONDAY)).isEqualTo(jun8)
-        // A Sunday-anchored week containing the 10th starts on the 7th.
-        assertThat(wed.startOfGridWeek(DayOfWeek.SUNDAY)).isEqualTo(LocalDate(2026, 6, 7))
-    }
-
-    @Test
-    fun `monthGridRange always covers 42 days from the grid start`() {
-        val range = monthGridRange(jun, DayOfWeek.MONDAY, zone)
-        assertThat(range.start).isEqualTo(at(jun1, 0))
-        // 42 days inclusive → the last second of 2026-07-12.
-        assertThat(range.endInclusive)
-            .isEqualTo(LocalDate(2026, 7, 12).atTime(23, 59, 59).toInstant(zone))
-    }
-
-    @Test
-    fun `week count follows the month's shape rather than a fixed six rows`() {
-        // June 2026: starts Monday, 30 days → 5 rows.
-        assertThat(layoutMonthWeeks(jun, DayOfWeek.MONDAY, emptyList(), zone)).hasSize(5)
-        // August 2026: starts Saturday, 31 days → spills to 6 rows.
-        val aug = YearMonth(2026, kotlinx.datetime.Month.AUGUST)
-        assertThat(layoutMonthWeeks(aug, DayOfWeek.MONDAY, emptyList(), zone)).hasSize(6)
-        // February 2021: starts Monday, 28 days → exactly 4 rows.
-        val feb = YearMonth(2021, kotlinx.datetime.Month.FEBRUARY)
-        assertThat(layoutMonthWeeks(feb, DayOfWeek.MONDAY, emptyList(), zone)).hasSize(4)
-    }
-
-    @Test
-    fun `layoutMonthWeeks rows are contiguous and seven days wide`() {
-        val weeks = layoutMonthWeeks(jun, DayOfWeek.MONDAY, emptyList(), zone)
-        assertThat(weeks.first().days.first()).isEqualTo(jun1)
-        weeks.forEach { assertThat(it.days).hasSize(7) }
-        val allDays = weeks.flatMap { it.days }
-        allDays.zipWithNext { a, b -> assertThat(b).isEqualTo(a.plus(1, DateTimeUnit.DAY)) }
-    }
-
-    @Test
-    fun `a multi-day event becomes one span across its columns`() {
-        val ev = allDay(LocalDate(2026, 6, 10), LocalDate(2026, 6, 12))
-        val week = layoutCalendarWeek(weekOf8th, listOf(ev), zone)
-
-        assertThat(week.spans).hasSize(1)
-        val span = week.spans.single()
-        assertThat(span.startCol).isEqualTo(2) // Wednesday the 10th
-        assertThat(span.endCol).isEqualTo(4) // Friday the 12th
-        assertThat(span.lane).isEqualTo(0)
-        assertThat(span.continuesLeft).isFalse()
-        assertThat(span.continuesRight).isFalse()
-    }
-
-    @Test
-    fun `a span running past the row end is flagged as continuing`() {
-        // Saturday the 13th through Tuesday the 16th straddles the row boundary.
-        val ev = allDay(LocalDate(2026, 6, 13), LocalDate(2026, 6, 16))
-        val week = layoutCalendarWeek(weekOf8th, listOf(ev), zone)
-
-        val span = week.spans.single()
-        assertThat(span.startCol).isEqualTo(5)
-        assertThat(span.endCol).isEqualTo(6)
-        assertThat(span.continuesLeft).isFalse()
-        assertThat(span.continuesRight).isTrue()
-
-        // The following row picks it up with the flags mirrored.
-        val nextRow = layoutCalendarWeek(
-            weekOf8th.map { it.plus(7, DateTimeUnit.DAY) },
-            listOf(ev),
-            zone,
-        )
-        val tail = nextRow.spans.single()
-        assertThat(tail.startCol).isEqualTo(0)
-        assertThat(tail.endCol).isEqualTo(1)
-        assertThat(tail.continuesLeft).isTrue()
-        assertThat(tail.continuesRight).isFalse()
-    }
-
-    @Test
-    fun `overlapping spans are stacked on separate lanes`() {
-        val a = allDay(LocalDate(2026, 6, 9), LocalDate(2026, 6, 11), id = 1L)
-        val b = allDay(LocalDate(2026, 6, 10), LocalDate(2026, 6, 12), id = 2L)
-        val week = layoutCalendarWeek(weekOf8th, listOf(a, b), zone)
-
-        assertThat(week.spans.map { it.lane }).containsExactly(0, 1)
-    }
-
-    @Test
-    fun `single-day timed events stay pills and sort by start`() {
-        val late = timed(LocalDate(2026, 6, 10), 14, 15, id = 1L)
-        val early = timed(LocalDate(2026, 6, 10), 9, 10, id = 2L)
-        val week = layoutCalendarWeek(weekOf8th, listOf(late, early), zone)
-
-        assertThat(week.spans).isEmpty()
-        assertThat(week.timedByDay[LocalDate(2026, 6, 10)]?.map { it.instanceId })
-            .containsExactly(2L, 1L)
-            .inOrder()
-        assertThat(week.timedByDay[LocalDate(2026, 6, 11)]).isEmpty()
-    }
-
-    @Test
-    fun `countByDay totals bars and pills on each date`() {
-        val span = allDay(LocalDate(2026, 6, 10), LocalDate(2026, 6, 12), id = 1L)
-        val pill = timed(LocalDate(2026, 6, 10), 9, 10, id = 2L)
-        val week = layoutCalendarWeek(weekOf8th, listOf(span, pill), zone)
-
-        assertThat(week.countByDay[LocalDate(2026, 6, 10)]).isEqualTo(2)
-        assertThat(week.countByDay[LocalDate(2026, 6, 11)]).isEqualTo(1)
-        assertThat(week.countByDay[LocalDate(2026, 6, 13)]).isEqualTo(0)
-    }
-
-    @Test
-    fun `layoutMonthWeeks agrees with laying each row out on its own`() {
-        val events = listOf(
-            allDay(LocalDate(2026, 6, 10), LocalDate(2026, 6, 12), id = 1L),
-            timed(LocalDate(2026, 6, 18), 9, 10, id = 2L),
-        )
-        val weeks = layoutMonthWeeks(jun, DayOfWeek.MONDAY, events, zone)
-
-        weeks.forEach { row ->
-            assertThat(row).isEqualTo(layoutCalendarWeek(row.days, events, zone))
-        }
-    }
-
-    @Test
-    fun `instancesByDay puts all-day events first then orders by start`() {
-        val allDayEv = allDay(LocalDate(2026, 6, 10), id = 1L)
-        val late = timed(LocalDate(2026, 6, 10), 14, 15, id = 2L)
-        val early = timed(LocalDate(2026, 6, 10), 9, 10, id = 3L)
-
-        val byDay = instancesByDay(weekOf8th, listOf(late, early, allDayEv), zone)
-
-        assertThat(byDay.getValue(LocalDate(2026, 6, 10)).map { it.instanceId })
-            .containsExactly(1L, 3L, 2L)
-            .inOrder()
-    }
-
-    @Test
-    fun `instancesByDay repeats a multi-day event on every date it covers`() {
-        val ev = allDay(LocalDate(2026, 6, 10), LocalDate(2026, 6, 12))
-        val byDay = instancesByDay(weekOf8th, listOf(ev), zone)
-
-        assertThat(byDay.getValue(LocalDate(2026, 6, 9))).isEmpty()
-        assertThat(byDay.getValue(LocalDate(2026, 6, 10))).hasSize(1)
-        assertThat(byDay.getValue(LocalDate(2026, 6, 11))).hasSize(1)
-        assertThat(byDay.getValue(LocalDate(2026, 6, 12))).hasSize(1)
-        assertThat(byDay.getValue(LocalDate(2026, 6, 13))).isEmpty()
-    }
-
-    @Test
-    fun `instancesByDay covers every date in the grid, empty ones included`() {
-        val byDay = instancesByDay(weekOf8th, emptyList(), zone)
-        assertThat(byDay.keys).containsExactlyElementsIn(weekOf8th)
-        assertThat(byDay.values.flatten()).isEmpty()
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/widget/WidgetScaleTest.kt

@@ -1,89 +0,0 @@
-package de.jeanlucmakiola.calendula.widget
-
-import androidx.compose.ui.unit.DpSize
-import androidx.compose.ui.unit.dp
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-
-class WidgetScaleTest {
-
-    @Test
-    fun `the on-device calibration points map to their tiers`() {
-        // The two sizes measured on-device: the compact widget stays COMPACT (the
-        // baseline, unchanged), the full-width one steps up to LARGE — not XLARGE,
-        // which read as too big on a phone (#51).
-        assertThat(scaleFor(DpSize(222.dp, 270.dp))).isEqualTo(WidgetScale.COMPACT)
-        assertThat(scaleFor(DpSize(378.dp, 672.dp))).isEqualTo(WidgetScale.LARGE)
-    }
-
-    @Test
-    fun `a full-width widget at ordinary height still scales up`() {
-        // The regression the height cap used to cause: widening the widget without
-        // also making it unusually tall is *the* resize #51 reports, and it must
-        // reach the tier its width earned. Three cells tall is about 270dp.
-        assertThat(scaleFor(DpSize(378.dp, 270.dp))).isEqualTo(WidgetScale.LARGE)
-        assertThat(scaleFor(DpSize(300.dp, 270.dp))).isEqualTo(WidgetScale.REGULAR)
-        assertThat(scaleFor(DpSize(460.dp, 300.dp))).isEqualTo(WidgetScale.XLARGE)
-    }
-
-    @Test
-    fun `width buckets into the four tiers`() {
-        // Tall enough that the height cap never binds, isolating the width rule.
-        val h = 500.dp
-        assertThat(scaleFor(DpSize(180.dp, h))).isEqualTo(WidgetScale.COMPACT)
-        assertThat(scaleFor(DpSize(259.dp, h))).isEqualTo(WidgetScale.COMPACT)
-        assertThat(scaleFor(DpSize(260.dp, h))).isEqualTo(WidgetScale.REGULAR)
-        assertThat(scaleFor(DpSize(329.dp, h))).isEqualTo(WidgetScale.REGULAR)
-        assertThat(scaleFor(DpSize(330.dp, h))).isEqualTo(WidgetScale.LARGE)
-        assertThat(scaleFor(DpSize(419.dp, h))).isEqualTo(WidgetScale.LARGE)
-        assertThat(scaleFor(DpSize(420.dp, h))).isEqualTo(WidgetScale.XLARGE)
-        assertThat(scaleFor(DpSize(900.dp, h))).isEqualTo(WidgetScale.XLARGE)
-    }
-
-    @Test
-    fun `extra height never raises the tier`() {
-        // Height decides how many rows are visible, not how big they are: a tall,
-        // narrow widget wants more events, not bigger text.
-        assertThat(scaleFor(DpSize(222.dp, 200.dp))).isEqualTo(WidgetScale.COMPACT)
-        assertThat(scaleFor(DpSize(222.dp, 900.dp))).isEqualTo(WidgetScale.COMPACT)
-        assertThat(scaleFor(DpSize(300.dp, 900.dp))).isEqualTo(WidgetScale.REGULAR)
-    }
-
-    @Test
-    fun `only a genuinely squashed widget is stepped back down`() {
-        // Same (wide) width, shrinking height. The cap exists to stop oversized type
-        // surviving in a one- or two-row sliver — it must not fire at normal heights.
-        // Heights are gross; the cap works on height minus 60dp of chrome, so the
-        // LARGE floor is 190dp (130dp usable) and the REGULAR floor 130dp (70dp).
-        val wide = 378.dp
-        assertThat(scaleFor(DpSize(wide, 400.dp))).isEqualTo(WidgetScale.LARGE)
-        assertThat(scaleFor(DpSize(wide, 260.dp))).isEqualTo(WidgetScale.LARGE)
-        assertThat(scaleFor(DpSize(wide, 190.dp))).isEqualTo(WidgetScale.LARGE)
-        assertThat(scaleFor(DpSize(wide, 189.dp))).isEqualTo(WidgetScale.REGULAR)
-        assertThat(scaleFor(DpSize(wide, 130.dp))).isEqualTo(WidgetScale.REGULAR)
-        assertThat(scaleFor(DpSize(wide, 129.dp))).isEqualTo(WidgetScale.COMPACT)
-        // The provider's declared floor (minResizeWidth/Height = 110dp) is COMPACT.
-        assertThat(scaleFor(DpSize(110.dp, 110.dp))).isEqualTo(WidgetScale.COMPACT)
-    }
-
-    @Test
-    fun `the tier is monotonic in both axes`() {
-        // Growing a widget must never make its type smaller. Sweeps the whole
-        // plausible range rather than spot-checking, so a future threshold edit
-        // can't accidentally invert a step.
-        val widths = (110..900 step 7).map { it.dp }
-        val heights = (110..900 step 7).map { it.dp }
-        widths.forEach { w ->
-            heights.zipWithNext { shorter, taller ->
-                assertThat(scaleFor(DpSize(w, taller)))
-                    .isAtLeast(scaleFor(DpSize(w, shorter)))
-            }
-        }
-        heights.forEach { h ->
-            widths.zipWithNext { narrower, wider ->
-                assertThat(scaleFor(DpSize(wider, h)))
-                    .isAtLeast(scaleFor(DpSize(narrower, h)))
-            }
-        }
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaScaleTest.kt

@@ -1,121 +0,0 @@
-package de.jeanlucmakiola.calendula.widget.agenda
-
-import androidx.compose.ui.unit.DpSize
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.widget.WidgetScale
-import de.jeanlucmakiola.calendula.widget.scaleFor
-import org.junit.jupiter.api.Test
-
-class AgendaScaleTest {
-
-    // --- the "default size is unchanged" regression guard ---------------------
-
-    @Test
-    fun `every default placement width stays COMPACT`() {
-        // Ties the guarantee to the provider XML's declared 3-cell default rather
-        // than to one measured launcher: the whole band a default placement can
-        // land in must bucket to COMPACT, or a freshly placed widget silently
-        // changes appearance (#51). See AGENDA_DEFAULT_WIDTH_BAND.
-        val band = AGENDA_DEFAULT_WIDTH_BAND
-        var w = band.start
-        while (w <= band.endInclusive) {
-            assertThat(scaleFor(DpSize(w, 270.dp))).isEqualTo(WidgetScale.COMPACT)
-            w += 1.dp
-        }
-    }
-
-    @Test
-    fun `COMPACT metrics equal the widget's original constants`() {
-        // If this fails, a default-sized agenda widget no longer looks as it did.
-        val m = metricsFor(WidgetScale.COMPACT)
-        assertThat(m.title).isEqualTo(16.sp)
-        assertThat(m.dayHeader).isEqualTo(13.sp)
-        assertThat(m.eventTitle).isEqualTo(14.sp)
-        assertThat(m.eventTime).isEqualTo(12.sp)
-        assertThat(m.placeholder).isEqualTo(14.sp)
-        assertThat(m.message).isEqualTo(14.sp)
-        assertThat(m.stripeH).isEqualTo(36.dp)
-        assertThat(m.iconImage).isEqualTo(22.dp)
-        assertThat(m.iconBox).isEqualTo(40.dp)
-        assertThat(m.rowVPad).isEqualTo(4.dp)
-        assertThat(m.dayHeaderTopPad).isEqualTo(10.dp)
-    }
-
-    @Test
-    fun `the derived text indent matches the original hardcoded inset`() {
-        // TEXT_INDENT replaced a hardcoded 19dp; it must still resolve to 19dp or
-        // day headers and the placeholder line stop aligning with event titles.
-        assertThat(TEXT_INDENT).isEqualTo(19.dp)
-        assertThat(TEXT_INDENT).isEqualTo(ROW_H_PAD + STRIPE_WIDTH + STRIPE_GAP)
-    }
-
-    // --- the ramp ------------------------------------------------------------
-
-    @Test
-    fun `sizes are non-decreasing across the tiers`() {
-        val tiers = WidgetScale.entries.map(::metricsFor)
-
-        tiers.zipWithNext { small, big ->
-            assertThat(big.title.value).isAtLeast(small.title.value)
-            assertThat(big.dayHeader.value).isAtLeast(small.dayHeader.value)
-            assertThat(big.eventTitle.value).isAtLeast(small.eventTitle.value)
-            assertThat(big.eventTime.value).isAtLeast(small.eventTime.value)
-            assertThat(big.placeholder.value).isAtLeast(small.placeholder.value)
-            assertThat(big.message.value).isAtLeast(small.message.value)
-            assertThat(big.stripeH.value).isAtLeast(small.stripeH.value)
-            assertThat(big.iconImage.value).isAtLeast(small.iconImage.value)
-            assertThat(big.iconBox.value).isAtLeast(small.iconBox.value)
-            assertThat(big.rowVPad.value).isAtLeast(small.rowVPad.value)
-            assertThat(big.dayHeaderTopPad.value).isAtLeast(small.dayHeaderTopPad.value)
-        }
-    }
-
-    @Test
-    fun `the event title keeps its lead over the time line`() {
-        // The secondary line steps more slowly on purpose; if it ever caught up the
-        // row would lose its hierarchy.
-        WidgetScale.entries.map(::metricsFor).forEach { m ->
-            assertThat(m.eventTitle.value).isGreaterThan(m.eventTime.value)
-        }
-    }
-
-    @Test
-    fun `no tier grows type more than half again over the baseline`() {
-        // Guards against a future edit turning "more readable" into "absurd".
-        val base = metricsFor(WidgetScale.COMPACT)
-        val top = metricsFor(WidgetScale.XLARGE)
-        assertThat(top.title.value / base.title.value).isLessThan(1.5f)
-        assertThat(top.eventTitle.value / base.eventTitle.value).isLessThan(1.5f)
-    }
-
-    // --- font scale ----------------------------------------------------------
-
-    @Test
-    fun `the stripe tracks the system font scale`() {
-        // The stripe is Dp, the text beside it is sp: without this the two diverge
-        // at large accessibility font settings and the stripe under-runs the row.
-        val m = metricsFor(WidgetScale.COMPACT)
-        assertThat(m.scaledForFont(1f).stripeH).isEqualTo(36.dp)
-        assertThat(m.scaledForFont(1.3f).stripeH.value).isWithin(0.01f).of(46.8f)
-        assertThat(m.scaledForFont(0.85f).stripeH.value).isWithin(0.01f).of(30.6f)
-    }
-
-    @Test
-    fun `scaling for the default font scale changes nothing`() {
-        val m = metricsFor(WidgetScale.LARGE)
-        assertThat(m.scaledForFont(1f)).isSameInstanceAs(m)
-    }
-
-    @Test
-    fun `font scaling leaves the sp sizes alone`() {
-        // Glance already applies the font scale to sp; scaling them here too would
-        // double-count it.
-        val m = metricsFor(WidgetScale.REGULAR)
-        val scaled = m.scaledForFont(1.3f)
-        assertThat(scaled.title).isEqualTo(m.title)
-        assertThat(scaled.eventTitle).isEqualTo(m.eventTitle)
-        assertThat(scaled.rowVPad).isEqualTo(m.rowVPad)
-    }
-}

docs/ARCHITECTURE.md

@@ -99,30 +99,6 @@ on-device — see plan 03):
   UTC, so zones ahead of UTC can't leak an extra occurrence.
 - All-day events are normalised to UTC midnights with an exclusive end.
 
-### Event time zones
-
-`EventForm.timezone` is the zone its wall-clock times mean, and **null means
-"the device zone at save time"** — not "no zone". The data layer resolves it in
-`toWriteTimes` and always stamps a concrete `EVENT_TIMEZONE`, so an ordinary
-event behaves exactly as it did before the field existed.
-
-- A non-null value **pins** the event: it keeps tracking that zone's offset
-  across DST no matter where the device is. `toEditForm` only pins when the
-  stored zone differs from the device's, so the optional Time-zone field stays
-  hidden on ordinary events and reveals itself (via `populatedFields`) on
-  foreign-zone ones.
-- A pinned event is prefilled **in its own zone**, so the form shows the
-  wall-clock the event means rather than the device's rendering of it.
-- A zone change counts as a **time change** even with the wall-clock untouched
-  (same 09:00 elsewhere is a different instant), so `buildEventUpdateValues`
-  includes it in `timesChanged` and rewrites `DTSTART`.
-- **All-day events never carry a zone.** They're date-anchored — the UTC
-  midnights above are an anchor, not a location — so the field is withheld from
-  the form entirely and `toWriteTimes` forces `"UTC"` regardless.
-
-Still device-zone-relative, and knowingly so: `RRULE`'s `UNTIL` rendering and
-`AllDayReminderEncoding`'s offset (see its KDoc).
-
 ## Save conflicts
 
 No locking. `openForEdit` keeps an `EditSnapshot` — the prefilled form

fastlane/metadata/android/en-US/changelogs/21600.txt

@@ -1,37 +0,0 @@
-### Added
-- Give an event its own time zone. A new Time zone field (under "more fields" in
-  the event form) pins an event to a specific zone, so a call set for 8:00 AM in
-  New York stays 8:00 AM in New York wherever you open it, and keeps tracking
-  that zone across daylight-saving changes. The form shows the local equivalent
-  under the times, and the event's details keep your local time first with the
-  original noted beneath. Pick a zone from a searchable full-screen picker — by
-  city, IANA id, or abbreviation like "CEST". All-day events stay date-anchored
-  and carry no zone ([#31]).
-- Put the "jump to today" button in the toolbar. A new Today button in toolbar
-  setting (Settings → Appearance, off by default) swaps the floating corner
-  button for a permanent today icon in the top bar — always there, matching the
-  familiar calendar-app pattern. Leave it off to keep the floating button ([#60]).
-- Show the app as "Calendar" in your launcher. A new App name setting
-  (Settings → Appearance) switches the launcher label from "Calendula" to the
-  generic "Calendar" for anyone who prefers it — handy on launchers that can't
-  rename apps themselves. Only the launcher name changes; your home-screen icon
-  may move to a new spot after switching ([#44]).
-
-### Changed
-- Dates in the Month, Week and Day title bars now follow your language and
-  region instead of one hardcoded layout. Every date was rendered in a fixed
-  German-style order with a trailing dot on the day number, whatever your
-  settings: US English showed "Fri, 17. Jul 2026" where it should read
-  "Fri, Jul 17". The Agenda view already formatted correctly, so the two
-  disagreed about the same date. All four views now share one formatter, and the
-  day/month order, the separators and the ordinal all come from your locale —
-  so English-in-Germany reads "Fri, 17 Jul" and English-in-the-US "Fri, Jul 17",
-  each correct for where you are ([#60]).
-- The title bar drops the year while you're in the current one — "July" rather
-  than "July 2026". The year reappears the moment you page out of the current
-  year, which is when it tells you something you didn't already know.
-- The Week view's title now names the month instead of spelling out the day range.
-  "24. Jun – 31. Jun" restated the day numbers already printed in the column
-  headers right below it, in the widest string in the bar. A week that straddles
-  two months keeps the outgoing month until it is fully gone ([#60]).
-