docs(design): contact special-dates calendars + per-calendar multiple reminders

Capture the full design for surfacing contact birthdays/anniversaries/custom
dates as auto-updating local calendars (Codeberg #15), plus the #14
prerequisite (per-calendar multiple default reminders). One local calendar per
type to reuse existing per-calendar color/visibility/reminder infra; one-way
mirror with field-level managed events keyed on contact LOOKUP_KEY.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

CHANGELOG.md

@@ -5,49 +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
-- Set more than one default reminder per calendar. A calendar's default
-  reminders — and the global defaults under Settings → Notifications — can now
-  hold several lead times instead of just one, so new events can start with, say,
-  a reminder a week before *and* one on the day. The reminder pickers are now
-  multi-select; per-calendar overrides can still inherit the global default or
-  turn reminders off entirely. Thanks to @moonj for the suggestion ([#14]).
-- Widget headers now open the app. Tapping the month/year title on the month
-  widget opens the app on the month view, and tapping the "Upcoming" title on
-  the agenda widget opens it on your default view — so there's a one-tap way
-  back into the app that lands where you'd expect, instead of only through a day
-  or event. On the month widget, tapping anywhere on a day — not just the small
-  date number — now opens that day, and the "today" button snaps the grid back
-  to the current month in place. Thanks to @rgz46vic and @ptab for the
-  suggestions ([#18], [#20]).
-
-### Fixed
-- A tidy colour picker on CalDAV calendars. For calendars synced by a CalDAV
-  app (such as DAVx5), the event colour picker showed every colour the account
-  publishes — nearly 150 swatches in alphabetical order, many of them
-  duplicates or near-identical shades. The picker now shows only visually
-  distinct colours, arranged as a rainbow; near-duplicate shades and the
-  washed-out neutrals are folded away so no two swatches look alike. Picked
-  colours still sync exactly as before, and calendars with hand-picked
-  palettes (like Google's) are unaffected. Thanks to @ptab for the report
-  ([#22]).
-- Month widget arrows and "today" button work again. On release builds the
-  prev/next-month arrows and the jump-to-today control on the month widget did
-  nothing when tapped — code shrinking had stripped the tap handlers behind
-  them. They respond again. Thanks to @rgz46vic for the report ([#18]).
-- Disabled calendars no longer notify. Reminders for events in a calendar you
-  have disabled (Settings → Calendars) are now suppressed instead of still
-  popping up — matching how a disabled calendar's events already stay hidden
-  everywhere else in the app ([#17]).
-- Editing a single occurrence of a recurring event works again. Choosing **Only
-  this event** and saving a change to one event in a repeating series silently
-  did nothing — the change was rejected and the edit form simply reappeared with
-  nothing applied. The edited occurrence is now stored correctly, so the change
-  lands on just that one event and leaves the rest of the series untouched
-  ([#16]).
-
 ## [2.12.0] — 2026-06-28
 
 ### Added
@@ -772,9 +729,3 @@ automatically, with zero telemetry and no internet permission.
 [#10]: https://codeberg.org/jlmakiola/calendula/issues/10
 [#12]: https://codeberg.org/jlmakiola/calendula/issues/12
 [#13]: https://codeberg.org/jlmakiola/calendula/issues/13
-[#14]: https://codeberg.org/jlmakiola/calendula/issues/14
-[#16]: https://codeberg.org/jlmakiola/calendula/issues/16
-[#17]: https://codeberg.org/jlmakiola/calendula/issues/17
-[#18]: https://codeberg.org/jlmakiola/calendula/issues/18
-[#20]: https://codeberg.org/jlmakiola/calendula/issues/20
-[#22]: https://codeberg.org/jlmakiola/calendula/issues/22

app/build.gradle.kts

@@ -90,8 +90,6 @@ android {
 
     buildFeatures {
         compose = true
-        // BuildConfig.DEBUG gates the in-app debug ribbon (see DebugRibbon).
-        buildConfig = true
     }
 
     // Don't embed AGP's dependency-metadata block in the APK signing block. It's

app/proguard-rules.pro

@@ -16,18 +16,6 @@
 -keep class * extends androidx.room.RoomDatabase { *; }
 -dontwarn androidx.room.paging.**
 
-# Glance runs an @Composable's `actionRunCallback<T>()` by persisting the
-# callback's fully-qualified class name into the click PendingIntent, then
-# reflectively instantiating it (Class.forName(name).newInstance()) when the tap
-# fires. Under R8 full mode (AGP 9 default) these ActionCallback classes — only
-# ever referenced reflectively — get renamed or have their no-arg constructor
-# stripped, so the lookup fails silently and the tap does nothing. In the month
-# and agenda widgets that broke every run-callback control (the prev/next/today
-# month arrows and the agenda refresh) in release builds while actionStartActivity
-# taps, which ride a PendingIntent and need no reflection, kept working. Keep
-# every ActionCallback's name and constructor intact.
--keep class * implements androidx.glance.appwidget.action.ActionCallback { <init>(...); }
-
 # WorkManager instantiates an InputMerger reflectively (Class.newInstance) from
 # the fully-qualified class name persisted in the WorkSpec, so the class must
 # keep both its name and a no-arg constructor. Glance renders every widget

app/src/debug/res/values/colors.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Debug-only launcher-icon background. Production is slate (#5C6B7A); the
-    debug build paints the adaptive-icon background burnt orange instead, so the
-    debug icon reads at a glance as "not the real app" on the home screen. The
-    off-white foreground mark contrasts on both. See drawable/ic_launcher_background.
--->
-<resources>
-    <color name="ic_launcher_background">#FFB23B00</color>
-</resources>

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

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Debug-build resource overrides. Merged on top of src/main for the `debug`
-    build type only (release/releaseTest keep the production values), so the
-    debug app is unmistakable on the launcher: its own label, alongside the
-    real app thanks to the `.debug` applicationId suffix.
--->
-<resources>
-    <string name="app_name">Calendula Debug</string>
-</resources>

app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt

@@ -8,7 +8,6 @@ import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.getValue
@@ -30,7 +29,6 @@ import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.WidgetNavRequest
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
-import de.jeanlucmakiola.calendula.ui.common.DebugRibbon
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportActivity
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportDialog
 import de.jeanlucmakiola.calendula.ui.crash.submitCrashReport
@@ -103,24 +101,19 @@ class MainActivity : AppCompatActivity() {
                 darkTheme = darkTheme,
                 dynamicColor = settings.dynamicColor,
             ) {
-                Box(modifier = Modifier.fillMaxSize()) {
-                    CompositionLocalProvider(
-                        LocalUse24HourFormat provides use24Hour,
-                        LocalShowHourLines provides settings.showHourLines,
-                    ) {
-                        RootScreen(
-                            modifier = Modifier.fillMaxSize(),
-                            requestedDetailKey = requestedDetailKey,
-                            onDetailKeyConsumed = { requestedDetailKey = null },
-                            widgetNavRequest = requestedNav,
-                            onWidgetNavConsumed = { requestedNav = null },
-                            requestedImportUri = requestedImportUri,
-                            onImportConsumed = { requestedImportUri = null },
-                        )
-                    }
-                    // A persistent corner marker so a debug build is never
-                    // mistaken for the production app; compiled out of release.
-                    if (BuildConfig.DEBUG) DebugRibbon()
+                CompositionLocalProvider(
+                    LocalUse24HourFormat provides use24Hour,
+                    LocalShowHourLines provides settings.showHourLines,
+                ) {
+                    RootScreen(
+                        modifier = Modifier.fillMaxSize(),
+                        requestedDetailKey = requestedDetailKey,
+                        onDetailKeyConsumed = { requestedDetailKey = null },
+                        widgetNavRequest = requestedNav,
+                        onWidgetNavConsumed = { requestedNav = null },
+                        requestedImportUri = requestedImportUri,
+                        onImportConsumed = { requestedImportUri = null },
+                    )
                 }
                 pendingCrashReport?.let { report ->
                     CrashReportDialog(
@@ -193,12 +186,6 @@ class MainActivity : AppCompatActivity() {
         // An external date tap (launcher/clock) has no widget source, so it opens
         // the day view rooted over the default home view (OpenDate source = null).
         calendarTimeDateOrNull()?.let { return WidgetNavRequest.OpenDate(it.toString(), source = null) }
-        // A widget header tap: open a top-level view with no date drill-in. The
-        // empty string carried by [openViewIntent] means "the default home view".
-        if (hasExtra(EXTRA_OPEN_VIEW)) {
-            val name = getStringExtra(EXTRA_OPEN_VIEW).orEmpty()
-            return WidgetNavRequest.OpenView(CalendarView.entries.firstOrNull { it.name == name })
-        }
         val source = sourceViewOrNull()
         val eventId = getLongExtra(EXTRA_EVENT_ID, -1L)
         return when {
@@ -250,10 +237,6 @@ class MainActivity : AppCompatActivity() {
         private const val EXTRA_DATE_ISO = "de.jeanlucmakiola.calendula.extra.DATE_ISO"
         private const val EXTRA_CREATE = "de.jeanlucmakiola.calendula.extra.CREATE"
 
-        // A widget header tap asking to open a top-level view (no date drill-in).
-        // Its value is the target [CalendarView] name, or "" for the default view.
-        private const val EXTRA_OPEN_VIEW = "de.jeanlucmakiola.calendula.extra.OPEN_VIEW"
-
         // The [CalendarView] (by name) of the widget a launch came from. Roots the
         // in-app back stack in that view; absent for non-widget launches (reminders).
         private const val EXTRA_SOURCE_VIEW = "de.jeanlucmakiola.calendula.extra.SOURCE_VIEW"
@@ -317,19 +300,5 @@ class MainActivity : AppCompatActivity() {
                 putExtra(EXTRA_DATE_ISO, date.toString())
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
             }
-
-        /**
-         * Open the app on a top-level [view] with no date drill-in — a widget
-         * header tap. A null [view] opens the user's default home view (the agenda
-         * widget's "Upcoming" title); a concrete view roots there over the default
-         * home (the month widget's month/year title → [CalendarView.Month]). The
-         * per-view data URI keeps distinct headers' PendingIntents from collapsing.
-         */
-        fun openViewIntent(context: Context, view: CalendarView?): Intent =
-            Intent(context, MainActivity::class.java).apply {
-                data = "calendula://view/${view?.name ?: "default"}".toUri()
-                putExtra(EXTRA_OPEN_VIEW, view?.name ?: "")
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            }
     }
 }

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

@@ -20,7 +20,6 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventAttendee
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
-import de.jeanlucmakiola.calendula.domain.curatedForPicker
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventStatus
@@ -58,10 +57,7 @@ interface CalendarDataSource {
 
     /**
      * The event-colour palette the calendar's account publishes
-     * (`CalendarContract.Colors`, `TYPE_EVENT`), curated for display — deduped,
-     * thinned to visually distinct swatches when oversized (CalDAV adapters
-     * publish all ~147 CSS3 names, #22) and hue-sorted; see
-     * [curatedForPicker]. Empty when the
+     * (`CalendarContract.Colors`, `TYPE_EVENT`), sorted by key. Empty when the
      * account exposes no palette (most local calendars, some CalDAV) — the
      * signal that a custom colour can only be written as a raw `EVENT_COLOR`,
      * which a synced calendar may drop on its next sync.
@@ -424,7 +420,7 @@ class AndroidCalendarDataSource @Inject constructor(
             c.mapAll { EventColorOption(key = it.getString(0).orEmpty(), argb = it.getInt(1)) }
         }
             ?.filter { it.key.isNotEmpty() }
-            ?.curatedForPicker()
+            ?.sortedBy { it.key }
             ?: emptyList()
     }
 

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

@@ -118,14 +118,8 @@ internal fun buildEventUpdateValues(
  * provider clone the series row and apply these on top. Unlike the series
  * update there is no dirty check — the exception is a fresh row, so every
  * form-backed column is written (empty optionals as explicit NULLs, since the
- * clone starts from the parent's values).
- *
- * The occurrence's length travels as DURATION, never DTEND: the provider
- * rejects DTEND on an exception outright (`CalendarProvider2`:
- * "Exceptions can't overwrite dtend") and derives the instance end from
- * DTSTART + DURATION itself, clearing the inherited RRULE in the process. This
- * matches how AOSP Calendar/Etar write exceptions; sending DTEND is what made
- * "only this event" fail on-device (Codeberg #16).
+ * clone starts from the parent's values). An exception is a single event:
+ * DTEND, never RRULE/DURATION.
  */
 internal fun buildOccurrenceExceptionValues(
     form: EventForm,
@@ -137,7 +131,7 @@ internal fun buildOccurrenceExceptionValues(
     put(CalendarContract.Events.TITLE, form.title.trim())
     put(CalendarContract.Events.ALL_DAY, if (form.isAllDay) 1 else 0)
     put(CalendarContract.Events.DTSTART, times.dtStartMillis)
-    put(CalendarContract.Events.DURATION, times.toRfc2445Duration(form.isAllDay))
+    put(CalendarContract.Events.DTEND, times.dtEndMillis)
     put(CalendarContract.Events.EVENT_TIMEZONE, times.timezone)
     put(CalendarContract.Events.AVAILABILITY, form.availability.toProviderValue())
     put(CalendarContract.Events.ACCESS_LEVEL, form.accessLevel.toProviderValue())

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

@@ -12,8 +12,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.parseAgendaRange
 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 kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import kotlinx.datetime.DayOfWeek
@@ -204,34 +202,6 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[DEFAULT_VIEW_KEY] = view.name }
     }
 
-    /**
-     * Quick-switch button customisation (#24): the ordered full view list plus
-     * which views are enabled in the cycle. Stored comma-joined by enum name, a
-     * "!" prefix marking a disabled view (e.g. "Month,Week,!Day,Agenda"). Missing
-     * views are appended enabled and unknown names dropped, so a future view
-     * defaults into the cycle. An absent key means [QuickSwitchConfig.Default].
-     */
-    val quickSwitchConfig: Flow<QuickSwitchConfig> = store.data.map { prefs ->
-        parseQuickSwitch(prefs[QUICK_SWITCH_VIEWS_KEY])
-    }
-
-    suspend fun setQuickSwitchConfig(config: QuickSwitchConfig) {
-        store.edit { it[QUICK_SWITCH_VIEWS_KEY] = serializeQuickSwitch(config) }
-    }
-
-    /**
-     * Navigation-drawer view order (#24). Comma-joined enum names; missing views
-     * are appended in default order and unknown names dropped. Absent key means
-     * [IMPLEMENTED_VIEWS] (the historical fixed order).
-     */
-    val drawerViewOrder: Flow<List<CalendarView>> = store.data.map { prefs ->
-        parseViewOrder(prefs[DRAWER_VIEW_ORDER_KEY])
-    }
-
-    suspend fun setDrawerViewOrder(order: List<CalendarView>) {
-        store.edit { it[DRAWER_VIEW_ORDER_KEY] = order.joinToString(",") { view -> view.name } }
-    }
-
     /**
      * Optional event-form fields shown by default (the rest hide behind
      * "more fields"). Stored comma-joined by enum name: an absent key means
@@ -306,36 +276,35 @@ class SettingsPrefs @Inject constructor(
     }
 
     /**
-     * The default reminder lead times (minutes before start) prefilled on new
-     * **timed** events. The empty list = no default reminder — the prior
-     * behaviour, kept as the factory default so existing users aren't surprised by
-     * reminders they never asked for. Stored as a comma-joined list of minutes, or
-     * "none"/empty for no reminder (also the unset state). A legacy single value
-     * ("30") parses transparently to a one-element list. Per-calendar overrides in
-     * [perCalendarReminderOverride] take precedence; all-day events instead use
+     * The default reminder lead time (minutes before start) prefilled on new
+     * **timed** events. `null` = no default reminder — the prior behaviour, kept
+     * as the factory default so existing users aren't surprised by reminders they
+     * never asked for. Stored as a string so "none" is distinct from a numeric
+     * value (and from an unset key, which is also "none"). Per-calendar overrides
+     * in [perCalendarReminderOverride] take precedence; all-day events instead use
      * [defaultAllDayReminderMinutes]. Resolve with [resolveDefaultReminder].
      */
-    val defaultReminderMinutes: Flow<List<Int>> = store.data.map { prefs ->
-        prefs[DEFAULT_REMINDER_KEY].toReminderList()
+    val defaultReminderMinutes: Flow<Int?> = store.data.map { prefs ->
+        prefs[DEFAULT_REMINDER_KEY].toReminderMinutes()
     }
 
-    suspend fun setDefaultReminderMinutes(minutes: List<Int>) {
-        store.edit { it[DEFAULT_REMINDER_KEY] = minutes.toStoredReminders() }
+    suspend fun setDefaultReminderMinutes(minutes: Int?) {
+        store.edit { it[DEFAULT_REMINDER_KEY] = minutes?.toString() ?: NONE }
     }
 
     /**
-     * The default reminder lead times prefilled on new **all-day** events, in
+     * The default reminder lead time prefilled on new **all-day** events, in
      * minutes before the start of the day. All-day events want day-scale lead
      * times ("1 day before"), so they have their own default rather than reusing
-     * the timed one. Empty list = no default. Per-calendar overrides do **not**
-     * apply to all-day events — they always use this global value.
+     * the timed one. `null` = no default. Per-calendar overrides do **not** apply
+     * to all-day events — they always use this global value.
      */
-    val defaultAllDayReminderMinutes: Flow<List<Int>> = store.data.map { prefs ->
-        prefs[DEFAULT_ALLDAY_REMINDER_KEY].toReminderList()
+    val defaultAllDayReminderMinutes: Flow<Int?> = store.data.map { prefs ->
+        prefs[DEFAULT_ALLDAY_REMINDER_KEY].toReminderMinutes()
     }
 
-    suspend fun setDefaultAllDayReminderMinutes(minutes: List<Int>) {
-        store.edit { it[DEFAULT_ALLDAY_REMINDER_KEY] = minutes.toStoredReminders() }
+    suspend fun setDefaultAllDayReminderMinutes(minutes: Int?) {
+        store.edit { it[DEFAULT_ALLDAY_REMINDER_KEY] = minutes?.toString() ?: NONE }
     }
 
     /**
@@ -372,13 +341,13 @@ class SettingsPrefs @Inject constructor(
     /**
      * Per-calendar overrides of [defaultReminderMinutes] for **timed** events,
      * keyed by calendar id. A calendar **present** in the map overrides the global
-     * timed default for its new events: an **empty** list means "no reminder", a
-     * non-empty list means those lead times. A calendar **absent** from the map
-     * inherits the global default. Serialised as `id=value;id=value`, where a value
-     * is a comma-joined minute list or `none` for an explicit no-reminder override.
-     * (All-day events ignore this and use [defaultAllDayReminderMinutes].)
+     * timed default for its new events: a `null` value means "no reminder", an int
+     * means that lead time. A calendar **absent** from the map inherits the global
+     * default. Serialised as `id=value;id=value`, with `none` for an explicit
+     * no-reminder override. (All-day events ignore this and use
+     * [defaultAllDayReminderMinutes].)
      */
-    val perCalendarReminderOverride: Flow<Map<Long, List<Int>>> = store.data.map { prefs ->
+    val perCalendarReminderOverride: Flow<Map<Long, Int?>> = store.data.map { prefs ->
         parseReminderOverrides(prefs[CALENDAR_REMINDER_OVERRIDE_KEY])
     }
 
@@ -395,7 +364,7 @@ class SettingsPrefs @Inject constructor(
      * events, with the same semantics as [perCalendarReminderOverride] (absent =
      * inherit the global all-day default; present null = no reminder).
      */
-    val perCalendarAllDayReminderOverride: Flow<Map<Long, List<Int>>> = store.data.map { prefs ->
+    val perCalendarAllDayReminderOverride: Flow<Map<Long, Int?>> = store.data.map { prefs ->
         parseReminderOverrides(prefs[CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY])
     }
 
@@ -464,40 +433,6 @@ class SettingsPrefs @Inject constructor(
             .toSet()
     }
 
-    /** Parse a plain comma-joined view order, completed to every implemented view. */
-    private fun parseViewOrder(stored: String?): List<CalendarView> =
-        completeViewOrder(
-            stored?.split(',').orEmpty()
-                .mapNotNull { name -> CalendarView.entries.firstOrNull { it.name == name.trim() } },
-        )
-
-    /** Parse the quick-switch config; "!"-prefixed names are disabled. */
-    private fun parseQuickSwitch(stored: String?): QuickSwitchConfig {
-        if (stored == null) return QuickSwitchConfig.Default
-        val parsed = stored.split(',').mapNotNull { raw ->
-            val token = raw.trim()
-            val disabled = token.startsWith("!")
-            val name = if (disabled) token.drop(1) else token
-            CalendarView.entries.firstOrNull { it.name == name }?.let { it to disabled }
-        }
-        val order = completeViewOrder(parsed.map { it.first })
-        // Only views explicitly stored disabled are excluded; anything appended
-        // (a view added in a later release) defaults into the cycle.
-        val disabled = parsed.filter { it.second }.map { it.first }.toSet()
-        return QuickSwitchConfig(order, order.filterNot { it in disabled }.toSet())
-    }
-
-    private fun serializeQuickSwitch(config: QuickSwitchConfig): String =
-        completeViewOrder(config.order).joinToString(",") { view ->
-            if (view in config.enabled) view.name else "!${view.name}"
-        }
-
-    /** Keep the given order (de-duplicated), then append any views it omits. */
-    private fun completeViewOrder(seen: List<CalendarView>): List<CalendarView> {
-        val ordered = seen.distinct()
-        return ordered + IMPLEMENTED_VIEWS.filterNot { it in ordered }
-    }
-
     companion object {
         internal val THEME_MODE_KEY = stringPreferencesKey("theme_mode")
         internal val DYNAMIC_COLOR_KEY = booleanPreferencesKey("dynamic_color")
@@ -510,8 +445,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 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")
         internal val FORM_FIELDS_KEY = stringPreferencesKey("event_form_default_fields")
         internal val AUTOFOCUS_EVENT_TITLE_KEY = booleanPreferencesKey("autofocus_event_title")
         internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")
@@ -562,46 +495,43 @@ sealed interface CalendarReminderOverride {
     data object Inherit : CalendarReminderOverride
     /** Explicit "no reminder" for this calendar, regardless of the global default. */
     data object None : CalendarReminderOverride
-    /** Specific lead times in minutes before the event start (non-empty). */
-    data class Minutes(val minutes: List<Int>) : CalendarReminderOverride
+    /** A specific lead time in minutes before the event start. */
+    data class Minutes(val minutes: Int) : CalendarReminderOverride
 }
 
 /**
- * The lead times to prefill on a new event: the matching per-calendar override
+ * The lead time to prefill on a new event: the matching per-calendar override
  * if [calendarId] has one for this event kind, otherwise the global default for
  * that kind. All-day events consult [allDayOverrides] / [allDayGlobal]; timed
- * events consult [timedOverrides] / [timedGlobal]. The empty list = no reminder.
- * Pure so it can be unit-tested.
+ * events consult [timedOverrides] / [timedGlobal]. `null` = no reminder. Pure so
+ * it can be unit-tested.
  */
 fun resolveDefaultReminder(
-    timedGlobal: List<Int>,
-    allDayGlobal: List<Int>,
-    timedOverrides: Map<Long, List<Int>>,
-    allDayOverrides: Map<Long, List<Int>>,
+    timedGlobal: Int?,
+    allDayGlobal: Int?,
+    timedOverrides: Map<Long, Int?>,
+    allDayOverrides: Map<Long, Int?>,
     calendarId: Long?,
     isAllDay: Boolean,
-): List<Int> {
+): Int? {
     val overrides = if (isAllDay) allDayOverrides else timedOverrides
     val global = if (isAllDay) allDayGlobal else timedGlobal
     return if (calendarId != null && overrides.containsKey(calendarId)) {
-        overrides.getValue(calendarId)
+        overrides[calendarId]
     } else {
         global
     }
 }
 
-/**
- * Apply a [CalendarReminderOverride] to an override map ([Inherit] removes the
- * key; [None] and an empty [Minutes] both store the empty list).
- */
-private fun MutableMap<Long, List<Int>>.applyOverride(
+/** Apply a [CalendarReminderOverride] to an override map ([Inherit] removes the key). */
+private fun MutableMap<Long, Int?>.applyOverride(
     calendarId: Long,
     override: CalendarReminderOverride,
 ) {
     when (override) {
         CalendarReminderOverride.Inherit -> remove(calendarId)
-        CalendarReminderOverride.None -> put(calendarId, emptyList())
-        is CalendarReminderOverride.Minutes -> put(calendarId, override.minutes.normalizeReminders())
+        CalendarReminderOverride.None -> put(calendarId, null)
+        is CalendarReminderOverride.Minutes -> put(calendarId, override.minutes)
     }
 }
 
@@ -627,36 +557,24 @@ private fun parseWeekStart(stored: String?): WeekStartPref = when (stored) {
 private const val NONE = "none"
 private const val ENTRY_SEP = ";"
 private const val KEY_VALUE_SEP = "="
-private const val LIST_SEP = ","
 
-/** Distinct, ascending lead times — the canonical form stored and resolved. */
-private fun List<Int>.normalizeReminders(): List<Int> = distinct().sorted()
-
-/**
- * Parse a stored reminder value into lead times. `null`/empty/"none" → empty
- * list; a comma-joined list → its minutes; a legacy single value ("30") → a
- * one-element list. Non-numeric parts are dropped defensively.
- */
-private fun String?.toReminderList(): List<Int> = when {
-    this == null || isEmpty() || this == NONE -> emptyList()
-    else -> split(LIST_SEP).mapNotNull { it.trim().toIntOrNull() }.normalizeReminders()
+private fun String?.toReminderMinutes(): Int? = when (this) {
+    null, "", NONE -> null
+    else -> toIntOrNull()
 }
 
-/** Serialise lead times for storage: "none" when empty, else comma-joined. */
-private fun List<Int>.toStoredReminders(): String =
-    if (isEmpty()) NONE else normalizeReminders().joinToString(LIST_SEP) { it.toString() }
-
-private fun parseReminderOverrides(stored: String?): Map<Long, List<Int>> {
+private fun parseReminderOverrides(stored: String?): Map<Long, Int?> {
     if (stored.isNullOrBlank()) return emptyMap()
     return stored.split(ENTRY_SEP).mapNotNull { entry ->
         val parts = entry.split(KEY_VALUE_SEP).takeIf { it.size == 2 } ?: return@mapNotNull null
         val id = parts[0].toLongOrNull() ?: return@mapNotNull null
-        id to parts[1].toReminderList()
+        val value = if (parts[1] == NONE) null else parts[1].toIntOrNull() ?: return@mapNotNull null
+        id to value
     }.toMap()
 }
 
-private fun serializeReminderOverrides(map: Map<Long, List<Int>>): String =
-    map.entries.joinToString(ENTRY_SEP) { (id, minutes) -> "$id$KEY_VALUE_SEP${minutes.toStoredReminders()}" }
+private fun serializeReminderOverrides(map: Map<Long, Int?>): String =
+    map.entries.joinToString(ENTRY_SEP) { (id, minutes) -> "$id$KEY_VALUE_SEP${minutes ?: NONE}" }
 
 private inline fun <reified E : Enum<E>> String?.toEnum(default: E): E =
     this?.let { stored -> enumValues<E>().firstOrNull { it.name == stored } } ?: default

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/EventReminderReceiver.kt

@@ -8,7 +8,6 @@ import android.content.pm.PackageManager
 import android.provider.CalendarContract
 import androidx.core.content.ContextCompat
 import dagger.hilt.android.AndroidEntryPoint
-import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -17,17 +16,6 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
-/**
- * The due alerts that should actually surface as notifications: everything
- * except alerts whose calendar the user has disabled in-app (mirroring the
- * event filtering in CalendarRepositoryImpl). The caller still marks the full
- * due set fired, so suppressed alerts are not re-broadcast by the provider.
- */
-internal fun postableAlerts(
-    due: List<ReminderAlert>,
-    disabledCalendarIds: Set<Long>,
-): List<ReminderAlert> = due.filterNot { it.calendarId in disabledCalendarIds }
-
 /**
  * Becomes the app that turns the calendar provider's reminder alarms into
  * visible notifications (the Etar model — the provider broadcasts
@@ -44,7 +32,6 @@ class EventReminderReceiver : BroadcastReceiver() {
     @Inject lateinit var alertStore: ReminderAlertStore
     @Inject lateinit var notifier: ReminderNotifier
     @Inject lateinit var settingsPrefs: SettingsPrefs
-    @Inject lateinit var calendarPrefs: CalendarPrefs
 
     override fun onReceive(context: Context, intent: Intent) {
         if (intent.action != CalendarContract.ACTION_EVENT_REMINDER) return
@@ -59,11 +46,7 @@ class EventReminderReceiver : BroadcastReceiver() {
                 if (settingsPrefs.remindersEnabled.first()) {
                     val now = System.currentTimeMillis()
                     val due = alertStore.dueAlerts(now)
-                    val disabled = calendarPrefs.disabledCalendarIds.first()
-                    // Suppress reminders for disabled calendars, but still mark
-                    // every due alert fired so the provider stops re-broadcasting
-                    // the suppressed ones.
-                    postableAlerts(due, disabled).forEach { notifier.post(it) }
+                    due.forEach { notifier.post(it) }
                     alertStore.markFired(due.map { it.alertId }, now)
                 }
             } finally {

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderActionReceiver.kt

@@ -75,7 +75,6 @@ class ReminderActionReceiver : BroadcastReceiver() {
 
         private const val EXTRA_ALERT_ID = "alert_id"
         private const val EXTRA_EVENT_ID = "event_id"
-        private const val EXTRA_CALENDAR_ID = "calendar_id"
         private const val EXTRA_BEGIN = "begin"
         private const val EXTRA_END = "end"
         private const val EXTRA_TITLE = "title"
@@ -88,7 +87,6 @@ class ReminderActionReceiver : BroadcastReceiver() {
                 this.action = action
                 putExtra(EXTRA_ALERT_ID, alert.alertId)
                 putExtra(EXTRA_EVENT_ID, alert.eventId)
-                putExtra(EXTRA_CALENDAR_ID, alert.calendarId)
                 putExtra(EXTRA_BEGIN, alert.beginMillis)
                 putExtra(EXTRA_END, alert.endMillis)
                 putExtra(EXTRA_TITLE, alert.title)
@@ -115,7 +113,6 @@ class ReminderActionReceiver : BroadcastReceiver() {
             return ReminderAlert(
                 alertId = intent.getLongExtra(EXTRA_ALERT_ID, 0L),
                 eventId = intent.getLongExtra(EXTRA_EVENT_ID, 0L),
-                calendarId = intent.getLongExtra(EXTRA_CALENDAR_ID, 0L),
                 beginMillis = intent.getLongExtra(EXTRA_BEGIN, 0L),
                 endMillis = intent.getLongExtra(EXTRA_END, 0L),
                 title = intent.getStringExtra(EXTRA_TITLE).orEmpty(),

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderAlertStore.kt

@@ -16,7 +16,6 @@ import javax.inject.Singleton
 data class ReminderAlert(
     val alertId: Long,
     val eventId: Long,
-    val calendarId: Long,
     val beginMillis: Long,
     val endMillis: Long,
     /** Raw event title; may be blank — the notifier substitutes "(no title)". */
@@ -67,12 +66,11 @@ class AndroidReminderAlertStore @Inject constructor(
                     ReminderAlert(
                         alertId = c.getLong(0),
                         eventId = c.getLong(1),
-                        calendarId = c.getLong(2),
-                        beginMillis = c.getLong(3),
-                        endMillis = c.getLong(4),
-                        title = c.getString(5).orEmpty(),
-                        location = c.getString(6)?.takeIf { it.isNotBlank() },
-                        isAllDay = c.getInt(7) == 1,
+                        beginMillis = c.getLong(2),
+                        endMillis = c.getLong(3),
+                        title = c.getString(4).orEmpty(),
+                        location = c.getString(5)?.takeIf { it.isNotBlank() },
+                        isAllDay = c.getInt(6) == 1,
                     ),
                 )
             }
@@ -104,7 +102,6 @@ class AndroidReminderAlertStore @Inject constructor(
         val PROJECTION = arrayOf(
             CalendarContract.CalendarAlerts._ID,
             CalendarContract.CalendarAlerts.EVENT_ID,
-            CalendarContract.CalendarAlerts.CALENDAR_ID,
             CalendarContract.CalendarAlerts.BEGIN,
             CalendarContract.CalendarAlerts.END,
             CalendarContract.CalendarAlerts.TITLE,

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

@@ -1,179 +0,0 @@
-package de.jeanlucmakiola.calendula.domain
-
-import kotlin.math.abs
-import kotlin.math.atan2
-import kotlin.math.cbrt
-import kotlin.math.hypot
-import kotlin.math.pow
-import kotlin.math.roundToInt
-import kotlin.math.sqrt
-
-/**
- * Curates an account's published event palette for the colour picker.
- *
- * Sync adapters differ wildly in what they publish: Google exposes a
- * hand-picked two-dozen set, while CalDAV adapters (DAVx5) dump all ~147 CSS3
- * named colours — including exact-value aliases (aqua/cyan, the gray/grey
- * spelling pairs) and dozens of visually indistinguishable whites and grays
- * (#22).
- *
- * Crucially, curation runs against the colour the picker actually *paints*, not
- * the raw provider value. The picker softens every swatch through [pastelArgb]:
- * it pins lightness to a constant and caps saturation, so the raw palette's
- * lightness axis is invisible on screen. Two raw colours that look different —
- * a navy and a mid blue — paint as one swatch, and every neutral (black, the
- * grays, white) paints as the same pale tint. Judging distinctness in raw
- * space, as before, left near-identical painted swatches and stranded the
- * neutrals as a run of look-alike "pinks" at the end of the grid.
- *
- * Three steps, all in painted space:
- *  1. Collapse swatches that paint identically to one (alphabetically-first key
- *     wins, deterministically) — this folds aliases, dark/light shades of a
- *     hue, and all the neutrals together.
- *  2. Oversized palettes (> [CURATION_TRIGGER_SIZE]) drop the washed-out
- *     neutral-origin tints (painted chroma < [PASTEL_CHROMA_FLOOR]) and are
- *     then thinned to visually distinct colours: most vivid first, a colour is
- *     kept only when at least [MIN_DELTA_E] (CIE76, painted Lab) from every
- *     colour already kept. Small palettes are already curated by their adapter
- *     and pass through whole.
- *  3. The survivors are ordered like a rainbow — continuously by painted hue —
- *     with the wheel cut at its single widest empty gap so the one unavoidable
- *     seam lands in dead space and no hue family is torn across both ends.
- *
- * Every surviving option keeps its provider [EventColorOption.key], so a pick
- * still round-trips through sync.
- */
-fun List<EventColorOption>.curatedForPicker(): List<EventColorOption> {
-    val painted = sortedBy { it.key }
-        .distinctBy { pastelArgb(it.argb) }
-        .map { it to Lab.of(pastelArgb(it.argb)) }
-    val kept = if (painted.size <= CURATION_TRIGGER_SIZE) {
-        painted
-    } else {
-        thin(painted.filter { (_, lab) -> lab.chroma >= PASTEL_CHROMA_FLOOR })
-    }
-    return orderAroundWheel(kept).map { (option, _) -> option }
-}
-
-/**
- * Orders swatches continuously around the (painted) hue wheel, then cuts the
- * circle at its widest angular gap so the single seam lands in empty space
- * instead of mid-family. Saturation breaks ties, vivid first.
- */
-private fun orderAroundWheel(
-    swatches: List<Pair<EventColorOption, Lab>>,
-): List<Pair<EventColorOption, Lab>> {
-    if (swatches.size < 2) return swatches
-    val byHue = swatches.sortedWith(
-        compareBy({ (_, lab) -> lab.hue }, { (_, lab) -> -lab.chroma }),
-    )
-    // Split the wheel after the largest empty arc between neighbouring hues;
-    // the default is the wrap gap (last hue back round to the first), i.e. the
-    // familiar 0→360 order, and we only rotate away from it for a wider void.
-    var cutAfter = byHue.lastIndex
-    var widestGap = 360.0 - byHue.last().second.hue + byHue.first().second.hue
-    for (i in 0 until byHue.lastIndex) {
-        val gap = byHue[i + 1].second.hue - byHue[i].second.hue
-        if (gap > widestGap) {
-            widestGap = gap
-            cutAfter = i
-        }
-    }
-    return byHue.subList(cutAfter + 1, byHue.size) + byHue.subList(0, cutAfter + 1)
-}
-
-/** Greedy max-distance filter: vivid colours stake out clusters first. */
-private fun thin(
-    swatches: List<Pair<EventColorOption, Lab>>,
-): List<Pair<EventColorOption, Lab>> {
-    val byVividness = swatches
-        .sortedWith(compareByDescending<Pair<EventColorOption, Lab>> { it.second.chroma }.thenBy { it.first.key })
-    val kept = mutableListOf<Pair<EventColorOption, Lab>>()
-    for (candidate in byVividness) {
-        if (kept.none { it.second.deltaE(candidate.second) < MIN_DELTA_E }) kept += candidate
-    }
-    return kept
-}
-
-/**
- * The softening the colour picker paints over every swatch (mirrored by
- * ui/pastelize, which wraps this): keep the hue, scale and clamp saturation
- * into a gentle band, and pin value to a constant so nothing screams and
- * everything reads on the surface. Value is fixed here so curation is
- * theme-independent — only hue and saturation distinguish painted swatches.
- */
-fun pastelArgb(rawArgb: Int): Int {
-    val r = ((rawArgb shr 16) and 0xFF) / 255f
-    val g = ((rawArgb shr 8) and 0xFF) / 255f
-    val b = (rawArgb and 0xFF) / 255f
-    val max = maxOf(r, g, b)
-    val min = minOf(r, g, b)
-    val delta = max - min
-    val hue = when {
-        delta == 0f -> 0f
-        max == r -> 60f * (((g - b) / delta) % 6f)
-        max == g -> 60f * (((b - r) / delta) + 2f)
-        else -> 60f * (((r - g) / delta) + 4f)
-    }.let { if (it < 0f) it + 360f else it }
-    val sat = (if (max == 0f) 0f else delta / max) * 0.6f
-    val s = sat.coerceIn(0.25f, 0.65f)
-    val v = PASTEL_VALUE
-    val c = v * s
-    val x = c * (1f - abs((hue / 60f) % 2f - 1f))
-    val m = v - c
-    val (rr, gg, bb) = when {
-        hue < 60f -> Triple(c, x, 0f)
-        hue < 120f -> Triple(x, c, 0f)
-        hue < 180f -> Triple(0f, c, x)
-        hue < 240f -> Triple(0f, x, c)
-        hue < 300f -> Triple(x, 0f, c)
-        else -> Triple(c, 0f, x)
-    }
-    fun channel(value: Float) = ((value + m) * 255f).roundToInt().coerceIn(0, 255)
-    return (0xFF shl 24) or (channel(rr) shl 16) or (channel(gg) shl 8) or channel(bb)
-}
-
-/** Reference lightness for curation; the picker paints at this on dark surfaces. */
-private const val PASTEL_VALUE = 0.82f
-
-/** Palettes at most this big skip the thinning (Google's ~26 pass through). */
-private const val CURATION_TRIGGER_SIZE = 36
-
-/** Minimum CIE76 ΔE between surviving painted swatches. */
-private const val MIN_DELTA_E = 13.0
-
-/**
- * Painted-chroma floor for oversized palettes: below this a swatch is a washed-
- * out tint — the neutrals and near-whites the saturation clamp muddies — so it
- * is dropped rather than shown as pale filler.
- */
-private const val PASTEL_CHROMA_FLOOR = 22.0
-
-/** CIE Lab (D65) — the space where Euclidean distance ≈ perceived difference. */
-private class Lab(val l: Double, val a: Double, val b: Double) {
-    val chroma: Double get() = hypot(a, b)
-
-    /** Hue angle in degrees, 0–360, around the Lab a-b plane. */
-    val hue: Double get() = (Math.toDegrees(atan2(b, a)) + 360.0) % 360.0
-
-    fun deltaE(other: Lab): Double =
-        sqrt((l - other.l).pow(2) + (a - other.a).pow(2) + (b - other.b).pow(2))
-
-    companion object {
-        fun of(argb: Int): Lab {
-            fun linear(shift: Int): Double {
-                val c = ((argb shr shift) and 0xFF) / 255.0
-                return if (c <= 0.04045) c / 12.92 else ((c + 0.055) / 1.055).pow(2.4)
-            }
-            val r = linear(16)
-            val g = linear(8)
-            val b = linear(0)
-            val x = (0.4124 * r + 0.3576 * g + 0.1805 * b) / 0.95047
-            val y = 0.2126 * r + 0.7152 * g + 0.0722 * b
-            val z = (0.0193 * r + 0.1192 * g + 0.9505 * b) / 1.08883
-            fun f(t: Double) = if (t > 0.008856) cbrt(t) else 7.787 * t + 16.0 / 116.0
-            val fy = f(y)
-            return Lab(116 * fy - 16, 500 * (f(x) - fy), 200 * (fy - f(z)))
-        }
-    }
-}

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

@@ -79,11 +79,6 @@ fun CalendarHost(
     // correcting it. Brief blank first frame, matching the onboarding gate above.
     val defaultView = viewModel.defaultView.collectAsStateWithLifecycle().value ?: return
 
-    // View customisation (#24): the quick-switch cycle and drawer order. Both have
-    // 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
-
     var viewStack by rememberSaveable(stateSaver = viewStackSaver) {
         mutableStateOf(listOf(defaultView))
     }
@@ -217,17 +212,6 @@ fun CalendarHost(
                 detailKey = key
                 onWidgetNavConsumed()
             }
-            is WidgetNavRequest.OpenView -> {
-                // A widget header tap: land on a top-level view with no date
-                // drill-in. Reveal it by dropping any covering overlay, then root
-                // the stack on the target (null → the default home) over the
-                // default home — so backing out returns to the default, then exits.
-                dismissCoveringOverlays()
-                createDateIso = null
-                pendingDayIso = null
-                viewStack = viewBaseStack(defaultView, req.view ?: defaultView)
-                onWidgetNavConsumed()
-            }
             is WidgetNavRequest.Create -> {
                 // External "new event" entries (QS tile / launcher shortcut /
                 // widget) must land on top of whatever is open — the form overlay
@@ -276,8 +260,6 @@ fun CalendarHost(
                     onOpenSettings = onOpenSettings,
                     onOpenSearch = onOpenSearch,
                     onCreateEvent = onCreateEvent,
-                    quickSwitchViews = quickSwitchViews,
-                    drawerViewOrder = drawerViewOrder,
                 )
                 CalendarView.Day -> DayScreen(
                     selectedView = currentView,
@@ -287,8 +269,6 @@ fun CalendarHost(
                     onOpenSearch = onOpenSearch,
                     onCreateEvent = onCreateEvent,
                     initialDateIso = pendingDayIso,
-                    quickSwitchViews = quickSwitchViews,
-                    drawerViewOrder = drawerViewOrder,
                 )
                 CalendarView.Month -> MonthScreen(
                     selectedView = currentView,
@@ -297,8 +277,6 @@ fun CalendarHost(
                     onOpenSettings = onOpenSettings,
                     onOpenSearch = onOpenSearch,
                     onCreateEvent = onCreateEvent,
-                    quickSwitchViews = quickSwitchViews,
-                    drawerViewOrder = drawerViewOrder,
                 )
                 CalendarView.Agenda -> AgendaScreen(
                     selectedView = currentView,
@@ -307,8 +285,6 @@ fun CalendarHost(
                     onOpenSettings = onOpenSettings,
                     onOpenSearch = onOpenSearch,
                     onCreateEvent = onCreateEvent,
-                    quickSwitchViews = quickSwitchViews,
-                    drawerViewOrder = drawerViewOrder,
                 )
             }
         }

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

@@ -5,10 +5,8 @@ import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
-import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import javax.inject.Inject
 
@@ -28,21 +26,4 @@ class CalendarHostViewModel @Inject constructor(
         started = SharingStarted.WhileSubscribed(5_000L),
         initialValue = null,
     )
-
-    /** Views the top-bar quick-switch pill cycles through, in the user's order (#24). */
-    val quickSwitchViews: StateFlow<List<CalendarView>> = prefs.quickSwitchConfig
-        .map { it.cycle }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = IMPLEMENTED_VIEWS,
-        )
-
-    /** Order of the views in the navigation drawer (#24); every view always shown. */
-    val drawerViewOrder: StateFlow<List<CalendarView>> = prefs.drawerViewOrder
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = IMPLEMENTED_VIEWS,
-        )
 }

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

@@ -31,13 +31,4 @@ sealed interface WidgetNavRequest {
 
     /** Open the create-event form prefilled for [dateIso] (today when null). */
     data class Create(val dateIso: String?) : WidgetNavRequest
-
-    /**
-     * Open the app rooted on a top-level [view] with no date drill-in — a widget
-     * header tap. A null [view] means "the user's default home view" (the agenda
-     * widget's "Upcoming" title, issue #20); a concrete view roots there over the
-     * default home (the month widget's month/year title → [CalendarView.Month],
-     * issue #18), so backing out returns to the default view, then exits.
-     */
-    data class OpenView(val view: CalendarView?) : WidgetNavRequest
 }

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

@@ -64,7 +64,6 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 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.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.GroupedRow
 import de.jeanlucmakiola.calendula.ui.common.Position
@@ -97,8 +96,6 @@ fun AgendaScreen(
     onOpenSettings: () -> Unit,
     onOpenSearch: () -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
-    quickSwitchViews: List<CalendarView> = IMPLEMENTED_VIEWS,
-    drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
     modifier: Modifier = Modifier,
     viewModel: AgendaViewModel = hiltViewModel(),
 ) {
@@ -123,7 +120,6 @@ fun AgendaScreen(
             CalendarDrawer(
                 currentView = selectedView,
                 currentDate = anchor,
-                viewOrder = drawerViewOrder,
                 onSelectView = { view ->
                     onSelectView(view)
                     scope.launch { drawerState.close() }
@@ -144,7 +140,7 @@ fun AgendaScreen(
             topBar = {
                 AgendaTopBar(
                     selectedView = selectedView,
-                    onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
+                    onCycleView = { onSelectView(selectedView.next()) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
                     scrollBehavior = scrollBehavior,

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

@@ -15,21 +15,17 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.domain.pastelArgb
 
 /**
  * Soften a raw calendar color toward a pastel that fits the active theme.
  *  - Keeps the hue (so users still recognise their calendars)
  *  - Caps saturation so harsh provider colors stop screaming
  *  - Pins value/brightness to a band that reads on both light and dark surfaces
- *
- * The hue/saturation shaping lives in [pastelArgb] so the event-colour picker's
- * curation reasons about the exact colour painted here (#22); this only picks
- * the theme's brightness.
  */
 fun pastelize(rawArgb: Int, dark: Boolean): Color {
     val hsv = FloatArray(3)
-    android.graphics.Color.colorToHSV(pastelArgb(rawArgb), hsv)
+    android.graphics.Color.colorToHSV(rawArgb, hsv)
+    hsv[1] = (hsv[1] * 0.6f).coerceIn(0.25f, 0.65f)
     hsv[2] = if (dark) 0.82f else 0.72f
     return Color(android.graphics.Color.HSVToColor(hsv))
 }

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

@@ -59,7 +59,6 @@ fun CalendarDrawer(
     onSelectView: (CalendarView) -> Unit,
     onJumpToDate: (LocalDate) -> Unit,
     onSettings: () -> Unit,
-    viewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
 ) {
     var showDatePicker by remember { mutableStateOf(false) }
 
@@ -74,10 +73,10 @@ fun CalendarDrawer(
             DrawerHeader()
 
             DrawerSectionHeader(stringResource(R.string.view_section))
-            viewOrder.forEachIndexed { index, view ->
+            IMPLEMENTED_VIEWS.forEachIndexed { index, view ->
                 GroupedRow(
                     title = stringResource(view.labelRes),
-                    position = positionOf(index, viewOrder.size),
+                    position = positionOf(index, IMPLEMENTED_VIEWS.size),
                     selected = view == currentView,
                     minHeight = 56.dp,
                     leading = { Icon(view.icon, contentDescription = null) },

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

@@ -45,39 +45,11 @@ val IMPLEMENTED_VIEWS: List<CalendarView> =
 
 /** Next view in [available], wrapping around. Falls back to Month if absent. */
 fun CalendarView.next(available: List<CalendarView> = IMPLEMENTED_VIEWS): CalendarView {
-    if (available.isEmpty()) return this
     val i = available.indexOf(this)
-    if (i < 0) return available.first()
+    if (i < 0) return available.firstOrNull() ?: CalendarView.Month
     return available[(i + 1) % available.size]
 }
 
-/**
- * The user's customisation of the top-bar quick-switch button (#24): which views
- * it cycles through ([enabled]) and in what [order]. [order] always lists every
- * implemented view — the settings screen reorders the whole set — while [cycle]
- * is the subset the pill actually steps through, in [order]. The navigation
- * drawer keeps its own separate order and always lists every view, so a view
- * disabled here stays reachable there.
- */
-data class QuickSwitchConfig(
-    val order: List<CalendarView>,
-    val enabled: Set<CalendarView>,
-) {
-    /** Views the pill steps through, in [order]. */
-    val cycle: List<CalendarView> get() = order.filter { it in enabled }
-
-    companion object {
-        /** All views, in default order, all enabled. */
-        val Default = QuickSwitchConfig(IMPLEMENTED_VIEWS, IMPLEMENTED_VIEWS.toSet())
-
-        /**
-         * Fewest views that keep the switch meaningful — a "switch" needs at
-         * least two targets, so the settings screen blocks disabling below this.
-         */
-        const val MIN_ENABLED = 2
-    }
-}
-
 /**
  * The top-level view back stack (bottom → top): the [default] home view always
  * sits at the bottom. Pressing back pops one level until only the home view

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

@@ -1,50 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.BoxScope
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-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.rotate
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.zIndex
-
-/**
- * A Flutter-style "DEBUG" corner ribbon, drawn across the top-right corner of
- * the app. Deliberately a stark, un-themed marker (not a product component) so a
- * debug build is unmistakable at a glance — gate it on `BuildConfig.DEBUG` at the
- * call site so it never reaches a release build. Non-interactive: it's a plain
- * label with no pointer handler, so taps fall through to whatever is beneath it.
- *
- * Drop it in as the last child of a full-screen [androidx.compose.foundation.layout.Box]
- * so it overlays the UI.
- */
-@Composable
-fun BoxScope.DebugRibbon() {
-    Text(
-        text = "DEBUG",
-        color = Color.White,
-        fontSize = 10.sp,
-        fontWeight = FontWeight.Bold,
-        letterSpacing = 1.sp,
-        textAlign = TextAlign.Center,
-        modifier = Modifier
-            .align(Alignment.TopEnd)
-            .zIndex(1f)
-            // Push the band out so its midline crosses the very corner, then
-            // rotate it to the classic 45° ribbon.
-            .offset(x = 36.dp, y = 24.dp)
-            .rotate(45f)
-            .background(Color(0xFFB23B00))
-            .width(140.dp)
-            .padding(vertical = 2.dp),
-    )
-}

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

@@ -142,9 +142,6 @@ fun GroupedRow(
     dimmed: Boolean = false,
     container: Color? = null,
     minHeight: Dp = 72.dp,
-    // The 2.dp separation between rows in a run. Suppressed by the reorderable
-    // list, which owns uniform spacing itself so every slot has the same pitch.
-    gapBelow: Boolean = true,
     leading: @Composable (() -> Unit)? = null,
     trailing: @Composable (() -> Unit)? = null,
     onClick: (() -> Unit)? = null,
@@ -163,10 +160,9 @@ fun GroupedRow(
             topStart = small, topEnd = small, bottomStart = full, bottomEnd = full,
         )
     }
-    val gap = when {
-        !gapBelow -> Modifier
-        position == Position.Top || position == Position.Middle -> Modifier.padding(bottom = 2.dp)
-        else -> Modifier
+    val gap = when (position) {
+        Position.Top, Position.Middle -> Modifier.padding(bottom = 2.dp)
+        Position.Bottom, Position.Alone -> Modifier
     }
     val itemColors = if (selected) {
         ListItemDefaults.colors(

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

@@ -13,7 +13,6 @@ import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Check
-import androidx.compose.material3.Checkbox
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
@@ -27,7 +26,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -113,15 +111,10 @@ fun <T> OptionPicker(
 }
 
 /**
- * Reminder-default picker, full-screen and **multi-select**: each [presets]
- * lead time (plus any chosen custom value) is a checkbox row that toggles
- * independently, so a default can carry several reminders ("1 week before" *and*
- * "on the day"). A per-calendar picker ([allowInherit]) gains an exclusive "Use
- * default reminder" row above the list; choosing it defers to the global default
- * and clears the checked times. With nothing checked and inherit off, the choice
- * is [CalendarReminderOverride.None] (an explicit no-reminder). A "Custom" row
- * expands an inline number field plus a unit selector to add an arbitrary lead
- * time to the set. Changes apply live via [onSelect]; the user leaves via back.
+ * Reminder-default picker, full-screen: the grouped list (with an optional "Use
+ * default reminder" row and a "None" row), the [presets] as lead-time rows, and
+ * a "Custom" row that expands an inline number field plus a segmented unit
+ * selector. Returns the choice as a [CalendarReminderOverride].
  */
 @Composable
 fun ReminderDefaultPicker(
@@ -132,74 +125,57 @@ fun ReminderDefaultPicker(
     onSelect: (CalendarReminderOverride) -> Unit,
     onDismiss: () -> Unit,
 ) {
-    // Optimistic local state: the chosen override is authoritative while the
-    // picker is open, so quick successive toggles compose on each other instead
-    // of racing the round-trip through the settings flow (which would drop a
-    // toggle made before the previous write echoes back). Seeded once on open;
-    // the picker leaves composition on dismiss, so reopening re-reads [selected].
-    var current by remember { mutableStateOf(selected) }
-    val inherits = current is CalendarReminderOverride.Inherit
-    val selectedMinutes = (current as? CalendarReminderOverride.Minutes)?.minutes.orEmpty()
-    // Presets plus any selected custom (non-preset) values, each as its own row.
-    val rows = presets + selectedMinutes.filter { it !in presets }.sorted()
+    val selectedMinutes = (selected as? CalendarReminderOverride.Minutes)?.minutes
+    val customSelected = selectedMinutes != null && selectedMinutes !in presets
+    val seed = decomposeReminder(selectedMinutes?.takeIf { customSelected })
 
     var customExpanded by rememberSaveable { mutableStateOf(false) }
-    var amountText by rememberSaveable { mutableStateOf("") }
-    var unit by rememberSaveable { mutableStateOf(ReminderUnit.Minutes) }
+    var amountText by rememberSaveable { mutableStateOf(seed.first) }
+    var unit by rememberSaveable { mutableStateOf(seed.second) }
 
-    fun apply(override: CalendarReminderOverride) {
-        current = override
-        onSelect(override)
+    val options = buildList {
+        if (allowInherit) add(CalendarReminderOverride.Inherit)
+        add(CalendarReminderOverride.None)
+        presets.forEach { add(CalendarReminderOverride.Minutes(it)) }
     }
-    // Emit the override for a new set of minutes: empty collapses to None, which
-    // (with inherit unchosen) reads as an explicit "no reminder".
-    fun emit(minutes: List<Int>) {
-        val norm = minutes.distinct().sorted()
-        apply(
-            if (norm.isEmpty()) {
-                CalendarReminderOverride.None
-            } else {
-                CalendarReminderOverride.Minutes(norm)
-            },
-        )
-    }
-    fun toggle(minute: Int) =
-        emit(if (minute in selectedMinutes) selectedMinutes - minute else selectedMinutes + minute)
+    val rowCount = options.size + 1 // + the custom row
 
     FullScreenPicker(title = title, onDismiss = onDismiss) {
-        // Exclusive "use default" choice (per-calendar only): its own group above
-        // the multi-select list, since inheriting is mutually exclusive with
-        // picking specific times.
-        if (allowInherit) {
+        options.forEachIndexed { index, option ->
+            val isSelected = option == selected
             GroupedRow(
-                title = stringResource(R.string.reminder_use_default),
-                position = Position.Alone,
-                selected = inherits,
-                trailing = if (inherits) {
+                title = reminderOverrideLabel(option),
+                position = positionOf(index, rowCount),
+                selected = isSelected,
+                trailing = if (isSelected) {
                     { SelectedCheck() }
                 } else {
                     null
                 },
-                onClick = { apply(CalendarReminderOverride.Inherit) },
-            )
-            Spacer(Modifier.height(24.dp))
-        }
-        val rowCount = rows.size + 1 // + the custom row
-        rows.forEachIndexed { index, minute ->
-            val checked = minute in selectedMinutes
-            GroupedRow(
-                title = reminderLeadTimeLabel(minute),
-                position = positionOf(index, rowCount),
-                selected = checked,
-                trailing = { Checkbox(checked = checked, onCheckedChange = { toggle(minute) }) },
-                onClick = { toggle(minute) },
+                onClick = {
+                    onSelect(option)
+                    onDismiss()
+                },
             )
         }
         // When expanded, the Custom row connects downward into the editor card
         // so the two read as one grouped container (the per-calendar pattern).
         GroupedRow(
-            title = stringResource(R.string.event_edit_reminder_custom),
-            position = if (customExpanded) Position.Top else positionOf(rows.size, rowCount),
+            title = if (customSelected) {
+                stringResource(
+                    R.string.reminder_custom_with_value,
+                    reminderLeadTimeLabel(selectedMinutes!!),
+                )
+            } else {
+                stringResource(R.string.event_edit_reminder_custom)
+            },
+            position = if (customExpanded) Position.Top else positionOf(options.size, rowCount),
+            selected = customSelected,
+            trailing = if (customSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
             onClick = { customExpanded = !customExpanded },
         )
         AnimatedVisibility(
@@ -213,9 +189,8 @@ fun ReminderDefaultPicker(
                 unit = unit,
                 onUnitChange = { unit = it },
                 onConfirm = { minutes ->
-                    emit(selectedMinutes + minutes)
-                    amountText = ""
-                    customExpanded = false
+                    onSelect(CalendarReminderOverride.Minutes(minutes))
+                    onDismiss()
                 },
             )
         }
@@ -453,3 +428,18 @@ fun agendaRangeLabel(range: AgendaRange): String = when (range) {
     is AgendaRange.Custom -> pluralStringResource(R.plurals.agenda_range_days, range.days, range.days)
 }
 
+@Composable
+private fun reminderOverrideLabel(override: CalendarReminderOverride): String = when (override) {
+    CalendarReminderOverride.Inherit -> stringResource(R.string.reminder_use_default)
+    CalendarReminderOverride.None -> stringResource(R.string.reminder_none)
+    is CalendarReminderOverride.Minutes -> reminderLeadTimeLabel(override.minutes)
+}
+
+/** Seed the custom editor: the largest exact unit for [minutes] (null → empty). */
+private fun decomposeReminder(minutes: Int?): Pair<String, ReminderUnit> = when {
+    minutes == null -> "" to ReminderUnit.Minutes
+    minutes % 10_080 == 0 -> (minutes / 10_080).toString() to ReminderUnit.Weeks
+    minutes % 1_440 == 0 -> (minutes / 1_440).toString() to ReminderUnit.Days
+    minutes % 60 == 0 -> (minutes / 60).toString() to ReminderUnit.Hours
+    else -> minutes.toString() to ReminderUnit.Minutes
+}

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

@@ -1,158 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.animation.core.snap
-import androidx.compose.animation.core.spring
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.gestures.detectDragGestures
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.zIndex
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
-import kotlin.math.roundToInt
-
-/** Uniform row height for [ReorderableColumn]; a fixed pitch keeps drag maths exact. */
-val ReorderableRowHeight: Dp = 64.dp
-private val RowGap: Dp = 2.dp
-
-/**
- * A vertical list whose rows can be dragged into a new order by their handle.
- *
- * Built for the short, fixed grouped-card lists in Settings (#24) — no external
- * dependency and no [androidx.compose.foundation.lazy.LazyColumn] (the settings
- * screens are a single [androidx.compose.foundation.verticalScroll] column, which
- * can't nest a scrolling list). Rows are a fixed [ReorderableRowHeight] with a
- * uniform gap, so a row's target slot is simply how many whole pitches it has
- * been dragged. The held row follows the finger while the others slide out of
- * its way (animated); on release the held row settles into its slot, then the
- * order is committed with a single [onReorder] call.
- *
- * [rowContent] receives the [Position] for the row's place in the order (to reuse
- * [GroupedRow]'s card shaping — pass `gapBelow = false` there, this owns spacing)
- * and a `dragHandle` [Modifier] to attach to the element that starts a drag.
- */
-@Composable
-fun <T> ReorderableColumn(
-    items: List<T>,
-    keyOf: (T) -> Any,
-    onReorder: (List<T>) -> Unit,
-    modifier: Modifier = Modifier,
-    rowContent: @Composable (item: T, position: Position, dragHandle: Modifier, isDragging: Boolean) -> Unit,
-) {
-    val pitchPx = with(LocalDensity.current) { (ReorderableRowHeight + RowGap).toPx() }
-    val scope = rememberCoroutineScope()
-
-    // Local working copy; re-seeded when the incoming list changes (including the
-    // echo of our own committed order).
-    var order by remember(items) { mutableStateOf(items) }
-    var draggedKey by remember { mutableStateOf<Any?>(null) }
-    // Live translation of the held row from its slot (px); also drives the
-    // release settle, animated back onto a slot before the order is committed.
-    var dragOffset by remember { mutableFloatStateOf(0f) }
-    // The running release/cancel settle, cancelled if a new drag pre-empts it.
-    var settleJob by remember { mutableStateOf<Job?>(null) }
-
-    val draggedIndex = draggedKey?.let { key -> order.indexOfFirst { keyOf(it) == key }.takeIf { it >= 0 } }
-    // Whole slots dragged → the slot the held row currently hovers over.
-    val targetIndex = draggedIndex?.let {
-        (it + (dragOffset / pitchPx).roundToInt()).coerceIn(0, order.lastIndex)
-    }
-
-    Column(modifier, verticalArrangement = Arrangement.spacedBy(RowGap)) {
-        order.forEachIndexed { index, item ->
-            val key = keyOf(item)
-            val isDragged = key == draggedKey
-
-            // Slide neighbours by one pitch to open the gap the held row will drop
-            // into. Snap (not animate) once idle, so committing the new order — which
-            // moves each row's slot — doesn't visibly fight a lingering animation.
-            val shift = when {
-                draggedIndex == null || targetIndex == null || isDragged -> 0f
-                index in (draggedIndex + 1)..targetIndex -> -pitchPx
-                index in targetIndex until draggedIndex -> pitchPx
-                else -> 0f
-            }
-            val animatedShift by animateFloatAsState(
-                targetValue = shift,
-                animationSpec = if (draggedKey != null) spring(stiffness = Spring.StiffnessMediumLow) else snap(),
-                label = "reorderShift",
-            )
-
-            val dragHandle = Modifier.pointerInput(key) {
-                detectDragGestures(
-                    onDragStart = {
-                        settleJob?.cancel()
-                        draggedKey = key
-                        dragOffset = 0f
-                    },
-                    onDrag = { change, amount ->
-                        change.consume()
-                        dragOffset += amount.y
-                    },
-                    onDragEnd = {
-                        val from = order.indexOfFirst { keyOf(it) == key }
-                        if (from < 0) return@detectDragGestures
-                        val to = (from + (dragOffset / pitchPx).roundToInt()).coerceIn(0, order.lastIndex)
-                        settleJob = scope.launch {
-                            // Settle the held row onto its target slot, then commit —
-                            // resetting offset and slot in the same frame, so nothing jumps.
-                            Animatable(dragOffset).animateTo((to - from) * pitchPx, tween(160)) {
-                                dragOffset = value
-                            }
-                            if (to != from) {
-                                order = order.toMutableList().apply { add(to, removeAt(from)) }
-                                onReorder(order)
-                            }
-                            draggedKey = null
-                            dragOffset = 0f
-                        }
-                    },
-                    onDragCancel = {
-                        settleJob = scope.launch {
-                            Animatable(dragOffset).animateTo(0f, tween(160)) { dragOffset = value }
-                            draggedKey = null
-                            dragOffset = 0f
-                        }
-                    },
-                )
-            }
-
-            Box(
-                Modifier
-                    .height(ReorderableRowHeight)
-                    .zIndex(if (isDragged) 1f else 0f)
-                    .graphicsLayer {
-                        translationY = if (isDragged) dragOffset else animatedShift
-                        if (isDragged) {
-                            scaleX = 1.02f
-                            scaleY = 1.02f
-                            shadowElevation = 8.dp.toPx()
-                            shape = RoundedCornerShape(20.dp)
-                            clip = false
-                        }
-                    },
-            ) {
-                rowContent(item, positionOf(index, order.size), dragHandle, isDragged)
-            }
-        }
-    }
-}

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

@@ -72,7 +72,6 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 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.NowLine
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
@@ -117,8 +116,6 @@ fun DayScreen(
     onOpenSettings: () -> Unit,
     onOpenSearch: () -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
-    quickSwitchViews: List<CalendarView> = IMPLEMENTED_VIEWS,
-    drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
     modifier: Modifier = Modifier,
     initialDateIso: String? = null,
     viewModel: DayViewModel = hiltViewModel(),
@@ -178,7 +175,6 @@ fun DayScreen(
             CalendarDrawer(
                 currentView = selectedView,
                 currentDate = date,
-                viewOrder = drawerViewOrder,
                 onSelectView = { view ->
                     onSelectView(view)
                     scope.launch { drawerState.close() }
@@ -200,7 +196,7 @@ fun DayScreen(
                 DayTopBar(
                     date = date,
                     selectedView = selectedView,
-                    onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
+                    onCycleView = { onSelectView(selectedView.next()) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
                     scrollBehavior = scrollBehavior,

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

@@ -1712,20 +1712,12 @@ private fun ColorPickerDialog(
         text = {
             Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
                 if (palette.isNotEmpty()) {
-                    // The event's current colour may not be in the curated
-                    // palette (thinned near-duplicate, or a raw colour set
-                    // elsewhere) — append it so the selection ring has a home.
-                    val swatches = palette.map { it.argb }.let {
-                        if (selected != null && selected !in it) it + selected else it
-                    }
                     ColorSwatchRow(
-                        colors = swatches,
+                        colors = palette.map { it.argb },
                         selected = selected,
                         onSelect = { argb ->
-                            val option = palette.firstOrNull { it.argb == argb }
-                            // The appended current colour has no key to write —
-                            // it is already the event's colour, so just close.
-                            if (option != null) onPickKey(option.key, option.argb) else onDismiss()
+                            palette.firstOrNull { it.argb == argb }
+                                ?.let { onPickKey(it.key, it.argb) }
                         },
                         dark = dark,
                     )

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

@@ -108,10 +108,10 @@ class EventEditViewModel @Inject constructor(
     )
 
     private data class ReminderDefaults(
-        val timed: List<Int>,
-        val allDay: List<Int>,
-        val timedOverrides: Map<Long, List<Int>>,
-        val allDayOverrides: Map<Long, List<Int>>,
+        val timed: Int?,
+        val allDay: Int?,
+        val timedOverrides: Map<Long, Int?>,
+        val allDayOverrides: Map<Long, Int?>,
     )
 
     private data class ExternalInputs(
@@ -260,7 +260,7 @@ class EventEditViewModel @Inject constructor(
             // Re-check after suspending: bail if the form closed or the user edited.
             val form = _form.value ?: return@launch
             if (_editTarget.value != null || _remindersTouched.value) return@launch
-            val reminders = resolveDefaultReminder(
+            val default = resolveDefaultReminder(
                 timedGlobal = defaults.timed,
                 allDayGlobal = defaults.allDay,
                 timedOverrides = defaults.timedOverrides,
@@ -268,6 +268,7 @@ class EventEditViewModel @Inject constructor(
                 calendarId = targetId,
                 isAllDay = form.isAllDay,
             )
+            val reminders = listOfNotNull(default)
             _form.value = form.copy(reminders = reminders)
             // Surface the section so an auto-applied default is visible and
             // removable, even when Reminders isn't a default-shown field.

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

@@ -68,7 +68,6 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 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.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
 import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
@@ -99,8 +98,6 @@ fun MonthScreen(
     onOpenSettings: () -> Unit,
     onOpenSearch: () -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
-    quickSwitchViews: List<CalendarView> = IMPLEMENTED_VIEWS,
-    drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
     modifier: Modifier = Modifier,
     viewModel: MonthViewModel = hiltViewModel(),
 ) {
@@ -160,7 +157,6 @@ fun MonthScreen(
             CalendarDrawer(
                 currentView = selectedView,
                 currentDate = LocalDate(month.year, month.month, 1),
-                viewOrder = drawerViewOrder,
                 onSelectView = { view ->
                     onSelectView(view)
                     scope.launch { drawerState.close() }
@@ -182,7 +178,7 @@ fun MonthScreen(
                 MonthTopBar(
                     month = month,
                     selectedView = selectedView,
-                    onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
+                    onCycleView = { onSelectView(selectedView.next()) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
                     scrollBehavior = scrollBehavior,

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

@@ -41,8 +41,6 @@ import androidx.compose.material.icons.filled.BugReport
 import androidx.compose.material.icons.filled.CalendarMonth
 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
 import androidx.compose.material.icons.filled.ExpandMore
 import androidx.compose.material.icons.filled.Favorite
@@ -101,14 +99,9 @@ import de.jeanlucmakiola.calendula.ui.common.calendarCollapseExit
 import de.jeanlucmakiola.calendula.ui.common.calendarExpandEnter
 import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
 import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
-import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.CollapsingScaffold
 import de.jeanlucmakiola.calendula.ui.common.GroupedRow
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
-import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.common.ReorderableColumn
-import de.jeanlucmakiola.calendula.ui.common.ReorderableRowHeight
-import de.jeanlucmakiola.calendula.ui.common.icon
 import de.jeanlucmakiola.calendula.ui.common.labelRes
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
 import de.jeanlucmakiola.calendula.ui.common.OptionPicker
@@ -128,7 +121,7 @@ import java.time.format.TextStyle as JavaTextStyle
 import java.util.Calendar
 
 /** The settings sub-screens reached from the hub's category rows. */
-private enum class SettingsSection { Appearance, Views, EventForm, Notifications }
+private enum class SettingsSection { Appearance, EventForm, Notifications }
 
 /**
  * Token-based accent for a leading icon chip (container / on-container pair).
@@ -173,13 +166,6 @@ fun SettingsScreen(
         ) {
             AppearanceScreen(state = state, viewModel = viewModel, onBack = { section = null })
         }
-        AnimatedVisibility(
-            visible = section == SettingsSection.Views,
-            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
-            exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
-        ) {
-            ViewsScreen(state = state, viewModel = viewModel, onBack = { section = null })
-        }
         AnimatedVisibility(
             visible = section == SettingsSection.EventForm,
             enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
@@ -218,13 +204,6 @@ private fun SettingsHub(
             leading = { CategoryIcon(Icons.Default.Palette, ChipAccent.Neutral) },
             onClick = { onOpenSection(SettingsSection.Appearance) },
         )
-        GroupedRow(
-            title = stringResource(R.string.settings_section_views),
-            summary = stringResource(R.string.settings_views_subtitle),
-            position = Position.Middle,
-            leading = { CategoryIcon(Icons.Default.SwapVert, ChipAccent.Neutral) },
-            onClick = { onOpenSection(SettingsSection.Views) },
-        )
         GroupedRow(
             title = stringResource(R.string.settings_section_event_form),
             summary = stringResource(R.string.settings_event_form_subtitle),
@@ -685,131 +664,6 @@ private fun AppearanceScreen(
     }
 }
 
-/**
- * Views (#24): reorder the top-bar quick-switch cycle and choose which views it
- * steps through, plus reorder the navigation-drawer list. Two independent lists —
- * a view disabled in the quick-switch cycle is still reachable from the drawer,
- * which always lists every view. The switch needs at least two targets, so the
- * last [QuickSwitchConfig.MIN_ENABLED] enabled views can't be turned off.
- */
-@Composable
-private fun ViewsScreen(
-    state: SettingsUiState,
-    viewModel: SettingsViewModel,
-    onBack: () -> Unit,
-) {
-    CollapsingScaffold(
-        title = stringResource(R.string.settings_section_views),
-        onBack = onBack,
-    ) {
-        val config = state.quickSwitchConfig
-
-        SectionHeader(stringResource(R.string.settings_quick_switch_header))
-        SettingsHint(stringResource(R.string.settings_quick_switch_hint))
-        Spacer(Modifier.height(8.dp))
-        // Turning a view off is blocked once only the minimum remain enabled.
-        val canDisable = config.enabled.size > QuickSwitchConfig.MIN_ENABLED
-        ReorderableColumn(
-            items = config.order,
-            keyOf = { it },
-            onReorder = { viewModel.setQuickSwitchConfig(config.copy(order = it)) },
-        ) { view, position, dragHandle, isDragging ->
-            val checked = view in config.enabled
-            ViewRow(
-                view = view,
-                position = position,
-                isDragging = isDragging,
-                dragHandle = dragHandle,
-                dimmed = !checked,
-                trailing = {
-                    Switch(
-                        checked = checked,
-                        // Keep the last two on: with fewer, the pill can't switch.
-                        enabled = !checked || canDisable,
-                        onCheckedChange = { on ->
-                            val enabled = if (on) config.enabled + view else config.enabled - view
-                            viewModel.setQuickSwitchConfig(config.copy(enabled = enabled))
-                        },
-                    )
-                },
-            )
-        }
-
-        Spacer(Modifier.height(24.dp))
-        SectionHeader(stringResource(R.string.settings_drawer_order_header))
-        SettingsHint(stringResource(R.string.settings_drawer_order_hint))
-        Spacer(Modifier.height(8.dp))
-        ReorderableColumn(
-            items = state.drawerViewOrder,
-            keyOf = { it },
-            onReorder = { viewModel.setDrawerViewOrder(it) },
-        ) { view, position, dragHandle, isDragging ->
-            ViewRow(
-                view = view,
-                position = position,
-                isDragging = isDragging,
-                dragHandle = dragHandle,
-            )
-        }
-    }
-}
-
-/** One reorderable view row: the view's icon and name, an optional [trailing]
- *  control, and a drag handle carrying the [dragHandle] gesture modifier. */
-@Composable
-private fun ViewRow(
-    view: CalendarView,
-    position: Position,
-    isDragging: Boolean,
-    dragHandle: Modifier,
-    dimmed: Boolean = false,
-    trailing: @Composable (() -> Unit)? = null,
-) {
-    GroupedRow(
-        title = stringResource(view.labelRes),
-        position = position,
-        dimmed = dimmed,
-        minHeight = ReorderableRowHeight,
-        // The reorderable column owns the inter-row spacing (uniform pitch).
-        gapBelow = false,
-        container = if (isDragging) MaterialTheme.colorScheme.secondaryContainer else null,
-        leading = {
-            Icon(
-                imageVector = view.icon,
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-        },
-        trailing = {
-            Row(verticalAlignment = Alignment.CenterVertically) {
-                trailing?.invoke()
-                if (trailing != null) Spacer(Modifier.width(8.dp))
-                Box(
-                    modifier = dragHandle.size(48.dp),
-                    contentAlignment = Alignment.Center,
-                ) {
-                    Icon(
-                        imageVector = Icons.Default.DragHandle,
-                        contentDescription = stringResource(R.string.reorder_drag_handle),
-                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                    )
-                }
-            }
-        },
-    )
-}
-
-/** Muted supporting text under a [SectionHeader], matching the form-fields hint. */
-@Composable
-private fun SettingsHint(text: String) {
-    Text(
-        text = text,
-        style = MaterialTheme.typography.bodyMedium,
-        color = MaterialTheme.colorScheme.onSurfaceVariant,
-        modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp),
-    )
-}
-
 @Composable
 private fun EventFormScreen(
     state: SettingsUiState,
@@ -1115,7 +969,7 @@ private fun NotificationsScreen(
             presets = REMINDER_PRESETS,
             selected = state.defaultReminderMinutes.toReminderChoice(),
             allowInherit = false,
-            onSelect = { viewModel.setDefaultReminderMinutes(it.toMinutesList()) },
+            onSelect = { viewModel.setDefaultReminderMinutes(it.toMinutesOrNull()) },
             onDismiss = { showDefaultReminder = false },
         )
     }
@@ -1125,7 +979,7 @@ private fun NotificationsScreen(
             presets = ALLDAY_REMINDER_PRESETS,
             selected = state.defaultAllDayReminderMinutes.toReminderChoice(),
             allowInherit = false,
-            onSelect = { viewModel.setDefaultAllDayReminderMinutes(it.toMinutesList()) },
+            onSelect = { viewModel.setDefaultAllDayReminderMinutes(it.toMinutesOrNull()) },
             onDismiss = { showAllDayReminder = false },
         )
     }
@@ -1174,13 +1028,13 @@ private fun NotificationsScreen(
 /** Which calendar + event kind a per-calendar reminder-override dialog targets. */
 private data class OverrideTarget(val calendarId: Long, val isAllDay: Boolean)
 
-/** A global default (empty = none) as a picker choice for selection highlighting. */
-private fun List<Int>.toReminderChoice(): CalendarReminderOverride =
-    if (isEmpty()) CalendarReminderOverride.None else CalendarReminderOverride.Minutes(this)
+/** A global default (null = none) as a picker choice for selection highlighting. */
+private fun Int?.toReminderChoice(): CalendarReminderOverride =
+    if (this == null) CalendarReminderOverride.None else CalendarReminderOverride.Minutes(this)
 
 /** A picked choice as global-default minutes (Inherit isn't offered for globals). */
-private fun CalendarReminderOverride.toMinutesList(): List<Int> =
-    (this as? CalendarReminderOverride.Minutes)?.minutes ?: emptyList()
+private fun CalendarReminderOverride.toMinutesOrNull(): Int? =
+    (this as? CalendarReminderOverride.Minutes)?.minutes
 
 /**
  * Whether Calendula is exempt from battery optimisation, re-read on every
@@ -1255,33 +1109,27 @@ private fun formatTimeOfDay(context: Context, minutesOfDay: Int): String {
 }
 
 /** The stored override for [calendarId], as a picker choice (absent → inherit). */
-private fun Map<Long, List<Int>>.choiceFor(calendarId: Long): CalendarReminderOverride = when {
+private fun Map<Long, Int?>.choiceFor(calendarId: Long): CalendarReminderOverride = when {
     !containsKey(calendarId) -> CalendarReminderOverride.Inherit
-    this.getValue(calendarId).isEmpty() -> CalendarReminderOverride.None
-    else -> CalendarReminderOverride.Minutes(this.getValue(calendarId))
+    this[calendarId] == null -> CalendarReminderOverride.None
+    else -> CalendarReminderOverride.Minutes(this.getValue(calendarId)!!)
 }
 
-/** Label for a global-default choice: empty → "None", else the lead times joined. */
+/** Label for a global-default choice: null → "None", else the lead time. */
 @Composable
-private fun reminderChoiceLabel(minutes: List<Int>): String {
-    if (minutes.isEmpty()) return stringResource(R.string.reminder_none)
-    // reminderLeadTimeLabel is @Composable, so resolve each part in a loop rather
-    // than a (non-composable) joinToString transform.
-    val parts = ArrayList<String>(minutes.size)
-    for (m in minutes) parts.add(reminderLeadTimeLabel(m))
-    return parts.joinToString(", ")
-}
+private fun reminderChoiceLabel(minutes: Int?): String =
+    if (minutes == null) stringResource(R.string.reminder_none) else reminderLeadTimeLabel(minutes)
 
 /** Row summary for a calendar: its override, or the inherited global default. */
 @Composable
 private fun calendarOverrideSummary(
     choice: CalendarReminderOverride,
-    globalDefault: List<Int>,
+    globalDefault: Int?,
 ): String = when (choice) {
     CalendarReminderOverride.Inherit ->
         stringResource(R.string.settings_calendar_reminder_inherits, reminderChoiceLabel(globalDefault))
     CalendarReminderOverride.None -> stringResource(R.string.reminder_none)
-    is CalendarReminderOverride.Minutes -> reminderChoiceLabel(choice.minutes)
+    is CalendarReminderOverride.Minutes -> reminderLeadTimeLabel(choice.minutes)
 }
 
 // ---------------------------------------------------------------------------

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

@@ -9,8 +9,6 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
 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
 
 /**
  * Settings screen state (M4). Persisted preferences are instant to read, so
@@ -39,10 +37,6 @@ data class SettingsUiState(
     val agendaShowRangeBar: Boolean = true,
     /** The calendar view the app opens on, and the home of the view back stack (M1). */
     val defaultView: CalendarView = CalendarView.Week,
-    /** Which views the top-bar quick-switch button cycles through, and their order (#24). */
-    val quickSwitchConfig: QuickSwitchConfig = QuickSwitchConfig.Default,
-    /** 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"). */
     val defaultFormFields: Set<EventFormField> = SettingsPrefs.DEFAULT_FORM_FIELDS,
     /** Whether the new-event form auto-focuses the title and shows the keyboard (#10). */
@@ -50,24 +44,24 @@ data class SettingsUiState(
     /** Whether Calendula posts reminder notifications (v1.4). */
     val remindersEnabled: Boolean = true,
     /**
-     * The default reminder lead times (minutes) prefilled on new timed events;
-     * empty = no default reminder. Per-calendar overrides take precedence.
+     * The default reminder lead time (minutes) prefilled on new timed events;
+     * null = no default reminder. Per-calendar overrides take precedence.
      */
-    val defaultReminderMinutes: List<Int> = emptyList(),
-    /** The default reminder lead times prefilled on new all-day events; empty = none. */
-    val defaultAllDayReminderMinutes: List<Int> = emptyList(),
+    val defaultReminderMinutes: Int? = null,
+    /** The default reminder lead time prefilled on new all-day events; null = none. */
+    val defaultAllDayReminderMinutes: Int? = null,
     /** Wall-clock time (minutes from midnight) all-day reminders fire at; default 09:00. */
     val allDayReminderTimeMinutes: Int = SettingsPrefs.DEFAULT_ALLDAY_REMINDER_TIME,
     /** How long the notification "Snooze" action defers a reminder; default 10 min. */
     val snoozeMinutes: Int = SettingsPrefs.DEFAULT_SNOOZE_MINUTES,
     /**
      * Per-calendar overrides of [defaultReminderMinutes] for timed events: a
-     * calendar present in the map overrides the global default (empty value = no
+     * calendar present in the map overrides the global default (null value = no
      * reminder); absent = inherit the global default.
      */
-    val perCalendarReminderOverride: Map<Long, List<Int>> = emptyMap(),
+    val perCalendarReminderOverride: Map<Long, Int?> = emptyMap(),
     /** Per-calendar overrides of [defaultAllDayReminderMinutes] for all-day events. */
-    val perCalendarAllDayReminderOverride: Map<Long, List<Int>> = emptyMap(),
+    val perCalendarAllDayReminderOverride: Map<Long, Int?> = emptyMap(),
     /** Writable calendars, shown as per-calendar reminder-override rows. */
     val writableCalendars: List<CalendarSource> = emptyList(),
     /**

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

@@ -21,7 +21,6 @@ import de.jeanlucmakiola.calendula.domain.EventFormField
 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.widget.agenda.AGENDA_PAST_DISPLAY_KEY
 import de.jeanlucmakiola.calendula.widget.agenda.AGENDA_RANGE_KEY
 import de.jeanlucmakiola.calendula.widget.agenda.AgendaWidget
@@ -104,14 +103,8 @@ class SettingsViewModel @Inject constructor(
                 prefs.autofocusEventTitle,
                 prefs.pastEventDisplay,
                 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) { quickSwitch, drawer ->
-                    ViewCustomization(quickSwitch, drawer)
-                },
-            ) { showRangeBar, autofocus, pastEvents, dimCompleted, viewCustomization ->
-                MiscSettings(showRangeBar, autofocus, pastEvents, dimCompleted, viewCustomization)
-            },
+                ::MiscSettings,
+            ),
         ) { base, defaults, overrides, views, misc ->
             base.copy(
                 defaultView = views.defaultView,
@@ -123,8 +116,6 @@ class SettingsViewModel @Inject constructor(
                 autofocusEventTitle = misc.autofocusEventTitle,
                 pastEventDisplay = misc.pastEventDisplay,
                 dimCompletedEvents = misc.dimCompletedEvents,
-                quickSwitchConfig = misc.viewCustomization.quickSwitch,
-                drawerViewOrder = misc.viewCustomization.drawerOrder,
                 allowColorOnUnsupportedCalendars = defaults.allowColor,
                 defaultReminderMinutes = defaults.defaultReminder,
                 defaultAllDayReminderMinutes = defaults.allDayReminder,
@@ -148,15 +139,15 @@ class SettingsViewModel @Inject constructor(
 
     private data class ReminderDefaults(
         val allowColor: Boolean,
-        val defaultReminder: List<Int>,
-        val allDayReminder: List<Int>,
+        val defaultReminder: Int?,
+        val allDayReminder: Int?,
         val allDayReminderTime: Int,
         val snoozeMinutes: Int,
     )
 
     private data class ReminderOverrides(
-        val timed: Map<Long, List<Int>>,
-        val allDay: Map<Long, List<Int>>,
+        val timed: Map<Long, Int?>,
+        val allDay: Map<Long, Int?>,
         val calendars: List<CalendarSource>,
     )
 
@@ -173,12 +164,6 @@ class SettingsViewModel @Inject constructor(
         val autofocusEventTitle: Boolean,
         val pastEventDisplay: PastEventDisplay,
         val dimCompletedEvents: Boolean,
-        val viewCustomization: ViewCustomization,
-    )
-
-    private data class ViewCustomization(
-        val quickSwitch: QuickSwitchConfig,
-        val drawerOrder: List<CalendarView>,
     )
 
     fun setThemeMode(mode: ThemeMode) {
@@ -262,14 +247,6 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setFormFieldDefault(field, enabled) }
     }
 
-    fun setQuickSwitchConfig(config: QuickSwitchConfig) {
-        viewModelScope.launch { prefs.setQuickSwitchConfig(config) }
-    }
-
-    fun setDrawerViewOrder(order: List<CalendarView>) {
-        viewModelScope.launch { prefs.setDrawerViewOrder(order) }
-    }
-
     fun setRemindersEnabled(enabled: Boolean) {
         viewModelScope.launch { prefs.setRemindersEnabled(enabled) }
     }
@@ -278,11 +255,11 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setAutofocusEventTitle(enabled) }
     }
 
-    fun setDefaultReminderMinutes(minutes: List<Int>) {
+    fun setDefaultReminderMinutes(minutes: Int?) {
         viewModelScope.launch { prefs.setDefaultReminderMinutes(minutes) }
     }
 
-    fun setDefaultAllDayReminderMinutes(minutes: List<Int>) {
+    fun setDefaultAllDayReminderMinutes(minutes: Int?) {
         viewModelScope.launch { prefs.setDefaultAllDayReminderMinutes(minutes) }
     }
 

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

@@ -81,7 +81,6 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 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.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
 import de.jeanlucmakiola.calendula.ui.common.NowLine
@@ -132,8 +131,6 @@ fun WeekScreen(
     onOpenSettings: () -> Unit,
     onOpenSearch: () -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
-    quickSwitchViews: List<CalendarView> = IMPLEMENTED_VIEWS,
-    drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
     modifier: Modifier = Modifier,
     viewModel: WeekViewModel = hiltViewModel(),
 ) {
@@ -198,7 +195,6 @@ fun WeekScreen(
             CalendarDrawer(
                 currentView = selectedView,
                 currentDate = weekStart,
-                viewOrder = drawerViewOrder,
                 onSelectView = { view ->
                     onSelectView(view)
                     scope.launch { drawerState.close() }
@@ -220,7 +216,7 @@ fun WeekScreen(
                 WeekTopBar(
                     weekStart = weekStart,
                     selectedView = selectedView,
-                    onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
+                    onCycleView = { onSelectView(selectedView.next()) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
                     scrollBehavior = scrollBehavior,

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

@@ -193,8 +193,6 @@ private fun AgendaHeader() {
         modifier = GlanceModifier.fillMaxWidth().padding(horizontal = 4.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
-        // Tap the "Upcoming" title to open the app on the user's default view
-        // (issue #20) — a null target resolves to the default home in the host.
         Text(
             text = context.getString(R.string.widget_agenda_title),
             style = TextStyle(
@@ -202,11 +200,7 @@ private fun AgendaHeader() {
                 fontSize = 16.sp,
                 fontWeight = FontWeight.Medium,
             ),
-            modifier = GlanceModifier
-                .defaultWeight()
-                .clickable(
-                    actionStartActivity(MainActivity.openViewIntent(context, view = null)),
-                ),
+            modifier = GlanceModifier.defaultWeight(),
         )
         IconButton(
             resId = R.drawable.ic_widget_refresh,

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

@@ -194,8 +194,6 @@ private fun MonthHeader(label: String) {
                 ),
             ),
         )
-        // Tap the month/year title to open the app on the month view (issue #18),
-        // rooted over the default home so backing out returns there.
         Text(
             text = label,
             style = TextStyle(
@@ -206,17 +204,16 @@ private fun MonthHeader(label: String) {
             ),
             modifier = GlanceModifier
                 .defaultWeight()
-                .clickable(
-                    actionStartActivity(
-                        MainActivity.openViewIntent(context, CalendarView.Month),
-                    ),
-                ),
+                .clickable(actionRunCallback<ResetMonthAction>()),
         )
-        // The "today" button snaps the grid back to the current month in place.
         HeaderIcon(
             resId = R.drawable.ic_widget_today,
             contentDescription = context.getString(R.string.widget_today),
-            onClick = GlanceModifier.clickable(actionRunCallback<ResetMonthAction>()),
+            onClick = GlanceModifier.clickable(
+                actionStartActivity(
+                    MainActivity.openDateIntent(context, today(systemZone()), CalendarView.Month),
+                ),
+            ),
         )
         HeaderIcon(
             resId = R.drawable.ic_widget_chevron_right,
@@ -304,15 +301,6 @@ private fun WeekRow(
     }
 }
 
-/**
- * Open [date]'s day view rooted in the month view (so back returns to the month
- * grid) — the same target the in-app month grid uses when a day cell is tapped.
- * Shared by every tappable part of a day column so, as in the app, a tap anywhere
- * on a day opens it; only an event bar on top opts out to open its own detail.
- */
-private fun openDayAction(context: Context, date: LocalDate) =
-    actionStartActivity(MainActivity.openDateIntent(context, date, CalendarView.Month))
-
 @Composable
 private fun DayNumber(date: LocalDate, isToday: Boolean, inMonth: Boolean, colW: Dp) {
     val context = LocalContext.current
@@ -320,7 +308,11 @@ private fun DayNumber(date: LocalDate, isToday: Boolean, inMonth: Boolean, colW:
         modifier = GlanceModifier
             .width(colW)
             .height(DAY_NUMBER_HEIGHT)
-            .clickable(openDayAction(context, date)),
+            // Tap a day number to open that day, rooted in the month view so back
+            // returns to the month grid.
+            .clickable(
+                actionStartActivity(MainActivity.openDateIntent(context, date, CalendarView.Month)),
+            ),
         contentAlignment = Alignment.Center,
     ) {
         Box(
@@ -347,7 +339,6 @@ private fun DayNumber(date: LocalDate, isToday: Boolean, inMonth: Boolean, colW:
 
 @Composable
 private fun LaneRow(week: MonthWeek, lane: Int, dark: Boolean, colW: Dp) {
-    val context = LocalContext.current
     Row(modifier = GlanceModifier.fillMaxWidth()) {
         var col = 0
         while (col < 7) {
@@ -361,14 +352,7 @@ private fun LaneRow(week: MonthWeek, lane: Int, dark: Boolean, colW: Dp) {
                 if (timed != null) {
                     SpanBar(event = timed, dark = dark, width = colW)
                 } else {
-                    // Empty lane cell: a tap opens that day, so blank space in a
-                    // day column is a day-open target just like the number is.
-                    Box(
-                        GlanceModifier
-                            .width(colW)
-                            .height(LANE_HEIGHT)
-                            .clickable(openDayAction(context, week.days[col])),
-                    ) {}
+                    Box(GlanceModifier.width(colW).height(LANE_HEIGHT)) {}
                 }
                 col += 1
             }
@@ -417,20 +401,14 @@ private fun SpanBar(event: EventInstance, dark: Boolean, width: Dp) {
 
 @Composable
 private fun OverflowRow(week: MonthWeek, colW: Dp) {
-    val context = LocalContext.current
     Row(modifier = GlanceModifier.fillMaxWidth()) {
         week.days.forEachIndexed { col, date ->
             val shownSpans = week.spans.count { col in it.startCol..it.endCol && it.lane < MAX_LANES }
             val freeSlots = (MAX_LANES - shownSpans).coerceAtLeast(0)
             val timedShown = minOf(freeSlots, week.timedByDay[date].orEmpty().size)
             val hidden = (week.countByDay[date] ?: 0) - shownSpans - timedShown
-            // The overflow row is part of the day column too: tapping it (whether
-            // it shows "+N" or is blank) opens that day, same as the app.
             Box(
-                modifier = GlanceModifier
-                    .width(colW)
-                    .height(LANE_HEIGHT)
-                    .clickable(openDayAction(context, date)),
+                modifier = GlanceModifier.width(colW).height(LANE_HEIGHT),
                 contentAlignment = Alignment.CenterStart,
             ) {
                 if (hidden > 0) {

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

@@ -1,7 +1,7 @@
-<?xml version="1.0" encoding="utf-8"?>
 <resources>
     <string name="app_name">Calendula</string>
     <string name="app_tagline">Ein moderner Kalender.</string>
+
     <string name="state_loading">Lädt…</string>
     <string name="state_retry">Erneut versuchen</string>
     <string name="state_failure_unknown">Etwas ist schiefgelaufen.</string>
@@ -10,6 +10,7 @@
     <string name="state_failure_no_calendars">Keine Kalender eingerichtet.</string>
     <string name="state_failure_no_calendars_action">System-Kalender-Einstellungen öffnen</string>
     <string name="state_failure_provider">Kalender konnte nicht gelesen werden.</string>
+
     <!-- Permission-Flow (F1) -->
     <string name="permission_rationale_title">Alle Termine, schön im Blick</string>
     <string name="permission_rationale_body">Calendula braucht Zugriff auf deinen Kalender, um deine Termine zu zeigen und zu verwalten. Mehr verlangt die App nie.</string>
@@ -25,6 +26,7 @@
     <string name="permission_benefit_privacy_title">Kein Tracking, niemals</string>
     <string name="permission_benefit_privacy_body">Keine Telemetrie, keine Analyse, keine Werbung.</string>
     <string name="permission_privacy_footnote">Bleibt auf deinem Gerät · keine Internet-Berechtigung</string>
+
     <!-- Monatsansicht (S1) -->
     <string name="month_prev">Vorheriger Monat</string>
     <string name="month_next">Nächster Monat</string>
@@ -33,11 +35,14 @@
     <string name="month_open_menu">Menü öffnen</string>
     <string name="month_action_settings">Einstellungen</string>
     <string name="month_a11y_today_prefix">Heute</string>
+
     <!-- Wochenansicht (S2) -->
     <string name="week_today_action">Diese Woche</string>
     <string name="week_number_label">KW</string>
+
     <!-- Tagesansicht (S3) -->
     <string name="day_today_action">Heute</string>
+
     <!-- Event-Detail-Screen (S4) -->
     <string name="event_detail_back">Zurück</string>
     <string name="event_detail_edit">Bearbeiten</string>
@@ -56,6 +61,7 @@
     <string name="event_delete_write_denied">Calendula braucht Schreibzugriff, um Termine zu löschen</string>
     <string name="dialog_cancel">Abbrechen</string>
     <string name="dialog_ok">OK</string>
+
     <!-- Termin-Formular (v1.2 Erstellen) -->
     <string name="event_edit_new_title">Neuer Termin</string>
     <string name="event_edit_close">Schließen</string>
@@ -88,6 +94,7 @@
     <string name="reminder_unit_weeks">Wochen</string>
     <string name="event_edit_availability">Verfügbarkeit</string>
     <string name="event_edit_visibility">Sichtbarkeit</string>
+
     <!-- Termin-Formular — eigene Terminfarbe -->
     <string name="event_edit_color">Farbe</string>
     <string name="event_edit_color_default">Kalenderfarbe</string>
@@ -96,6 +103,7 @@
     <string name="event_edit_color_unsupported">Für diesen Kalender nicht verfügbar</string>
     <string name="event_edit_color_unsupported_hint">Dieser Kalender stellt keine Farbpalette bereit. Du kannst eigene Farben für solche Kalender in den Einstellungen aktivieren.</string>
     <string name="event_edit_color_sync_warning">Dieser Kalender verwirft oder überschreibt die Farbe unter Umständen bei der nächsten Synchronisierung.</string>
+
     <!-- Termin-Formular — Speicher-Konflikt (v2.0) -->
     <string name="event_edit_conflict_title">Termin wurde extern geändert</string>
     <string name="event_edit_conflict_body">Während du bearbeitet hast, wurde dieser Termin anderswo geändert — durch Synchronisierung oder eine andere App. Was soll mit deinen Änderungen passieren?</string>
@@ -105,6 +113,7 @@
     <string name="event_edit_conflict_discard_hint">Der Termin bleibt, wie er jetzt ist</string>
     <string name="event_edit_gone_title">Termin wurde gelöscht</string>
     <string name="event_edit_gone_body">Dieser Termin wurde zwischenzeitlich gelöscht, etwa auf einem anderen Gerät. Deine Änderungen können nicht mehr gespeichert werden.</string>
+
     <!-- Termin-Formular — Wiederholungs-Picker (v1.3) -->
     <string name="event_edit_recurrence_none">Wiederholt sich nicht</string>
     <string name="event_edit_recurrence_custom">Benutzerdefiniert</string>
@@ -147,6 +156,7 @@
     <string name="event_attendee_tentative">Vorläufig</string>
     <string name="event_attendee_needs_action">Keine Antwort</string>
     <string name="event_attendee_unknown">—</string>
+
     <!-- Event-Detail — vollständiges Auslesen (v0.6) -->
     <string name="event_detail_reminders">Erinnerungen</string>
     <string name="event_detail_timezone">Zeitzone</string>
@@ -186,8 +196,10 @@
         <item quantity="one">%d Stunde</item>
         <item quantity="other">%d Stunden</item>
     </plurals>
+
     <!-- Geteilte Event-Strings -->
     <string name="event_untitled">(Ohne Titel)</string>
+
     <!-- Erinnerungs-Benachrichtigungen (v1.4) -->
     <string name="reminder_channel_name">Termin-Erinnerungen</string>
     <string name="reminder_channel_description">Benachrichtigungen zu den Erinnerungszeiten deiner Termine</string>
@@ -203,19 +215,23 @@
     <string name="reminder_onboarding_skip_button">Später</string>
     <string name="reminder_action_snooze">Schlummern</string>
     <string name="reminder_action_dismiss">Verwerfen</string>
+
     <!-- View-Switcher (M1) -->
     <string name="view_month">Monat</string>
     <string name="view_week">Woche</string>
     <string name="view_day">Tag</string>
     <string name="view_agenda">Agenda</string>
     <string name="view_section">Ansicht</string>
+
     <!-- Zu Datum springen (Navigationsleiste) -->
     <string name="drawer_jump_to_date">Zu Datum springen</string>
+
     <!-- Agenda-Ansicht -->
     <string name="agenda_today_action">Heute</string>
     <string name="agenda_header_today">Heute</string>
     <string name="agenda_header_tomorrow">Morgen</string>
     <string name="agenda_empty_title">Alles erledigt</string>
+
     <!-- Terminsuche -->
     <string name="search_action">Suchen</string>
     <string name="search_hint">Termine suchen</string>
@@ -223,6 +239,7 @@
     <string name="search_clear">Löschen</string>
     <string name="search_idle_hint">Durchsuche deine Termine nach Titel, Ort oder Notizen.</string>
     <string name="search_empty">Keine Termine passen zu „%1$s“.</string>
+
     <!-- Startbildschirm-Widgets -->
     <string name="widget_agenda_title">Anstehend</string>
     <string name="widget_agenda_label">Calendula Agenda</string>
@@ -233,15 +250,19 @@
     <string name="widget_prev_month">Vorheriger Monat</string>
     <string name="widget_next_month">Nächster Monat</string>
     <string name="widget_today">Heute</string>
+
     <!-- Verknüpfungen (Long-Press auf das App-Symbol) -->
     <string name="shortcut_new_event_short">Neuer Termin</string>
     <string name="shortcut_new_event_long">Neuen Termin erstellen</string>
+
     <!-- Schnelleinstellungen-Kachel -->
     <string name="qs_tile_new_event_label">Neuer Termin</string>
     <string name="settings_qs_tile">Schnelleinstellungen-Kachel hinzufügen</string>
     <string name="settings_qs_tile_hint">Eine Kachel „Neuer Termin“ zu den Schnelleinstellungen hinzufügen.</string>
+
     <!-- Kalender-Filter (M3) -->
     <string name="filter_title">Kalender</string>
+
     <!-- Einstellungen (M4) -->
     <string name="settings_title">Einstellungen</string>
     <string name="settings_back">Zurück</string>
@@ -295,6 +316,7 @@
     <string name="reminder_none">Keine</string>
     <string name="reminder_use_default">Standard-Erinnerung verwenden</string>
     <string name="reminder_custom_amount">Anzahl</string>
+    <string name="reminder_custom_with_value">Benutzerdefiniert (%1$s)</string>
     <string name="reminder_custom_set">Übernehmen</string>
     <string name="settings_calendar_reminders_hint">Standard pro Kalender überschreiben — getrennt für Termine mit Uhrzeit und ganztägige Termine. Ein Kalender kann den Standard übernehmen, weglassen oder einen eigenen festlegen.</string>
     <string name="settings_calendar_reminder_inherits">Standard (%1$s)</string>
@@ -322,6 +344,7 @@
     <string name="settings_about_logo_desc">Calendula-App-Symbol</string>
     <string name="settings_report_problem">Problem melden</string>
     <string name="settings_report_problem_hint">Absturzbericht senden oder Issue-Tracker öffnen</string>
+
     <!-- Calendar manager -->
     <string name="calendars_title">Kalender</string>
     <string name="calendars_local_header">Deine Kalender</string>
@@ -376,6 +399,7 @@
         <item quantity="one">%d bereits in diesem Kalender übersprungen.</item>
         <item quantity="other">%d bereits in diesem Kalender übersprungen.</item>
     </plurals>
+
     <!-- Absturzberichte: vom Nutzer selbst als Gitea-Issue einreichbar -->
     <string name="crash_dialog_title">Calendula ist abgestürzt</string>
     <string name="crash_dialog_message">Calendula wurde beim letzten Mal unerwartet beendet. Du kannst bei der Behebung helfen, indem du diesen Bericht als Issue sendest. Er bleibt auf deinem Gerät, bis du ihn teilst, und enthält keine persönlichen Daten oder Kalenderinhalte — nur die technischen Angaben unten.</string>

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

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string-array name="backup_interval_units">
-        <item>Minutes</item>
-        <item>Hours</item>
-        <item>Days</item>
-        <item>Weeks</item>
-    </string-array>
-</resources>

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

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string-array name="backup_interval_units">
-        <item>Minutes</item>
-        <item>Hours</item>
-        <item>Days</item>
-        <item>Weeks</item>
-    </string-array>
-</resources>

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

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string-array name="backup_interval_units">
-        <item>Minutes</item>
-        <item>Hours</item>
-        <item>Days</item>
-        <item>Weeks</item>
-    </string-array>
-</resources>

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

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string-array name="backup_interval_units">
-        <item>Minutes</item>
-        <item>Hours</item>
-        <item>Days</item>
-        <item>Weeks</item>
-    </string-array>
-</resources>

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

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string-array name="backup_interval_units">
-        <item>Minutes</item>
-        <item>Hours</item>
-        <item>Days</item>
-        <item>Weeks</item>
-    </string-array>
-</resources>

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

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string-array name="backup_interval_units">
-        <item>Minutes</item>
-        <item>Hours</item>
-        <item>Days</item>
-        <item>Weeks</item>
-    </string-array>
-</resources>

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

@@ -308,12 +308,6 @@
         <item quantity="one">%d day</item>
         <item quantity="other">%d days</item>
     </plurals>
-    <string name="settings_section_views">Views</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>
-    <string name="settings_drawer_order_hint">Drag to reorder the views listed in the navigation menu.</string>
-    <string name="reorder_drag_handle">Drag to reorder</string>
     <string name="settings_section_event_form">New event form</string>
     <string name="settings_form_fields_hint">Fields shown by default — everything else sits behind \"More fields\"</string>
     <string name="settings_autofocus_title">Focus title on new event</string>
@@ -330,6 +324,7 @@
     <string name="reminder_none">None</string>
     <string name="reminder_use_default">Use default reminder</string>
     <string name="reminder_custom_amount">Amount</string>
+    <string name="reminder_custom_with_value">Custom (%1$s)</string>
     <string name="reminder_custom_set">Set</string>
     <string name="settings_calendar_reminders_title">Per-calendar reminders</string>
     <string name="settings_calendar_reminders_hint">Override the default per calendar — separately for timed and all-day events. A calendar can keep the default, drop it, or set its own.</string>
@@ -348,7 +343,6 @@
     <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">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_section_about">About</string>

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

@@ -199,12 +199,11 @@ class EventWriteMapperTest {
         assertThat(values[CalendarContract.Events.TITLE]).isEqualTo("Moved")
         assertThat(values[CalendarContract.Events.EVENT_LOCATION]).isEqualTo("Berlin")
         assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L)
-        // The occurrence's length travels as DURATION, never DTEND — the provider
-        // rejects DTEND on an exception ("Exceptions can't overwrite dtend") and
-        // derives the end from DTSTART + DURATION, clearing the inherited RRULE.
-        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P5400S")
-        assertThat(values).doesNotContainKey(CalendarContract.Events.DTEND)
+        assertThat(values[CalendarContract.Events.DTEND])
+            .isEqualTo(1_781_164_800_000L + 5_400_000L)
+        // A single occurrence never carries its own rule.
         assertThat(values).doesNotContainKey(CalendarContract.Events.RRULE)
+        assertThat(values).doesNotContainKey(CalendarContract.Events.DURATION)
     }
 
     @Test

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

@@ -6,9 +6,6 @@ import androidx.datastore.preferences.core.Preferences
 import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.domain.EventFormField
 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 kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
 import kotlinx.datetime.DayOfWeek
@@ -152,78 +149,6 @@ class SettingsPrefsTest {
         assertThat(prefs.defaultFormFields.first()).isEmpty()
     }
 
-    @Test
-    fun `quick-switch defaults to every view enabled in default order`(@TempDir tempDir: Path) = runTest {
-        val prefs = SettingsPrefs(newDataStore(tempDir))
-        val config = prefs.quickSwitchConfig.first()
-        assertThat(config.order).containsExactlyElementsIn(IMPLEMENTED_VIEWS).inOrder()
-        assertThat(config.enabled).containsExactlyElementsIn(IMPLEMENTED_VIEWS)
-        assertThat(config.cycle).containsExactlyElementsIn(IMPLEMENTED_VIEWS).inOrder()
-    }
-
-    @Test
-    fun `quick-switch config round-trips order and disabled views`(@TempDir tempDir: Path) = runTest {
-        val prefs = SettingsPrefs(newDataStore(tempDir))
-        val config = QuickSwitchConfig(
-            order = listOf(CalendarView.Agenda, CalendarView.Month, CalendarView.Week, CalendarView.Day),
-            enabled = setOf(CalendarView.Agenda, CalendarView.Month),
-        )
-        prefs.setQuickSwitchConfig(config)
-        val loaded = prefs.quickSwitchConfig.first()
-        assertThat(loaded.order).containsExactly(
-            CalendarView.Agenda, CalendarView.Month, CalendarView.Week, CalendarView.Day,
-        ).inOrder()
-        assertThat(loaded.enabled).containsExactly(CalendarView.Agenda, CalendarView.Month)
-        assertThat(loaded.cycle).containsExactly(CalendarView.Agenda, CalendarView.Month).inOrder()
-    }
-
-    @Test
-    fun `quick-switch parse appends missing views enabled and drops unknowns`(@TempDir tempDir: Path) = runTest {
-        val store = newDataStore(tempDir)
-        val prefs = SettingsPrefs(store)
-        // Only Day (disabled) and Week stored, plus a bogus name; Month & Agenda absent.
-        store.updateData { p ->
-            val m = p.toMutablePreferences()
-            m[SettingsPrefs.QUICK_SWITCH_VIEWS_KEY] = "!Day,Week,Hologram"
-            m
-        }
-        val config = prefs.quickSwitchConfig.first()
-        // Stored order first (Day, Week), then the omitted views in default order.
-        assertThat(config.order).containsExactly(
-            CalendarView.Day, CalendarView.Week, CalendarView.Month, CalendarView.Agenda,
-        ).inOrder()
-        // Day was explicitly disabled; the appended Month & Agenda default enabled.
-        assertThat(config.enabled).containsExactly(
-            CalendarView.Week, CalendarView.Month, CalendarView.Agenda,
-        )
-    }
-
-    @Test
-    fun `drawer order defaults to the implemented order and round-trips`(@TempDir tempDir: Path) = runTest {
-        val prefs = SettingsPrefs(newDataStore(tempDir))
-        assertThat(prefs.drawerViewOrder.first()).containsExactlyElementsIn(IMPLEMENTED_VIEWS).inOrder()
-        prefs.setDrawerViewOrder(
-            listOf(CalendarView.Agenda, CalendarView.Day, CalendarView.Week, CalendarView.Month),
-        )
-        assertThat(prefs.drawerViewOrder.first()).containsExactly(
-            CalendarView.Agenda, CalendarView.Day, CalendarView.Week, CalendarView.Month,
-        ).inOrder()
-    }
-
-    @Test
-    fun `drawer order parse appends missing views and drops unknowns`(@TempDir tempDir: Path) = runTest {
-        val store = newDataStore(tempDir)
-        val prefs = SettingsPrefs(store)
-        store.updateData { p ->
-            val m = p.toMutablePreferences()
-            m[SettingsPrefs.DRAWER_VIEW_ORDER_KEY] = "Agenda,Nope,Week"
-            m
-        }
-        assertThat(prefs.drawerViewOrder.first()).containsExactly(
-            CalendarView.Agenda, CalendarView.Week, CalendarView.Month, CalendarView.Day,
-        ).inOrder()
-    }
-
     @Test
     fun `unknown stored form-field names are dropped`(@TempDir tempDir: Path) = runTest {
         val store = newDataStore(tempDir)
@@ -258,38 +183,22 @@ class SettingsPrefsTest {
     }
 
     @Test
-    fun `default reminder is empty until set`(@TempDir tempDir: Path) = runTest {
+    fun `default reminder is none until set`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
-        assertThat(prefs.defaultReminderMinutes.first()).isEmpty()
+        assertThat(prefs.defaultReminderMinutes.first()).isNull()
     }
 
     @Test
-    fun `default reminder round-trips none, single, and multiple lead times`(@TempDir tempDir: Path) = runTest {
+    fun `default reminder round-trips, including none`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
-        prefs.setDefaultReminderMinutes(listOf(30))
-        assertThat(prefs.defaultReminderMinutes.first()).containsExactly(30)
-        // Several lead times persist, normalised to distinct ascending order.
-        prefs.setDefaultReminderMinutes(listOf(10_080, 0, 30, 30))
-        assertThat(prefs.defaultReminderMinutes.first()).containsExactly(0, 30, 10_080).inOrder()
-        prefs.setDefaultReminderMinutes(emptyList())
-        assertThat(prefs.defaultReminderMinutes.first()).isEmpty()
+        prefs.setDefaultReminderMinutes(30)
+        assertThat(prefs.defaultReminderMinutes.first()).isEqualTo(30)
+        prefs.setDefaultReminderMinutes(null)
+        assertThat(prefs.defaultReminderMinutes.first()).isNull()
     }
 
     @Test
-    fun `legacy single-value default reminder parses as a one-element list`(@TempDir tempDir: Path) = runTest {
-        val store = newDataStore(tempDir)
-        val prefs = SettingsPrefs(store)
-        // The pre-multi-reminder format stored a bare integer string.
-        store.updateData { p ->
-            val m = p.toMutablePreferences()
-            m[SettingsPrefs.DEFAULT_REMINDER_KEY] = "30"
-            m
-        }
-        assertThat(prefs.defaultReminderMinutes.first()).containsExactly(30)
-    }
-
-    @Test
-    fun `garbage stored default reminder reads as empty`(@TempDir tempDir: Path) = runTest {
+    fun `garbage stored default reminder reads as none`(@TempDir tempDir: Path) = runTest {
         val store = newDataStore(tempDir)
         val prefs = SettingsPrefs(store)
         store.updateData { p ->
@@ -297,7 +206,7 @@ class SettingsPrefsTest {
             m[SettingsPrefs.DEFAULT_REMINDER_KEY] = "soon"
             m
         }
-        assertThat(prefs.defaultReminderMinutes.first()).isEmpty()
+        assertThat(prefs.defaultReminderMinutes.first()).isNull()
     }
 
     @Test
@@ -305,16 +214,16 @@ class SettingsPrefsTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
         assertThat(prefs.perCalendarReminderOverride.first()).isEmpty()
 
-        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(listOf(15, 10_080)))
+        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(15))
         prefs.setCalendarReminderOverride(9L, CalendarReminderOverride.None)
         prefs.perCalendarReminderOverride.first().let { map ->
-            assertThat(map).containsExactly(7L, listOf(15, 10_080), 9L, emptyList<Int>())
+            assertThat(map).containsExactly(7L, 15, 9L, null)
         }
 
-        // Inherit drops the override entirely (absent != an empty-list value).
+        // Inherit drops the override entirely (absent != null value).
         prefs.setCalendarReminderOverride(9L, CalendarReminderOverride.Inherit)
         prefs.perCalendarReminderOverride.first().let { map ->
-            assertThat(map).containsExactly(7L, listOf(15, 10_080))
+            assertThat(map).containsExactly(7L, 15)
             assertThat(map.containsKey(9L)).isFalse()
         }
     }
@@ -322,48 +231,48 @@ class SettingsPrefsTest {
     @Test
     fun `all-day default round-trips, including none`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
-        assertThat(prefs.defaultAllDayReminderMinutes.first()).isEmpty()
-        prefs.setDefaultAllDayReminderMinutes(listOf(1_440))
-        assertThat(prefs.defaultAllDayReminderMinutes.first()).containsExactly(1_440)
-        prefs.setDefaultAllDayReminderMinutes(emptyList())
-        assertThat(prefs.defaultAllDayReminderMinutes.first()).isEmpty()
+        assertThat(prefs.defaultAllDayReminderMinutes.first()).isNull()
+        prefs.setDefaultAllDayReminderMinutes(1_440)
+        assertThat(prefs.defaultAllDayReminderMinutes.first()).isEqualTo(1_440)
+        prefs.setDefaultAllDayReminderMinutes(null)
+        assertThat(prefs.defaultAllDayReminderMinutes.first()).isNull()
     }
 
     @Test
     fun `per-calendar all-day override round-trips independently of the timed one`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
-        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(listOf(15)))
-        prefs.setCalendarAllDayReminderOverride(7L, CalendarReminderOverride.Minutes(listOf(1_440)))
-        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, listOf(15))
-        assertThat(prefs.perCalendarAllDayReminderOverride.first()).containsExactly(7L, listOf(1_440))
+        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(15))
+        prefs.setCalendarAllDayReminderOverride(7L, CalendarReminderOverride.Minutes(1_440))
+        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, 15)
+        assertThat(prefs.perCalendarAllDayReminderOverride.first()).containsExactly(7L, 1_440)
         // Clearing the all-day override leaves the timed one untouched.
         prefs.setCalendarAllDayReminderOverride(7L, CalendarReminderOverride.Inherit)
         assertThat(prefs.perCalendarAllDayReminderOverride.first()).isEmpty()
-        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, listOf(15))
+        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, 15)
     }
 
     @Test
     fun `resolveDefaultReminder picks the kind-matching override or global`() {
-        val timed = mapOf(7L to listOf(15, 10_080), 9L to emptyList<Int>())
-        val allDay = mapOf(7L to listOf(2_880))
+        val timed = mapOf(7L to 15, 9L to null)
+        val allDay = mapOf(7L to 2_880)
         fun resolve(calendarId: Long?, isAllDay: Boolean) = resolveDefaultReminder(
-            timedGlobal = listOf(30),
-            allDayGlobal = listOf(1_440),
+            timedGlobal = 30,
+            allDayGlobal = 1_440,
             timedOverrides = timed,
             allDayOverrides = allDay,
             calendarId = calendarId,
             isAllDay = isAllDay,
         )
-        // Timed: multi-value override, explicit none, inherit global, no calendar.
-        assertThat(resolve(7L, isAllDay = false)).containsExactly(15, 10_080).inOrder()
-        assertThat(resolve(9L, isAllDay = false)).isEmpty()
-        assertThat(resolve(5L, isAllDay = false)).containsExactly(30)
-        assertThat(resolve(null, isAllDay = false)).containsExactly(30)
+        // Timed: minutes override, explicit none, inherit global, no calendar.
+        assertThat(resolve(7L, isAllDay = false)).isEqualTo(15)
+        assertThat(resolve(9L, isAllDay = false)).isNull()
+        assertThat(resolve(5L, isAllDay = false)).isEqualTo(30)
+        assertThat(resolve(null, isAllDay = false)).isEqualTo(30)
         // All-day: its own override wins; absent → all-day global; a timed-only
         // override (cal 9) does not bleed into all-day.
-        assertThat(resolve(7L, isAllDay = true)).containsExactly(2_880)
-        assertThat(resolve(9L, isAllDay = true)).containsExactly(1_440)
-        assertThat(resolve(5L, isAllDay = true)).containsExactly(1_440)
+        assertThat(resolve(7L, isAllDay = true)).isEqualTo(2_880)
+        assertThat(resolve(9L, isAllDay = true)).isEqualTo(1_440)
+        assertThat(resolve(5L, isAllDay = true)).isEqualTo(1_440)
     }
 
     @Test

app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/PostableAlertsTest.kt

@@ -1,55 +0,0 @@
-package de.jeanlucmakiola.calendula.data.reminders
-
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-
-class PostableAlertsTest {
-
-    private fun alert(alertId: Long, calendarId: Long) = ReminderAlert(
-        alertId = alertId,
-        eventId = alertId * 10,
-        calendarId = calendarId,
-        beginMillis = 0L,
-        endMillis = 0L,
-        title = "Event $alertId",
-        location = null,
-        isAllDay = false,
-    )
-
-    @Test
-    fun `keeps alerts when no calendar is disabled`() {
-        val due = listOf(alert(1, calendarId = 100), alert(2, calendarId = 200))
-
-        val postable = postableAlerts(due, disabledCalendarIds = emptySet())
-
-        assertThat(postable).isEqualTo(due)
-    }
-
-    @Test
-    fun `drops alerts for a disabled calendar`() {
-        val keep = alert(1, calendarId = 100)
-        val drop = alert(2, calendarId = 200)
-
-        val postable = postableAlerts(listOf(keep, drop), disabledCalendarIds = setOf(200))
-
-        assertThat(postable).containsExactly(keep)
-    }
-
-    @Test
-    fun `drops every alert when all their calendars are disabled`() {
-        val due = listOf(alert(1, calendarId = 100), alert(2, calendarId = 100))
-
-        val postable = postableAlerts(due, disabledCalendarIds = setOf(100))
-
-        assertThat(postable).isEmpty()
-    }
-
-    @Test
-    fun `keeps multiple alerts from the same enabled calendar`() {
-        val due = listOf(alert(1, calendarId = 100), alert(2, calendarId = 100))
-
-        val postable = postableAlerts(due, disabledCalendarIds = setOf(999))
-
-        assertThat(postable).isEqualTo(due)
-    }
-}

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

@@ -1,214 +0,0 @@
-package de.jeanlucmakiola.calendula.domain
-
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-
-class EventColorPaletteTest {
-
-    @Test
-    fun `empty palette stays empty`() {
-        assertThat(emptyList<EventColorOption>().curatedForPicker()).isEmpty()
-    }
-
-    @Test
-    fun `exact duplicate values collapse to the alphabetically first key`() {
-        val curated = listOf(
-            EventColorOption("cyan", 0xFF00FFFF.toInt()),
-            EventColorOption("aqua", 0xFF00FFFF.toInt()),
-            EventColorOption("red", 0xFFFF0000.toInt()),
-        ).curatedForPicker()
-
-        assertThat(curated.map { it.key }).containsExactly("aqua", "red")
-    }
-
-    @Test
-    fun `small palettes pass through whole, so Google's curated set is untouched`() {
-        // A Google-like palette: two dozen distinct hand-picked colours.
-        val palette = (0 until 24).map {
-            val hue = it * 15
-            EventColorOption("$it", hsvArgb(hue.toFloat()))
-        }
-
-        val curated = palette.curatedForPicker()
-
-        assertThat(curated).containsExactlyElementsIn(palette)
-    }
-
-    @Test
-    fun `oversized CSS3 palette thins to a pickable number of distinct swatches`() {
-        val curated = css3Palette().curatedForPicker()
-
-        // The whole point of #22: ~147 published colours become a single
-        // manageable grid instead of a full screen.
-        assertThat(curated.size).isAtLeast(30)
-        assertThat(curated.size).isAtMost(60)
-    }
-
-    @Test
-    fun `curation never invents colours or drops keys`() {
-        val source = css3Palette()
-        val curated = source.curatedForPicker()
-
-        assertThat(source).containsAtLeastElementsIn(curated)
-        assertThat(curated.map { it.argb }).containsNoDuplicates()
-    }
-
-    @Test
-    fun `spelling-alias pairs never both survive`() {
-        val keys = css3Palette().curatedForPicker().map { it.key }.toSet()
-
-        val aliasPairs = listOf(
-            "aqua" to "cyan",
-            "fuchsia" to "magenta",
-            "gray" to "grey",
-            "darkgray" to "darkgrey",
-            "dimgray" to "dimgrey",
-            "lightgray" to "lightgrey",
-            "slategray" to "slategrey",
-            "lightslategray" to "lightslategrey",
-            "darkslategray" to "darkslategrey",
-        )
-        aliasPairs.forEach { (a, b) ->
-            assertThat(keys.contains(a) && keys.contains(b)).isFalse()
-        }
-    }
-
-    @Test
-    fun `neutrals collapse to one painted tint instead of a run of look-alikes`() {
-        // Black and every gray paint as the same pale swatch (the picker pins
-        // lightness and floors saturation), so only one survives — no stranded
-        // run of look-alike "pinks" at the end of the grid (#22).
-        val curated = listOf(
-            EventColorOption("black", 0xFF000000.toInt()),
-            EventColorOption("gray", 0xFF808080.toInt()),
-            EventColorOption("darkgray", 0xFFA9A9A9.toInt()),
-            EventColorOption("blue", 0xFF0000FF.toInt()),
-            EventColorOption("red", 0xFFFF0000.toInt()),
-        ).curatedForPicker().map { it.key }
-
-        assertThat(curated).containsNoneOf("gray", "darkgray") // folded into black
-        assertThat(curated).containsAtLeast("black", "red", "blue")
-    }
-
-    @Test
-    fun `a dark and a light shade of one hue collapse to a single swatch`() {
-        // The picker paints every swatch at one fixed lightness, so navy and a
-        // mid blue are indistinguishable once painted — keep just one.
-        val curated = listOf(
-            EventColorOption("navy", 0xFF000080.toInt()),
-            EventColorOption("blue", 0xFF0000FF.toInt()),
-        ).curatedForPicker()
-
-        assertThat(curated).hasSize(1)
-    }
-
-    @Test
-    fun `the wheel is cut once, keeping each hue family contiguous`() {
-        // Twelve pure hues, deliberately shuffled; a small palette passes the
-        // thinning stage untouched so only the ordering is under test.
-        val shuffledHues = listOf(0, 300, 60, 180, 120, 240, 30, 330, 90, 210, 150, 270)
-        val curated = shuffledHues
-            .map { EventColorOption("$it", hsvArgb(it.toFloat())) }
-            .curatedForPicker()
-            .map { it.key.toInt() }
-
-        // A proper single-seam sweep around the wheel descends exactly once
-        // (at the seam). The old bucketed sort could scatter a family across
-        // both ends, producing extra descents.
-        val descents = curated.indices.count { i ->
-            curated[(i + 1) % curated.size] < curated[i]
-        }
-        assertThat(descents).isEqualTo(1)
-    }
-
-    @Test
-    fun `CSS3 survivors span the whole rainbow`() {
-        val keys = css3Palette().curatedForPicker().map { it.key }
-        fun has(vararg families: String) = keys.any { k -> families.any { k.contains(it) } }
-
-        // Which exact name represents a hue family depends on the vivid-first
-        // thinning, so assert each family survives, not a specific key.
-        assertThat(has("red", "crimson", "firebrick", "tomato", "maroon", "brown")).isTrue()
-        assertThat(has("orange", "gold", "goldenrod", "peru", "sienna", "salmon")).isTrue()
-        assertThat(has("green", "olive", "lime", "chartreuse", "forest", "sea")).isTrue()
-        assertThat(has("blue", "navy", "dodger", "steel", "royal", "sky", "aqua")).isTrue()
-        assertThat(has("violet", "purple", "magenta", "orchid", "fuchsia", "indigo", "plum")).isTrue()
-    }
-
-    private fun hsvArgb(hue: Float): Int {
-        val h = hue / 60f
-        val sector = h.toInt() % 6
-        val f = h - h.toInt()
-        val q = ((1 - f) * 255).toInt()
-        val t = (f * 255).toInt()
-        return when (sector) {
-            0 -> argb(255, t, 0)
-            1 -> argb(q, 255, 0)
-            2 -> argb(0, 255, t)
-            3 -> argb(0, q, 255)
-            4 -> argb(t, 0, 255)
-            else -> argb(255, 0, q)
-        }
-    }
-
-    private fun argb(r: Int, g: Int, b: Int): Int =
-        (0xFF shl 24) or (r shl 16) or (g shl 8) or b
-
-    /** The exact set ical4android/DAVx5 publishes: CSS3's 147 named colours. */
-    private fun css3Palette(): List<EventColorOption> = CSS3.map { (name, rgb) ->
-        EventColorOption(name, 0xFF000000.toInt() or rgb)
-    }
-
-    private val CSS3 = mapOf(
-        "aliceblue" to 0xF0F8FF, "antiquewhite" to 0xFAEBD7, "aqua" to 0x00FFFF,
-        "aquamarine" to 0x7FFFD4, "azure" to 0xF0FFFF, "beige" to 0xF5F5DC,
-        "bisque" to 0xFFE4C4, "black" to 0x000000, "blanchedalmond" to 0xFFEBCD,
-        "blue" to 0x0000FF, "blueviolet" to 0x8A2BE2, "brown" to 0xA52A2A,
-        "burlywood" to 0xDEB887, "cadetblue" to 0x5F9EA0, "chartreuse" to 0x7FFF00,
-        "chocolate" to 0xD2691E, "coral" to 0xFF7F50, "cornflowerblue" to 0x6495ED,
-        "cornsilk" to 0xFFF8DC, "crimson" to 0xDC143C, "cyan" to 0x00FFFF,
-        "darkblue" to 0x00008B, "darkcyan" to 0x008B8B, "darkgoldenrod" to 0xB8860B,
-        "darkgray" to 0xA9A9A9, "darkgreen" to 0x006400, "darkgrey" to 0xA9A9A9,
-        "darkkhaki" to 0xBDB76B, "darkmagenta" to 0x8B008B, "darkolivegreen" to 0x556B2F,
-        "darkorange" to 0xFF8C00, "darkorchid" to 0x9932CC, "darkred" to 0x8B0000,
-        "darksalmon" to 0xE9967A, "darkseagreen" to 0x8FBC8F, "darkslateblue" to 0x483D8B,
-        "darkslategray" to 0x2F4F4F, "darkslategrey" to 0x2F4F4F, "darkturquoise" to 0x00CED1,
-        "darkviolet" to 0x9400D3, "deeppink" to 0xFF1493, "deepskyblue" to 0x00BFFF,
-        "dimgray" to 0x696969, "dimgrey" to 0x696969, "dodgerblue" to 0x1E90FF,
-        "firebrick" to 0xB22222, "floralwhite" to 0xFFFAF0, "forestgreen" to 0x228B22,
-        "fuchsia" to 0xFF00FF, "gainsboro" to 0xDCDCDC, "ghostwhite" to 0xF8F8FF,
-        "gold" to 0xFFD700, "goldenrod" to 0xDAA520, "gray" to 0x808080,
-        "green" to 0x008000, "greenyellow" to 0xADFF2F, "grey" to 0x808080,
-        "honeydew" to 0xF0FFF0, "hotpink" to 0xFF69B4, "indianred" to 0xCD5C5C,
-        "indigo" to 0x4B0082, "ivory" to 0xFFFFF0, "khaki" to 0xF0E68C,
-        "lavender" to 0xE6E6FA, "lavenderblush" to 0xFFF0F5, "lawngreen" to 0x7CFC00,
-        "lemonchiffon" to 0xFFFACD, "lightblue" to 0xADD8E6, "lightcoral" to 0xF08080,
-        "lightcyan" to 0xE0FFFF, "lightgoldenrodyellow" to 0xFAFAD2, "lightgray" to 0xD3D3D3,
-        "lightgreen" to 0x90EE90, "lightgrey" to 0xD3D3D3, "lightpink" to 0xFFB6C1,
-        "lightsalmon" to 0xFFA07A, "lightseagreen" to 0x20B2AA, "lightskyblue" to 0x87CEFA,
-        "lightslategray" to 0x778899, "lightslategrey" to 0x778899, "lightsteelblue" to 0xB0C4DE,
-        "lightyellow" to 0xFFFFE0, "lime" to 0x00FF00, "limegreen" to 0x32CD32,
-        "linen" to 0xFAF0E6, "magenta" to 0xFF00FF, "maroon" to 0x800000,
-        "mediumaquamarine" to 0x66CDAA, "mediumblue" to 0x0000CD, "mediumorchid" to 0xBA55D3,
-        "mediumpurple" to 0x9370DB, "mediumseagreen" to 0x3CB371, "mediumslateblue" to 0x7B68EE,
-        "mediumspringgreen" to 0x00FA9A, "mediumturquoise" to 0x48D1CC,
-        "mediumvioletred" to 0xC71585, "midnightblue" to 0x191970, "mintcream" to 0xF5FFFA,
-        "mistyrose" to 0xFFE4E1, "moccasin" to 0xFFE4B5, "navajowhite" to 0xFFDEAD,
-        "navy" to 0x000080, "oldlace" to 0xFDF5E6, "olive" to 0x808000,
-        "olivedrab" to 0x6B8E23, "orange" to 0xFFA500, "orangered" to 0xFF4500,
-        "orchid" to 0xDA70D6, "palegoldenrod" to 0xEEE8AA, "palegreen" to 0x98FB98,
-        "paleturquoise" to 0xAFEEEE, "palevioletred" to 0xDB7093, "papayawhip" to 0xFFEFD5,
-        "peachpuff" to 0xFFDAB9, "peru" to 0xCD853F, "pink" to 0xFFC0CB,
-        "plum" to 0xDDA0DD, "powderblue" to 0xB0E0E6, "purple" to 0x800080,
-        "red" to 0xFF0000, "rosybrown" to 0xBC8F8F, "royalblue" to 0x4169E1,
-        "saddlebrown" to 0x8B4513, "salmon" to 0xFA8072, "sandybrown" to 0xF4A460,
-        "seagreen" to 0x2E8B57, "seashell" to 0xFFF5EE, "sienna" to 0xA0522D,
-        "silver" to 0xC0C0C0, "skyblue" to 0x87CEEB, "slateblue" to 0x6A5ACD,
-        "slategray" to 0x708090, "slategrey" to 0x708090, "snow" to 0xFFFAFA,
-        "springgreen" to 0x00FF7F, "steelblue" to 0x4682B4, "tan" to 0xD2B48C,
-        "teal" to 0x008080, "thistle" to 0xD8BFD8, "tomato" to 0xFF6347,
-        "turquoise" to 0x40E0D0, "violet" to 0xEE82EE, "wheat" to 0xF5DEB3,
-        "white" to 0xFFFFFF, "whitesmoke" to 0xF5F5F5, "yellow" to 0xFFFF00,
-        "yellowgreen" to 0x9ACD32,
-    )
-}

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

@@ -91,33 +91,4 @@ class ViewBackStackTest {
         assertThat(viewBaseStack(CalendarView.Agenda, CalendarView.Agenda))
             .containsExactly(CalendarView.Agenda)
     }
-
-    @Test
-    fun `next cycles through the configured views in order, wrapping around`() {
-        val cycle = listOf(CalendarView.Month, CalendarView.Agenda)
-        assertThat(CalendarView.Month.next(cycle)).isEqualTo(CalendarView.Agenda)
-        // Wraps back to the first from the last.
-        assertThat(CalendarView.Agenda.next(cycle)).isEqualTo(CalendarView.Month)
-    }
-
-    @Test
-    fun `next from a view outside the cycle lands on the first enabled view`() {
-        // Day was disabled in the quick-switch cycle but is still the current view.
-        val cycle = listOf(CalendarView.Week, CalendarView.Month)
-        assertThat(CalendarView.Day.next(cycle)).isEqualTo(CalendarView.Week)
-    }
-
-    @Test
-    fun `next on an empty cycle stays put`() {
-        assertThat(CalendarView.Week.next(emptyList())).isEqualTo(CalendarView.Week)
-    }
-
-    @Test
-    fun `quick-switch cycle keeps enabled views in their configured order`() {
-        val config = QuickSwitchConfig(
-            order = listOf(CalendarView.Agenda, CalendarView.Day, CalendarView.Month, CalendarView.Week),
-            enabled = setOf(CalendarView.Agenda, CalendarView.Month),
-        )
-        assertThat(config.cycle).containsExactly(CalendarView.Agenda, CalendarView.Month).inOrder()
-    }
 }

docs/design/contact-special-dates.md

@@ -0,0 +1,229 @@
+# Design: Contact special-dates calendars (+ per-calendar multiple reminders)
+
+Status: **design / not yet implemented**
+Date: 2026-06-30
+Tracking: Codeberg #15 (feature), Codeberg #14 (prerequisite)
+
+This document captures the full design for surfacing contact birthdays —
+and, by extension, anniversaries and custom dates — as auto-updating local
+calendars in Calendula. It also specifies #14 (per-calendar *multiple*
+default reminders), which is a hard prerequisite and ships first.
+
+The two pieces are deliberately split across **two branches / two
+shipments**:
+
+- `feat/per-calendar-multi-reminders` — #14, ships first.
+- `feat/contact-special-dates` — #15, builds on #14.
+
+They *may* release together depending on timing, but #14 is independently
+useful and is the foundation the special-dates calendars lean on.
+
+---
+
+## Why this is worth doing carefully
+
+Calendula's identity is privacy: **no INTERNET permission**, and historically
+**no `READ_CONTACTS`** — guest-picking uses a one-shot `ACTION_PICK` so the app
+never holds the contacts permission (`EventEditScreen.kt:446-460`).
+
+This feature **declares `READ_CONTACTS`** for the first time. That is a
+deliberate, owner-approved shift, mitigated by:
+
+- The permission is **opt-in and feature-gated** — requested only when the user
+  enables the feature, never at startup.
+- Everything stays **offline**. Contacts are read locally and mirrored into a
+  local calendar; nothing leaves the device.
+- The mirror is **one-way** (contacts → calendar). Calendula never writes to
+  Contacts.
+
+Store listing / About copy will need to explain the optional permission.
+
+---
+
+## Prerequisite — #14: per-calendar *multiple* default reminders
+
+### Today
+
+- Events already support **multiple reminders** — `EventForm.reminders:
+  List<Int>` (`EventForm.kt:24`), each written as a separate
+  `CalendarContract.Reminders` row (`CalendarDataSource.kt:620-630`), each
+  firing independently. The runtime/notification path is done.
+- The **defaults** layer is single-valued, though:
+  - Global: `defaultReminderMinutes` / `defaultAllDayReminderMinutes` — single
+    `Int` (`SettingsPrefs.kt:287,302`).
+  - Per-calendar override: `perCalendarReminderOverride: Map<Long, Int?>` and
+    the all-day variant (`SettingsPrefs.kt:350-381`), resolved by
+    `resolveDefaultReminder()` (`SettingsPrefs.kt:509-524`).
+  - UI: expandable per-calendar override section
+    (`SettingsScreen.kt:879-953`); `ReminderDefaultPicker` (`:956+`).
+
+### The change
+
+Widen the **defaults**, not the runtime, from one reminder to a list:
+
+1. Resolution model `Int` → `List<Int>` in global defaults + per-calendar
+   override + `resolveDefaultReminder()`. The DataStore string format already
+   parses `id=value;id=value` (`SettingsPrefs.kt:576-577`); `value` becomes a
+   comma-separated list. Keep the `Inherit / None / Minutes` override states
+   (`CalendarReminderOverride`, `SettingsPrefs.kt:493-500`) — `Minutes` carries
+   a list.
+2. `ReminderDefaultPicker` → multi-select. Mirror the event-form multi-reminder
+   UI rather than inventing new interaction.
+3. New events seed `EventForm.reminders` from the **resolved list** instead of
+   a single value.
+
+No new permissions, no provider changes, no scheduling changes. Type widening
+plus one picker upgrade.
+
+### Why it gates #15
+
+Each special-dates calendar is a normal local calendar, so it inherits the
+**per-calendar reminder default** for free. A birthdays calendar is useless
+without lead time (the reporter literally asked for "a week before *and* on the
+day") — that requires *multiple* defaults, i.e. #14.
+
+---
+
+## #15: Contact special-dates calendars
+
+### Core model: one-way mirror, one local calendar per type
+
+Contacts → **separate local calendars per type**:
+
+- "Birthdays"
+- "Anniversaries"
+- "Custom dates" (everything else / `TYPE_OTHER` / `TYPE_CUSTOM`)
+
+Separate-per-type is the key architectural decision: each is a normal local
+calendar (`createLocalCalendar()`, `CalendarDataSource.kt:238-260`), so the
+**existing per-calendar infra applies for free**:
+
+- **Color** → existing per-calendar color.
+- **Show/hide** → existing calendar visibility.
+- **Default reminders** → per-calendar override from #14.
+
+This shrinks the new surface dramatically: anniversaries and custom dates are
+near copy-paste of birthdays (same engine, different `ContactsContract` data
+kind, one extra local calendar each), and the settings sub-page does **not**
+need to reinvent color/visibility/reminders.
+
+### Events: field-level managed, not read-only
+
+Calendula manages a few fields; the user owns the rest.
+
+- **Managed** (overwritten on every sync, disabled in the editor for these
+  events): title, start date, recurrence (`FREQ=YEARLY`), existence.
+- **User-owned** (seeded once on insert, never touched again by sync):
+  location, reminders, notes, busy/free.
+
+The rule that makes this safe: sync performs a **targeted column update**
+(managed columns only), **never delete-and-reinsert**. Reminders live in
+separate rows, so once seeded they are simply never re-touched. A user can move
+a birthday reminder to "2 weeks before" or add a location and neither is
+clobbered.
+
+In the editor, when an event belongs to a managed calendar: disable the
+title/date/recurrence fields; allow the rest.
+
+### Reconciliation identity
+
+Stamp each event with the contact's `LOOKUP_KEY` in `Events.SYNC_DATA1` (ours,
+since it's a local calendar). Sync becomes an idempotent diff keyed on it:
+
+- contact added → insert
+- birthday/date changed → targeted update of managed columns
+- contact or date removed → delete the event
+
+Getting this wrong = duplicate birthdays on every sync, so the identity key is
+non-negotiable.
+
+### Data source
+
+`ContactsContract.Data` rows of `Event.CONTENT_ITEM_TYPE`, split by
+`Event.TYPE`:
+
+- `TYPE_BIRTHDAY` → Birthdays calendar
+- `TYPE_ANNIVERSARY` → Anniversaries calendar
+- `TYPE_OTHER` / `TYPE_CUSTOM` (+ label) → Custom dates calendar
+
+### Dates: year-less + age
+
+Many contacts store `--MM-DD` (no year). Handle both:
+
+- **Year present:** anchor `DTSTART` at that year; `FREQ=YEARLY`. We can show
+  age ("Jane turns 30") when the show-age option is on.
+- **Year absent:** `FREQ=YEARLY` from an arbitrary anchor year; no age shown.
+
+Recurrence support is already there: `FREQ=YEARLY` + `UNTIL`/`COUNT`/`INTERVAL`
+(`Recurrence.kt:32-174`).
+
+### Auto-update cadence
+
+Birthdays change rarely, so nothing live/expensive:
+
+- Sync **on enable**, **on app foreground**, and a **daily WorkManager** job
+  (catches new/edited/deleted contacts even if the app isn't opened).
+- **No `ContentObserver`** — needs the process alive and buys almost nothing
+  for once-a-year events.
+
+### Permission + lifecycle
+
+- **Enable:** request `READ_CONTACTS` (feature-gated, contextual — mirror the
+  contextual `WRITE_CALENDAR` pattern at `EventEditScreen.kt:216-231`). On
+  grant, create the enabled calendars and run the first sync.
+- **Disable:** delete the managed calendars + their events (with a confirm).
+- **Permission revoked in system settings:** detect on next sync; surface that
+  the feature is stalled rather than failing silently.
+
+### Configurable settings sub-page
+
+Enabling the feature reveals a **dedicated sub-page** (not inline rows). Because
+color/visibility/reminders already live in normal calendar settings, the
+sub-page only carries the genuinely new knobs:
+
+- Master enable toggle.
+- Per-type toggles: Birthdays / Anniversaries / Custom dates.
+- Title/display template, e.g. `"{name}'s birthday"` (new translatable string).
+- Show-age toggle (only meaningful when the year is known).
+- (Possibly) sync-cadence / "sync now".
+- Pointer to the normal calendar settings for color, visibility, reminders.
+
+The owner wants this broadly configurable — keep the sub-page the home for
+display/behaviour options, and lean on existing per-calendar settings for the
+rest.
+
+---
+
+## Open questions / deferred
+
+- Title template: free-form vs a small set of presets. Start with one good
+  localized default; revisit configurability.
+- Whether "Custom dates" is one bucket or split further by label. Start: one
+  bucket.
+- Contact scope: all contacts vs per-account/group filtering. Start: all;
+  filtering is a later refinement.
+
+## Task outline
+
+### #14 — per-calendar multiple default reminders (`feat/per-calendar-multi-reminders`)
+- [ ] Widen global + per-calendar reminder defaults `Int` → `List<Int>`
+      (`SettingsPrefs.kt`), keep `Inherit/None/Minutes(list)`.
+- [ ] `resolveDefaultReminder()` returns a list.
+- [ ] `ReminderDefaultPicker` → multi-select (mirror event-form UI).
+- [ ] Seed new events' `EventForm.reminders` from the resolved list.
+- [ ] Migration / parse compatibility for existing single-value stored prefs.
+- [ ] Tests: resolution, parse round-trip, all-day variant.
+
+### #15 — contact special-dates (`feat/contact-special-dates`)
+- [ ] Declare `READ_CONTACTS`; feature-gated contextual request on enable.
+- [ ] Per-type local calendars (create on enable, delete on disable+confirm).
+- [ ] Contacts reader: `Event` rows by `TYPE`, year-less handling.
+- [ ] Sync engine: idempotent diff keyed on `LOOKUP_KEY` in `SYNC_DATA1`;
+      targeted managed-column updates; seed user-owned fields on insert only.
+- [ ] `FREQ=YEARLY` event generation + age (when year known).
+- [ ] Auto-update: on enable, on foreground, daily WorkManager.
+- [ ] Editor: disable managed fields for managed-calendar events.
+- [ ] Revoked-permission detection + stalled-state surface.
+- [ ] Settings sub-page: enable, per-type toggles, title template, show-age.
+- [ ] Translatable strings (titles, sub-page).
+- [ ] About / store copy for the optional `READ_CONTACTS` permission.