Merge pull request 'Release 2.14.1' (!72) from release/v2.14.1 into main

Reviewed-on: #72

.gitea/workflows/translations.yaml

@@ -3,15 +3,13 @@ name: Translations
 # Fast, SDK-free parity check for translation resources, so Weblate PRs (which
 # only touch values-*/strings.xml) get quick feedback without the full Android
 # build. The deeper checks still run in CI via lintDebug (ExtraTranslation).
-#
-# Runs on every PR (no path filter) so the required "Translations / check"
-# status is always reported — like the `ci` job. A path-filtered workflow is
-# skipped on unrelated PRs and never posts its status, which leaves that
-# required check pending forever and blocks the merge of any code-only PR into a
-# release/* branch. The check itself is cheap and simply passes when the
-# committed translations are consistent, so always running it costs nothing.
 on:
   pull_request:
+    paths:
+      - 'app/src/main/res/values*/strings.xml'
+      - 'app/src/main/res/xml/locales_config.xml'
+      - 'scripts/check_translations.py'
+      - '.gitea/workflows/translations.yaml'
 
 concurrency:
   group: translations-${{ github.ref }}

CHANGELOG.md

@@ -7,19 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Added
-- A custom snooze duration. The **Snooze duration** setting (Settings →
-  Notifications) gains a **Custom…** option next to the minute presets: pick any
-  amount and switch between minutes and hours, so a snoozed reminder comes back
-  after exactly the delay you want instead of only a preset one ([#40]).
-- Move an event to another calendar. When editing an existing event, the
-  calendar row is now tappable — pick a different calendar and saving moves the
-  event across, instead of having to delete it and recreate it elsewhere.
-  Recurring series move as a whole, keeping their individually-edited and
-  cancelled occurrences, and any reminders and guests come along too. A calendar
-  can't simply be reassigned underneath an event, so Calendula recreates it on
-  the target and removes the original — the same approach other calendar apps
-  take. Thanks to @prismplex for the suggestion ([#39]).
+## [2.14.1] — 2026-07-13
+
+### Fixed
+- Deleting one occurrence of a repeating event no longer breaks the series.
+  Choosing "This event" when deleting an occurrence of a recurring event could
+  wipe out every *other* occurrence while leaving the one you deleted behind as
+  a stale, still-tappable ghost — and deleting it again brought the series back.
+  A single-occurrence delete now removes exactly that occurrence and leaves the
+  rest of the series untouched, and the deleted occurrence disappears from the
+  grid straight away. This holds on every kind of calendar, including the
+  on-device ones Calendula keeps for contact birthdays and anniversaries, where
+  the series is a yearly repeat. Thanks to @moonj for the report ([#47]).
+- Tapping an event in a third-party widget opens it in Calendula. v2.13.1 taught
+  Calendula to answer the "new event" hand-off from other apps and widgets; now
+  it also answers the "open this event" one, so tapping an existing event in a
+  widget such as Todo Agenda offers Calendula and lands on that event's details.
+  Thanks to @bushrang3r for the report ([#48]).
+- Events created from other apps get your default reminder. An event handed over
+  by another app or widget — Google Maps' "add to calendar", the Todo Agenda
+  widget's "+" — opened with no reminder at all, ignoring the default set in
+  Settings. It now starts with your default reminder, the same as an event you
+  create in Calendula. An event opened from an `.ics` file is treated differently,
+  because the file has its own say: Calendula keeps whatever reminders it carries
+  (including none at all) and asks you once whether to apply your default instead
+  — it never quietly overrides the file. If you have no default set, it doesn't
+  ask ([#49]).
+- 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]).
 
 ## [2.14.0] — 2026-07-06
 
@@ -881,6 +903,7 @@ automatically, with zero telemetry and no internet permission.
 [#18]: https://codeberg.org/jlmakiola/calendula/issues/18
 [#19]: https://codeberg.org/jlmakiola/calendula/issues/19
 [#20]: https://codeberg.org/jlmakiola/calendula/issues/20
+[#22]: https://codeberg.org/jlmakiola/calendula/issues/22
 [#24]: https://codeberg.org/jlmakiola/calendula/issues/24
 [#25]: https://codeberg.org/jlmakiola/calendula/issues/25
 [#27]: https://codeberg.org/jlmakiola/calendula/issues/27
@@ -890,5 +913,6 @@ automatically, with zero telemetry and no internet permission.
 [#33]: https://codeberg.org/jlmakiola/calendula/issues/33
 [#34]: https://codeberg.org/jlmakiola/calendula/issues/34
 [#37]: https://codeberg.org/jlmakiola/calendula/issues/37
-[#39]: https://codeberg.org/jlmakiola/calendula/issues/39
-[#40]: https://codeberg.org/jlmakiola/calendula/issues/40
+[#47]: https://codeberg.org/jlmakiola/calendula/issues/47
+[#48]: https://codeberg.org/jlmakiola/calendula/issues/48
+[#49]: https://codeberg.org/jlmakiola/calendula/issues/49

app/build.gradle.kts

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

app/src/main/AndroidManifest.xml

@@ -123,6 +123,22 @@
                 <data android:mimeType="vnd.android.cursor.dir/event" />
             </intent-filter>
 
+            <!-- Open an existing event another app/widget points at (e.g. tapping
+                 an event in the Todo Agenda widget): ACTION_VIEW on
+                 content://com.android.calendar/events/<id>, the way AOSP fires it.
+                 Matched by the provider's item MIME type, not the path — a
+                 content: VIEW intent carries the resolved type
+                 (vnd.android.cursor.item/event) and a path-only filter wouldn't
+                 match it. The occurrence's times ride as EXTRA_EVENT_BEGIN_TIME /
+                 EXTRA_EVENT_END_TIME when the launcher supplies them
+                 (MainActivity.viewEventKeyOrNull, issue #48). -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:mimeType="vnd.android.cursor.item/event" />
+            </intent-filter>
+
             <!-- Launcher long-press shortcuts (e.g. "New event"). -->
             <meta-data
                 android:name="android.app.shortcuts"

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

@@ -32,6 +32,7 @@ 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.detail.EventDetailViewModel.Companion.NO_OCCURRENCE_TIME
 import de.jeanlucmakiola.floret.components.DebugRibbon
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportActivity
 import de.jeanlucmakiola.calendula.domain.FontRole
@@ -90,7 +91,7 @@ class MainActivity : AppCompatActivity() {
         }
 
         enableEdgeToEdge()
-        requestedDetailKey = intent.detailKeyOrNull()
+        requestedDetailKey = intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull()
         requestedNav = intent.navRequestOrNull()
         requestedImportUri = intent.importUriOrNull()
         requestedInsertForm = intent.insertFormOrNull()
@@ -178,7 +179,7 @@ class MainActivity : AppCompatActivity() {
 
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
-        intent.detailKeyOrNull()?.let { requestedDetailKey = it }
+        (intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull())?.let { requestedDetailKey = it }
         intent.navRequestOrNull()?.let { requestedNav = it }
         intent.importUriOrNull()?.let { requestedImportUri = it }
         intent.insertFormOrNull()?.let { requestedInsertForm = it }
@@ -293,6 +294,30 @@ class MainActivity : AppCompatActivity() {
         )
     }
 
+    /**
+     * The detail key for an external "open this event" — ACTION_VIEW on
+     * `content://com.android.calendar/events/<id>`, the way AOSP fires it (e.g.
+     * tapping an existing event in the Todo Agenda widget, issue #48). Reuses the
+     * same occurrence-key channel as reminder taps. The launcher passes the
+     * occurrence's times as `EXTRA_EVENT_BEGIN_TIME` / `EXTRA_EVENT_END_TIME` when
+     * it has them; a bare URI omits them, so we carry [NO_OCCURRENCE_TIME] and
+     * [EventDetailViewModel] falls back to the event row's own DTSTART/DTEND
+     * rather than rendering at the epoch.
+     */
+    private fun Intent.viewEventKeyOrNull(): LongArray? {
+        if (action != Intent.ACTION_VIEW) return null
+        val uri = data ?: return null
+        if (uri.host != CALENDAR_PROVIDER_HOST) return null
+        val segments = uri.pathSegments
+        if (segments.firstOrNull() != "events") return null
+        val eventId = segments.getOrNull(1)?.toLongOrNull() ?: return null
+        return longArrayOf(
+            eventId,
+            longExtraOrNull(CalendarContract.EXTRA_EVENT_BEGIN_TIME) ?: NO_OCCURRENCE_TIME,
+            longExtraOrNull(CalendarContract.EXTRA_EVENT_END_TIME) ?: NO_OCCURRENCE_TIME,
+        )
+    }
+
     companion object {
         // The calendar provider's authority/host. A date tap arrives as
         // ACTION_VIEW on content://com.android.calendar/time/<epochMillis>.

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

@@ -18,12 +18,11 @@ import android.util.Log
 import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.domain.Attendee
-import de.jeanlucmakiola.calendula.domain.AttendeeRelationship
-import de.jeanlucmakiola.calendula.domain.AttendeeType
 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
@@ -65,10 +64,12 @@ interface CalendarDataSource {
 
     /**
      * The event-colour palette the calendar's account publishes
-     * (`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.
+     * (`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 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.
      */
     fun eventColorPalette(calendarId: Long): List<EventColorOption>
 
@@ -178,25 +179,6 @@ interface CalendarDataSource {
         allDayReminderTimeMinutes: Int,
     )
 
-    /**
-     * Move an event (for recurring events: the whole series, with its modified
-     * and cancelled occurrences) to [targetCalendarId], returning the new
-     * `Events._ID`. `CALENDAR_ID` is sync-adapter-owned and can't be updated in
-     * place, so this is copy+delete: the row is re-inserted on the target (its
-     * `UID_2445` preserved), its exceptions, reminders and editable guests
-     * replayed, the [original]→[updated] field edits applied, then the source
-     * deleted. The source is removed only once the copy fully succeeds; a failure
-     * before that rolls the new event back, leaving the original untouched.
-     * [allDayReminderTimeMinutes]: see [insertEvent].
-     */
-    fun moveEvent(
-        eventId: Long,
-        targetCalendarId: Long,
-        original: EventForm,
-        updated: EventForm,
-        allDayReminderTimeMinutes: Int,
-    ): Long
-
     /**
      * Change a single occurrence of a recurring event by inserting a
      * modified-occurrence exception at [beginMillis] (the occurrence's
@@ -513,7 +495,13 @@ class AndroidCalendarDataSource @Inject constructor(
         return resolver.query(
             uri,
             InstanceProjection.COLUMNS,
-            null, null,
+            // Hide cancelled occurrences: "delete only this event" writes a
+            // cancelled exception for the one instance (#47). A NULL status is a
+            // normal, un-cancelled event, so it must survive the filter — a bare
+            // `!= CANCELED` would drop it (NULL != 2 is NULL, not true).
+            "${CalendarContract.Instances.STATUS} IS NULL OR " +
+                "${CalendarContract.Instances.STATUS} != ${CalendarContract.Events.STATUS_CANCELED}",
+            null,
             CalendarContract.Instances.BEGIN + " ASC",
         )?.use { c -> c.mapAllNotNull { CursorColumnReader(c).toEventInstance() } } ?: emptyList()
     }
@@ -632,7 +620,7 @@ class AndroidCalendarDataSource @Inject constructor(
             c.mapAll { EventColorOption(key = it.getString(0).orEmpty(), argb = it.getInt(1)) }
         }
             ?.filter { it.key.isNotEmpty() }
-            ?.sortedBy { it.key }
+            ?.curatedForPicker()
             ?: emptyList()
     }
 
@@ -897,190 +885,6 @@ class AndroidCalendarDataSource @Inject constructor(
         }
     }
 
-    override fun moveEvent(
-        eventId: Long,
-        targetCalendarId: Long,
-        original: EventForm,
-        updated: EventForm,
-        allDayReminderTimeMinutes: Int,
-    ): Long {
-        // CALENDAR_ID can't be updated in place, so re-create the event on the
-        // target calendar and delete the source. Everything that identifies or
-        // hangs off the event is copied first; the source row is removed only
-        // once the copy (including its exceptions) is complete — a failure
-        // anywhere before that rolls the new event back, so the move is
-        // all-or-nothing and never leaves a half-copied duplicate.
-        val master = queryMoveMaster(eventId)
-            ?: throw WriteFailedException("read event to move id=$eventId")
-        // Keep the source UID so an .ics backup dedups and a sync adapter can
-        // recognise the moved event; mint one only if the source carried none.
-        val uid = master.uid?.takeIf { it.isNotEmpty() } ?: "${UUID.randomUUID()}@calendula"
-        val newEventId = resolver.insert(
-            CalendarContract.Events.CONTENT_URI,
-            buildMovedMasterValues(master.event, targetCalendarId, uid).toContentValues(),
-        )?.let(ContentUris::parseId)
-            ?: throw WriteFailedException("insert moved event into calendar id=$targetCalendarId")
-        try {
-            copyReminderRows(fromEventId = eventId, toEventId = newEventId)
-            insertAttendees(newEventId, editableAttendees(eventId))
-            copyExceptions(fromEventId = eventId, toEventId = newEventId)
-            // Apply the user's field edits exactly as a same-calendar "all
-            // events" save would: the moved master carries the source's values,
-            // so the dirty diff against [original] writes only what changed
-            // (including a time or rrule edit made in the same save).
-            updateEvent(newEventId, original, updated, allDayReminderTimeMinutes)
-        } catch (t: Throwable) {
-            // Undo the partial copy so a failed move leaves nothing behind; the
-            // source is still intact (it's deleted only past this point).
-            runCatching { deleteEvent(newEventId) }
-            throw t
-        }
-        deleteEvent(eventId)
-        return newEventId
-    }
-
-    /** The master row of the event to move, as a verbatim-insert snapshot. */
-    private fun queryMoveMaster(eventId: Long): MoveMaster? = resolver.query(
-        ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
-        MoveMasterProjection.COLUMNS,
-        null, null, null,
-    )?.use { c ->
-        if (!c.moveToFirst()) return@use null
-        val r = CursorColumnReader(c)
-        MoveMaster(
-            uid = r.getString(MoveMasterProjection.IDX_UID),
-            event = MasterEventSnapshot(
-                title = r.getString(MoveMasterProjection.IDX_TITLE).orEmpty(),
-                isAllDay = r.getInt(MoveMasterProjection.IDX_ALL_DAY) != 0,
-                dtStartMillis = r.getLong(MoveMasterProjection.IDX_DTSTART),
-                dtEndMillis = r.getLong(MoveMasterProjection.IDX_DTEND)
-                    .takeUnless { r.isNull(MoveMasterProjection.IDX_DTEND) },
-                duration = r.getString(MoveMasterProjection.IDX_DURATION),
-                rrule = r.getString(MoveMasterProjection.IDX_RRULE)?.takeIf { it.isNotBlank() },
-                rdate = r.getString(MoveMasterProjection.IDX_RDATE),
-                exdate = r.getString(MoveMasterProjection.IDX_EXDATE),
-                timezone = r.getString(MoveMasterProjection.IDX_EVENT_TIMEZONE),
-                availability = r.getInt(MoveMasterProjection.IDX_AVAILABILITY),
-                accessLevel = r.getInt(MoveMasterProjection.IDX_ACCESS_LEVEL),
-                status = r.getInt(MoveMasterProjection.IDX_STATUS)
-                    .takeUnless { r.isNull(MoveMasterProjection.IDX_STATUS) },
-                location = r.getString(MoveMasterProjection.IDX_LOCATION),
-                description = r.getString(MoveMasterProjection.IDX_DESCRIPTION),
-            ),
-        )
-    }
-
-    private data class MoveMaster(val uid: String?, val event: MasterEventSnapshot)
-
-    /** Copy every stored reminder row (raw offsets and method) onto [toEventId]. */
-    private fun copyReminderRows(fromEventId: Long, toEventId: Long) = resolver.query(
-        CalendarContract.Reminders.CONTENT_URI,
-        arrayOf(CalendarContract.Reminders.MINUTES, CalendarContract.Reminders.METHOD),
-        CalendarContract.Reminders.EVENT_ID + " = ?",
-        arrayOf(fromEventId.toString()),
-        null,
-    )?.use { c ->
-        while (c.moveToNext()) {
-            val values = ContentValues().apply {
-                put(CalendarContract.Reminders.EVENT_ID, toEventId)
-                put(CalendarContract.Reminders.MINUTES, c.getInt(0))
-                put(CalendarContract.Reminders.METHOD, c.getInt(1))
-            }
-            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, values) == null) {
-                Log.w(TAG, "Failed to copy a reminder to moved event $toEventId")
-            }
-        }
-    } ?: Unit
-
-    /**
-     * The event's editable guests as [EventAttendee]s — the rows the move
-     * re-creates. Mirrors the edit form's filter: the organizer and resource
-     * rows (backend-owned, not user-editable) and any without an email are
-     * dropped; the response status resets to "invited" on re-insert.
-     */
-    private fun editableAttendees(eventId: Long): List<EventAttendee> = queryAttendees(eventId)
-        .filter {
-            it.relationship != AttendeeRelationship.Organizer && it.type != AttendeeType.Resource
-        }
-        .mapNotNull { a ->
-            a.email?.takeIf { it.isNotBlank() }?.let { email ->
-                EventAttendee(email = email, name = a.name, optional = a.type == AttendeeType.Optional)
-            }
-        }
-
-    /**
-     * Replay every exception of the series [fromEventId] against the moved series
-     * [toEventId]. The copy preserved the recurrence skeleton, so each occurrence
-     * time still resolves: a cancelled occurrence is re-hidden with a cancelled
-     * exception, a modified one is re-inserted with its fields (then its reminders
-     * reconciled and editable guests copied). No-op for a non-recurring event.
-     */
-    private fun copyExceptions(fromEventId: Long, toEventId: Long) {
-        queryExceptionRows(fromEventId).forEach { ex ->
-            if (ex.isCancelled) {
-                val values = ContentValues().apply {
-                    put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, ex.originalInstanceMillis)
-                    put(CalendarContract.Events.STATUS, CalendarContract.Events.STATUS_CANCELED)
-                }
-                resolver.insert(
-                    ContentUris.withAppendedId(
-                        CalendarContract.Events.CONTENT_EXCEPTION_URI, toEventId,
-                    ),
-                    values,
-                ) ?: throw WriteFailedException("copy cancelled occurrence to event id=$toEventId")
-            } else {
-                val uri = resolver.insert(
-                    ContentUris.withAppendedId(
-                        CalendarContract.Events.CONTENT_EXCEPTION_URI, toEventId,
-                    ),
-                    buildCopiedExceptionValues(ex).toContentValues(),
-                ) ?: throw WriteFailedException("copy modified occurrence to event id=$toEventId")
-                val newExceptionId = ContentUris.parseId(uri)
-                // The provider may clone the parent's reminders onto the new
-                // exception; reconcile to the source exception's exact set so
-                // they neither double nor drop. Same DTSTART → same all-day
-                // encoding, so the stored offsets match directly.
-                reconcileReminders(
-                    newExceptionId,
-                    queryReminders(ex.exceptionEventId).map { it.minutes },
-                )
-                insertAttendees(newExceptionId, editableAttendees(ex.exceptionEventId))
-            }
-        }
-    }
-
-    /** The series' exception rows (modified + cancelled), oldest occurrence first. */
-    private fun queryExceptionRows(seriesEventId: Long): List<ExceptionRowSnapshot> = resolver.query(
-        CalendarContract.Events.CONTENT_URI,
-        ExceptionProjection.COLUMNS,
-        "${CalendarContract.Events.ORIGINAL_ID} = ? AND ${CalendarContract.Events.DELETED} = 0",
-        arrayOf(seriesEventId.toString()),
-        CalendarContract.Events.ORIGINAL_INSTANCE_TIME + " ASC",
-    )?.use { c ->
-        c.mapAll {
-            val r = CursorColumnReader(c)
-            val status = r.getInt(ExceptionProjection.IDX_STATUS)
-                .takeUnless { r.isNull(ExceptionProjection.IDX_STATUS) }
-            ExceptionRowSnapshot(
-                exceptionEventId = r.getLong(ExceptionProjection.IDX_ID),
-                originalInstanceMillis = r.getLong(ExceptionProjection.IDX_ORIGINAL_INSTANCE_TIME),
-                isCancelled = status == CalendarContract.Events.STATUS_CANCELED,
-                status = status,
-                title = r.getString(ExceptionProjection.IDX_TITLE).orEmpty(),
-                isAllDay = r.getInt(ExceptionProjection.IDX_ALL_DAY) != 0,
-                dtStartMillis = r.getLong(ExceptionProjection.IDX_DTSTART),
-                dtEndMillis = r.getLong(ExceptionProjection.IDX_DTEND)
-                    .takeUnless { r.isNull(ExceptionProjection.IDX_DTEND) },
-                duration = r.getString(ExceptionProjection.IDX_DURATION),
-                timezone = r.getString(ExceptionProjection.IDX_EVENT_TIMEZONE),
-                availability = r.getInt(ExceptionProjection.IDX_AVAILABILITY),
-                accessLevel = r.getInt(ExceptionProjection.IDX_ACCESS_LEVEL),
-                location = r.getString(ExceptionProjection.IDX_LOCATION),
-                description = r.getString(ExceptionProjection.IDX_DESCRIPTION),
-            )
-        }
-    } ?: emptyList()
-
     override fun updateOccurrence(
         eventId: Long,
         beginMillis: Long,
@@ -1175,6 +979,8 @@ class AndroidCalendarDataSource @Inject constructor(
             CalendarContract.Events.EVENT_TIMEZONE,
             CalendarContract.Events.DURATION,
             CalendarContract.Events.ALL_DAY,
+            CalendarContract.Events._SYNC_ID,
+            CalendarContract.Events.EXDATE,
         ),
         null, null, null,
     )?.use { c ->
@@ -1185,6 +991,8 @@ class AndroidCalendarDataSource @Inject constructor(
                 timezone = c.getString(2),
                 duration = c.getString(3),
                 allDay = c.getInt(4),
+                syncId = c.getString(5),
+                exdate = c.getString(6),
             )
         } else {
             null
@@ -1197,6 +1005,9 @@ class AndroidCalendarDataSource @Inject constructor(
         val timezone: String?,
         val duration: String?,
         val allDay: Int,
+        /** Null on a local calendar (and before a synced event's first push). */
+        val syncId: String? = null,
+        val exdate: String? = null,
     ) {
         /** UNTIL cutoff for ending the series before the occurrence at [beginMillis]. */
         fun truncationCutoff(beginMillis: Long): Long = previousLocalDayEndUtcMillis(
@@ -1387,16 +1198,49 @@ class AndroidCalendarDataSource @Inject constructor(
     }
 
     override fun deleteOccurrence(eventId: Long, beginMillis: Long) {
-        // A cancelled exception row hides exactly this occurrence; the sync
-        // adapter turns it into an EXDATE/cancelled VEVENT upstream.
-        val values = ContentValues().apply {
-            put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, beginMillis)
-            put(CalendarContract.Events.STATUS, CalendarContract.Events.STATUS_CANCELED)
+        val row = querySeriesRow(eventId)
+        if (row.syncId == null) {
+            // No _sync_id — a local calendar, or a synced event not pushed yet.
+            // A cancelled exception can only attach to its parent through
+            // ORIGINAL_SYNC_ID, so with none the link never forms and the
+            // provider's expansion of the *parent* collapses, taking every other
+            // occurrence with it (#47 on a local calendar). EXDATE needs no link.
+            // Calendula's own contact special-date calendars are local and hold
+            // yearly series, so this path is reached in normal use.
+            val values = buildOccurrenceExdateValues(
+                existingExdate = row.exdate,
+                occurrenceMillis = beginMillis,
+                dtStartMillis = row.dtStartMillis,
+                rrule = row.rrule,
+                duration = row.duration,
+                timezone = row.timezone,
+                allDay = row.allDay,
+            )
+            val updated = resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+                values.toContentValues(), null, null,
+            )
+            if (updated == 0) {
+                throw WriteFailedException("exdate occurrence event id=$eventId begin=$beginMillis")
+            }
+            return
         }
+        // A cancelled exception row hides exactly this occurrence; the sync
+        // adapter turns it into an EXDATE/cancelled VEVENT upstream. It carries
+        // the full time set (DTSTART + DURATION + zone) so the provider derives a
+        // single instance rather than cloning the master's RRULE — the same trap
+        // the edit path documents (Codeberg #16).
+        val values = buildOccurrenceCancelValues(
+            originalInstanceMillis = beginMillis,
+            dtStartMillis = beginMillis,
+            duration = row.duration,
+            timezone = row.timezone,
+            allDay = row.allDay,
+        )
         val uri = ContentUris.withAppendedId(
             CalendarContract.Events.CONTENT_EXCEPTION_URI, eventId,
         )
-        resolver.insert(uri, values)
+        resolver.insert(uri, values.toContentValues())
             ?: throw WriteFailedException("cancel occurrence event id=$eventId begin=$beginMillis")
     }
 

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

@@ -61,20 +61,6 @@ interface CalendarRepository {
      */
     suspend fun updateEvent(eventId: Long, original: EventForm, updated: EventForm)
 
-    /**
-     * Move an event (recurring: the whole series, with its exceptions) to
-     * [targetCalendarId] and apply the [original]→[updated] field edits; returns
-     * the new event's `Events._ID`. Copy+delete under the hood
-     * (see [CalendarDataSource.moveEvent]) — `CALENDAR_ID` can't be updated in
-     * place.
-     */
-    suspend fun moveEvent(
-        eventId: Long,
-        targetCalendarId: Long,
-        original: EventForm,
-        updated: EventForm,
-    ): Long
-
     /**
      * Change a single occurrence of a recurring event (exception row with the
      * form's values); returns the exception's `Events._ID`.

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

@@ -157,17 +157,6 @@ class CalendarRepositoryImpl @Inject constructor(
         dataSource.deleteEvent(eventId)
     }
 
-    override suspend fun moveEvent(
-        eventId: Long,
-        targetCalendarId: Long,
-        original: EventForm,
-        updated: EventForm,
-    ): Long = withContext(io) {
-        dataSource.moveEvent(
-            eventId, targetCalendarId, original, updated, allDayReminderTimeMinutes(),
-        )
-    }
-
     override suspend fun updateOccurrence(
         eventId: Long,
         beginMillis: Long,

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

@@ -14,6 +14,7 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.domain.ReminderMethod
+import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
 import java.time.Instant
 import java.time.ZoneId
 import java.time.ZoneOffset
@@ -36,15 +37,18 @@ internal fun ColumnReader.toEventDetailCore(
     val begin = getLong(EventDetailProjection.IDX_DTSTART)
 
     // Recurring events store DURATION instead of DTEND, so the series row's
-    // DTEND is null. Keep the event (end == begin); callers that opened a
-    // specific occurrence supply the real per-occurrence times from
-    // CalendarContract.Instances. A present-but-backwards DTEND is malformed,
-    // but dropping the row would make the event un-openable — the same trap as
-    // the pre-1970 DTSTART bug above (issue #34): it would surface as the
-    // generic error screen with no way to open the event and fix it. Clamp to a
-    // zero-length event instead (matching SearchMapper's coerceAtLeast).
+    // DTEND is null — derive the length from DURATION (as SearchMapper and
+    // IcsExportMapper do). Callers that opened a specific occurrence overwrite
+    // both times with the per-occurrence values from CalendarContract.Instances;
+    // a caller that names no occurrence (a bare content://.../events/<id> VIEW
+    // intent, issue #48) keeps this row's own times, so the length has to be
+    // right here or the series renders zero-length. A present-but-backwards
+    // DTEND is malformed, but dropping the row would make the event un-openable
+    // — the same trap as the pre-1970 DTSTART bug above (issue #34): it would
+    // surface as the generic error screen with no way to open the event and fix
+    // it. Clamp to a zero-length event instead (matching SearchMapper).
     val end = if (isNull(EventDetailProjection.IDX_DTEND)) {
-        begin
+        begin + parseRfc2445DurationMillis(getString(EventDetailProjection.IDX_DURATION))
     } else {
         getLong(EventDetailProjection.IDX_DTEND).coerceAtLeast(begin)
     }

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

@@ -43,19 +43,10 @@ internal fun EventForm.toWriteTimes(zone: ZoneId): EventWriteTimes = if (isAllDa
  * DURATION instead of DTEND when an RRULE is set): whole days for all-day
  * events, seconds otherwise.
  */
-internal fun EventWriteTimes.toRfc2445Duration(isAllDay: Boolean): String =
-    rfc2445Duration(dtEndMillis - dtStartMillis, isAllDay)
-
-/**
- * RFC 2445 duration for a [spanMillis]-long event: whole days for all-day
- * events (the provider's convention), seconds otherwise. Shared by the write
- * paths that need a DURATION but start from a raw millisecond span (the series
- * copy and exception replay of a calendar move) rather than [EventWriteTimes].
- */
-internal fun rfc2445Duration(spanMillis: Long, isAllDay: Boolean): String = if (isAllDay) {
-    "P${spanMillis / MILLIS_PER_DAY}D"
+internal fun EventWriteTimes.toRfc2445Duration(isAllDay: Boolean): String = if (isAllDay) {
+    "P${(dtEndMillis - dtStartMillis) / MILLIS_PER_DAY}D"
 } else {
-    "P${spanMillis / 1_000L}S"
+    "P${(dtEndMillis - dtStartMillis) / 1_000L}S"
 }
 
 /**
@@ -192,119 +183,98 @@ internal fun buildOccurrenceExceptionValues(
 }
 
 /**
- * Raw provider snapshot of a master/one-off Events row, enough to re-insert it
- * verbatim on another calendar (a calendar move is copy+delete — `CALENDAR_ID`
- * is sync-adapter-owned and can't be updated in place). Recurring rows carry
- * [rrule]/[duration] (and any [rdate]/[exdate]) with a null [dtEndMillis];
- * one-off rows carry [dtEndMillis]. Colour is deliberately absent: a raw
- * `EVENT_COLOR` or account-scoped `EVENT_COLOR_KEY` may be invalid on the target
- * account, so the moved copy inherits the target calendar's colour instead.
+ * Column values for a *cancelled*-occurrence exception row ("delete only this
+ * event"): inserting them at `Events.CONTENT_EXCEPTION_URI/<id>` makes the
+ * provider clone the series row and cancel exactly this one instance.
+ *
+ * As with [buildOccurrenceExceptionValues], the occurrence must be anchored with
+ * DTSTART + DURATION so the provider derives a single instance and clears the
+ * inherited RRULE. A STATUS-only cancel skips that: the clone keeps the RRULE, so
+ * the *whole series* is cancelled and every other occurrence disappears
+ * (Codeberg #47). The occurrence's length/zone come straight from the series row
+ * — cancelling never changes them.
  */
-internal data class MasterEventSnapshot(
-    val title: String,
-    val isAllDay: Boolean,
-    val dtStartMillis: Long,
-    val dtEndMillis: Long?,
-    val duration: String?,
-    val rrule: String?,
-    val rdate: String?,
-    val exdate: String?,
-    val timezone: String?,
-    val availability: Int,
-    val accessLevel: Int,
-    val status: Int?,
-    val location: String?,
-    val description: String?,
-)
-
-/**
- * Column values re-creating [snapshot] as a fresh Events row on
- * [targetCalendarId], keeping its [uid] so `.ics` backup dedup and sync identity
- * survive the move. Preserves the recurrence skeleton (DTSTART/RRULE/DURATION,
- * RDATE/EXDATE) so the series' generated instances — and therefore the
- * ORIGINAL_INSTANCE_TIME of every copied exception — line up unchanged. The
- * caller layers the user's field edits on top with a normal series update.
- */
-internal fun buildMovedMasterValues(
-    snapshot: MasterEventSnapshot,
-    targetCalendarId: Long,
-    uid: String,
+internal fun buildOccurrenceCancelValues(
+    originalInstanceMillis: Long,
+    dtStartMillis: Long,
+    duration: String?,
+    timezone: String?,
+    allDay: Int,
 ): Map<String, Any?> = buildMap {
-    put(CalendarContract.Events.CALENDAR_ID, targetCalendarId)
-    put(CalendarContract.Events.UID_2445, uid)
-    put(CalendarContract.Events.TITLE, snapshot.title)
-    put(CalendarContract.Events.ALL_DAY, if (snapshot.isAllDay) 1 else 0)
-    put(CalendarContract.Events.DTSTART, snapshot.dtStartMillis)
-    put(CalendarContract.Events.EVENT_TIMEZONE, snapshot.timezone ?: "UTC")
-    if (snapshot.rrule != null) {
-        put(CalendarContract.Events.RRULE, snapshot.rrule)
-        snapshot.rdate?.takeIf { it.isNotBlank() }?.let { put(CalendarContract.Events.RDATE, it) }
-        snapshot.exdate?.takeIf { it.isNotBlank() }?.let { put(CalendarContract.Events.EXDATE, it) }
-        put(CalendarContract.Events.DURATION, snapshot.movedDuration())
-    } else {
-        snapshot.dtEndMillis?.let { put(CalendarContract.Events.DTEND, it) }
-    }
-    put(CalendarContract.Events.AVAILABILITY, snapshot.availability)
-    put(CalendarContract.Events.ACCESS_LEVEL, snapshot.accessLevel)
-    snapshot.status?.let { put(CalendarContract.Events.STATUS, it) }
-    put(CalendarContract.Events.EVENT_LOCATION, snapshot.location?.ifEmpty { null })
-    put(CalendarContract.Events.DESCRIPTION, snapshot.description?.ifEmpty { null })
+    put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, originalInstanceMillis)
+    put(CalendarContract.Events.DTSTART, dtStartMillis)
+    put(CalendarContract.Events.DURATION, duration)
+    put(CalendarContract.Events.EVENT_TIMEZONE, timezone)
+    put(CalendarContract.Events.ALL_DAY, allDay)
+    put(CalendarContract.Events.STATUS, CalendarContract.Events.STATUS_CANCELED)
 }
 
-/** The recurring copy's DURATION: its own if present, else derived from DTEND. */
-private fun MasterEventSnapshot.movedDuration(): String = duration?.takeIf { it.isNotBlank() }
-    ?: rfc2445Duration((dtEndMillis ?: dtStartMillis) - dtStartMillis, isAllDay)
+/**
+ * The master-row columns that drop the occurrence at [occurrenceMillis] from a
+ * series by adding it to `EXDATE` — the path for events that have **no
+ * `_sync_id`** (a local calendar, or a synced event not yet pushed).
+ *
+ * A cancelled exception row (see [buildOccurrenceCancelValues]) only attaches to
+ * its parent through `ORIGINAL_SYNC_ID`. Without a `_sync_id` the link never
+ * forms, and the provider's expansion of the *parent* collapses — every other
+ * occurrence disappears (Codeberg #47, reproduced on a local calendar). EXDATE
+ * needs no link, and is the canonical iCalendar way to drop an occurrence, so a
+ * sync adapter carries it upstream unchanged if the calendar later syncs.
+ *
+ * The whole time/recurrence set is rewritten alongside it on purpose. The
+ * provider does **not** treat an EXDATE-only update as a recurrence change: it
+ * leaves the expanded `Instances` rows untouched, so the occurrence stays visible
+ * (and, symmetrically, un-excluding one leaves it hidden). Writing DTSTART with
+ * it forces the re-expansion — but DTSTART *alone* makes the provider recompute
+ * `lastDate` as if the event were a single instance, collapsing the series to its
+ * first occurrence. Passing DTSTART + DURATION + RRULE + zone together is what
+ * re-expands it correctly. All observed on a Pixel; see the #47 notes.
+ *
+ * EXDATE is a comma-separated list, so an existing one is appended to (a repeat
+ * of the same occurrence is folded away). All-day series take the `VALUE=DATE`
+ * form (`yyyyMMdd`), timed ones the UTC date-time form (`yyyyMMddTHHmmssZ`).
+ */
+internal fun buildOccurrenceExdateValues(
+    existingExdate: String?,
+    occurrenceMillis: Long,
+    dtStartMillis: Long,
+    rrule: String?,
+    duration: String?,
+    timezone: String?,
+    allDay: Int,
+): Map<String, Any?> {
+    val stamp = formatExdateStamp(occurrenceMillis, isAllDay = allDay != 0)
+    val existing = existingExdate?.split(',')
+        ?.map { it.trim() }
+        ?.filter { it.isNotEmpty() }
+        .orEmpty()
+    val merged = (existing + stamp).distinct().joinToString(",")
+    return mapOf(
+        CalendarContract.Events.EXDATE to merged,
+        CalendarContract.Events.DTSTART to dtStartMillis,
+        CalendarContract.Events.RRULE to rrule,
+        CalendarContract.Events.DURATION to duration,
+        CalendarContract.Events.EVENT_TIMEZONE to timezone,
+        CalendarContract.Events.ALL_DAY to allDay,
+    )
+}
 
 /**
- * Raw provider snapshot of one exception row of a recurring series (a modified
- * or cancelled occurrence, `ORIGINAL_ID` = the series). [originalInstanceMillis]
- * ties it to the occurrence it overrides; a [isCancelled] row only needs that.
+ * One EXDATE entry for the occurrence starting at [occurrenceMillis]. Both forms
+ * are UTC: the provider stores an all-day DTSTART at UTC midnight, so its date
+ * reads off the UTC calendar day.
  */
-internal data class ExceptionRowSnapshot(
-    val exceptionEventId: Long,
-    val originalInstanceMillis: Long,
-    val isCancelled: Boolean,
-    val status: Int?,
-    val title: String,
-    val isAllDay: Boolean,
-    val dtStartMillis: Long,
-    val dtEndMillis: Long?,
-    val duration: String?,
-    val timezone: String?,
-    val availability: Int,
-    val accessLevel: Int,
-    val location: String?,
-    val description: String?,
-)
-
-/**
- * Column values replaying a *modified* occurrence [snapshot] against the moved
- * series via `CONTENT_EXCEPTION_URI`. Like [buildOccurrenceExceptionValues] the
- * length travels as DURATION (the provider rejects DTEND on an exception). A
- * cancelled occurrence is written separately (ORIGINAL_INSTANCE_TIME +
- * STATUS_CANCELED) — this builder is only for the modified case.
- */
-internal fun buildCopiedExceptionValues(snapshot: ExceptionRowSnapshot): Map<String, Any?> =
-    buildMap {
-        put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, snapshot.originalInstanceMillis)
-        put(CalendarContract.Events.TITLE, snapshot.title)
-        put(CalendarContract.Events.ALL_DAY, if (snapshot.isAllDay) 1 else 0)
-        put(CalendarContract.Events.DTSTART, snapshot.dtStartMillis)
-        put(
-            CalendarContract.Events.DURATION,
-            snapshot.duration?.takeIf { it.isNotBlank() }
-                ?: rfc2445Duration(
-                    (snapshot.dtEndMillis ?: snapshot.dtStartMillis) - snapshot.dtStartMillis,
-                    snapshot.isAllDay,
-                ),
+private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String {
+    val utc = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC)
+    return if (isAllDay) {
+        "%04d%02d%02d".format(utc.year, utc.monthValue, utc.dayOfMonth)
+    } else {
+        "%04d%02d%02dT%02d%02d%02dZ".format(
+            utc.year, utc.monthValue, utc.dayOfMonth,
+            utc.hour, utc.minute, utc.second,
         )
-        put(CalendarContract.Events.EVENT_TIMEZONE, snapshot.timezone ?: "UTC")
-        put(CalendarContract.Events.AVAILABILITY, snapshot.availability)
-        put(CalendarContract.Events.ACCESS_LEVEL, snapshot.accessLevel)
-        put(CalendarContract.Events.EVENT_LOCATION, snapshot.location?.ifEmpty { null })
-        put(CalendarContract.Events.DESCRIPTION, snapshot.description?.ifEmpty { null })
-        snapshot.status?.let { put(CalendarContract.Events.STATUS, it) }
     }
+}
 
 /**
  * The `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A

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

@@ -84,6 +84,9 @@ internal object EventDetailProjection {
         CalendarContract.Events.EVENT_TIMEZONE,
         CalendarContract.Events.SELF_ATTENDEE_STATUS,
         CalendarContract.Events.EVENT_COLOR_KEY,
+        // Recurring rows carry DURATION instead of DTEND; the detail screen
+        // needs it to render a series opened without a named occurrence.
+        CalendarContract.Events.DURATION,
     )
 
     const val IDX_EVENT_ID = 0
@@ -104,6 +107,7 @@ internal object EventDetailProjection {
     const val IDX_EVENT_TIMEZONE = 15
     const val IDX_SELF_ATTENDEE_STATUS = 16
     const val IDX_EVENT_COLOR_KEY = 17
+    const val IDX_DURATION = 18
 }
 
 /**
@@ -186,86 +190,6 @@ internal object SearchProjection {
     const val IDX_RDATE = 11
 }
 
-/**
- * The master/one-off Events row of an event about to be moved to another
- * calendar, read for a verbatim re-insert (see [MasterEventSnapshot]). Carries
- * the full recurrence skeleton (RRULE/DURATION, RDATE/EXDATE) so the moved copy
- * generates the same instances, and `UID_2445` so identity survives the move.
- */
-internal object MoveMasterProjection {
-    val COLUMNS: Array<String> = arrayOf(
-        CalendarContract.Events.UID_2445,
-        CalendarContract.Events.TITLE,
-        CalendarContract.Events.DTSTART,
-        CalendarContract.Events.DTEND,
-        CalendarContract.Events.DURATION,
-        CalendarContract.Events.RRULE,
-        CalendarContract.Events.RDATE,
-        CalendarContract.Events.EXDATE,
-        CalendarContract.Events.EVENT_TIMEZONE,
-        CalendarContract.Events.ALL_DAY,
-        CalendarContract.Events.AVAILABILITY,
-        CalendarContract.Events.ACCESS_LEVEL,
-        CalendarContract.Events.STATUS,
-        CalendarContract.Events.EVENT_LOCATION,
-        CalendarContract.Events.DESCRIPTION,
-    )
-
-    const val IDX_UID = 0
-    const val IDX_TITLE = 1
-    const val IDX_DTSTART = 2
-    const val IDX_DTEND = 3
-    const val IDX_DURATION = 4
-    const val IDX_RRULE = 5
-    const val IDX_RDATE = 6
-    const val IDX_EXDATE = 7
-    const val IDX_EVENT_TIMEZONE = 8
-    const val IDX_ALL_DAY = 9
-    const val IDX_AVAILABILITY = 10
-    const val IDX_ACCESS_LEVEL = 11
-    const val IDX_STATUS = 12
-    const val IDX_LOCATION = 13
-    const val IDX_DESCRIPTION = 14
-}
-
-/**
- * The exception rows of a recurring series (`ORIGINAL_ID` = the series), read to
- * replay them against a moved copy (see [ExceptionRowSnapshot]). Both modified
- * occurrences and cancellations (`STATUS_CANCELED`) are read; the query filters
- * `DELETED = 0` so provider tombstones aren't replayed.
- */
-internal object ExceptionProjection {
-    val COLUMNS: Array<String> = arrayOf(
-        CalendarContract.Events._ID,
-        CalendarContract.Events.ORIGINAL_INSTANCE_TIME,
-        CalendarContract.Events.STATUS,
-        CalendarContract.Events.TITLE,
-        CalendarContract.Events.ALL_DAY,
-        CalendarContract.Events.DTSTART,
-        CalendarContract.Events.DTEND,
-        CalendarContract.Events.DURATION,
-        CalendarContract.Events.EVENT_TIMEZONE,
-        CalendarContract.Events.AVAILABILITY,
-        CalendarContract.Events.ACCESS_LEVEL,
-        CalendarContract.Events.EVENT_LOCATION,
-        CalendarContract.Events.DESCRIPTION,
-    )
-
-    const val IDX_ID = 0
-    const val IDX_ORIGINAL_INSTANCE_TIME = 1
-    const val IDX_STATUS = 2
-    const val IDX_TITLE = 3
-    const val IDX_ALL_DAY = 4
-    const val IDX_DTSTART = 5
-    const val IDX_DTEND = 6
-    const val IDX_DURATION = 7
-    const val IDX_EVENT_TIMEZONE = 8
-    const val IDX_AVAILABILITY = 9
-    const val IDX_ACCESS_LEVEL = 10
-    const val IDX_LOCATION = 11
-    const val IDX_DESCRIPTION = 12
-}
-
 internal object AttendeeProjection {
     val COLUMNS: Array<String> = arrayOf(
         CalendarContract.Attendees.ATTENDEE_NAME,

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

@@ -0,0 +1,185 @@
+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: 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.
+ *
+ * This is a self-contained mirror of floret-kit's `pastelize` hue/saturation
+ * shaping (`de.jeanlucmakiola.floret.components.pastelize`), with value pinned
+ * rather than theme-picked. Curation must reason about the colour the picker
+ * paints, so the two shapings have to agree: if floret's saturation band or
+ * curve changes, update this in step.
+ */
+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

@@ -33,6 +33,7 @@ import de.jeanlucmakiola.calendula.ui.common.viewBaseStack
 import de.jeanlucmakiola.calendula.ui.day.DayScreen
 import de.jeanlucmakiola.calendula.ui.detail.EventDetailScreen
 import de.jeanlucmakiola.calendula.ui.edit.EventEditScreen
+import de.jeanlucmakiola.calendula.ui.edit.ImportSource
 import de.jeanlucmakiola.calendula.ui.imports.ImportScreen
 import de.jeanlucmakiola.calendula.ui.month.MonthScreen
 import de.jeanlucmakiola.calendula.ui.search.SearchScreen
@@ -172,6 +173,9 @@ fun CalendarHost(
     // picker (many). A plain conditional overlay (no slide) — it's transient.
     var importUri by remember { mutableStateOf<android.net.Uri?>(null) }
     var importForm by remember { mutableStateOf<EventForm?>(null) }
+    // Which channel filled [importForm]: an .ics file (prompt to apply the default
+    // reminder) or an ACTION_INSERT intent (apply it automatically) — #49.
+    var importFormSource by remember { mutableStateOf(ImportSource.File) }
     // A restore (in-app "Restore from .ics" button) always runs the full import
     // flow — picker + summary — even for a single-event file, because the intent
     // is "restore a backup", not "add this one event". An externally opened .ics
@@ -190,6 +194,7 @@ fun CalendarHost(
     // reveals on top of whatever was open without extra dismissal.
     LaunchedEffect(requestedInsertForm) {
         if (requestedInsertForm != null) {
+            importFormSource = ImportSource.Insert
             importForm = requestedInsertForm
             onInsertConsumed()
         }
@@ -435,6 +440,7 @@ fun CalendarHost(
                 onClose = { importUri = null },
                 onOpenSingle = { form ->
                     importUri = null
+                    importFormSource = ImportSource.File
                     importForm = form
                 },
             )
@@ -443,6 +449,7 @@ fun CalendarHost(
             EventEditScreen(
                 initialDateIso = null,
                 initialForm = form,
+                initialFormSource = importFormSource,
                 onClose = { importForm = null },
                 onSaved = { importForm = null },
             )

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

@@ -1,14 +1,26 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.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
+import androidx.compose.material3.SegmentedButton
+import androidx.compose.material3.SegmentedButtonDefaults
+import androidx.compose.material3.SingleChoiceSegmentedButtonRow
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
@@ -17,12 +29,13 @@ 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
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.floret.components.CustomAmountEditor
+import de.jeanlucmakiola.floret.components.DialogAmountField
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
@@ -182,18 +195,56 @@ private fun CustomReminderEditor(
     onConfirm: (Int) -> Unit,
 ) {
     val amount = amountText.toIntOrNull()?.takeIf { it in 1..999 }
-    CustomAmountEditor(
-        amountText = amountText,
-        onAmountChange = onAmountChange,
-        unitLabels = ReminderUnit.entries.map { stringResource(reminderUnitLabel(it)) },
-        selectedUnit = unit.ordinal,
-        onUnitChange = { onUnitChange(ReminderUnit.entries[it]) },
-        preview = amount?.let { reminderLeadTimeLabel(it * unit.minutesFactor) }
-            ?: stringResource(R.string.reminder_custom_amount),
-        setLabel = stringResource(R.string.reminder_custom_set),
-        confirmEnabled = amount != null,
-        onConfirm = { amount?.let { onConfirm(it * unit.minutesFactor) } },
-    )
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        // A Position.Bottom shape: tight top corners meeting the row, full bottom.
+        shape = RoundedCornerShape(topStart = 6.dp, topEnd = 6.dp, bottomStart = 22.dp, bottomEnd = 22.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp),
+    ) {
+        Column(
+            modifier = Modifier.padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            // Unit toggle first so it stays visible above the keyboard once the
+            // amount field (the bottom row) is focused and scrolled into view.
+            SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
+                ReminderUnit.entries.forEachIndexed { index, entry ->
+                    SegmentedButton(
+                        selected = unit == entry,
+                        onClick = { onUnitChange(entry) },
+                        shape = SegmentedButtonDefaults.itemShape(index, ReminderUnit.entries.size),
+                        label = { Text(stringResource(reminderUnitLabel(entry))) },
+                    )
+                }
+            }
+            // Amount, a live preview of the lead time it resolves to, and Set —
+            // all on one row, sitting just above the keyboard.
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                DialogAmountField(
+                    value = amountText,
+                    onValueChange = onAmountChange,
+                    placeholder = "10",
+                )
+                Spacer(Modifier.width(16.dp))
+                Text(
+                    text = amount?.let { reminderLeadTimeLabel(it * unit.minutesFactor) }
+                        ?: stringResource(R.string.reminder_custom_amount),
+                    style = MaterialTheme.typography.bodyLarge,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.weight(1f),
+                )
+                Spacer(Modifier.width(16.dp))
+                FilledTonalButton(
+                    onClick = { amount?.let { onConfirm(it * unit.minutesFactor) } },
+                    enabled = amount != null,
+                ) {
+                    Text(stringResource(R.string.reminder_custom_set))
+                }
+            }
+        }
+    }
 }
 
 /** A short explanatory paragraph shown under a picker's title, above the rows. */
@@ -313,136 +364,41 @@ private fun CustomDaysEditor(
 ) {
     val days = amountText.toIntOrNull()
         ?.takeIf { it in AgendaRange.MIN_CUSTOM_DAYS..AgendaRange.MAX_CUSTOM_DAYS }
-    CustomAmountEditor(
-        amountText = amountText,
-        onAmountChange = onAmountChange,
-        placeholder = "30",
-        preview = days?.let { pluralStringResource(R.plurals.agenda_range_days, it, it) }
-            ?: stringResource(R.string.agenda_range_custom_hint),
-        setLabel = stringResource(R.string.reminder_custom_set),
-        confirmEnabled = days != null,
-        onConfirm = { days?.let(onConfirm) },
-    )
-}
-
-/**
- * Snooze-duration picker, full-screen and **single-select**: the [presets]
- * (whole-minute delays) each sit as a checkmark row, with a "Custom" row that
- * expands an inline amount field plus a Minutes/Hours unit toggle to enter an
- * arbitrary delay. Mirrors [AgendaRangePicker]'s custom-expand pattern; picking
- * a preset or confirming a custom value applies via [onSelect] and closes.
- * [label] renders a delay in minutes as a duration ("10 minutes", "1 hour") and
- * is reused for both the rows and the custom preview.
- */
-@Composable
-fun SnoozeDurationPicker(
-    title: String,
-    presets: List<Int>,
-    selected: Int,
-    label: @Composable (Int) -> String,
-    onSelect: (Int) -> Unit,
-    onDismiss: () -> Unit,
-) {
-    val customSelected = selected !in presets
-    val rowCount = presets.size + 1 // + the custom row
-
-    var customExpanded by rememberSaveable { mutableStateOf(false) }
-    var amountText by rememberSaveable {
-        mutableStateOf(if (customSelected) snoozeCustomAmount(selected).toString() else "")
-    }
-    var unit by rememberSaveable {
-        mutableStateOf(if (customSelected) snoozeCustomUnit(selected) else ReminderUnit.Minutes)
-    }
-
-    FullScreenPicker(title = title, onDismiss = onDismiss, predictiveBack = true) {
-        presets.forEachIndexed { index, minute ->
-            val isSelected = minute == selected
-            GroupedRow(
-                title = label(minute),
-                position = positionOf(index, rowCount),
-                selected = isSelected,
-                trailing = if (isSelected) {
-                    { SelectedCheck() }
-                } else {
-                    null
-                },
-                onClick = {
-                    onSelect(minute)
-                    onDismiss()
-                },
-            )
-        }
-        // The Custom row connects downward into the editor card when expanded, so
-        // the two read as one grouped container (the shared custom-expand pattern).
-        GroupedRow(
-            title = if (customSelected) label(selected) else stringResource(R.string.event_edit_reminder_custom),
-            position = if (customExpanded) Position.Top else positionOf(presets.size, rowCount),
-            selected = customSelected,
-            trailing = if (customSelected) {
-                { SelectedCheck() }
-            } else {
-                null
-            },
-            onClick = { customExpanded = !customExpanded },
-        )
-        AnimatedVisibility(
-            visible = customExpanded,
-            enter = expandEnter(),
-            exit = collapseExit(),
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = RoundedCornerShape(topStart = 6.dp, topEnd = 6.dp, bottomStart = 22.dp, bottomEnd = 22.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp),
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = Alignment.CenterVertically,
         ) {
-            CustomSnoozeEditor(
-                amountText = amountText,
-                onAmountChange = { amountText = it },
-                unit = unit,
-                onUnitChange = { unit = it },
-                label = label,
-                onConfirm = { minutes ->
-                    onSelect(minutes)
-                    onDismiss()
-                },
+            DialogAmountField(
+                value = amountText,
+                onValueChange = onAmountChange,
+                placeholder = "30",
             )
+            Spacer(Modifier.width(16.dp))
+            Text(
+                text = days?.let { pluralStringResource(R.plurals.agenda_range_days, it, it) }
+                    ?: stringResource(R.string.agenda_range_custom_hint),
+                style = MaterialTheme.typography.bodyLarge,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.weight(1f),
+            )
+            Spacer(Modifier.width(16.dp))
+            FilledTonalButton(
+                onClick = { days?.let(onConfirm) },
+                enabled = days != null,
+            ) {
+                Text(stringResource(R.string.reminder_custom_set))
+            }
         }
     }
 }
 
-/** Whole hours if the delay divides evenly, else minutes. */
-private fun snoozeCustomUnit(minutes: Int): ReminderUnit =
-    if (minutes % ReminderUnit.Hours.minutesFactor == 0) ReminderUnit.Hours else ReminderUnit.Minutes
-
-private fun snoozeCustomAmount(minutes: Int): Int =
-    if (minutes % ReminderUnit.Hours.minutesFactor == 0) minutes / ReminderUnit.Hours.minutesFactor else minutes
-
-/**
- * The expanded "Custom" snooze editor: a tonal card connected to the Custom row
- * above it. A Minutes/Hours unit toggle, an amount field with a live preview of
- * the delay it resolves to, and a tonal confirm enabled only for a valid 1–999
- * amount. [onConfirm] receives the final delay in minutes.
- */
-@Composable
-private fun CustomSnoozeEditor(
-    amountText: String,
-    onAmountChange: (String) -> Unit,
-    unit: ReminderUnit,
-    onUnitChange: (ReminderUnit) -> Unit,
-    label: @Composable (Int) -> String,
-    onConfirm: (Int) -> Unit,
-) {
-    val units = remember { listOf(ReminderUnit.Minutes, ReminderUnit.Hours) }
-    val amount = amountText.toIntOrNull()?.takeIf { it in 1..999 }
-    CustomAmountEditor(
-        amountText = amountText,
-        onAmountChange = onAmountChange,
-        unitLabels = units.map { stringResource(reminderUnitLabel(it)) },
-        selectedUnit = units.indexOf(unit).coerceAtLeast(0),
-        onUnitChange = { onUnitChange(units[it]) },
-        preview = amount?.let { label(it * unit.minutesFactor) }
-            ?: stringResource(R.string.reminder_custom_amount),
-        setLabel = stringResource(R.string.reminder_custom_set),
-        confirmEnabled = amount != null,
-        onConfirm = { amount?.let { onConfirm(it * unit.minutesFactor) } },
-    )
-}
-
 /** Human label for an [AgendaRange] (used by the picker rows and settings summary). */
 @Composable
 fun agendaRangeLabel(range: AgendaRange): String = when (range) {

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

@@ -141,13 +141,20 @@ class EventDetailViewModel @Inject constructor(
     private suspend fun loadDetail(target: Target): EventDetailUiState = try {
         val detail = repository.eventDetail(target.eventId)
         // The Events row holds the series start; replace it with this
-        // occurrence's time so recurring events render correctly.
-        val corrected = detail.copy(
-            instance = detail.instance.copy(
-                start = Instant.fromEpochMilliseconds(target.beginMillis),
-                end = Instant.fromEpochMilliseconds(target.endMillis),
-            ),
-        )
+        // occurrence's time so recurring events render correctly. An external
+        // "open event" that names no occurrence ([NO_OCCURRENCE_TIME] — e.g. a
+        // bare content://.../events/<id> VIEW intent, issue #48) keeps the row's
+        // own DTSTART/DTEND instead of overriding it to the epoch.
+        val corrected = if (target.beginMillis == NO_OCCURRENCE_TIME) {
+            detail
+        } else {
+            detail.copy(
+                instance = detail.instance.copy(
+                    start = Instant.fromEpochMilliseconds(target.beginMillis),
+                    end = Instant.fromEpochMilliseconds(target.endMillis),
+                ),
+            )
+        }
         val calendar = repository.calendars().first()
             .firstOrNull { it.id == corrected.instance.calendarId }
         EventDetailUiState.Success(
@@ -168,6 +175,16 @@ class EventDetailViewModel @Inject constructor(
 
     /** A tapped occurrence: the series [eventId] plus this occurrence's own times. */
     private data class Target(val eventId: Long, val beginMillis: Long, val endMillis: Long)
+
+    companion object {
+        /**
+         * Sentinel begin/end for an "open this event" that names no occurrence —
+         * a bare `content://com.android.calendar/events/<id>` VIEW intent with no
+         * `EXTRA_EVENT_BEGIN_TIME` (issue #48). [loadDetail] then keeps the event
+         * row's own DTSTART/DTEND instead of overriding it to the epoch.
+         */
+        const val NO_OCCURRENCE_TIME: Long = Long.MIN_VALUE
+    }
 }
 
 /** A filesystem-safe `.ics` file name from an event title (or a fallback). */

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

@@ -89,6 +89,7 @@ import androidx.compose.ui.graphics.isSpecified
 import androidx.compose.ui.graphics.Shape
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.TextStyle
@@ -182,12 +183,14 @@ fun EventEditScreen(
     editKey: LongArray? = null,
     initialStartMinutes: Int? = null,
     initialForm: EventForm? = null,
+    initialFormSource: ImportSource = ImportSource.File,
     viewModel: EventEditViewModel = hiltViewModel(),
 ) {
     LaunchedEffect(initialDateIso, editKey, initialForm) {
         when {
-            // Single-event .ics open: the form arrives prefilled for review.
-            initialForm != null -> viewModel.openImported(initialForm)
+            // A prefilled open: a single-event .ics for review, or an external
+            // ACTION_INSERT intent. The source drives how reminders are seeded.
+            initialForm != null -> viewModel.openImported(initialForm, initialFormSource)
             editKey != null -> viewModel.openForEdit(
                 eventId = editKey[0],
                 beginMillis = editKey[1],
@@ -202,6 +205,7 @@ fun EventEditScreen(
     }
     val state by viewModel.state.collectAsStateWithLifecycle()
     val loadFailed by viewModel.loadFailed.collectAsStateWithLifecycle()
+    val importReminderPrompt by viewModel.importReminderPrompt.collectAsStateWithLifecycle()
 
     // The form is intentionally forgotten on every close (cancel or save) so
     // the next open starts clean; it survives rotation because openNew /
@@ -332,6 +336,56 @@ fun EventEditScreen(
             },
         )
     }
+
+    // A .ics import respects the file's reminders, but offers to swap in the
+    // configured default rather than silently deciding for the user (#49).
+    importReminderPrompt?.let { prompt ->
+        ImportReminderPromptDialog(
+            currentReminderCount = prompt.currentReminderCount,
+            onApply = viewModel::applyImportedReminderDefault,
+            onKeep = viewModel::dismissImportedReminderPrompt,
+        )
+    }
+}
+
+/**
+ * Offer to apply the settings default reminder to an event opened from a `.ics`
+ * file. The file's own reminders are kept unless the user accepts. A plain
+ * two-choice confirmation, so an [AlertDialog] (not a full-screen picker).
+ */
+@Composable
+private fun ImportReminderPromptDialog(
+    currentReminderCount: Int,
+    onApply: () -> Unit,
+    onKeep: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onKeep,
+        title = { Text(stringResource(R.string.import_reminder_prompt_title)) },
+        text = {
+            Text(
+                if (currentReminderCount == 0) {
+                    stringResource(R.string.import_reminder_prompt_body_none)
+                } else {
+                    pluralStringResource(
+                        R.plurals.import_reminder_prompt_body_existing,
+                        currentReminderCount,
+                        currentReminderCount,
+                    )
+                },
+            )
+        },
+        confirmButton = {
+            TextButton(onClick = onApply) {
+                Text(stringResource(R.string.import_reminder_prompt_apply))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onKeep) {
+                Text(stringResource(R.string.import_reminder_prompt_keep))
+            }
+        },
+    )
 }
 
 /**
@@ -618,16 +672,15 @@ private fun EventEditContent(
 
         Spacer(Modifier.height(gap))
 
-        // Calendar card — tap anywhere to pick the target calendar. Picking a
-        // different one while editing *moves* the event (copy+delete on save,
-        // since CALENDAR_ID can't be updated in place). Managed special-dates
-        // events stay locked: the contact sync owns their calendar.
+        // Calendar card — tap anywhere to pick the target calendar. Editing
+        // keeps the owning calendar (moving events between calendars is a
+        // sync-adapter minefield; every stock calendar app locks it too).
         EditCard(
             icon = Icons.Default.CalendarMonth,
             iconContentDescription = stringResource(R.string.event_detail_calendar),
             iconTint = accent,
             onClick = { showCalendarPicker = true }
-                .takeIf { state.calendars.isNotEmpty() && !state.isManaged },
+                .takeIf { state.calendars.isNotEmpty() && !state.isEditing },
         ) {
             Text(
                 text = selectedCalendar?.displayName
@@ -1748,12 +1801,21 @@ private fun ColorPickerDialog(
             modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
         ) {
             if (palette.isNotEmpty()) {
+                // The event's current colour may not be in the curated palette
+                // (a 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 = palette.map { it.argb },
+                    colors = swatches,
                     selected = selected,
                     onSelect = { argb ->
-                        palette.firstOrNull { it.argb == argb }
-                            ?.let { onPickKey(it.key, it.argb) }
+                        val option = palette.firstOrNull { it.argb == argb }
+                        // The appended current colour has no provider key to
+                        // write — it is already the event's colour, so just
+                        // close.
+                        if (option != null) onPickKey(option.key, option.argb) else onDismiss()
                     },
                     dark = dark,
                 )

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

@@ -50,6 +50,36 @@ import kotlin.time.Duration.Companion.hours
 import kotlin.time.Instant
 import javax.inject.Inject
 
+/**
+ * Where a prefilled [EventEditViewModel.openImported] form came from — the two
+ * sources want different reminder handling (#49).
+ */
+enum class ImportSource {
+    /**
+     * An external `ACTION_INSERT` intent (another app/widget, e.g. Google Maps).
+     * It carries no reminders of its own, so the settings default is applied
+     * automatically, exactly like an in-app new event.
+     */
+    Insert,
+
+    /**
+     * A parsed single-event `.ics` file. Its own reminders are respected; the
+     * settings default is offered through [EventEditViewModel.importReminderPrompt]
+     * rather than silently applied or suppressed.
+     */
+    File,
+}
+
+/**
+ * A pending offer to swap an imported `.ics` event's reminders for the settings
+ * default (#49). [currentReminderCount] is what the file carried (0 or more);
+ * [defaultReminders] is what accepting would set.
+ */
+data class ImportReminderPrompt(
+    val currentReminderCount: Int,
+    val defaultReminders: List<Int>,
+)
+
 /**
  * Holds the event form being composed. The form's calendar id resolves to
  * (user pick > last used > first writable); the resolved value is what the UI
@@ -78,10 +108,16 @@ class EventEditViewModel @Inject constructor(
     // freezes the auto-applied default: switching calendars no longer overwrites
     // their choice. Reset with the form.
     private val _remindersTouched = MutableStateFlow(false)
+    // A one-time offer, raised when a .ics import opens, to replace the file's
+    // reminders with the settings default (#49). Null while there's nothing to ask.
+    private val _importReminderPrompt = MutableStateFlow<ImportReminderPrompt?>(null)
 
     /** True when the event to edit couldn't be loaded; the screen closes itself. */
     val loadFailed: StateFlow<Boolean> = _loadFailed.asStateFlow()
 
+    /** Pending "apply your default reminder?" offer for a `.ics` import; null when none. */
+    val importReminderPrompt: StateFlow<ImportReminderPrompt?> = _importReminderPrompt.asStateFlow()
+
     /**
      * The event being edited plus everything the form saw at load time.
      * For recurring events the write scope is chosen at save time; the
@@ -112,7 +148,17 @@ class EventEditViewModel @Inject constructor(
         val allDay: List<Int>,
         val timedOverrides: Map<Long, List<Int>>,
         val allDayOverrides: Map<Long, List<Int>>,
-    )
+    ) {
+        /** The default reminders for an event on [calendarId] of the given kind. */
+        fun resolveFor(calendarId: Long?, isAllDay: Boolean): List<Int> = resolveDefaultReminder(
+            timedGlobal = timed,
+            allDayGlobal = allDay,
+            timedOverrides = timedOverrides,
+            allDayOverrides = allDayOverrides,
+            calendarId = calendarId,
+            isAllDay = isAllDay,
+        )
+    }
 
     private data class ExternalInputs(
         val writable: List<CalendarSource>,
@@ -241,18 +287,39 @@ class EventEditViewModel @Inject constructor(
     }
 
     /**
-     * Seed a fresh event from a parsed `.ics` file (the single-event "open into
-     * the create form" path). [form] already carries the file's fields; its
-     * [EventForm.calendarId] is null so the calendar still resolves to the
-     * last-used/first-writable one, and reminders are frozen as touched so the
-     * settings default never overwrites what the file specified. No-op when a
-     * form is already open, so the prefill survives configuration changes.
+     * Seed a fresh event from a prefilled [form] — a parsed single-event `.ics`
+     * file ([ImportSource.File]) or an external `ACTION_INSERT` intent (another
+     * app/widget creating an event, e.g. Google Maps' "add to calendar";
+     * [ImportSource.Insert]; #30, #49). [EventForm.calendarId] is null so the
+     * calendar still resolves to the last-used/first-writable one.
+     *
+     * Reminders are handled per [source], because the two paths mean different
+     * things by "no reminders":
+     * - [ImportSource.Insert] carries no reminder semantics, so the settings
+     *   default is applied automatically like an in-app new event (a form that
+     *   somehow did carry reminders keeps them, frozen).
+     * - [ImportSource.File] owns its reminders, so they're frozen as-is; if a
+     *   settings default is configured and differs, [importReminderPrompt] offers
+     *   to swap it in rather than silently deciding for the user.
+     *
+     * No-op when a form is already open, so the prefill survives configuration
+     * changes.
      */
-    fun openImported(form: EventForm) {
+    fun openImported(form: EventForm, source: ImportSource) {
         if (_form.value != null || _editTarget.value != null) return
-        _remindersTouched.value = true
         _revealed.value = form.populatedFields()
         _form.value = form
+        when (source) {
+            ImportSource.Insert ->
+                if (form.reminders.isNotEmpty()) _remindersTouched.value = true
+                else applyDefaultReminder()
+
+            ImportSource.File -> {
+                // Respect the file's own reminders; never silently overwrite them.
+                _remindersTouched.value = true
+                maybePromptImportedReminderDefault(form)
+            }
+        }
     }
 
     /**
@@ -266,26 +333,12 @@ class EventEditViewModel @Inject constructor(
     private fun applyDefaultReminder(calendarId: Long? = null) {
         if (_editTarget.value != null || _remindersTouched.value) return
         viewModelScope.launch {
-            val defaults = combine(
-                settingsPrefs.defaultReminderMinutes,
-                settingsPrefs.defaultAllDayReminderMinutes,
-                settingsPrefs.perCalendarReminderOverride,
-                settingsPrefs.perCalendarAllDayReminderOverride,
-            ) { timed, allDay, timedOv, allDayOv ->
-                ReminderDefaults(timed, allDay, timedOv, allDayOv)
-            }.first()
+            val defaults = reminderDefaults()
             val targetId = calendarId ?: resolvedCalendarId.first()
             // 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(
-                timedGlobal = defaults.timed,
-                allDayGlobal = defaults.allDay,
-                timedOverrides = defaults.timedOverrides,
-                allDayOverrides = defaults.allDayOverrides,
-                calendarId = targetId,
-                isAllDay = form.isAllDay,
-            )
+            val reminders = defaults.resolveFor(targetId, form.isAllDay)
             _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.
@@ -295,6 +348,52 @@ class EventEditViewModel @Inject constructor(
         }
     }
 
+    /** Snapshot the four settings-default reminder flows into one value. */
+    private suspend fun reminderDefaults(): ReminderDefaults = combine(
+        settingsPrefs.defaultReminderMinutes,
+        settingsPrefs.defaultAllDayReminderMinutes,
+        settingsPrefs.perCalendarReminderOverride,
+        settingsPrefs.perCalendarAllDayReminderOverride,
+    ) { timed, allDay, timedOv, allDayOv ->
+        ReminderDefaults(timed, allDay, timedOv, allDayOv)
+    }.first()
+
+    /**
+     * A `.ics` import respects the file's reminders, but an event opened from a
+     * file often has none while the user still expects their configured default.
+     * Rather than silently deciding, raise a one-time offer to swap in the
+     * settings default — but only when there's a real choice: a default is
+     * configured and it isn't already exactly what the file carried.
+     */
+    private fun maybePromptImportedReminderDefault(form: EventForm) {
+        viewModelScope.launch {
+            val targetId = resolvedCalendarId.first()
+            val default = reminderDefaults().resolveFor(targetId, form.isAllDay)
+            // Bail if the form closed or became an edit while we resolved.
+            val current = _form.value ?: return@launch
+            if (_editTarget.value != null) return@launch
+            if (default.isEmpty() || default == current.reminders) return@launch
+            _importReminderPrompt.value = ImportReminderPrompt(
+                currentReminderCount = current.reminders.size,
+                defaultReminders = default,
+            )
+        }
+    }
+
+    /** Accept the import prompt: replace the file's reminders with the default. */
+    fun applyImportedReminderDefault() {
+        val prompt = _importReminderPrompt.value ?: return
+        _importReminderPrompt.value = null
+        // Already frozen as touched by openImported; this just swaps the values.
+        update { it.copy(reminders = prompt.defaultReminders) }
+        _revealed.value = _revealed.value + EventFormField.Reminders
+    }
+
+    /** Decline the import prompt: keep the file's own reminders untouched. */
+    fun dismissImportedReminderPrompt() {
+        _importReminderPrompt.value = null
+    }
+
     /**
      * Load an existing event into the form. [beginMillis]/[endMillis] are the
      * tapped occurrence's own times, like on the detail screen. No-op while a
@@ -329,6 +428,7 @@ class EventEditViewModel @Inject constructor(
         _editTarget.value = null
         _loadFailed.value = false
         _remindersTouched.value = false
+        _importReminderPrompt.value = null
     }
 
     /** Unfold one optional field, picked in the "more fields" dialog. */
@@ -439,15 +539,10 @@ class EventEditViewModel @Inject constructor(
             _saveState.value = SaveUiState.Saved
             return
         }
-        // Changing the calendar moves the event (copy+delete — CALENDAR_ID can't
-        // be updated in place) and is inherently whole-series: an occurrence
-        // can't live in a different calendar than its series, so a move skips the
-        // scope dialog even for a recurring event.
-        val movingCalendar = target != null && form.calendarId != target.original.calendarId
         // Managed events are a yearly series whose editable fields (reminders,
         // notes, location) live on the series row — never offer the scope dialog,
         // which would split the series into an exception the sync then reverts.
-        if (target != null && target.original.rrule != null && !current.isManaged && !movingCalendar) {
+        if (target != null && target.original.rrule != null && !current.isManaged) {
             _saveState.value = SaveUiState.AwaitingScope
             return
         }
@@ -502,17 +597,6 @@ class EventEditViewModel @Inject constructor(
                 if (target == null) {
                     repository.createEvent(form)
                     prefs.setLastUsedCalendarId(requireNotNull(form.calendarId))
-                } else if (form.calendarId != target.original.calendarId) {
-                    // Move to the picked calendar (copy+delete), carrying any
-                    // field edits made in the same save. The target becomes the
-                    // last-used calendar, like a create does.
-                    repository.moveEvent(
-                        eventId = target.eventId,
-                        targetCalendarId = requireNotNull(form.calendarId),
-                        original = target.original,
-                        updated = form,
-                    )
-                    prefs.setLastUsedCalendarId(requireNotNull(form.calendarId))
                 } else {
                     when (scope) {
                         RecurringWriteScope.ThisEvent ->

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

@@ -133,7 +133,6 @@ import de.jeanlucmakiola.calendula.ui.common.ReminderDefaultPicker
 import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
-import de.jeanlucmakiola.calendula.ui.common.SnoozeDurationPicker
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.eventFormFieldIcon
@@ -1175,9 +1174,10 @@ private fun NotificationsScreen(
     }
 
     if (showSnooze) {
-        SnoozeDurationPicker(
+        OptionPicker(
             title = stringResource(R.string.settings_snooze_duration),
-            presets = SNOOZE_PRESETS,
+            predictiveBack = true,
+            options = SNOOZE_PRESETS,
             selected = state.snoozeMinutes,
             label = { snoozeDurationLabel(it) },
             onSelect = { viewModel.setSnoozeMinutes(it) },

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

@@ -310,7 +310,7 @@
     <string name="settings_language">App-Sprache</string>
     <string name="settings_language_auto">Systemstandard</string>
     <!-- Hub category subtitles -->
-    <string name="settings_appearance_subtitle">Design, Standartansicht, Wochenstart</string>
+    <string name="settings_appearance_subtitle">Design, Standardansicht, Wochenstart</string>
     <string name="settings_event_form_subtitle">Standardfelder für neue Termine</string>
     <string name="settings_notifications_subtitle">Termin-Erinnerungen</string>
     <string name="settings_section_about">Über</string>
@@ -474,4 +474,20 @@
     <string name="special_dates_default_title_birthday">Geburtstag von {name} ({year})</string>
     <string name="special_dates_default_title_anniversary">Jahrestag von {name} ({year})</string>
     <string name="special_dates_default_title_custom">{name}</string>
+    <string name="settings_week_numbers">Kalenderwochen</string>
+    <string name="settings_week_numbers_summary">Kalenderwochen der Monatsansicht anzeigen</string>
+    <string name="calendars_export_title">Kalender exportieren</string>
+    <string name="calendars_export_hint">Wähle aus, welche Kalender in die .ics-Datei aufgenommen werden sollen.</string>
+    <string name="calendars_export_action">Exportieren</string>
+    <string name="calendars_restore_header">Wiederherstellen</string>
+    <string name="calendars_restore_action">Aus .ics-Datei wiederherstellen</string>
+    <string name="calendars_restore_hint">Importiere Ereignisse aus einem Backup oder einer anderen Kalender-App.</string>
+    <string name="import_done_dedup_note">Bereits im Kalender vorhandene Ereignisse wurden übersprungen.</string>
+    <string name="import_done_added_label">Hinzugefügt</string>
+    <string name="import_done_skipped_label">Duplikate</string>
+    <string name="import_button">Importieren</string>
+    <plurals name="import_title_count">
+        <item quantity="one">%d Ereignis wird importiert</item>
+        <item quantity="other">%d Ereignisse werden importiert</item>
+    </plurals>
 </resources>

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

@@ -16,17 +16,17 @@
     <string name="state_failure_no_calendars">Nessun calendario configurato.</string>
     <string name="state_failure_no_calendars_action">Apri le impostazioni calendario di sistema</string>
     <string name="state_failure_provider">Errore nella lettura del calendario.</string>
-    <string name="permission_rationale_title">Guarda tutti i tuoi eventi, magnificamente</string>
-    <string name="permission_rationale_body">Calendula ha bisogno di accedere al tuo calendario per mostrare e gestire gli eventi. È l\'unica cosa che ti chiederà.</string>
+    <string name="permission_rationale_title">Gestisci magnificamente tutti i tuoi eventi</string>
+    <string name="permission_rationale_body">Calendula ha bisogno di accedere al tuo calendario per mostrare e gestire gli eventi. È l\'unica cosa di cui ha bisogno e nessuna informazione lascerà mai il tuo dispositivo.</string>
     <string name="permission_request_button">Concedi l\'accesso al calendario</string>
     <string name="permission_denied_title">Accesso al calendario negato</string>
     <string name="permission_denied_body">Calendula non può mostrare gli eventi senza accesso al calendario. Puoi concederlo dalle impostazioni di sistema.</string>
     <string name="permission_open_settings_button">Apri le impostazioni di sistema</string>
     <string name="permission_retry_button">Riprova</string>
     <string name="permission_benefit_private_title">Rimane sul tuo dispositivo</string>
-    <string name="permission_benefit_private_body">I tuoi calendari sono letti localmente e non lasciano mai il tuo telefono.</string>
+    <string name="permission_benefit_private_body">I tuoi calendari sono letti localmente e non lasciano mai il tuo dispositivo.</string>
     <string name="permission_benefit_sync_title">Tutti i tuoi calendari, insieme</string>
-    <string name="permission_benefit_sync_body">Google, CalDAV, locali - qualsiasi calendario sincronizzato sul dispositivo semplicemente compare.</string>
+    <string name="permission_benefit_sync_body">Google, CalDAV, locali - qualsiasi calendario sincronizzato sul dispositivo, semplicemente, compare.</string>
     <string name="permission_benefit_privacy_title">Nessun tracking, per sempre</string>
     <string name="permission_benefit_privacy_body">Zero telemetria, zero analytics, zero pubblicità.</string>
     <string name="permission_privacy_footnote">Rimane sul tuo dispositivo - nessun accesso a internet</string>
@@ -38,7 +38,7 @@
     <string name="month_action_settings">Impostazioni</string>
     <string name="month_a11y_today_prefix">Oggi</string>
     <string name="week_today_action">Questa settimana</string>
-    <string name="week_number_label">Wk</string>
+    <string name="week_number_label">Sett.</string>
     <string name="day_today_action">Oggi</string>
     <string name="event_detail_back">Indietro</string>
     <string name="event_detail_edit">Modifica</string>
@@ -73,14 +73,14 @@
     <string name="event_edit_remove_reminder">Rimuovi promemoria</string>
     <string name="event_edit_attendees">Partecipanti</string>
     <string name="event_edit_add_guest">Aggiungi partecipante</string>
-    <string name="event_edit_add_guest_hint">Aggiungi un partecipante via email…</string>
+    <string name="event_edit_add_guest_hint">Aggiungi un partecipante tramite indirizzo email…</string>
     <string name="event_edit_add_guest_from_contacts">Aggiungi dai contatti</string>
     <string name="event_edit_location_from_contacts">Scegli un indirizzo dai contatti</string>
     <string name="event_edit_remove_guest">Rimuovi partecipante</string>
     <string name="event_edit_attendee_required">Obbligatorio</string>
     <string name="event_edit_attendee_optional">Facoltativo</string>
     <string name="event_edit_attendees_note_synced">Calendula non manda gli inviti agli eventi. Il tuo account calendario potrà inviare le email ai partecipanti al momento della sincronizzazione.</string>
-    <string name="event_edit_attendees_note_local">Salvato sul dispositivo. Nessuno ha ricevuto notifiche.</string>
+    <string name="event_edit_attendees_note_local">Salvato sul dispositivo. Nessuno dei partecipanti ha ricevuto notifiche.</string>
     <string name="event_edit_reminder_custom">Personalizza</string>
     <string name="reminder_unit_minutes">minuti</string>
     <string name="reminder_unit_hours">ore</string>
@@ -89,7 +89,7 @@
     <string name="event_edit_availability">Disponibilità</string>
     <string name="event_edit_visibility">Visibilità</string>
     <string name="event_edit_color">Colore</string>
-    <string name="event_edit_color_default">Colore calendario</string>
+    <string name="event_edit_color_default">Colore del calendario</string>
     <string name="event_edit_color_custom">Colore personalizzato</string>
     <string name="event_edit_color_reset">Reset</string>
     <string name="event_edit_color_unsupported">Non disponibile per questo calendario</string>
@@ -99,13 +99,13 @@
     <string name="event_edit_conflict_body">Durante la modifica l\'evento è stato cambiato, tramite sincronizzazione o tramite altra app. Cosa fare con le modifiche in corso?</string>
     <string name="event_edit_conflict_overwrite">Salva le modifiche</string>
     <string name="event_edit_conflict_overwrite_hint">Sovrascrivi solo i campi modificati</string>
-    <string name="event_edit_conflict_discard">Annulla le mie modifiche</string>
-    <string name="event_edit_conflict_discard_hint">Mantieni l\'evento com\'è ora</string>
+    <string name="event_edit_conflict_discard">Annulla le modifiche</string>
+    <string name="event_edit_conflict_discard_hint">Lascia l\'evento invariato</string>
     <string name="event_edit_gone_title">Evento eliminato</string>
     <string name="event_edit_gone_body">Nel frattempo, questo evento è stato eliminato, ad esempio su un altro dispositivo. Le modifiche non possono più essere salvate.</string>
     <string name="event_edit_recurrence_none">Non si ripete</string>
     <string name="event_edit_recurrence_custom">Personalizza</string>
-    <string name="event_edit_recurrence_every">La serie</string>
+    <string name="event_edit_recurrence_every">Ogni</string>
     <string name="recurrence_unit_days">giorni</string>
     <string name="recurrence_unit_weeks">settimane</string>
     <string name="recurrence_unit_months">mesi</string>
@@ -113,7 +113,7 @@
     <string name="event_edit_recurrence_ends">Fine</string>
     <string name="event_edit_recurrence_end_never">Mai</string>
     <string name="event_edit_recurrence_end_until">Fino alla data</string>
-    <string name="event_edit_recurrence_end_count">Dopo un certo numero di occorrenze</string>
+    <string name="event_edit_recurrence_end_count">Numero di occorrenze</string>
     <string name="event_edit_recurrence_times">occorrenze</string>
     <string name="event_edit_error_recurrence_ends_before_start">Fine antecedente l\'inizio</string>
     <string name="event_availability_busy">Occupato</string>
@@ -125,7 +125,7 @@
     <string name="event_detail_location">Luogo</string>
     <string name="event_detail_description">Descrizione</string>
     <string name="event_detail_attendees">Partecipanti</string>
-    <string name="recurrence_daily">Ogni giorni</string>
+    <string name="recurrence_daily">Ogni giorno</string>
     <string name="recurrence_weekly">Ogni settimana</string>
     <string name="recurrence_monthly">Ogni mese</string>
     <string name="recurrence_yearly">Ogni anno</string>
@@ -204,7 +204,7 @@
     <string name="reminder_benefit_reversible_body">Lo switch è nelle Impostazioni, sezione Notifiche.</string>
     <string name="reminder_onboarding_enable_button">Attiva i promemoria</string>
     <string name="reminder_onboarding_skip_button">Non ora</string>
-    <string name="reminder_action_snooze">Posponi</string>
+    <string name="reminder_action_snooze">Posticipa</string>
     <string name="reminder_action_dismiss">Ignora</string>
     <string name="view_month">Mese</string>
     <string name="view_week">Settimana</string>
@@ -418,16 +418,16 @@
     <string name="settings_default_reminder">Promemoria standard</string>
     <string name="settings_notifications_subtitle">Promemoria evento</string>
     <string name="shortcut_new_event_short">Nuovo evento</string>
-    <string name="event_edit_managed_hint">Gestito da “%1$s” - titolo, data e ripetizioni sono sincronizzate dai tuoi contatti. Promemoria e note sono modificabili dall\'utente</string>
-    <string name="settings_font_headings">Carattere dell\'intestazione</string>
+    <string name="event_edit_managed_hint">Gestito da “%1$s” - titolo, data e ripetizioni sono sincronizzate dai tuoi contatti. Promemoria e note sono modificabili dall\'utente.</string>
+    <string name="settings_font_headings">Carattere del titolo</string>
     <string name="settings_font_body">Carattere del corpo</string>
     <string name="settings_font_system">Predefinito di sistema</string>
     <string name="settings_font_choose_file">Scegli file…</string>
-    <string name="settings_font_custom_selected">Carattere personalizzato</string>
+    <string name="settings_font_custom_selected">Font personalizzato</string>
     <string name="settings_font_import_failed">Impossibile leggere il file come font</string>
     <string name="settings_section_views">Viste</string>
     <string name="settings_quick_switch_header">Pulsante di cambio rapido</string>
-    <string name="settings_quick_switch_hint">Scegli attraverso quali viste scorrere mediante il pulsante in alto a destra, trascinale per riordinarle. Le viste disattivate rimangono raggiungibili dal menù di navigazione.</string>
+    <string name="settings_quick_switch_hint">Scegli attraverso quali viste scorrere col pulsante in alto a destra, trascinale per riordinarle. Le viste disattivate rimangono raggiungibili dal menù di navigazione.</string>
     <string name="settings_drawer_order_header">Menù di navigazione</string>
     <string name="settings_drawer_order_hint">Trascina per riordinare le viste elencate nel menù di navigazione.</string>
     <string name="reorder_drag_handle">Trascina per riordinare</string>
@@ -463,4 +463,7 @@
     <string name="special_dates_calendar_custom">Date speciali</string>
     <string name="special_dates_default_title_birthday">Compleanno di {name} ({year})</string>
     <string name="special_dates_default_title_anniversary">Anniversario di {name} ({year})</string>
+    <string name="font_lora">Lora</string>
+    <string name="font_jetbrains_mono">JetBrains Mono</string>
+    <string name="special_dates_default_title_custom">{name}</string>
 </resources>

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

@@ -117,6 +117,16 @@
     <string name="event_edit_gone_title">Event deleted</string>
     <string name="event_edit_gone_body">This event was deleted in the meantime, for example on another device. Your changes can no longer be saved.</string>
 
+    <!-- Event form — apply default reminder to an imported .ics event (#49) -->
+    <string name="import_reminder_prompt_title">Apply your default reminder?</string>
+    <string name="import_reminder_prompt_body_none">This event was imported without any reminder.</string>
+    <plurals name="import_reminder_prompt_body_existing">
+        <item quantity="one">This event was imported with %1$d reminder.</item>
+        <item quantity="other">This event was imported with %1$d reminders.</item>
+    </plurals>
+    <string name="import_reminder_prompt_apply">Apply default</string>
+    <string name="import_reminder_prompt_keep">Keep as-is</string>
+
     <!-- Event form — recurrence picker (v1.3) -->
     <string name="event_edit_recurrence_none">Does not repeat</string>
     <string name="event_edit_recurrence_custom">Custom</string>

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

@@ -312,46 +312,6 @@ class CalendarRepositoryImplTest {
         assertThat(fake.updatedEvents).containsExactly(Triple(42L, original, updated))
     }
 
-    @Test
-    fun `moveEvent forwards id, target calendar and both forms`(@TempDir tempDir: Path) = runTest {
-        val fake = FakeCalendarDataSource().apply { nextInsertId = 77L }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
-        val original = EventForm(
-            calendarId = 1L,
-            title = "Stand-up",
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15)),
-        )
-        val updated = original.copy(calendarId = 3L)
-
-        val newId = repo.moveEvent(eventId = 42L, targetCalendarId = 3L, original = original, updated = updated)
-
-        assertThat(newId).isEqualTo(77L)
-        assertThat(fake.movedEvents).containsExactly(
-            FakeCalendarDataSource.MovedEvent(42L, 3L, original, updated),
-        )
-    }
-
-    @Test
-    fun `moveEvent propagates write failures`(@TempDir tempDir: Path) = runTest {
-        val fake = FakeCalendarDataSource().apply {
-            writeError = WriteFailedException("insert moved event into calendar id=3")
-        }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
-        val form = EventForm(
-            calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
-        )
-
-        try {
-            repo.moveEvent(eventId = 42L, targetCalendarId = 3L, original = form, updated = form.copy(calendarId = 3L))
-            error("Expected WriteFailedException")
-        } catch (expected: WriteFailedException) {
-            assertThat(expected.message).contains("3")
-        }
-    }
-
     @Test
     fun `updateEvent propagates write failures`(@TempDir tempDir: Path) = runTest {
         val fake = FakeCalendarDataSource().apply {

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

@@ -32,6 +32,7 @@ class EventDetailMapperTest {
         accessLevel: Any? = null,
         timezone: String? = null,
         selfStatus: Any? = null,
+        duration: String? = null,
     ): MapColumnReader = MapColumnReader(
         EventDetailProjection.IDX_EVENT_ID to eventId,
         EventDetailProjection.IDX_TITLE to title,
@@ -51,6 +52,7 @@ class EventDetailMapperTest {
         EventDetailProjection.IDX_EVENT_TIMEZONE to timezone,
         EventDetailProjection.IDX_SELF_ATTENDEE_STATUS to selfStatus,
         EventDetailProjection.IDX_EVENT_COLOR_KEY to eventColorKey,
+        EventDetailProjection.IDX_DURATION to duration,
     )
 
     private fun attendeeReader(
@@ -134,12 +136,32 @@ class EventDetailMapperTest {
     fun `pre-1970 negative dtstart is kept, not dropped (issue #34)`() {
         // A yearly birthday/anniversary anchored before the epoch has a
         // legitimately negative UTC epoch-millis DTSTART; recurring rows carry
-        // no DTEND (they use DURATION), so it stays end == begin.
+        // no DTEND (they use DURATION), so the length comes from DURATION.
         val begin = -157_766_400_000L // 1965-01-01T00:00:00Z
-        val detail = detailReader(dtstart = begin, dtend = null).toDetail()
+        val detail = detailReader(dtstart = begin, dtend = null, duration = "P1D").toDetail()
         assertThat(detail).isNotNull()
         assertThat(detail!!.instance.start.toEpochMilliseconds()).isEqualTo(begin)
-        assertThat(detail.instance.end.toEpochMilliseconds()).isEqualTo(begin)
+        assertThat(detail.instance.end.toEpochMilliseconds()).isEqualTo(begin + 86_400_000L)
+    }
+
+    @Test
+    fun `absent dtend takes its length from DURATION (issue #48)`() {
+        // A recurring series row has no DTEND. Opened without a named
+        // occurrence — a bare content://…/events/<id> VIEW intent — the row's
+        // own times are what render, so DURATION has to supply the length or
+        // the event shows as zero-length (10:00–10:00).
+        val begin = 1_000_000_000L
+        val detail = detailReader(dtstart = begin, dtend = null, duration = "PT1H").toDetail()
+        assertThat(detail).isNotNull()
+        assertThat(detail!!.instance.end.toEpochMilliseconds()).isEqualTo(begin + 3_600_000L)
+    }
+
+    @Test
+    fun `absent dtend and absent DURATION stays zero-length`() {
+        val begin = 1_000_000_000L
+        val detail = detailReader(dtstart = begin, dtend = null, duration = null).toDetail()
+        assertThat(detail).isNotNull()
+        assertThat(detail!!.instance.end.toEpochMilliseconds()).isEqualTo(begin)
     }
 
     @Test

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

@@ -220,6 +220,117 @@ class EventWriteMapperTest {
         assertThat(values).containsEntry(CalendarContract.Events.DESCRIPTION, null)
     }
 
+    // --- buildOccurrenceCancelValues ("delete only this event") ---
+
+    @Test
+    fun `occurrence cancel anchors a single instance and cancels only it`() {
+        val values = buildOccurrenceCancelValues(
+            originalInstanceMillis = 1_700_000_000_000L,
+            dtStartMillis = 1_700_000_000_000L,
+            duration = "P3600S",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.ORIGINAL_INSTANCE_TIME])
+            .isEqualTo(1_700_000_000_000L)
+        // DTSTART + DURATION make the provider derive a single instance and drop
+        // the inherited RRULE, so only this occurrence is cancelled — not the
+        // whole series (#47). DTEND is never sent (the provider rejects it).
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_700_000_000_000L)
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P3600S")
+        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("Europe/Berlin")
+        assertThat(values[CalendarContract.Events.STATUS])
+            .isEqualTo(CalendarContract.Events.STATUS_CANCELED)
+        assertThat(values).doesNotContainKey(CalendarContract.Events.DTEND)
+        assertThat(values).doesNotContainKey(CalendarContract.Events.RRULE)
+    }
+
+    @Test
+    fun `all-day occurrence cancel keeps the all-day flag and utc zone`() {
+        val values = buildOccurrenceCancelValues(
+            originalInstanceMillis = 1_700_000_000_000L,
+            dtStartMillis = 1_700_000_000_000L,
+            duration = "P1D",
+            timezone = "UTC",
+            allDay = 1,
+        )
+        assertThat(values[CalendarContract.Events.ALL_DAY]).isEqualTo(1)
+        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("UTC")
+        assertThat(values[CalendarContract.Events.STATUS])
+            .isEqualTo(CalendarContract.Events.STATUS_CANCELED)
+    }
+
+    // --- buildOccurrenceExdateValues ("delete only this event", no _sync_id) ---
+
+    @Test
+    fun `exdate drop excludes the occurrence and rewrites the recurrence set`() {
+        // 2026-07-15T08:00:00Z.
+        val values = buildOccurrenceExdateValues(
+            existingExdate = null,
+            occurrenceMillis = 1_784_102_400_000L,
+            dtStartMillis = 1_783_929_600_000L,
+            rrule = "FREQ=DAILY;COUNT=5",
+            duration = "PT1H",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260715T080000Z")
+        // The whole time/recurrence set rides along: an EXDATE-only update is not
+        // treated as a recurrence change, so the provider would leave the expanded
+        // instances (and the occurrence) in place. DTSTART alone is worse — it
+        // makes the provider recompute lastDate as a single instance and collapse
+        // the series to its first occurrence.
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_783_929_600_000L)
+        assertThat(values[CalendarContract.Events.RRULE]).isEqualTo("FREQ=DAILY;COUNT=5")
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("PT1H")
+        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("Europe/Berlin")
+    }
+
+    @Test
+    fun `exdate drop appends to an existing exdate list`() {
+        val values = buildOccurrenceExdateValues(
+            existingExdate = "20260714T080000Z",
+            occurrenceMillis = 1_784_102_400_000L,
+            dtStartMillis = 1_783_929_600_000L,
+            rrule = "FREQ=DAILY;COUNT=5",
+            duration = "PT1H",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE])
+            .isEqualTo("20260714T080000Z,20260715T080000Z")
+    }
+
+    @Test
+    fun `exdate drop folds away a repeated occurrence`() {
+        val values = buildOccurrenceExdateValues(
+            existingExdate = "20260715T080000Z",
+            occurrenceMillis = 1_784_102_400_000L,
+            dtStartMillis = 1_783_929_600_000L,
+            rrule = "FREQ=DAILY;COUNT=5",
+            duration = "PT1H",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260715T080000Z")
+    }
+
+    @Test
+    fun `all-day exdate drop uses the date-only form`() {
+        // An all-day DTSTART sits at UTC midnight, so the date reads off UTC.
+        val values = buildOccurrenceExdateValues(
+            existingExdate = null,
+            occurrenceMillis = 1_784_073_600_000L, // 2026-07-15T00:00:00Z
+            dtStartMillis = 1_783_900_800_000L,
+            rrule = "FREQ=YEARLY",
+            duration = "P1D",
+            timezone = "UTC",
+            allDay = 1,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260715")
+        assertThat(values[CalendarContract.Events.ALL_DAY]).isEqualTo(1)
+    }
+
     // --- per-event colour ---
 
     @Test
@@ -298,114 +409,4 @@ class EventWriteMapperTest {
         assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR, null)
         assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR_KEY, null)
     }
-
-    // --- buildMovedMasterValues (calendar move: verbatim series copy) ---
-
-    private fun masterSnapshot(
-        isAllDay: Boolean = false,
-        dtStartMillis: Long = 1_781_164_800_000L,
-        dtEndMillis: Long? = 1_781_164_800_000L + 5_400_000L,
-        duration: String? = null,
-        rrule: String? = null,
-        rdate: String? = null,
-        exdate: String? = null,
-    ) = MasterEventSnapshot(
-        title = "Standup",
-        isAllDay = isAllDay,
-        dtStartMillis = dtStartMillis,
-        dtEndMillis = dtEndMillis,
-        duration = duration,
-        rrule = rrule,
-        rdate = rdate,
-        exdate = exdate,
-        timezone = "Europe/Berlin",
-        availability = CalendarContract.Events.AVAILABILITY_BUSY,
-        accessLevel = CalendarContract.Events.ACCESS_DEFAULT,
-        status = CalendarContract.Events.STATUS_CONFIRMED,
-        location = "Room 1",
-        description = "",
-    )
-
-    @Test
-    fun `moved one-off carries target calendar, uid and DTEND but no recurrence`() {
-        val values = buildMovedMasterValues(masterSnapshot(), targetCalendarId = 9L, uid = "u@calendula")
-        assertThat(values[CalendarContract.Events.CALENDAR_ID]).isEqualTo(9L)
-        assertThat(values[CalendarContract.Events.UID_2445]).isEqualTo("u@calendula")
-        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L)
-        assertThat(values[CalendarContract.Events.DTEND]).isEqualTo(1_781_164_800_000L + 5_400_000L)
-        assertThat(values).doesNotContainKey(CalendarContract.Events.RRULE)
-        assertThat(values).doesNotContainKey(CalendarContract.Events.DURATION)
-        // Empty description clears explicitly; a raw/keyed colour is never copied
-        // (may be invalid on the target account — the copy inherits its colour).
-        assertThat(values).containsEntry(CalendarContract.Events.DESCRIPTION, null)
-        assertThat(values).doesNotContainKey(CalendarContract.Events.EVENT_COLOR)
-        assertThat(values).doesNotContainKey(CalendarContract.Events.EVENT_COLOR_KEY)
-    }
-
-    @Test
-    fun `moved series preserves the recurrence skeleton as RRULE plus DURATION`() {
-        val values = buildMovedMasterValues(
-            masterSnapshot(dtEndMillis = null, duration = "P5400S", rrule = "FREQ=WEEKLY", exdate = "20260618T080000Z"),
-            targetCalendarId = 9L,
-            uid = "u@calendula",
-        )
-        assertThat(values[CalendarContract.Events.RRULE]).isEqualTo("FREQ=WEEKLY")
-        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P5400S")
-        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260618T080000Z")
-        // Recurring rows never carry DTEND (the provider's invariant).
-        assertThat(values).doesNotContainKey(CalendarContract.Events.DTEND)
-    }
-
-    @Test
-    fun `moved series without a stored duration derives it from DTEND`() {
-        val values = buildMovedMasterValues(
-            masterSnapshot(duration = null, rrule = "FREQ=DAILY"),
-            targetCalendarId = 9L,
-            uid = "u@calendula",
-        )
-        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P5400S")
-    }
-
-    // --- buildCopiedExceptionValues (calendar move: exception replay) ---
-
-    private fun exceptionSnapshot(
-        isCancelled: Boolean = false,
-        duration: String? = null,
-        // Occurrence starts one hour into the day and runs 30 minutes.
-        dtEndMillis: Long? = 1_781_164_800_000L + 3_600_000L + 1_800_000L,
-    ) = ExceptionRowSnapshot(
-        exceptionEventId = 42L,
-        originalInstanceMillis = 1_781_164_800_000L,
-        isCancelled = isCancelled,
-        status = if (isCancelled) CalendarContract.Events.STATUS_CANCELED else CalendarContract.Events.STATUS_CONFIRMED,
-        title = "Moved occurrence",
-        isAllDay = false,
-        dtStartMillis = 1_781_164_800_000L + 3_600_000L,
-        dtEndMillis = dtEndMillis,
-        duration = duration,
-        timezone = "Europe/Berlin",
-        availability = CalendarContract.Events.AVAILABILITY_BUSY,
-        accessLevel = CalendarContract.Events.ACCESS_DEFAULT,
-        location = "",
-        description = "Notes",
-    )
-
-    @Test
-    fun `copied modified occurrence carries the original instance and DURATION not DTEND`() {
-        val values = buildCopiedExceptionValues(exceptionSnapshot())
-        assertThat(values[CalendarContract.Events.ORIGINAL_INSTANCE_TIME])
-            .isEqualTo(1_781_164_800_000L)
-        assertThat(values[CalendarContract.Events.TITLE]).isEqualTo("Moved occurrence")
-        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L + 3_600_000L)
-        // 30-minute occurrence derived from DTEND, written as DURATION only.
-        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P1800S")
-        assertThat(values).doesNotContainKey(CalendarContract.Events.DTEND)
-        assertThat(values).containsEntry(CalendarContract.Events.EVENT_LOCATION, null)
-    }
-
-    @Test
-    fun `copied modified occurrence keeps a stored duration verbatim`() {
-        val values = buildCopiedExceptionValues(exceptionSnapshot(duration = "P900S", dtEndMillis = null))
-        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P900S")
-    }
 }

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

@@ -34,13 +34,6 @@ internal class FakeCalendarDataSource : CalendarDataSource {
 
     val insertedForms = mutableListOf<EventForm>()
     val updatedEvents = mutableListOf<Triple<Long, EventForm, EventForm>>()
-    data class MovedEvent(
-        val eventId: Long,
-        val targetCalendarId: Long,
-        val original: EventForm,
-        val updated: EventForm,
-    )
-    val movedEvents = mutableListOf<MovedEvent>()
     val updatedOccurrences = mutableListOf<Triple<Long, Long, EventForm>>()
     val updatedFromOccurrences = mutableListOf<Triple<Long, Long, EventForm>>()
     val deletedEventIds = mutableListOf<Long>()
@@ -123,19 +116,6 @@ internal class FakeCalendarDataSource : CalendarDataSource {
         allDayReminderTimes += allDayReminderTimeMinutes
     }
 
-    override fun moveEvent(
-        eventId: Long,
-        targetCalendarId: Long,
-        original: EventForm,
-        updated: EventForm,
-        allDayReminderTimeMinutes: Int,
-    ): Long {
-        writeError?.let { throw it }
-        movedEvents += MovedEvent(eventId, targetCalendarId, original, updated)
-        allDayReminderTimes += allDayReminderTimeMinutes
-        return nextInsertId
-    }
-
     override fun updateOccurrence(
         eventId: Long,
         beginMillis: Long,

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

@@ -0,0 +1,214 @@
+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/edit/EventEditViewModelTest.kt

@@ -1,158 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.edit
-
-import androidx.datastore.core.DataStore
-import androidx.datastore.preferences.core.PreferenceDataStoreFactory
-import androidx.datastore.preferences.core.Preferences
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.data.calendar.CalendarRepositoryImpl
-import de.jeanlucmakiola.calendula.data.calendar.FakeCalendarDataSource
-import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
-import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.EventDetail
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.test.UnconfinedTestDispatcher
-import kotlinx.coroutines.test.advanceUntilIdle
-import kotlinx.coroutines.test.resetMain
-import kotlinx.coroutines.test.runTest
-import kotlinx.coroutines.test.setMain
-import kotlinx.coroutines.Dispatchers
-import org.junit.jupiter.api.AfterEach
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.io.TempDir
-import java.nio.file.Path
-import kotlin.time.Instant
-
-/**
- * Focuses on the save-time branch that decides between an in-place update and a
- * calendar *move* (copy+delete). The provider-level move itself is verified
- * on-device; here the fake records which repository call the ViewModel chose.
- */
-@OptIn(ExperimentalCoroutinesApi::class)
-class EventEditViewModelTest {
-
-    private val dispatcher = UnconfinedTestDispatcher()
-
-    @BeforeEach fun setUp() = Dispatchers.setMain(dispatcher)
-    @AfterEach fun tearDown() = Dispatchers.resetMain()
-
-    private val beginMillis = 1_781_164_800_000L
-    private val endMillis = beginMillis + 3_600_000L
-
-    private fun cal(id: Long): CalendarSource = CalendarSource(
-        id = id, displayName = "Cal $id", accountName = "acc@local", accountType = "LOCAL",
-        color = 0xFF112233.toInt(), isVisibleInSystem = true, canModifyContents = true,
-    )
-
-    private fun detail(calendarId: Long, rrule: String? = null): EventDetail = EventDetail(
-        instance = EventInstance(
-            instanceId = 42L, eventId = 42L, calendarId = calendarId, title = "Standup",
-            start = Instant.fromEpochMilliseconds(beginMillis),
-            end = Instant.fromEpochMilliseconds(endMillis),
-            isAllDay = false, color = 0xFF000000.toInt(), location = null,
-        ),
-        description = null, organizer = null, attendees = emptyList(), rrule = rrule,
-    )
-
-    // Pin the DataStore's scope to the test dispatcher so a settings write (e.g.
-    // last-used calendar) completes under advanceUntilIdle instead of on a real
-    // IO thread the virtual clock can't observe.
-    private fun prefs(tempDir: Path): CalendarPrefs = CalendarPrefs(
-        PreferenceDataStoreFactory.create(
-            scope = CoroutineScope(dispatcher),
-            produceFile = { tempDir.resolve("vm_prefs.preferences_pb").toFile() },
-        ),
-    )
-
-    private fun settings(tempDir: Path): SettingsPrefs = SettingsPrefs(
-        PreferenceDataStoreFactory.create(
-            scope = CoroutineScope(dispatcher),
-            produceFile = { tempDir.resolve("vm_settings.preferences_pb").toFile() },
-        ),
-    )
-
-    private fun viewModel(
-        tempDir: Path,
-        fake: FakeCalendarDataSource,
-    ): EventEditViewModel {
-        val p = prefs(tempDir)
-        val s = settings(tempDir)
-        val repo = CalendarRepositoryImpl(fake, p, s, dispatcher as CoroutineDispatcher)
-        return EventEditViewModel(repo, p, s, dispatcher)
-    }
-
-    /** Keep [EventEditViewModel.state] hot so it computes while the test drives it. */
-    private fun CoroutineScope.activate(vm: EventEditViewModel): Job = launch { vm.state.collect {} }
-
-    @Test
-    fun `changing the calendar routes the save through a move, not an update`(
-        @TempDir tempDir: Path,
-    ) = runTest(dispatcher) {
-        val fake = FakeCalendarDataSource().apply {
-            calendarsResult = listOf(cal(1L), cal(2L))
-            eventDetailResult = { detail(calendarId = 1L) }
-            nextInsertId = 99L
-        }
-        val vm = viewModel(tempDir, fake)
-        val job = activate(vm)
-
-        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
-        vm.setCalendar(2L)
-        vm.save()
-        advanceUntilIdle()
-
-        assertThat(fake.movedEvents).hasSize(1)
-        assertThat(fake.movedEvents.single().eventId).isEqualTo(42L)
-        assertThat(fake.movedEvents.single().targetCalendarId).isEqualTo(2L)
-        assertThat(fake.updatedEvents).isEmpty()
-        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.Saved)
-        job.cancel()
-    }
-
-    @Test
-    fun `moving a recurring event skips the scope dialog`(@TempDir tempDir: Path) = runTest(dispatcher) {
-        val fake = FakeCalendarDataSource().apply {
-            calendarsResult = listOf(cal(1L), cal(2L))
-            eventDetailResult = { detail(calendarId = 1L, rrule = "FREQ=WEEKLY") }
-        }
-        val vm = viewModel(tempDir, fake)
-        val job = activate(vm)
-
-        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
-        vm.setCalendar(2L)
-        vm.save()
-        advanceUntilIdle()
-
-        // No AwaitingScope park: a move is inherently whole-series.
-        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.Saved)
-        assertThat(fake.movedEvents).hasSize(1)
-        job.cancel()
-    }
-
-    @Test
-    fun `editing a recurring event without moving still asks for the scope`(
-        @TempDir tempDir: Path,
-    ) = runTest(dispatcher) {
-        val fake = FakeCalendarDataSource().apply {
-            calendarsResult = listOf(cal(1L), cal(2L))
-            eventDetailResult = { detail(calendarId = 1L, rrule = "FREQ=WEEKLY") }
-        }
-        val vm = viewModel(tempDir, fake)
-        val job = activate(vm)
-
-        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
-        vm.setTitle("Renamed")
-        vm.save()
-        advanceUntilIdle()
-
-        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.AwaitingScope)
-        assertThat(fake.movedEvents).isEmpty()
-        job.cancel()
-    }
-}

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

@@ -0,0 +1,34 @@
+### Fixed
+- Deleting one occurrence of a repeating event no longer breaks the series.
+  Choosing "This event" when deleting an occurrence of a recurring event could
+  wipe out every *other* occurrence while leaving the one you deleted behind as
+  a stale, still-tappable ghost — and deleting it again brought the series back.
+  A single-occurrence delete now removes exactly that occurrence and leaves the
+  rest of the series untouched, and the deleted occurrence disappears from the
+  grid straight away. This holds on every kind of calendar, including the
+  on-device ones Calendula keeps for contact birthdays and anniversaries, where
+  the series is a yearly repeat. Thanks to @moonj for the report ([#47]).
+- Tapping an event in a third-party widget opens it in Calendula. v2.13.1 taught
+  Calendula to answer the "new event" hand-off from other apps and widgets; now
+  it also answers the "open this event" one, so tapping an existing event in a
+  widget such as Todo Agenda offers Calendula and lands on that event's details.
+  Thanks to @bushrang3r for the report ([#48]).
+- Events created from other apps get your default reminder. An event handed over
+  by another app or widget — Google Maps' "add to calendar", the Todo Agenda
+  widget's "+" — opened with no reminder at all, ignoring the default set in
+  Settings. It now starts with your default reminder, the same as an event you
+  create in Calendula. An event opened from an `.ics` file is treated differently,
+  because the file has its own say: Calendula keeps whatever reminders it carries
+  (including none at all) and asks you once whether to apply your default instead
+  — it never quietly overrides the file. If you have no default set, it doesn't
+  ask ([#49]).
+- 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]).
+