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

Reviewed-on: #72

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

@@ -22,6 +22,7 @@ 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
@@ -63,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>
 
@@ -492,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()
     }
@@ -611,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()
     }
 
@@ -970,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 ->
@@ -980,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
@@ -992,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(
@@ -1182,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/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

@@ -182,6 +182,100 @@ internal fun buildOccurrenceExceptionValues(
     putAll(eventColorColumns(form.colorKey, form.color))
 }
 
+/**
+ * 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 fun buildOccurrenceCancelValues(
+    originalInstanceMillis: Long,
+    dtStartMillis: Long,
+    duration: String?,
+    timezone: String?,
+    allDay: Int,
+): Map<String, Any?> = buildMap {
+    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 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,
+    )
+}
+
+/**
+ * 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.
+ */
+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,
+        )
+    }
+}
+
 /**
  * The `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A
  * [colorKey] writes the key alone (the provider derives `EVENT_COLOR` from the

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
 }
 
 /**

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/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))
+            }
+        },
+    )
 }
 
 /**
@@ -1747,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. */

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>