Fix widget review findings for 2.24 (#452)

Feedback on 2.24.0-beta.1 from #90, #376 and #71. floret-kit is pinned to its main after floret-kit#24, which carries the shared parts.

- Transparent background: switching to or from it now shows right away on Date, Countdown, Week strip, Quick add, Upcoming and Today (and the Month and day grid). Their backings always set a fill, so a reapplied rendering can't keep the old one.
- App language: changing it in Settings redraws every widget, which now render in the app language. Below Android 13 the choice is mirrored for the widget process, since AppCompat only applies it inside an activity.
- Picker previews: Countdown and Week strip previews inflate on Android 14 and below (they used View/Space, which RemoteViews refuses).
- Month widget: days outside the month take a 40% lighter shade, in the widget and its XML preview.
- Add button: the filled header action is 44dp instead of 36dp wide (floret-kit).
- Tinted background: the tonal header and weekday pills had the same tone as the fill and disappeared; they now use inversePrimary there (floret-kit). Not in the issues, found while testing.
- Dimmed past events (Month and day, Today, Agenda): the fill fades to 30% and the text to 65% instead of both to 40%, so the title stays readable.
- Widget picker: names drop the Calendula prefix, and each widget gets its own description instead of repeating its name (#71).

The config screen stalling until touched (#90, item 2) is not addressed: it didn't reproduce on an Android 12 emulator.

Closes #376
Closes #71

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

CHANGELOG.md

@@ -16,9 +16,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **The agenda and month widgets have a new look.** The agenda puts each day in its own card, with a round date pill beside the first event and today's pill filled. The month widget has rounded day cells, weekday pills, shaded days outside the month and a + for a new event. The agenda's refresh button is gone, since widgets now update on their own ([#71], [#90]).
 - **Tapping a day in the month widget opens that day,** wherever in its cell you tap ([#386]).
 - **The widget picker shows what each widget looks like.** On Android 15 and later the previews are the real widgets with sample events, in your language and colours; on older versions they are redrawn to match.
+- **Widgets are listed by their name alone,** without "Calendula" in front, and each has a short description in the picker ([#71]).
+- **Past events in widgets stay readable when dimmed.** Their background fades further and their text less ([#90]).
 
 ### Fixed
 - **Widgets show your changes straight away.** After you added, edited or deleted an event, a widget could keep showing the old events until something else redrew it ([#420], [#229]).
+- **Widgets follow the app's language.** After you picked a language in Settings, widgets kept the old one until something redrew them ([#90]).
 - **The month widget handles busy months.** It could show "Can't show content", or only one or two events per day. Each day now shows as many events as its height fits, and the rest fold into +N ([#372]).
 
 ## [2.23.0] — 2026-10-21

app/build.gradle.kts

@@ -32,8 +32,8 @@ android {
         // (up to 2.22.3: 2.22.3 -> 22203; from 2.22.4: 2.23.0-beta.1 -> 2230001,
         // 2.22.4 -> 2220499), and CI fails if the committed one doesn't match.
         // See docs/RELEASING.md.
-        versionCode = 2240001
-        versionName = "2.24.0-beta.1"
+        versionCode = 2240002
+        versionName = "2.24.0-beta.2"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/AndroidManifest.xml

@@ -426,7 +426,7 @@
 
         <!-- A countdown widget's redraw for when its label changes (#439). -->
         <receiver
-            android:name=".widget.countdown.CountdownTickReceiver"
+            android:name=".widget.WidgetTickReceiver"
             android:exported="false" />
 
         <receiver
@@ -450,6 +450,12 @@
              move the boundary, boot / package-replace wipe the alarm, and
              LOCALE_CHANGED redraws the labels in the new language.
              Exported: the system broadcasts arrive from outside the app. -->
+        <!-- The app's own redraw request (language change); not exported so
+             other apps can't trigger it. -->
+        <receiver
+            android:name=".widget.WidgetRedrawReceiver"
+            android:exported="false" />
+
         <receiver
             android:name=".widget.WidgetUpdateReceiver"
             android:exported="true">

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

@@ -15,6 +15,7 @@ import de.jeanlucmakiola.calendula.widget.syncWidgetRollover
 import de.jeanlucmakiola.calendula.widget.widgetEntryPoint
 import de.jeanlucmakiola.floret.crash.CrashConfig
 import de.jeanlucmakiola.floret.crash.CrashReporter
+import de.jeanlucmakiola.floret.locale.AppLanguage
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -45,6 +46,9 @@ class CalendulaApp : Application() {
                 chooseIssueUrl = getString(R.string.report_issue_choose_url),
             ),
         )
+        // Below API 33 only AppCompat activities get the app language; a process
+        // woken for a widget formats in it too (#90).
+        AppLanguage.applyDefault(this)
         // Before anything that writes, so the widgets see every change (#420).
         widgetEntryPoint().widgetRefreshCoordinator().start()
         reconcileAutoBackup()

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

@@ -30,6 +30,7 @@ import androidx.lifecycle.lifecycleScope
 import dagger.hilt.android.AndroidEntryPoint
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.floret.locale.AppLanguage
 import de.jeanlucmakiola.floret.prefs.ThemeMode
 import de.jeanlucmakiola.floret.prefs.isDark
 import de.jeanlucmakiola.floret.prefs.isPureBlack
@@ -278,6 +279,7 @@ class MainActivity : AppCompatActivity() {
         super.onResume()
         // Reaching a running UI means startup succeeded; reset the loop trail.
         CrashReporter.markHealthy(this)
+        AppLanguage.syncMirror(this)
     }
 
     override fun onSaveInstanceState(outState: Bundle) {
@@ -593,7 +595,9 @@ class MainActivity : AppCompatActivity() {
          */
         fun openDateIntent(context: Context, date: LocalDate, source: CalendarView): Intent =
             Intent(context, MainActivity::class.java).apply {
-                data = "calendula://date/$date".toUri()
+                // The source is part of the URI so widgets of different kinds
+                // tapping the same date don't share one PendingIntent.
+                data = "calendula://date/$date/${source.name}".toUri()
                 putExtra(EXTRA_DATE_ISO, date.toString())
                 putExtra(EXTRA_SOURCE_VIEW, source.name)
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
@@ -612,6 +616,7 @@ class MainActivity : AppCompatActivity() {
             endMillis: Long,
             source: CalendarView,
         ): Intent = eventDetailIntent(context, eventId, beginMillis, endMillis).apply {
+            data = "calendula://event/$eventId/$beginMillis/${source.name}".toUri()
             putExtra(EXTRA_SOURCE_VIEW, source.name)
         }
 

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

@@ -571,7 +571,14 @@ class AndroidCalendarDataSource @Inject constructor(
         queryInstances(beginMillis, endMillis, null, null)
 
     override fun eventInstances(eventId: Long, beginMillis: Long, endMillis: Long): List<EventInstance> =
-        queryInstances(beginMillis, endMillis, "${CalendarContract.Instances.EVENT_ID} = ?", arrayOf(eventId.toString()))
+        // The series' own rows plus its exceptions, so an occurrence edited on
+        // its own is still one of the series' occurrences.
+        queryInstances(
+            beginMillis,
+            endMillis,
+            "(${CalendarContract.Instances.EVENT_ID} = ? OR ${CalendarContract.Instances.ORIGINAL_ID} = ?)",
+            arrayOf(eventId.toString(), eventId.toString()),
+        )
 
     private fun queryInstances(
         beginMillis: Long,

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

@@ -10,6 +10,7 @@ import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
 import kotlin.time.Instant
 
 interface CalendarRepository {
@@ -108,6 +109,12 @@ interface CalendarRepository {
         form: EventForm,
     ): Long
 
+    /**
+     * Every series split the app makes ([updateEventFromOccurrence]), so what
+     * follows a series by id can move on to the part that continues it.
+     */
+    val seriesSplits: Flow<SeriesSplit> get() = emptyFlow()
+
     /**
      * Change a recurring event from [beginMillis] onwards (series split);
      * returns the new event's `Events._ID`.
@@ -135,3 +142,6 @@ class NoSuchEventException(eventId: Long) :
 /** A ContentResolver write affected no rows or returned no URI. */
 class WriteFailedException(operation: String) :
     RuntimeException("Calendar write failed: $operation")
+
+/** A "this and following" edit: [oldEventId] now ends where [newEventId] picks up. */
+data class SeriesSplit(val oldEventId: Long, val newEventId: Long)

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

@@ -351,7 +351,11 @@ class CalendarRepositoryImpl @Inject constructor(
         dataSource.updateEventFromOccurrence(
             eventId, beginMillis, original, updated, allDayReminderTimeMinutes(),
         )
-    }
+    }.also { newId -> if (newId != eventId) splits.tryEmit(SeriesSplit(eventId, newId)) }
+
+    private val splits = MutableSharedFlow<SeriesSplit>(extraBufferCapacity = 8)
+
+    override val seriesSplits: Flow<SeriesSplit> = splits
 
     override suspend fun deleteOccurrence(eventId: Long, beginMillis: Long) = write {
         dataSource.deleteOccurrence(eventId, beginMillis)

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

@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.domain
 
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Instant
@@ -100,10 +101,16 @@ val EventInstance.isDeclined: Boolean get() = response == EventResponse.Declined
 /**
  * Whether this event has finished relative to [now] — its end is at or before
  * the current instant. An in-progress event (already started but not yet ended)
- * is *not* considered ended. All-day events end at the exclusive next-midnight,
- * so they only count as ended once their day is fully over.
+ * is *not* considered ended. All-day events end at the exclusive next-midnight
+ * in [zone] rather than the UTC midnight they are stored on, so they only count
+ * as ended once their local day is fully over.
  */
-fun EventInstance.hasEnded(now: Instant): Boolean = end <= now
+fun EventInstance.hasEnded(now: Instant, zone: TimeZone = TimeZone.currentSystemDefault()): Boolean =
+    localEnd(zone) <= now
+
+/** [EventInstance.end], with an all-day event's UTC midnight moved to local midnight in [zone]. */
+fun EventInstance.localEnd(zone: TimeZone): Instant =
+    if (isAllDay) end.toLocalDateTime(TimeZone.UTC).date.atStartOfDayIn(zone) else end
 
 /**
  * The zone this event's calendar dates live in: the device [zone] for timed

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

@@ -30,7 +30,7 @@ fun EventInstance.isPastOn(
     day: LocalDate,
     now: Instant,
     zone: TimeZone = TimeZone.currentSystemDefault(),
-): Boolean = hasEnded(now) || day < now.toLocalDateTime(zone).date
+): Boolean = hasEnded(now, zone) || day < now.toLocalDateTime(zone).date
 
 /** Opacity applied to a completed/past event chip when it is dimmed. */
 const val EventDimAlpha = 0.4f

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

@@ -63,6 +63,7 @@ import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.GroupedSectionHeader
 import de.jeanlucmakiola.floret.components.LanguagePickerRow
+import de.jeanlucmakiola.calendula.widget.requestWidgetRedraw
 import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.crash.CrashReportDialog
 import de.jeanlucmakiola.floret.crash.CrashReporter
@@ -258,15 +259,16 @@ private fun SettingsHub(
             leading = { CategoryIcon(Icons.Default.Widgets, ChipAccent.Tertiary) },
             onClick = { onOpenSection(SettingsSection.Widgets) },
         )
+        val context = LocalContext.current
         LanguagePickerRow(
             position = Position.Middle,
             title = stringResource(R.string.settings_language),
             autoLabel = stringResource(R.string.settings_language_auto),
             localesConfig = R.xml.locales_config,
             predictiveBack = true,
+            onChange = { requestWidgetRedraw(context) },
             // Invite contributions right where users pick their language.
             header = {
-                val context = LocalContext.current
                 val translateUrl = stringResource(R.string.about_translate_url)
                 GroupedRow(
                     title = stringResource(R.string.settings_translate),

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

@@ -27,6 +27,14 @@ abstract class CalendulaWidgetReceiver : GlanceAppWidgetReceiver() {
         syncWidgetRollover(context)
     }
 
+    override fun onDeleted(context: Context, appWidgetIds: IntArray) {
+        super.onDeleted(context, appWidgetIds)
+        evictMonthSources(appWidgetIds)
+        WidgetKind.entries.firstOrNull { it.receiver == this::class.java }?.let { kind ->
+            appWidgetIds.forEach { WidgetTicks.cancel(context, kind, it) }
+        }
+    }
+
     override fun onRestored(context: Context, oldWidgetIds: IntArray, newWidgetIds: IntArray) {
         restoreState(context, oldWidgetIds, newWidgetIds)
     }

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

@@ -5,6 +5,7 @@ import android.content.Context
 import android.content.pm.PackageManager
 import androidx.core.content.ContextCompat
 import androidx.glance.GlanceId
+import androidx.glance.appwidget.GlanceAppWidgetManager
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.SettingsKeys
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
@@ -170,7 +171,7 @@ internal suspend fun Context.loadAgendaWidgetData(
     val zone = systemZone()
     val anchor = today(zone)
     val ep = widgetEntryPoint()
-    val weekStart = settings.weekStart.resolveFirstDay(Locale.getDefault())
+    val weekStart = settings.weekStart.resolveFirstDay(widgetLocale())
     val dayCount = options.range.dayCount(anchor, weekStart)
     val window = agendaRange(anchor, dayCount - 1, zone)
     val windowEnd = anchor.plus(dayCount - 1, DateTimeUnit.DAY)
@@ -189,7 +190,8 @@ internal suspend fun Context.loadAgendaWidgetData(
 
 internal fun monthIndexOf(date: LocalDate): Int = date.year * 12 + date.month.ordinal
 
-private fun firstDayOfMonthIndex(index: Int): LocalDate = LocalDate(index / 12, index % 12 + 1, 1)
+internal fun firstDayOfMonthIndex(index: Int): LocalDate =
+    LocalDate(Math.floorDiv(index, 12), Math.floorMod(index, 12) + 1, 1)
 
 /**
  * The month the widget loads its window around while [index] is shown. Snapped
@@ -207,28 +209,50 @@ internal fun monthWindowCenter(index: Int): Int = Math.floorDiv(index, 3) * 3 +
 private object MonthSourceCache {
     private class Entry(val center: Int, val stamp: Long, val source: Themed<MonthWidgetSource.Ready>)
 
-    private val entries = ConcurrentHashMap<GlanceId, Entry>()
+    // Keyed by app-widget id, which a removed widget can still be named by.
+    private val entries = ConcurrentHashMap<Int, Entry>()
 
-    fun get(id: GlanceId, center: Int, stamp: Long): Themed<MonthWidgetSource>? =
+    fun get(id: Int, center: Int, stamp: Long): Themed<MonthWidgetSource>? =
         entries[id]?.takeIf { it.center == center && it.stamp == stamp && it.source.content.today == today(systemZone()) }
             ?.source
 
-    fun put(id: GlanceId, center: Int, stamp: Long, source: Themed<MonthWidgetSource>) {
+    fun put(id: Int, center: Int, stamp: Long, source: Themed<MonthWidgetSource>) {
         val ready = source.content as? MonthWidgetSource.Ready ?: return
         entries[id] = Entry(center, stamp, Themed(ready, source.appTheme))
     }
+
+    fun remove(id: Int) {
+        entries.remove(id)
+    }
 }
 
-/** [loadThemedMonthSource] for widget [id], served from [MonthSourceCache] while its [stamp] holds. */
-internal suspend fun Context.loadCachedMonthSource(id: GlanceId, centerIndex: Int, stamp: Long): Themed<MonthWidgetSource> =
-    MonthSourceCache.get(id, centerIndex, stamp)
-        ?: loadThemedMonthSource(centerIndex, widgetState(id).hiddenCalendars)
-            .also { MonthSourceCache.put(id, centerIndex, stamp, it) }
+/** Drops the cached windows of removed widgets [appWidgetIds]. */
+internal fun evictMonthSources(appWidgetIds: IntArray) = appWidgetIds.forEach(MonthSourceCache::remove)
+
+/**
+ * [loadThemedMonthSource] for widget [id], served from [MonthSourceCache] while its [stamp] holds.
+ * A [load] already read for this pass saves reading the settings and widget state again.
+ */
+internal suspend fun Context.loadCachedMonthSource(
+    id: GlanceId,
+    centerIndex: Int,
+    stamp: Long,
+    load: WidgetLoadContext? = null,
+): Themed<MonthWidgetSource> {
+    val key = GlanceAppWidgetManager(this).getAppWidgetId(id)
+    return MonthSourceCache.get(key, centerIndex, stamp)
+        ?: loadThemedMonthSource(centerIndex, load?.hiddenCalendars ?: widgetState(id).hiddenCalendars, load?.settings)
+            .also { MonthSourceCache.put(key, centerIndex, stamp, it) }
+}
 
 /** Read backing the month widget's grid for the window around [centerIndex], with the app theme. */
-internal suspend fun Context.loadThemedMonthSource(centerIndex: Int, hiddenCalendars: Set<Long>): Themed<MonthWidgetSource> {
-    val settings = widgetEntryPoint().settingsPrefs().widgetSettings.first()
-    return Themed(queryMonthSource(centerIndex, settings, hiddenCalendars), settings.themeMode)
+internal suspend fun Context.loadThemedMonthSource(
+    centerIndex: Int,
+    hiddenCalendars: Set<Long>,
+    settings: WidgetSettings? = null,
+): Themed<MonthWidgetSource> {
+    val resolved = settings ?: widgetEntryPoint().settingsPrefs().widgetSettings.first()
+    return Themed(queryMonthSource(centerIndex, resolved, hiddenCalendars), resolved.themeMode)
 }
 
 private suspend fun Context.queryMonthSource(
@@ -250,7 +274,7 @@ private suspend fun Context.queryMonthSource(
         .toInstant(zone)
     return MonthWidgetSource.Ready(
         today = today(zone),
-        weekStart = settings.weekStart.resolveFirstDay(Locale.getDefault()),
+        weekStart = settings.weekStart.resolveFirstDay(widgetLocale()),
         soften = settings.soften,
         instances = ep.calendarRepository().instances(from..to).first().withoutCalendars(hiddenCalendars),
         months = months,
@@ -298,7 +322,7 @@ internal suspend fun Context.loadDays(
     if (!hasCalendarPermission()) return Themed(DaysWidgetData.NeedsPermission, settings.themeMode)
     val zone = systemZone()
     val anchor = today(zone)
-    val weekStart = settings.weekStart.resolveFirstDay(Locale.getDefault())
+    val weekStart = settings.weekStart.resolveFirstDay(widgetLocale())
     val range = days(anchor, weekStart)
     val window = range.start.atStartOfDayIn(zone)..range.endInclusive.atTime(23, 59, 59).toInstant(zone)
     val instances = widgetEntryPoint().calendarRepository().instances(window).first().withoutCalendars(load.hiddenCalendars)

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

@@ -23,7 +23,6 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.isDeclined
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
-import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.SECONDARY_INK_ALPHA
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.eventInk
@@ -32,6 +31,16 @@ import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.glance.WidgetGroupedRow
 import de.jeanlucmakiola.floret.glance.themedColor
 
+/** A past event's fill when dimmed: fainter than the app's whole-row dim, so its text can stay readable (#90). */
+internal const val WidgetDimFillAlpha = 0.3f
+
+/** A dimmed event's ink, held above its fill. */
+private const val WidgetDimInkAlpha = 0.65f
+
+/** Ink for an event on [fill], picked against the opaque tone and faded when the fill is dimmed. */
+internal fun widgetEventInk(fill: Color, alpha: Float): Color =
+    eventInk(fill.copy(alpha = 1f), if (fill.alpha < 1f) alpha * WidgetDimInkAlpha else alpha)
+
 /** Text and row sizes of a compact event list, from a widget's [WidgetSize]. */
 internal data class EventRowMetrics(val title: TextUnit, val time: TextUnit, val rowHeight: Dp, val message: TextUnit)
 
@@ -63,11 +72,9 @@ internal fun WidgetEventRow(
     quiet: Boolean = false,
 ) {
     val context = LocalContext.current
-    fun tone(dark: Boolean): Color = eventFill(event.color, dark, soften).let { if (dimmed) it.copy(alpha = EventDimAlpha) else it }
+    fun tone(dark: Boolean): Color = eventFill(event.color, dark, soften).let { if (dimmed) it.copy(alpha = WidgetDimFillAlpha) else it }
     val day = tone(dark = false)
     val night = tone(dark = true)
-    // Ink is picked against the opaque fill, then carries the dim along with it.
-    fun ink(fill: Color, alpha: Float) = eventInk(fill.copy(alpha = 1f), alpha * fill.alpha)
     val card = widgetCardColor()
     WidgetGroupedRow(position = position, color = if (quiet) card else themedColor(day = day, night = night)) {
         Column(
@@ -91,12 +98,12 @@ internal fun WidgetEventRow(
             val titleInk = if (quiet) {
                 GlanceTheme.colors.onSurface
             } else {
-                themedColor(day = ink(day, 1f), night = ink(night, 1f))
+                themedColor(day = widgetEventInk(day, 1f), night = widgetEventInk(night, 1f))
             }
             val timeInk = if (quiet) {
                 GlanceTheme.colors.onSurfaceVariant
             } else {
-                themedColor(day = ink(day, SECONDARY_INK_ALPHA), night = ink(night, SECONDARY_INK_ALPHA))
+                themedColor(day = widgetEventInk(day, SECONDARY_INK_ALPHA), night = widgetEventInk(night, SECONDARY_INK_ALPHA))
             }
             Text(
                 text = event.title.ifBlank { context.getString(R.string.event_untitled) },

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

@@ -95,6 +95,9 @@ enum class WidgetKind(
     ),
     ;
 
+    /** Whether a calendar change can change what it draws; Date and Quick add draw no events. */
+    val drawsEvents: Boolean get() = this != QUICK_ADD && this != DATE
+
     fun widget(): GlanceAppWidget = when (this) {
         AGENDA -> AgendaWidget()
         MONTH -> MonthWidget()

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

@@ -18,7 +18,6 @@ import kotlinx.datetime.plus
 import kotlinx.datetime.toJavaDayOfWeek
 import kotlinx.datetime.toJavaLocalDate
 import kotlinx.datetime.toLocalDateTime
-import java.util.Locale
 import kotlin.time.Instant
 
 /** Cards sit one tone off the root fill, and stay opaque over a wallpaper (#292). */
@@ -39,15 +38,20 @@ internal fun widgetTimeLabel(context: Context, event: EventInstance, day: LocalD
 
 internal fun formatWidgetTime(instant: Instant, is24Hour: Boolean): String {
     val t = instant.toLocalDateTime(systemZone()).time
-    return formatTimeOfDay(t.hour, t.minute, is24Hour, Locale.getDefault())
+    return formatTimeOfDay(t.hour, t.minute, is24Hour, widgetLocale())
+}
+
+/** "Today" or "Tomorrow" for those two days, else null. */
+internal fun relativeDayWord(context: Context, date: LocalDate, today: LocalDate): String? = when (date) {
+    today -> context.getString(R.string.agenda_header_today)
+    today.plus(1, DateTimeUnit.DAY) -> context.getString(R.string.agenda_header_tomorrow)
+    else -> null
 }
 
 /** "Today", "Tomorrow", or the short weekday within the coming week, else the short date. */
 internal fun relativeDayLabel(context: Context, date: LocalDate, today: LocalDate): String {
-    val locale = Locale.getDefault()
-    return when {
-        date == today -> context.getString(R.string.agenda_header_today)
-        date == today.plus(1, DateTimeUnit.DAY) -> context.getString(R.string.agenda_header_tomorrow)
+    val locale = widgetLocale()
+    return relativeDayWord(context, date, today) ?: when {
         date < today.plus(7, DateTimeUnit.DAY) && date > today ->
             date.dayOfWeek.toJavaDayOfWeek().getDisplayName(java.time.format.TextStyle.SHORT, locale)
         else -> localizedDateFormatter(locale, "dMMM").format(date.toJavaLocalDate())

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

@@ -40,15 +40,29 @@ import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.atTime
 import kotlinx.datetime.plus
 import kotlinx.datetime.toInstant
-import java.util.Locale
 import kotlin.time.Duration.Companion.hours
 import kotlin.time.Duration.Companion.minutes
 
-/** Republishes the generated picker previews (Android 15+) after an app update or a language change. */
+/**
+ * Republishes the generated picker previews (Android 15+) when anything they
+ * draw with has changed: the app version, language, today's date, or the
+ * theme, week start, time format and colour softening.
+ */
 internal suspend fun publishCalendulaWidgetPreviews(context: Context) {
+    val settings = context.widgetEntryPoint().settingsPrefs().widgetSettings.first()
+    val updated = context.packageManager.getPackageInfo(context.packageName, 0).lastUpdateTime
+    val is24Hour = settings.timeFormat.is24Hour(android.text.format.DateFormat.is24HourFormat(context))
     publishWidgetPreviews(
         context,
-        version = "${context.packageManager.getPackageInfo(context.packageName, 0).lastUpdateTime}-${Locale.getDefault().toLanguageTag()}",
+        version = listOf(
+            updated,
+            widgetLocale().toLanguageTag(),
+            today(systemZone()),
+            settings.themeMode,
+            settings.weekStart,
+            is24Hour,
+            settings.soften,
+        ).joinToString("-"),
         receivers = listOf(
             AgendaWidgetReceiver::class,
             MonthWidgetReceiver::class,
@@ -73,7 +87,7 @@ internal suspend fun GlanceAppWidget.provideSamplePreview(context: Context, kind
     val today = today(zone)
     val now = today.atTime(8, 0).toInstant(zone)
     val instances = context.sampleInstances(today, zone)
-    val weekStart = settings.weekStart.resolveFirstDay(Locale.getDefault())
+    val weekStart = settings.weekStart.resolveFirstDay(widgetLocale())
     val is24Hour = settings.timeFormat.is24Hour(android.text.format.DateFormat.is24HourFormat(context))
     val options = settings.agendaDefaults
     val appearance = WidgetAppearance()

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

@@ -6,18 +6,22 @@ import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
 import android.os.SystemClock
+import android.util.Log
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.ApplicationScope
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.widget.countdown.repointCountdowns
 import de.jeanlucmakiola.floret.glance.WidgetRefresher
 import de.jeanlucmakiola.floret.glance.WidgetRollover
 import de.jeanlucmakiola.floret.glance.updatePlaced
 import de.jeanlucmakiola.floret.glance.updateWithRefresh
 import androidx.glance.appwidget.GlanceAppWidgetManager
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.drop
@@ -34,6 +38,20 @@ internal val WIDGET_RECEIVER_CLASSES: List<Class<*>> = WidgetKind.entries.map {
 /** The app's own midnight wake-up (#228). */
 internal const val ACTION_WIDGET_ROLLOVER = "de.jeanlucmakiola.calendula.widget.ROLLOVER"
 
+/** Redraws every widget, for app changes they draw with that no other signal reaches, like its language (#90). */
+internal const val ACTION_WIDGET_REDRAW = "de.jeanlucmakiola.calendula.widget.REDRAW"
+
+/**
+ * Asks [WidgetRedrawReceiver] to redraw every widget. A broadcast rather than a
+ * coroutine, so it outlives the activity a language change recreates.
+ */
+fun requestWidgetRedraw(context: Context) {
+    context.sendBroadcast(Intent(context, WidgetRedrawReceiver::class.java).setAction(ACTION_WIDGET_REDRAW))
+}
+
+/** The widgets a calendar change can affect. */
+internal val EVENT_WIDGET_KINDS: List<WidgetKind> = WidgetKind.entries.filter { it.drawsEvents }
+
 /** Fixed: there is only ever one rollover alarm, and re-arming must replace it. */
 private const val ROLLOVER_REQUEST_CODE = 0x0DA1
 
@@ -52,10 +70,22 @@ internal fun syncWidgetRollover(context: Context) =
  * Reloads and redraws every placed widget, a running session included: the
  * refresh stamp moves, and every widget keys its data load on it (#420).
  */
-internal suspend fun redrawWidgets(context: Context) {
-    WidgetKind.entries.forEach { redrawWidgets(context, it) }
+internal suspend fun redrawWidgets(context: Context, kinds: List<WidgetKind> = WidgetKind.entries) {
+    // One kind failing, say a widget removed mid-pass, mustn't stop the others
+    // or escape the broadcast's coroutine.
+    kinds.forEach { kind ->
+        try {
+            redrawWidgets(context, kind)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            Log.w(TAG, "Redrawing $kind widgets failed", e)
+        }
+    }
 }
 
+private const val TAG = "WidgetRedraw"
+
 internal suspend fun redrawWidgets(context: Context, kind: WidgetKind) =
     kind.widget().updatePlaced(context, kind.receiver, bumpRefreshStamp = true)
 
@@ -66,8 +96,14 @@ private suspend fun redrawUnconfiguredWidgets(context: Context) {
     val glanceManager = GlanceAppWidgetManager(appContext)
     WidgetKind.entries.filter { it.hasContentOptions }.forEach { kind ->
         manager.getAppWidgetIds(ComponentName(appContext, kind.receiver)).forEach { appWidgetId ->
-            val glanceId = glanceManager.getGlanceIdBy(appWidgetId)
-            if (!appContext.widgetState(glanceId).hasAgendaOptions) kind.widget().updateWithRefresh(appContext, glanceId)
+            try {
+                val glanceId = glanceManager.getGlanceIdBy(appWidgetId)
+                if (!appContext.widgetState(glanceId).hasAgendaOptions) kind.widget().updateWithRefresh(appContext, glanceId)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                Log.w(TAG, "Redrawing widget $appWidgetId failed", e)
+            }
         }
     }
 }
@@ -77,9 +113,32 @@ private val lastLocalChange = AtomicLong(0L)
 
 private const val PROVIDER_ECHO_WINDOW_MILLIS = 5_000L
 
-internal fun isProviderEcho(): Boolean {
+/** Set while a `PROVIDER_CHANGED` redraw waits out the echo window, so a burst of them redraws once. */
+private val echoRedrawQueued = AtomicBoolean(false)
+
+private fun providerEchoRemainingMillis(): Long {
     val last = lastLocalChange.get()
-    return last != 0L && SystemClock.elapsedRealtime() - last < PROVIDER_ECHO_WINDOW_MILLIS
+    if (last == 0L) return 0L
+    return PROVIDER_ECHO_WINDOW_MILLIS - (SystemClock.elapsedRealtime() - last)
+}
+
+/**
+ * Whether a `PROVIDER_CHANGED` should redraw. Within the echo window of one of
+ * the app's own changes it may only echo that change, or be a sync landing
+ * right after it, so it isn't dropped: the first one redraws once the window
+ * has passed ([awaitProviderEcho]) and the rest of the burst ride along.
+ */
+internal fun claimProviderRedraw(): Boolean =
+    providerEchoRemainingMillis() <= 0L || echoRedrawQueued.compareAndSet(false, true)
+
+/** Waits out the echo window, if one is open, before a `PROVIDER_CHANGED` redraw. */
+internal suspend fun awaitProviderEcho() {
+    try {
+        val wait = providerEchoRemainingMillis()
+        if (wait > 0L) delay(wait)
+    } finally {
+        echoRedrawQueued.set(false)
+    }
 }
 
 /**
@@ -102,23 +161,28 @@ class WidgetRefreshCoordinator @Inject constructor(
     /** Subscribes before returning, so a change made right after is never taken for the starting value. */
     fun start() {
         if (!started.compareAndSet(false, true)) return
-        val all = WidgetKind.entries.map { kind -> WidgetRefresher(scope) { redrawWidgets(context, kind) } }
+        val refreshers = WidgetKind.entries.associateWith { kind -> WidgetRefresher(scope) { redrawWidgets(context, kind) } }
+        val all = refreshers.values
         val unconfigured = WidgetRefresher(scope) { redrawUnconfiguredWidgets(context) }
         watch(repository.localChanges) {
             lastLocalChange.set(SystemClock.elapsedRealtime())
-            all.forEach { it.request() }
+            EVENT_WIDGET_KINDS.forEach { refreshers.getValue(it).request() }
+        }
+        watch(repository.seriesSplits) { split ->
+            scope.launch(Dispatchers.IO) { repointCountdowns(context, split.oldEventId, split.newEventId) }
         }
         watch(prefs.widgetSettings.map { it.shared }.distinctUntilChanged().drop(1)) {
             all.forEach { it.request() }
+            scope.launch(Dispatchers.IO) { publishCalendulaWidgetPreviews(context) }
         }
         watch(prefs.widgetSettings.map { it.agendaDefaults }.distinctUntilChanged().drop(1)) {
             unconfigured.request()
         }
     }
 
-    private fun watch(changes: Flow<*>, onChange: () -> Unit) {
+    private fun <T> watch(changes: Flow<T>, onChange: (T) -> Unit) {
         scope.launch(Dispatchers.IO, start = CoroutineStart.UNDISPATCHED) {
-            changes.collect { onChange() }
+            changes.collect { onChange(it) }
         }
     }
 }

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

@@ -0,0 +1,22 @@
+package de.jeanlucmakiola.calendula.widget
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import de.jeanlucmakiola.floret.android.goAsync
+import de.jeanlucmakiola.floret.locale.AppLanguage
+
+/**
+ * Takes [requestWidgetRedraw]'s in-app redraw. Not exported, unlike
+ * [WidgetUpdateReceiver], so no other app can make every widget reload.
+ */
+class WidgetRedrawReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        if (intent.action != ACTION_WIDGET_REDRAW) return
+        val appContext = context.applicationContext
+        goAsync {
+            AppLanguage.applyDefault(appContext)
+            redrawWidgets(appContext)
+        }
+    }
+}

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

@@ -1,12 +1,17 @@
 package de.jeanlucmakiola.calendula.widget
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.glance.LocalContext
 import androidx.glance.text.TextDecoration
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaDarkFallback
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaLightFallback
 import de.jeanlucmakiola.floret.glance.FloretGlanceTheme
 import de.jeanlucmakiola.floret.glance.WidgetSurface
 import de.jeanlucmakiola.floret.glance.WidgetThemeMode
+import de.jeanlucmakiola.floret.locale.AppLanguage
 import de.jeanlucmakiola.floret.prefs.ThemeMode
 
 /**
@@ -39,3 +44,20 @@ internal fun CalendulaWidgetRoot(appearance: WidgetAppearance, appTheme: ThemeMo
  */
 fun glanceDeclinedDecoration(isDeclined: Boolean): TextDecoration =
     if (isDeclined) TextDecoration.LineThrough else TextDecoration.None
+
+/** Static, so a language change recomposes the whole widget rather than letting unchanged parts skip. */
+private val LocalWidgetLanguage = staticCompositionLocalOf<String?> { null }
+
+/**
+ * Draws [content] in the app's own language (#90): [LocalContext] and the
+ * default locale follow it, which below API 33 nothing else does outside an
+ * AppCompat activity. Read on every recomposition, so a redraw picks up a change.
+ */
+@Composable
+internal fun InAppLanguage(content: @Composable () -> Unit) {
+    val base = LocalContext.current
+    val tag = AppLanguage.currentTag(base)
+    AppLanguage.applyDefault(base, tag)
+    val localized = remember(base, tag) { AppLanguage.localized(base, tag) }
+    CompositionLocalProvider(LocalContext provides localized, LocalWidgetLanguage provides tag, content = content)
+}

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

@@ -0,0 +1,79 @@
+package de.jeanlucmakiola.calendula.widget
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.appwidget.AppWidgetManager
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.net.toUri
+import androidx.glance.appwidget.GlanceAppWidgetManager
+import de.jeanlucmakiola.floret.android.goAsync
+import de.jeanlucmakiola.floret.glance.updateWithRefresh
+import kotlinx.coroutines.CancellationException
+import kotlin.time.Instant
+
+/**
+ * One alarm per placed widget, for the moment what it shows next changes: a
+ * countdown's label, the Today list's last event ending. Not a wake-up alarm:
+ * with the screen off nobody sees the widget, so the redraw waits for the
+ * device to wake. Exact where allowed (the app holds the exact alarm
+ * permission for reminders), else within a minute.
+ */
+internal object WidgetTicks {
+    private const val ACTION_TICK = "de.jeanlucmakiola.calendula.widget.TICK"
+    internal const val EXTRA_KIND = "de.jeanlucmakiola.calendula.widget.KIND"
+
+    fun schedule(context: Context, kind: WidgetKind, appWidgetId: Int, at: Instant) {
+        val alarms = context.getSystemService(AlarmManager::class.java) ?: return
+        val intent = pendingIntent(context, kind, appWidgetId)
+        val millis = at.toEpochMilliseconds()
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S || alarms.canScheduleExactAlarms()) {
+            alarms.setExact(AlarmManager.RTC, millis, intent)
+        } else {
+            alarms.setWindow(AlarmManager.RTC, millis, 60_000L, intent)
+        }
+    }
+
+    fun cancel(context: Context, kind: WidgetKind, appWidgetId: Int) {
+        context.getSystemService(AlarmManager::class.java)?.cancel(pendingIntent(context, kind, appWidgetId))
+    }
+
+    private fun pendingIntent(context: Context, kind: WidgetKind, appWidgetId: Int): PendingIntent =
+        PendingIntent.getBroadcast(
+            context,
+            0,
+            Intent(context, WidgetTickReceiver::class.java)
+                .setAction(ACTION_TICK)
+                // Keys the PendingIntent per widget.
+                .setData("calendula://tick/${kind.name}/$appWidgetId".toUri())
+                .putExtra(EXTRA_KIND, kind.name)
+                .putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId),
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+}
+
+/** Reloads the widget whose content just changed; the load arms its next tick. */
+class WidgetTickReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val appWidgetId = intent.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID)
+        val kind = intent.getStringExtra(WidgetTicks.EXTRA_KIND)
+            ?.let { name -> WidgetKind.entries.firstOrNull { it.name == name } }
+        if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID || kind == null) return
+        val appContext = context.applicationContext
+        goAsync {
+            try {
+                val glanceId = GlanceAppWidgetManager(appContext).getGlanceIdBy(appWidgetId)
+                kind.widget().updateWithRefresh(appContext, glanceId)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (_: IllegalArgumentException) {
+                // The widget is gone.
+                WidgetTicks.cancel(appContext, kind, appWidgetId)
+            } catch (_: Exception) {
+                // A failed redraw leaves the last frame; the next signal retries.
+            }
+        }
+    }
+}

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

@@ -4,16 +4,18 @@ import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import de.jeanlucmakiola.floret.glance.FloretWidgetUpdateReceiver
+import de.jeanlucmakiola.floret.locale.AppLanguage
 import kotlin.time.Duration.Companion.minutes
 
 /**
- * Redraws both widgets when their data, day or language goes stale, and keeps
+ * Redraws the widgets when their data, day or language goes stale, and keeps
  * the midnight rollover armed. `PROVIDER_CHANGED` covers changes made outside
- * the app; the app's own writes go through [WidgetRefreshCoordinator]. A data
- * change also re-arms, at most every 15 minutes: the inexact alarm can be
- * dropped in a restricted standby bucket, and a calendar change is the one
- * signal that keeps arriving. A `PROVIDER_CHANGED` right after one of the
- * app's own changes only echoes it, so it doesn't redraw a second time.
+ * the app, and only redraws the widgets that draw events; the app's own writes
+ * go through [WidgetRefreshCoordinator]. A data change also re-arms, at most
+ * every 15 minutes: the inexact alarm can be dropped in a restricted standby
+ * bucket, and a calendar change is the one signal that keeps arriving. A
+ * `PROVIDER_CHANGED` right after one of the app's own changes waits out the
+ * echo window and redraws once ([claimProviderRedraw]).
  */
 class WidgetUpdateReceiver : FloretWidgetUpdateReceiver() {
     override val rolloverAction = ACTION_WIDGET_ROLLOVER
@@ -21,9 +23,20 @@ class WidgetUpdateReceiver : FloretWidgetUpdateReceiver() {
     override val extraHandledActions = setOf(Intent.ACTION_PROVIDER_CHANGED)
     override val extraRearmInterval = 15.minutes
 
+    /** This broadcast's action; a receiver instance handles exactly one. */
+    private var action: String? = null
+
     override fun rolloverPendingIntent(context: Context): PendingIntent = widgetRolloverPendingIntent(context)
 
-    override fun skipRedraw(action: String) = action == Intent.ACTION_PROVIDER_CHANGED && isProviderEcho()
+    override fun skipRedraw(action: String): Boolean {
+        this.action = action
+        return action == Intent.ACTION_PROVIDER_CHANGED && !claimProviderRedraw()
+    }
 
-    override suspend fun redraw(context: Context) = redrawWidgets(context)
+    override suspend fun redraw(context: Context) {
+        val dataChange = action == Intent.ACTION_PROVIDER_CHANGED
+        if (dataChange) awaitProviderEcho()
+        AppLanguage.applyDefault(context)
+        redrawWidgets(context, if (dataChange) EVENT_WIDGET_KINDS else WidgetKind.entries)
+    }
 }

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

@@ -1,5 +1,8 @@
 package de.jeanlucmakiola.calendula.widget.agenda
 
+import de.jeanlucmakiola.calendula.widget.InAppLanguage
+import de.jeanlucmakiola.calendula.widget.relativeDayWord
+import de.jeanlucmakiola.calendula.widget.widgetLocale
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.previewSizeOf
 import de.jeanlucmakiola.calendula.widget.provideSamplePreview
@@ -50,11 +53,11 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.hasEnded
 import de.jeanlucmakiola.calendula.ui.agenda.anchorTodayIfMissing
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
-import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import de.jeanlucmakiola.calendula.ui.common.eventFill
-import de.jeanlucmakiola.calendula.ui.common.eventInk
+import de.jeanlucmakiola.calendula.widget.WidgetDimFillAlpha
+import de.jeanlucmakiola.calendula.widget.widgetEventInk
 import de.jeanlucmakiola.calendula.ui.common.SECONDARY_INK_ALPHA
 import de.jeanlucmakiola.calendula.widget.AgendaWidgetData
 import de.jeanlucmakiola.calendula.widget.WidgetSize
@@ -81,7 +84,6 @@ import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.plus
 import kotlinx.datetime.toJavaDayOfWeek
-import java.util.Locale
 
 /**
  * "Upcoming" agenda widget — a continuously scrolling list of the next ~30 days
@@ -110,11 +112,13 @@ class AgendaWidget : GlanceAppWidget() {
             // A running session never re-runs this preamble, so every redraw
             // moves the stamp and the data reloads here instead (#420).
             val loaded = widgetData.current(currentRefreshStamp()) { context.loadAgendaWidget(id) }
-            AgendaWidgetContent(
-                data = loaded.content,
-                appearance = currentState<Preferences>().widgetAppearance,
-                appTheme = loaded.appTheme,
-            )
+            InAppLanguage {
+                AgendaWidgetContent(
+                    data = loaded.content,
+                    appearance = currentState<Preferences>().widgetAppearance,
+                    appTheme = loaded.appTheme,
+                )
+            }
         }
     }
 }
@@ -392,7 +396,7 @@ private data class EventFill(val day: Color, val night: Color)
 private fun AgendaRow.Event.fill(data: AgendaWidgetData.Ready): EventFill {
     val dimmed = data.pastDisplay == PastEventDisplay.DIM && event.hasEnded(data.now)
     fun tone(dark: Boolean) = eventFill(event.color, dark, data.soften).let {
-        if (dimmed) it.copy(alpha = EventDimAlpha) else it
+        if (dimmed) it.copy(alpha = WidgetDimFillAlpha) else it
     }
     return EventFill(day = tone(dark = false), night = tone(dark = true))
 }
@@ -407,12 +411,10 @@ private fun EventRow(
 ) {
     val context = androidx.glance.LocalContext.current
     val title = event.title.ifBlank { context.getString(R.string.event_untitled) }
-    // Ink is picked against the opaque fill, then carries the dim along with it.
-    fun ink(fill: Color, alpha: Float) = eventInk(fill.copy(alpha = 1f), alpha * fill.alpha)
-    val titleInk = themedColor(day = ink(fill.day, 1f), night = ink(fill.night, 1f))
+    val titleInk = themedColor(day = widgetEventInk(fill.day, 1f), night = widgetEventInk(fill.night, 1f))
     val timeInk = themedColor(
-        day = ink(fill.day, SECONDARY_INK_ALPHA),
-        night = ink(fill.night, SECONDARY_INK_ALPHA),
+        day = widgetEventInk(fill.day, SECONDARY_INK_ALPHA),
+        night = widgetEventInk(fill.night, SECONDARY_INK_ALPHA),
     )
     Column(
         modifier = GlanceModifier
@@ -467,12 +469,8 @@ private fun WidgetMessage(resId: Int, metrics: AgendaMetrics) {
 
 /** "Today · Wed, 17 Jun" — relative word for today/tomorrow, else the date. */
 private fun agendaDayLabel(context: Context, date: LocalDate, today: LocalDate): String {
-    val relative = when (date) {
-        today -> context.getString(R.string.agenda_header_today)
-        today.plus(1, DateTimeUnit.DAY) -> context.getString(R.string.agenda_header_tomorrow)
-        else -> null
-    }
-    val locale = Locale.getDefault()
+    val relative = relativeDayWord(context, date, today)
+    val locale = widgetLocale()
     val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
     // Weekday + date in the locale's own field order (compact: no year), rather
     // than a hardcoded day-month layout.
@@ -482,13 +480,13 @@ private fun agendaDayLabel(context: Context, date: LocalDate, today: LocalDate):
 
 private fun monthName(date: LocalDate, today: LocalDate): String = formatCalendarTitle(
     date = java.time.LocalDate.of(date.year, date.month.ordinal + 1, 1),
-    locale = Locale.getDefault(),
+    locale = widgetLocale(),
     currentYear = today.year,
     skeleton = "LLLL",
 )
 
 private fun weekdayShort(date: LocalDate): String =
-    date.dayOfWeek.toJavaDayOfWeek().getDisplayName(java.time.format.TextStyle.SHORT, Locale.getDefault())
+    date.dayOfWeek.toJavaDayOfWeek().getDisplayName(java.time.format.TextStyle.SHORT, widgetLocale())
 
 private fun eventTimeSummary(
     context: Context,

app/src/main/java/de/jeanlucmakiola/calendula/widget/config/CountdownOptionsSection.kt

@@ -25,6 +25,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.domain.dateZone
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
 import de.jeanlucmakiola.calendula.ui.common.PickerSearchField
@@ -148,7 +149,7 @@ private fun CountdownEventPicker(
                     val formatter = remember(locale) { localizedDateFormatter(locale, "EEEdMMMy") }
                     LazyColumn(contentPadding = PaddingValues(top = 8.dp, bottom = 24.dp)) {
                         itemsIndexed(matches, key = { _, it -> it.event.eventId }) { index, candidate ->
-                            val date = formatter.format(candidate.event.start.toLocalDateTime(zone).date.toJavaLocalDate())
+                            val date = formatter.format(candidate.event.start.toLocalDateTime(candidate.event.dateZone(zone)).date.toJavaLocalDate())
                             GroupedRow(
                                 title = candidate.event.title.ifBlank { stringResource(R.string.event_untitled) },
                                 summary = if (candidate.repeats) stringResource(R.string.widget_config_countdown_repeats, date) else date,

app/src/main/java/de/jeanlucmakiola/calendula/widget/config/WidgetConfigViewModel.kt

@@ -15,6 +15,7 @@ import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.widget.WidgetKind
+import de.jeanlucmakiola.calendula.widget.widgetLocale
 import de.jeanlucmakiola.calendula.widget.DaysWidgetData
 import de.jeanlucmakiola.calendula.widget.WidgetLoadContext
 import de.jeanlucmakiola.calendula.widget.WidgetSettings
@@ -23,6 +24,7 @@ import de.jeanlucmakiola.calendula.widget.weekOf
 import de.jeanlucmakiola.calendula.widget.upcoming.loadUpcoming
 import de.jeanlucmakiola.calendula.widget.today.loadTodayList
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.hasEnded
 import de.jeanlucmakiola.calendula.widget.countdown.CountdownData
 import de.jeanlucmakiola.calendula.widget.countdown.CountdownOptions
 import de.jeanlucmakiola.calendula.widget.countdown.countdownOptions
@@ -55,6 +57,7 @@ import de.jeanlucmakiola.calendula.widget.widgetState
 import de.jeanlucmakiola.floret.glance.updateWithRefresh
 import de.jeanlucmakiola.floret.prefs.ThemeMode
 import javax.inject.Inject
+import kotlinx.datetime.TimeZone
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.channels.Channel
@@ -68,7 +71,6 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
-import java.util.Locale
 
 /** What the preview draws, loaded with the draft's options. */
 sealed interface WidgetPreviewData {
@@ -187,7 +189,7 @@ class WidgetConfigViewModel @Inject constructor(
                 ),
                 calendars = if (WidgetOption.CALENDARS in kind.options) shownCalendars() else emptyList(),
                 appTheme = settings.themeMode,
-                weekStart = settings.weekStart.resolveFirstDay(Locale.getDefault()),
+                weekStart = settings.weekStart.resolveFirstDay(widgetLocale()),
                 placedSize = placedSize(kind),
                 preview = null,
             )
@@ -237,11 +239,31 @@ class WidgetConfigViewModel @Inject constructor(
         viewModelScope.launch {
             val candidates = try {
                 val now = Clock.System.now()
-                val occurrences = repository.instances(now..now + 365.days).first().filter { it.end > now }
-                val perEvent = occurrences.groupBy { it.eventId }
+                val zone = TimeZone.currentSystemDefault()
+                // A year, a quarter at a time, keeping only each event's first
+                // occurrence so busy series don't hold the whole year in memory.
+                val first = LinkedHashMap<Long, EventInstance>()
+                val repeats = HashSet<Long>()
+                for (quarter in 0 until 4) {
+                    val from = now + (quarter * 91).days
+                    val to = if (quarter == 3) now + 365.days else now + ((quarter + 1) * 91).days
+                    repository.instances(from..to).first()
+                        .filter { !it.hasEnded(now, zone) }
+                        .forEach { occurrence ->
+                            val known = first[occurrence.eventId]
+                            when {
+                                known == null -> first[occurrence.eventId] = occurrence
+                                known.start == occurrence.start -> Unit
+                                else -> {
+                                    repeats += occurrence.eventId
+                                    if (occurrence.start < known.start) first[occurrence.eventId] = occurrence
+                                }
+                            }
+                        }
+                }
                 CountdownCandidates.Ready(
-                    perEvent.values
-                        .map { CountdownCandidate(it.minBy { o -> o.start }, repeats = it.size > 1) }
+                    first.values
+                        .map { CountdownCandidate(it, repeats = it.eventId in repeats) }
                         .sortedBy { it.event.start },
                 )
             } catch (e: CancellationException) {

app/src/main/java/de/jeanlucmakiola/calendula/widget/countdown/Countdown.kt

@@ -45,7 +45,7 @@ fun countdownLabel(event: EventInstance, now: Instant, zone: TimeZone): Countdow
     return when {
         delta < 1.minutes -> CountdownLabel(running, CountdownUnit.NOW, 0)
         delta < 1.hours -> CountdownLabel(running, CountdownUnit.MINUTES, ceil(delta / 1.minutes).toInt())
-        delta < 24.hours -> CountdownLabel(running, CountdownUnit.HOURS, (delta / 1.hours).roundToInt().coerceAtLeast(1))
+        delta < 24.hours -> CountdownLabel(running, CountdownUnit.HOURS, (delta / 1.hours).roundToInt().coerceIn(1, 23))
         else -> {
             val days = now.toLocalDateTime(zone).date.daysUntil(target.toLocalDateTime(zone).date)
             CountdownLabel(running, CountdownUnit.DAYS, days.coerceAtLeast(1))

app/src/main/java/de/jeanlucmakiola/calendula/widget/countdown/CountdownData.kt

@@ -1,23 +1,21 @@
 package de.jeanlucmakiola.calendula.widget.countdown
 
-import android.app.AlarmManager
-import android.app.PendingIntent
-import android.appwidget.AppWidgetManager
-import android.content.BroadcastReceiver
 import android.content.Context
-import android.content.Intent
-import android.os.Build
-import androidx.core.net.toUri
 import androidx.datastore.preferences.core.MutablePreferences
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.longPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.glance.GlanceId
 import androidx.glance.appwidget.GlanceAppWidgetManager
+import androidx.glance.appwidget.state.updateAppWidgetState
+import de.jeanlucmakiola.floret.glance.updateWithRefresh
+import kotlinx.coroutines.CancellationException
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.widget.Themed
+import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.WidgetLoadContext
+import de.jeanlucmakiola.calendula.widget.WidgetTicks
 import de.jeanlucmakiola.calendula.widget.hasCalendarPermission
 import de.jeanlucmakiola.calendula.widget.systemZone
 import de.jeanlucmakiola.calendula.widget.today
@@ -25,8 +23,6 @@ import de.jeanlucmakiola.calendula.widget.widgetEntryPoint
 import de.jeanlucmakiola.calendula.widget.widgetLoadContext
 import de.jeanlucmakiola.calendula.widget.widgetState
 import de.jeanlucmakiola.calendula.widget.withoutCalendars
-import de.jeanlucmakiola.floret.android.goAsync
-import de.jeanlucmakiola.floret.glance.updateWithRefresh
 import de.jeanlucmakiola.floret.prefs.toEnum
 import kotlinx.coroutines.flow.first
 import kotlinx.datetime.LocalDate
@@ -104,64 +100,39 @@ internal suspend fun Context.loadPlacedCountdown(id: GlanceId): Themed<Countdown
     val loaded = loadCountdown(widgetLoadContext(id), widgetState(id).countdownOptions, appWidgetId)
     val event = (loaded.content as? CountdownData.Ready)?.event
     if (event == null) {
-        CountdownTicks.cancel(this, appWidgetId)
+        WidgetTicks.cancel(this, WidgetKind.COUNTDOWN, appWidgetId)
     } else {
         val zone = systemZone()
-        CountdownTicks.schedule(this, appWidgetId, nextLabelChange(event.counted(zone), (loaded.content as CountdownData.Ready).now, zone))
+        WidgetTicks.schedule(
+            this,
+            WidgetKind.COUNTDOWN,
+            appWidgetId,
+            nextLabelChange(event.counted(zone), (loaded.content as CountdownData.Ready).now, zone),
+        )
     }
     return loaded
 }
 
 /**
- * One alarm per countdown widget, for the moment its label changes. Not a
- * wake-up alarm: with the screen off nobody sees the widget, so the redraw
- * waits for the device to wake. Exact where allowed (the app holds the exact
- * alarm permission for reminders), else within a minute.
+ * Moves countdowns pinned to [oldEventId] on to [newEventId] after the app
+ * split that series, so they keep counting to the part that continues it.
  */
-internal object CountdownTicks {
-    private const val ACTION_TICK = "de.jeanlucmakiola.calendula.widget.COUNTDOWN_TICK"
-
-    fun schedule(context: Context, appWidgetId: Int, at: Instant) {
-        val alarms = context.getSystemService(AlarmManager::class.java) ?: return
-        val intent = pendingIntent(context, appWidgetId)
-        val millis = at.toEpochMilliseconds()
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S || alarms.canScheduleExactAlarms()) {
-            alarms.setExact(AlarmManager.RTC, millis, intent)
-        } else {
-            alarms.setWindow(AlarmManager.RTC, millis, 60_000L, intent)
-        }
-    }
-
-    fun cancel(context: Context, appWidgetId: Int) {
-        context.getSystemService(AlarmManager::class.java)?.cancel(pendingIntent(context, appWidgetId))
-    }
-
-    private fun pendingIntent(context: Context, appWidgetId: Int): PendingIntent = PendingIntent.getBroadcast(
-        context,
-        0,
-        Intent(context, CountdownTickReceiver::class.java)
-            .setAction(ACTION_TICK)
-            // Keys the PendingIntent per widget.
-            .setData("calendula://countdown/$appWidgetId".toUri())
-            .putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId),
-        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-    )
-}
-
-/** Reloads the countdown widget whose label just changed; the load arms the next tick. */
-class CountdownTickReceiver : BroadcastReceiver() {
-    override fun onReceive(context: Context, intent: Intent) {
-        val appWidgetId = intent.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID)
-        if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) return
-        val appContext = context.applicationContext
-        goAsync {
-            try {
-                val glanceId = GlanceAppWidgetManager(appContext).getGlanceIdBy(appWidgetId)
-                CountdownWidget().updateWithRefresh(appContext, glanceId)
-            } catch (_: IllegalArgumentException) {
-                // The widget is gone.
-                CountdownTicks.cancel(appContext, appWidgetId)
+internal suspend fun repointCountdowns(context: Context, oldEventId: Long, newEventId: Long) {
+    val manager = GlanceAppWidgetManager(context)
+    manager.getGlanceIds(CountdownWidget::class.java).forEach { id ->
+        try {
+            var moved = false
+            updateAppWidgetState(context, id) { prefs ->
+                if (prefs[EventKey] == oldEventId) {
+                    prefs[EventKey] = newEventId
+                    moved = true
+                }
             }
+            if (moved) CountdownWidget().updateWithRefresh(context, id)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (_: Exception) {
+            // Gone mid-pass; nothing left to point anywhere.
         }
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/widget/countdown/CountdownWidget.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.countdown
 
+import de.jeanlucmakiola.calendula.widget.InAppLanguage
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.previewSizeOf
 import de.jeanlucmakiola.calendula.widget.provideSamplePreview
@@ -49,9 +50,7 @@ import de.jeanlucmakiola.calendula.widget.formatWidgetTime
 import de.jeanlucmakiola.calendula.widget.relativeDayLabel
 import de.jeanlucmakiola.calendula.widget.systemZone
 import de.jeanlucmakiola.calendula.widget.widgetAppearance
-import de.jeanlucmakiola.calendula.widget.widgetCardColor
-import de.jeanlucmakiola.floret.glance.LocalWidgetBackground
-import de.jeanlucmakiola.floret.glance.WidgetBackground
+import de.jeanlucmakiola.floret.glance.wallpaperBacking
 import de.jeanlucmakiola.floret.glance.WidgetData
 import de.jeanlucmakiola.floret.glance.WidgetMessage
 import de.jeanlucmakiola.floret.glance.currentRefreshStamp
@@ -65,7 +64,7 @@ import kotlinx.datetime.toLocalDateTime
 /**
  * Countdown (#439): to the next timed event, or to a chosen event or series
  * ("Vacation · in 12 days"). Redraws when its label changes, see
- * [nextLabelChange] and [CountdownTicks]. Tapping opens the event.
+ * [nextLabelChange] and [WidgetTicks]. Tapping opens the event.
  */
 class CountdownWidget : GlanceAppWidget() {
 
@@ -82,18 +81,15 @@ class CountdownWidget : GlanceAppWidget() {
         val widgetData = WidgetData(context.loadPlacedCountdown(id), refreshStamp(context, id))
         provideContent {
             val loaded = widgetData.current(currentRefreshStamp()) { context.loadPlacedCountdown(id) }
-            CountdownWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            InAppLanguage {
+                CountdownWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            }
         }
     }
 }
 
 class CountdownWidgetReceiver : CalendulaWidgetReceiver() {
     override val glanceAppWidget: GlanceAppWidget = CountdownWidget()
-
-    override fun onDeleted(context: Context, appWidgetIds: IntArray) {
-        super.onDeleted(context, appWidgetIds)
-        appWidgetIds.forEach { CountdownTicks.cancel(context, it) }
-    }
 }
 
 @Composable
@@ -144,11 +140,7 @@ private fun EventCountdown(event: EventInstance, data: CountdownData.Ready) {
         ),
     )
     // Over a wallpaper the text sits on its own card, as every other widget's rows do.
-    val card = if (LocalWidgetBackground.current == WidgetBackground.TRANSPARENT) {
-        GlanceModifier.cornerRadius(16.dp).background(widgetCardColor())
-    } else {
-        GlanceModifier
-    }
+    val card = GlanceModifier.wallpaperBacking(radius = 16.dp)
     Box(modifier = GlanceModifier.fillMaxSize().padding(6.dp)) {
         Row(
             modifier = card.fillMaxSize().clickable(open).padding(horizontal = 10.dp, vertical = 8.dp),

app/src/main/java/de/jeanlucmakiola/calendula/widget/date/DateWidget.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.date
 
+import de.jeanlucmakiola.calendula.widget.InAppLanguage
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.previewSizeOf
 import de.jeanlucmakiola.calendula.widget.provideSamplePreview
@@ -24,7 +25,6 @@ import androidx.glance.layout.Column
 import androidx.glance.layout.Spacer
 import androidx.glance.layout.fillMaxSize
 import androidx.glance.layout.height
-import androidx.glance.layout.padding
 import androidx.glance.semantics.contentDescription
 import androidx.glance.semantics.semantics
 import androidx.glance.state.PreferencesGlanceStateDefinition
@@ -40,8 +40,6 @@ import de.jeanlucmakiola.calendula.widget.WidgetAppearance
 import de.jeanlucmakiola.calendula.widget.loadToday
 import de.jeanlucmakiola.calendula.widget.widgetAppearance
 import de.jeanlucmakiola.calendula.widget.widgetLocale
-import de.jeanlucmakiola.floret.glance.LocalWidgetBackground
-import de.jeanlucmakiola.floret.glance.WidgetBackground
 import de.jeanlucmakiola.floret.glance.WidgetData
 import de.jeanlucmakiola.floret.glance.WidgetShape
 import de.jeanlucmakiola.floret.glance.WidgetShapedBox
@@ -71,7 +69,9 @@ class DateWidget : GlanceAppWidget() {
         val widgetData = WidgetData(context.loadToday(), refreshStamp(context, id))
         provideContent {
             val loaded = widgetData.current(currentRefreshStamp()) { context.loadToday() }
-            DateWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            InAppLanguage {
+                DateWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            }
         }
     }
 }
@@ -105,11 +105,7 @@ internal fun DateWidgetContent(today: LocalDate, appearance: WidgetAppearance, a
             verticalAlignment = Alignment.CenterVertically,
         ) {
             val name = today.dayOfWeek.toJavaDayOfWeek().getDisplayName(JavaTextStyle.SHORT, widgetLocale())
-            val backing = if (LocalWidgetBackground.current == WidgetBackground.TRANSPARENT) {
-                GlanceModifier.wallpaperBacking(radius = 8.dp).padding(horizontal = 6.dp)
-            } else {
-                GlanceModifier
-            }
+            val backing = GlanceModifier.wallpaperBacking(radius = 8.dp, horizontalPadding = 6.dp)
             Text(text = name.uppercase(widgetLocale()), maxLines = 1, style = weekday, modifier = backing)
             Spacer(GlanceModifier.height(2.dp))
             WidgetShapedBox(shape = WidgetShape.COOKIE, color = GlanceTheme.colors.primary, size = side) {

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

@@ -147,9 +147,9 @@ private fun openDayIntent(context: Context, date: LocalDate): PendingIntent = Pe
 )
 
 private val STRIP_IDS = intArrayOf(R.id.strip_0, R.id.strip_1, R.id.strip_2, R.id.strip_3, R.id.strip_4, R.id.strip_5, R.id.strip_6)
-/** The shade over a day outside the month: a dark cell needs more of it to read as dimmed. */
-private val OUTSIDE_SHADE_DAY = Color.Black.copy(alpha = 0.18f)
-private val OUTSIDE_SHADE_NIGHT = Color.Black.copy(alpha = 0.50f)
+/** The shade over a day outside the month: a dark cell needs more of it to read as dimmed. Mirrored by `widget_preview_outside_shade`. */
+private val OUTSIDE_SHADE_DAY = Color.Black.copy(alpha = 0.11f)
+private val OUTSIDE_SHADE_NIGHT = Color.Black.copy(alpha = 0.30f)
 
 private val CELL_DIM_IDS = intArrayOf(
     R.id.cell_dim_0, R.id.cell_dim_1, R.id.cell_dim_2, R.id.cell_dim_3, R.id.cell_dim_4, R.id.cell_dim_5, R.id.cell_dim_6,

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

@@ -1,5 +1,7 @@
 package de.jeanlucmakiola.calendula.widget.month
 
+import de.jeanlucmakiola.calendula.widget.InAppLanguage
+import de.jeanlucmakiola.calendula.widget.widgetLocale
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.previewSizeOf
 import de.jeanlucmakiola.calendula.widget.provideSamplePreview
@@ -69,6 +71,7 @@ import de.jeanlucmakiola.calendula.widget.widgetAppearance
 import de.jeanlucmakiola.floret.glance.wallpaperBacking
 import de.jeanlucmakiola.floret.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.widget.MonthWidgetSource
+import de.jeanlucmakiola.calendula.widget.firstDayOfMonthIndex
 import de.jeanlucmakiola.calendula.widget.loadCachedMonthSource
 import de.jeanlucmakiola.calendula.widget.monthWindowCenter
 import de.jeanlucmakiola.floret.glance.WidgetData
@@ -85,7 +88,6 @@ import kotlinx.datetime.Month
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.YearMonth
 import java.time.format.TextStyle as JavaTextStyle
-import java.util.Locale
 
 /** Per-widget state: the displayed month as `year * 12 + monthOrdinal`. */
 private val MONTH_INDEX_KEY = intPreferencesKey("month_index")
@@ -103,7 +105,7 @@ private fun gridChromeHeight(fontScale: Float): Dp =
 private fun currentMonthIndex(zone: TimeZone): Int = monthIndexOf(today(zone))
 
 private fun yearMonthOf(index: Int): YearMonth =
-    YearMonth(index / 12, Month(index % 12 + 1))
+    firstDayOfMonthIndex(index).let { YearMonth(it.year, it.month) }
 
 /**
  * Month-grid widget: a 6×7 calendar with today highlighted, connected multi-day
@@ -169,12 +171,14 @@ class MonthWidget : GlanceAppWidget() {
                 else -> index.coerceIn(source.months)
             }
             SideEffect { lastShown = shown }
-            MonthWidgetContent(
-                source = source,
-                index = shown,
-                appearance = currentState<Preferences>().widgetAppearance,
-                appTheme = loaded.appTheme,
-            )
+            InAppLanguage {
+                MonthWidgetContent(
+                    source = source,
+                    index = shown,
+                    appearance = currentState<Preferences>().widgetAppearance,
+                    appTheme = loaded.appTheme,
+                )
+            }
         }
     }
 }
@@ -354,7 +358,7 @@ private fun monthCellRole(): WidgetColorRole = monthCellRole(LocalWidgetBackgrou
 /** Narrow weekday initials starting at [weekStart], in the device locale.
  * Computed outside the composable so the locale read stays observable-safe. */
 private fun weekdayNarrowNames(weekStart: DayOfWeek): List<String> {
-    val locale = Locale.getDefault()
+    val locale = widgetLocale()
     return (0 until 7).map { i ->
         java.time.DayOfWeek.of((weekStart.ordinal + i) % 7 + 1)
             .getDisplayName(JavaTextStyle.NARROW, locale)
@@ -380,13 +384,10 @@ private fun PermissionMessage() {
     }
 }
 
-// Locale.getDefault() rather than currentLocale(): Glance has no
-// LocalConfiguration, and the widget is re-rendered on a configuration change
-// anyway (same convention as AgendaWidget).
 private fun monthLabel(month: YearMonth, currentYear: Int): String =
     formatCalendarTitle(
         date = java.time.LocalDate.of(month.year, month.month.ordinal + 1, 1),
-        locale = Locale.getDefault(),
+        locale = widgetLocale(),
         currentYear = currentYear,
         skeleton = "LLLL",
     )

app/src/main/java/de/jeanlucmakiola/calendula/widget/quickadd/QuickAddWidget.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.quickadd
 
+import de.jeanlucmakiola.calendula.widget.InAppLanguage
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.previewSizeOf
 import de.jeanlucmakiola.calendula.widget.provideSamplePreview
@@ -59,7 +60,9 @@ class QuickAddWidget : GlanceAppWidget() {
         provideContent {
             // The rollover moves the stamp, so the editor opens on the new day.
             val loaded = widgetData.current(currentRefreshStamp()) { context.loadToday() }
-            QuickAddWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            InAppLanguage {
+                QuickAddWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            }
         }
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/widget/split/MonthDayWidget.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.split
 
+import de.jeanlucmakiola.calendula.widget.InAppLanguage
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.previewSizeOf
 import de.jeanlucmakiola.calendula.widget.provideSamplePreview
@@ -64,8 +65,10 @@ import de.jeanlucmakiola.calendula.widget.MonthWidgetSource
 import de.jeanlucmakiola.calendula.widget.Themed
 import de.jeanlucmakiola.calendula.widget.WidgetAppearance
 import de.jeanlucmakiola.calendula.widget.WidgetEventRow
+import de.jeanlucmakiola.calendula.widget.WidgetSettings
 import de.jeanlucmakiola.calendula.widget.widgetLoadContext
 import de.jeanlucmakiola.calendula.widget.compactRowMetrics
+import de.jeanlucmakiola.calendula.widget.firstDayOfMonthIndex
 import de.jeanlucmakiola.calendula.widget.loadCachedMonthSource
 import de.jeanlucmakiola.calendula.widget.monthIndexOf
 import de.jeanlucmakiola.calendula.widget.monthWindowCenter
@@ -84,9 +87,7 @@ import kotlinx.datetime.toJavaLocalDate
 import de.jeanlucmakiola.calendula.widget.widgetTimeLabel
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.glance.LocalWidgetBackground
 import de.jeanlucmakiola.floret.glance.WidgetActionStyle
-import de.jeanlucmakiola.floret.glance.WidgetBackground
 import de.jeanlucmakiola.floret.glance.WidgetData
 import de.jeanlucmakiola.floret.glance.WidgetHeader
 import de.jeanlucmakiola.floret.glance.WidgetHeaderAction
@@ -123,9 +124,13 @@ sealed interface MonthDayData {
 }
 
 /** [loaded]'s month window with what the day list draws by. */
-internal suspend fun Context.loadMonthDay(loaded: Themed<MonthWidgetSource>, options: AgendaWidgetOptions): Themed<MonthDayData> {
+internal suspend fun Context.loadMonthDay(
+    loaded: Themed<MonthWidgetSource>,
+    options: AgendaWidgetOptions,
+    settings: WidgetSettings? = null,
+): Themed<MonthDayData> {
     val ready = loaded.content as? MonthWidgetSource.Ready ?: return Themed(MonthDayData.NeedsPermission, loaded.appTheme)
-    val settings = widgetEntryPoint().settingsPrefs().widgetSettings.first()
+    val settings = settings ?: widgetEntryPoint().settingsPrefs().widgetSettings.first()
     return Themed(
         MonthDayData.Ready(
             source = ready,
@@ -159,7 +164,8 @@ class MonthDayWidget : GlanceAppWidget() {
         val shown = context.widgetState(id)[MONTH_INDEX_KEY] ?: monthIndexOf(today(systemZone()))
         val center = monthWindowCenter(shown)
         val load: suspend (Int, Long) -> Themed<MonthDayData> = { c, s ->
-            context.loadMonthDay(context.loadCachedMonthSource(id, c, s), context.widgetLoadContext(id).options)
+            val ctx = context.widgetLoadContext(id)
+            context.loadMonthDay(context.loadCachedMonthSource(id, c, s, ctx), ctx.options, ctx.settings)
         }
         val widgetData = WidgetData(load(center, stamp), center, stamp)
         provideContent {
@@ -168,7 +174,9 @@ class MonthDayWidget : GlanceAppWidget() {
             val currentStamp = currentRefreshStamp()
             val loaded = widgetData.current(currentCenter, currentStamp) { load(currentCenter, currentStamp) }
             val selected = currentState(SELECTED_KEY)?.let(LocalDate::parse)
-            MonthDayWidgetContent(loaded.content, index, selected, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            InAppLanguage {
+                MonthDayWidgetContent(loaded.content, index, selected, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            }
         }
     }
 }
@@ -197,9 +205,17 @@ class ShiftMonthDayAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
         val delta = parameters[deltaKey] ?: 0
         val current = monthIndexOf(today(systemZone()))
+        // The selection moves with the page — to today on this month, else the
+        // 1st — so the list never shows a day outside the loaded window.
         updateAppWidgetState(context, glanceId) { prefs ->
             val next = (prefs[MONTH_INDEX_KEY] ?: current) + delta
-            if (next == current) prefs.remove(MONTH_INDEX_KEY) else prefs[MONTH_INDEX_KEY] = next
+            if (next == current) {
+                prefs.remove(MONTH_INDEX_KEY)
+                prefs.remove(SELECTED_KEY)
+            } else {
+                prefs[MONTH_INDEX_KEY] = next
+                prefs[SELECTED_KEY] = firstDayOfMonthIndex(next).toString()
+            }
         }
         MonthDayWidget().update(context.applicationContext, glanceId)
     }
@@ -222,7 +238,7 @@ class ResetMonthDayAction : ActionCallback {
 
 /** The grid's days: whole weeks from [weekStart] covering [index]'s month. */
 internal fun monthGridDays(index: Int, weekStart: DayOfWeek): List<LocalDate> {
-    val first = LocalDate(index / 12, index % 12 + 1, 1)
+    val first = firstDayOfMonthIndex(index)
     val start = weekOf(first, weekStart).start
     val last = first.plus(1, DateTimeUnit.MONTH).plus(-1, DateTimeUnit.DAY)
     val weeks = (start.daysUntilInclusive(last) + 6) / 7
@@ -277,7 +293,7 @@ private fun Header(index: Int, today: LocalDate) {
     val context = LocalContext.current
     WidgetHeader(
         title = formatCalendarTitle(
-            date = java.time.LocalDate.of(index / 12, index % 12 + 1, 1),
+            date = firstDayOfMonthIndex(index).toJavaLocalDate(),
             locale = widgetLocale(),
             currentYear = today.year,
             skeleton = "LLLL",
@@ -330,12 +346,8 @@ private fun Grid(
     width: Dp,
 ) {
     val locale = widgetLocale()
-    val month = index % 12 + 1
-    val backing = if (LocalWidgetBackground.current == WidgetBackground.TRANSPARENT) {
-        GlanceModifier.cornerRadius(14.dp).background(widgetCardColor())
-    } else {
-        GlanceModifier
-    }
+    val month = firstDayOfMonthIndex(index).month.ordinal + 1
+    val backing = GlanceModifier.wallpaperBacking(radius = 14.dp)
     Column(modifier = backing.fillMaxSize().padding(2.dp)) {
         Row(modifier = GlanceModifier.fillMaxWidth()) {
             for (i in 0 until 7) {

app/src/main/java/de/jeanlucmakiola/calendula/widget/today/TodayWidget.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.today
 
+import de.jeanlucmakiola.calendula.widget.InAppLanguage
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.previewSizeOf
 import de.jeanlucmakiola.calendula.widget.provideSamplePreview
@@ -50,6 +51,11 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.widget.CalendulaWidgetReceiver
 import de.jeanlucmakiola.calendula.widget.CalendulaWidgetRoot
 import de.jeanlucmakiola.calendula.widget.DaysWidgetData
+import de.jeanlucmakiola.calendula.widget.Themed
+import de.jeanlucmakiola.calendula.widget.WidgetTicks
+import de.jeanlucmakiola.calendula.widget.systemZone
+import de.jeanlucmakiola.calendula.domain.localEnd
+import androidx.glance.appwidget.GlanceAppWidgetManager
 import de.jeanlucmakiola.calendula.widget.EventRowMetrics
 import de.jeanlucmakiola.calendula.widget.WidgetAppearance
 import de.jeanlucmakiola.calendula.widget.WidgetEventRow
@@ -62,8 +68,6 @@ import de.jeanlucmakiola.calendula.widget.widgetLocale
 import de.jeanlucmakiola.calendula.widget.widgetLoadContext
 import de.jeanlucmakiola.calendula.widget.widgetTimeLabel
 import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.glance.LocalWidgetBackground
-import de.jeanlucmakiola.floret.glance.WidgetBackground
 import de.jeanlucmakiola.floret.glance.WidgetData
 import de.jeanlucmakiola.floret.glance.WidgetMessage
 import de.jeanlucmakiola.floret.glance.currentRefreshStamp
@@ -96,10 +100,12 @@ class TodayWidget : GlanceAppWidget() {
         provideSamplePreview(context, WidgetKind.TODAY)
 
     override suspend fun provideGlance(context: Context, id: GlanceId) {
-        val widgetData = WidgetData(context.loadTodayList(context.widgetLoadContext(id)), refreshStamp(context, id))
+        val widgetData = WidgetData(context.loadPlacedToday(id), refreshStamp(context, id))
         provideContent {
-            val loaded = widgetData.current(currentRefreshStamp()) { context.loadTodayList(context.widgetLoadContext(id)) }
-            TodayWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            val loaded = widgetData.current(currentRefreshStamp()) { context.loadPlacedToday(id) }
+            InAppLanguage {
+                TodayWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            }
         }
     }
 }
@@ -112,6 +118,21 @@ internal suspend fun Context.loadTodayList(load: WidgetLoadContext) = loadDays(l
     today..today.plus(1, DateTimeUnit.DAY)
 }
 
+/** [loadTodayList] for placed widget [id], arming its redraw for when the next of today's events ends. */
+private suspend fun Context.loadPlacedToday(id: GlanceId): Themed<DaysWidgetData> {
+    val loaded = loadTodayList(widgetLoadContext(id))
+    val appWidgetId = GlanceAppWidgetManager(this).getAppWidgetId(id)
+    val data = loaded.content as? DaysWidgetData.Ready
+    val zone = systemZone()
+    val nextEnd = data?.eventsOn(data.today)?.map { it.localEnd(zone) }?.filter { it > data.now }?.minOrNull()
+    if (nextEnd == null) {
+        WidgetTicks.cancel(this, WidgetKind.TODAY, appWidgetId)
+    } else {
+        WidgetTicks.schedule(this, WidgetKind.TODAY, appWidgetId, nextEnd)
+    }
+    return loaded
+}
+
 private val PillWidth = 44.dp
 private val RowGap = 2.dp
 
@@ -189,11 +210,7 @@ private fun NothingLeft(tomorrow: List<EventInstance>, data: DaysWidgetData.Read
     val room = LocalSize.current.height - 12.dp - lineHeight
     val fits = ((room + RowGap) / (metrics.rowHeight + RowGap)).toInt().coerceIn(0, 2)
     val ahead = tomorrow.take(fits)
-    val backing = if (LocalWidgetBackground.current == WidgetBackground.TRANSPARENT) {
-        GlanceModifier.wallpaperBacking(radius = 8.dp).padding(horizontal = 8.dp)
-    } else {
-        GlanceModifier.padding(horizontal = 4.dp)
-    }
+    val backing = GlanceModifier.wallpaperBacking(radius = 8.dp, horizontalPadding = 8.dp, filledHorizontalPadding = 4.dp)
     Column(modifier = GlanceModifier.fillMaxSize(), verticalAlignment = Alignment.CenterVertically) {
         Text(
             text = context.getString(R.string.widget_nothing_left_today),

app/src/main/java/de/jeanlucmakiola/calendula/widget/upcoming/UpcomingWidget.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.upcoming
 
+import de.jeanlucmakiola.calendula.widget.InAppLanguage
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.previewSizeOf
 import de.jeanlucmakiola.calendula.widget.provideSamplePreview
@@ -54,8 +55,6 @@ import de.jeanlucmakiola.calendula.widget.widgetLocale
 import de.jeanlucmakiola.calendula.widget.widgetLoadContext
 import de.jeanlucmakiola.calendula.widget.widgetTimeLabel
 import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.glance.LocalWidgetBackground
-import de.jeanlucmakiola.floret.glance.WidgetBackground
 import de.jeanlucmakiola.floret.glance.WidgetData
 import de.jeanlucmakiola.floret.glance.WidgetMessage
 import de.jeanlucmakiola.floret.glance.currentRefreshStamp
@@ -89,7 +88,9 @@ class UpcomingWidget : GlanceAppWidget() {
         val widgetData = WidgetData(context.loadUpcoming(context.widgetLoadContext(id)), refreshStamp(context, id))
         provideContent {
             val loaded = widgetData.current(currentRefreshStamp()) { context.loadUpcoming(context.widgetLoadContext(id)) }
-            UpcomingWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            InAppLanguage {
+                UpcomingWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            }
         }
     }
 }
@@ -155,11 +156,7 @@ internal fun UpcomingWidgetContent(data: DaysWidgetData, appearance: WidgetAppea
 private fun DateHeader(today: LocalDate, height: Dp) {
     val context = LocalContext.current
     val locale = widgetLocale()
-    val backing = if (LocalWidgetBackground.current == WidgetBackground.TRANSPARENT) {
-        GlanceModifier.wallpaperBacking(radius = 12.dp).padding(horizontal = 8.dp)
-    } else {
-        GlanceModifier.padding(horizontal = 4.dp)
-    }
+    val backing = GlanceModifier.wallpaperBacking(radius = 12.dp, horizontalPadding = 8.dp, filledHorizontalPadding = 4.dp)
     Box(modifier = GlanceModifier.fillMaxWidth().height(height), contentAlignment = Alignment.CenterStart) {
         Row(
             modifier = backing.clickable(actionStartActivity(MainActivity.openViewIntent(context, CalendarView.Agenda))),

app/src/main/java/de/jeanlucmakiola/calendula/widget/week/WeekStripWidget.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.week
 
+import de.jeanlucmakiola.calendula.widget.InAppLanguage
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.previewSizeOf
 import de.jeanlucmakiola.calendula.widget.provideSamplePreview
@@ -91,7 +92,9 @@ class WeekStripWidget : GlanceAppWidget() {
         val widgetData = WidgetData(context.loadWeek(id), refreshStamp(context, id))
         provideContent {
             val loaded = widgetData.current(currentRefreshStamp()) { context.loadWeek(id) }
-            WeekStripWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            InAppLanguage {
+                WeekStripWidgetContent(loaded.content, currentState<Preferences>().widgetAppearance, loaded.appTheme)
+            }
         }
     }
 }
@@ -114,13 +117,15 @@ internal fun WeekStripWidgetContent(data: DaysWidgetData, appearance: WidgetAppe
         when (data) {
             DaysWidgetData.NeedsPermission ->
                 WidgetMessage(LocalContext.current.getString(R.string.widget_needs_permission))
+            // The gap is padding on each tile rather than a Spacer between them:
+            // Glance drops a row's children past the tenth, and 7 tiles plus 6
+            // spacers would lose the weekend.
             is DaysWidgetData.Ready -> Row(
-                modifier = GlanceModifier.fillMaxSize().padding(6.dp),
+                modifier = GlanceModifier.fillMaxSize().padding(horizontal = 6.dp - DayGap / 2, vertical = 6.dp),
                 verticalAlignment = Alignment.CenterVertically,
             ) {
                 for (i in 0 until 7) {
-                    if (i > 0) Spacer(GlanceModifier.width(DayGap))
-                    Box(modifier = GlanceModifier.defaultWeight().fillMaxHeight()) {
+                    Box(modifier = GlanceModifier.defaultWeight().fillMaxHeight().padding(horizontal = DayGap / 2)) {
                         DayTile(data.firstDay.plus(i, DateTimeUnit.DAY), data)
                     }
                 }

app/src/main/res/drawable/preview_widget_outside_bg.xml

@@ -1,6 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
-<shape xmlns:android="http://schemas.android.com/apk/res/android"
-    android:shape="rectangle">
-    <solid android:color="@color/widget_preview_outside" />
-    <corners android:radius="12dp" />
-</shape>
+<!-- A day outside the month: its cell under the widget's shade (MonthGridViews). -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@drawable/preview_widget_cell_bg" />
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="@color/widget_preview_outside_shade" />
+            <corners android:radius="12dp" />
+        </shape>
+    </item>
+</layer-list>

app/src/main/res/layout/widget_preview_countdown.xml

@@ -9,9 +9,9 @@
     android:gravity="center_vertical"
     android:orientation="horizontal"
     android:padding="12dp"
-    tools:ignore="HardcodedText,NestedWeights,DisableBaselineAlignment,SmallSp,TooManyViews,UselessParent">
+    tools:ignore="HardcodedText,NestedWeights,DisableBaselineAlignment,SmallSp,TooManyViews,UselessLeaf,UselessParent">
 
-    <View
+    <FrameLayout
         android:layout_width="4dp"
         android:layout_height="match_parent"
         android:background="@drawable/preview_stripe"

app/src/main/res/layout/widget_preview_week_strip.xml

@@ -8,7 +8,7 @@
     android:background="@drawable/preview_widget_bg"
     android:orientation="horizontal"
     android:padding="6dp"
-    tools:ignore="HardcodedText,NestedWeights,DisableBaselineAlignment,SmallSp,TooManyViews,UselessParent">
+    tools:ignore="HardcodedText,NestedWeights,DisableBaselineAlignment,SmallSp,TooManyViews,UselessLeaf,UselessParent">
 
     <LinearLayout
         style="@style/WidgetPreviewWeekDay"
@@ -32,19 +32,19 @@
             android:layout_height="6dp"
             android:gravity="center"
             android:orientation="horizontal">
-        <View
+        <FrameLayout
             android:layout_width="4dp"
             android:layout_height="4dp"
             android:layout_marginHorizontal="1dp"
             android:background="@drawable/preview_today_circle"
             android:backgroundTint="@color/widget_preview_event_blue" />
-        <View
+        <FrameLayout
             android:layout_width="4dp"
             android:layout_height="4dp"
             android:layout_marginHorizontal="1dp"
             android:background="@drawable/preview_today_circle"
             android:backgroundTint="@color/widget_preview_event_green" />
-        <View
+        <FrameLayout
             android:layout_width="4dp"
             android:layout_height="4dp"
             android:layout_marginHorizontal="1dp"
@@ -73,7 +73,7 @@
             android:layout_height="6dp"
             android:gravity="center"
             android:orientation="horizontal">
-        <View
+        <FrameLayout
             android:layout_width="4dp"
             android:layout_height="4dp"
             android:layout_marginHorizontal="1dp"
@@ -102,7 +102,7 @@
             android:layout_height="6dp"
             android:gravity="center"
             android:orientation="horizontal">
-        <View
+        <FrameLayout
             android:layout_width="4dp"
             android:layout_height="4dp"
             android:layout_marginHorizontal="1dp"
@@ -126,7 +126,7 @@
             android:textColor="@color/widget_preview_on_surface"
             android:textSize="16sp"
             android:textStyle="bold" />
-        <Space
+        <FrameLayout
             android:layout_width="wrap_content"
             android:layout_height="6dp" />
     </LinearLayout>
@@ -146,7 +146,7 @@
             android:textColor="@color/widget_preview_on_surface"
             android:textSize="16sp"
             android:textStyle="bold" />
-        <Space
+        <FrameLayout
             android:layout_width="wrap_content"
             android:layout_height="6dp" />
     </LinearLayout>
@@ -171,7 +171,7 @@
             android:layout_height="6dp"
             android:gravity="center"
             android:orientation="horizontal">
-        <View
+        <FrameLayout
             android:layout_width="4dp"
             android:layout_height="4dp"
             android:layout_marginHorizontal="1dp"
@@ -195,7 +195,7 @@
             android:textColor="@color/widget_preview_on_surface"
             android:textSize="16sp"
             android:textStyle="bold" />
-        <Space
+        <FrameLayout
             android:layout_width="wrap_content"
             android:layout_height="6dp" />
     </LinearLayout>

app/src/main/res/values-night-v31/widget_preview_colors.xml

@@ -2,7 +2,6 @@
 <resources>
     <color name="widget_preview_surface">@android:color/system_accent2_700</color>
     <color name="widget_preview_cell">@android:color/system_accent2_900</color>
-    <color name="widget_preview_outside">@android:color/system_neutral2_600</color>
     <color name="widget_preview_on_surface">@android:color/system_neutral1_50</color>
     <color name="widget_preview_variant">@android:color/system_neutral2_200</color>
     <color name="widget_preview_primary">@android:color/system_accent1_200</color>

app/src/main/res/values-night/widget_preview_colors.xml

@@ -2,7 +2,7 @@
 <resources>
     <color name="widget_preview_surface">#2B3742</color>
     <color name="widget_preview_cell">#1C252D</color>
-    <color name="widget_preview_outside">#3A4651</color>
+    <color name="widget_preview_outside_shade">#4D000000</color>
     <color name="widget_preview_on_surface">#E1E3E6</color>
     <color name="widget_preview_variant">#A8ADB2</color>
     <color name="widget_preview_primary">#A3CBE2</color>

app/src/main/res/values-v31/widget_preview_colors.xml

@@ -2,7 +2,6 @@
 <resources>
     <color name="widget_preview_surface">@android:color/system_accent2_100</color>
     <color name="widget_preview_cell">@android:color/system_accent2_10</color>
-    <color name="widget_preview_outside">@android:color/system_neutral2_300</color>
     <color name="widget_preview_on_surface">@android:color/system_neutral1_900</color>
     <color name="widget_preview_variant">@android:color/system_neutral2_700</color>
     <color name="widget_preview_primary">@android:color/system_accent1_600</color>

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

@@ -433,21 +433,29 @@
 
     <!-- Home-screen widgets -->
     <string name="widget_agenda_title">Upcoming</string>
-    <string name="widget_agenda_label">Calendula agenda</string>
-    <string name="widget_month_label">Calendula month</string>
-    <string name="widget_quick_add_label">Calendula quick add</string>
-    <string name="widget_date_label">Calendula date</string>
-    <string name="widget_week_strip_label">Calendula week strip</string>
+    <string name="widget_agenda_label">Agenda</string>
+    <string name="widget_agenda_description">Your next events, grouped by day</string>
+    <string name="widget_month_label">Month</string>
+    <string name="widget_month_description">The month at a glance, with your events</string>
+    <string name="widget_quick_add_label">Quick add</string>
+    <string name="widget_quick_add_description">Start a new event in one tap</string>
+    <string name="widget_date_label">Date</string>
+    <string name="widget_date_description">Today\'s date</string>
+    <string name="widget_week_strip_label">Week strip</string>
+    <string name="widget_week_strip_description">This week, with the days that have events</string>
     <!-- A day in the week strip widget, for screen readers: "Wednesday, 7 October, 2 events" -->
     <plurals name="widget_day_with_events">
         <item quantity="one">%1$s, %2$d event</item>
         <item quantity="other">%1$s, %2$d events</item>
     </plurals>
-    <string name="widget_upcoming_label">Calendula upcoming</string>
+    <string name="widget_upcoming_label">Upcoming</string>
+    <string name="widget_upcoming_description">Today\'s date over your next events</string>
     <string name="widget_upcoming_empty">No upcoming events</string>
-    <string name="widget_today_label">Calendula today</string>
+    <string name="widget_today_label">Today</string>
+    <string name="widget_today_description">Today\'s events, then tomorrow\'s</string>
     <string name="widget_nothing_left_today">Nothing left today</string>
-    <string name="widget_countdown_label">Calendula countdown</string>
+    <string name="widget_countdown_label">Countdown</string>
+    <string name="widget_countdown_description">Time until an event, or the next one</string>
     <string name="widget_countdown_now">Now</string>
     <string name="widget_countdown_ending_now">Ending now</string>
     <string name="widget_countdown_tomorrow">Tomorrow</string>
@@ -492,7 +500,8 @@
     <string name="widget_config_countdown_load_failed">Couldn\'t load your events.</string>
     <!-- A repeating event in the countdown's event list: "Next: Fri, 24 Oct · repeats" -->
     <string name="widget_config_countdown_repeats">%1$s · repeats</string>
-    <string name="widget_month_day_label">Calendula month and day</string>
+    <string name="widget_month_day_label">Month and day</string>
+    <string name="widget_month_day_description">The month and the events of the day you pick</string>
     <string name="widget_day_empty">No events</string>
     <string name="widget_refresh">Refresh</string>
     <string name="widget_new_event">New event</string>
@@ -628,10 +637,10 @@
     <string name="settings_agenda_range">Agenda range</string>
     <string name="settings_agenda_range_hint">How far ahead the Agenda screen lists events.</string>
     <string name="settings_agenda_widget_range">Agenda widget range</string>
-    <string name="settings_agenda_widget_range_hint">How far ahead the agenda home-screen widget lists events.</string>
+    <string name="settings_agenda_widget_range_hint">How far ahead this widget lists events.</string>
 
     <string name="settings_widget_size">Agenda widget size</string>
-    <string name="settings_widget_size_hint">How large the agenda home-screen widget draws its text. The month widget has no setting — its grid always fits itself to the space you give it.</string>
+    <string name="settings_widget_size_hint">How large this widget draws its text.</string>
     <string name="settings_widget_size_small">Small</string>
     <string name="settings_widget_size_medium">Medium</string>
     <string name="settings_widget_size_large">Large</string>

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

@@ -6,7 +6,7 @@
 <resources>
     <color name="widget_preview_surface">#D6E4F0</color>
     <color name="widget_preview_cell">#EEF3F8</color>
-    <color name="widget_preview_outside">#C2CCD6</color>
+    <color name="widget_preview_outside_shade">#1C000000</color>
     <color name="widget_preview_on_surface">#191C1F</color>
     <color name="widget_preview_variant">#6E7479</color>
     <color name="widget_preview_primary">#3B5364</color>

app/src/main/res/xml/appwidget_info_agenda.xml

@@ -10,7 +10,7 @@
     android:widgetCategory="home_screen"
     android:configure="de.jeanlucmakiola.calendula.widget.config.WidgetConfigActivity"
     android:widgetFeatures="reconfigurable"
-    android:description="@string/widget_agenda_label"
+    android:description="@string/widget_agenda_description"
     android:updatePeriodMillis="1800000"
     android:previewLayout="@layout/widget_preview_agenda"
     android:initialLayout="@layout/glance_default_loading_layout" />

app/src/main/res/xml/appwidget_info_countdown.xml

@@ -10,7 +10,7 @@
     android:widgetCategory="home_screen"
     android:configure="de.jeanlucmakiola.calendula.widget.config.WidgetConfigActivity"
     android:widgetFeatures="reconfigurable"
-    android:description="@string/widget_countdown_label"
+    android:description="@string/widget_countdown_description"
     android:updatePeriodMillis="1800000"
     android:previewLayout="@layout/widget_preview_countdown"
     android:initialLayout="@layout/glance_default_loading_layout" />

app/src/main/res/xml/appwidget_info_date.xml

@@ -8,7 +8,7 @@
     android:widgetCategory="home_screen"
     android:configure="de.jeanlucmakiola.calendula.widget.config.WidgetConfigActivity"
     android:widgetFeatures="reconfigurable"
-    android:description="@string/widget_date_label"
+    android:description="@string/widget_date_description"
     android:updatePeriodMillis="1800000"
     android:previewLayout="@layout/widget_preview_date"
     android:initialLayout="@layout/glance_default_loading_layout" />

app/src/main/res/xml/appwidget_info_month.xml

@@ -10,7 +10,7 @@
     android:widgetCategory="home_screen"
     android:configure="de.jeanlucmakiola.calendula.widget.config.WidgetConfigActivity"
     android:widgetFeatures="reconfigurable"
-    android:description="@string/widget_month_label"
+    android:description="@string/widget_month_description"
     android:updatePeriodMillis="1800000"
     android:previewLayout="@layout/widget_preview_month"
     android:initialLayout="@layout/glance_default_loading_layout" />

app/src/main/res/xml/appwidget_info_month_day.xml

@@ -10,7 +10,7 @@
     android:widgetCategory="home_screen"
     android:configure="de.jeanlucmakiola.calendula.widget.config.WidgetConfigActivity"
     android:widgetFeatures="reconfigurable"
-    android:description="@string/widget_month_day_label"
+    android:description="@string/widget_month_day_description"
     android:updatePeriodMillis="1800000"
     android:previewLayout="@layout/widget_preview_month_day"
     android:initialLayout="@layout/glance_default_loading_layout" />

app/src/main/res/xml/appwidget_info_quick_add.xml

@@ -8,7 +8,7 @@
     android:widgetCategory="home_screen"
     android:configure="de.jeanlucmakiola.calendula.widget.config.WidgetConfigActivity"
     android:widgetFeatures="reconfigurable"
-    android:description="@string/widget_quick_add_label"
+    android:description="@string/widget_quick_add_description"
     android:updatePeriodMillis="1800000"
     android:previewLayout="@layout/widget_preview_quick_add"
     android:initialLayout="@layout/glance_default_loading_layout" />

app/src/main/res/xml/appwidget_info_today.xml

@@ -12,7 +12,7 @@
     android:widgetCategory="home_screen"
     android:configure="de.jeanlucmakiola.calendula.widget.config.WidgetConfigActivity"
     android:widgetFeatures="reconfigurable"
-    android:description="@string/widget_today_label"
+    android:description="@string/widget_today_description"
     android:updatePeriodMillis="1800000"
     android:previewLayout="@layout/widget_preview_today"
     android:initialLayout="@layout/glance_default_loading_layout" />

app/src/main/res/xml/appwidget_info_upcoming.xml

@@ -10,7 +10,7 @@
     android:widgetCategory="home_screen"
     android:configure="de.jeanlucmakiola.calendula.widget.config.WidgetConfigActivity"
     android:widgetFeatures="reconfigurable"
-    android:description="@string/widget_upcoming_label"
+    android:description="@string/widget_upcoming_description"
     android:updatePeriodMillis="1800000"
     android:previewLayout="@layout/widget_preview_upcoming"
     android:initialLayout="@layout/glance_default_loading_layout" />

app/src/main/res/xml/appwidget_info_week_strip.xml

@@ -10,7 +10,7 @@
     android:widgetCategory="home_screen"
     android:configure="de.jeanlucmakiola.calendula.widget.config.WidgetConfigActivity"
     android:widgetFeatures="reconfigurable"
-    android:description="@string/widget_week_strip_label"
+    android:description="@string/widget_week_strip_description"
     android:updatePeriodMillis="1800000"
     android:previewLayout="@layout/widget_preview_week_strip"
     android:initialLayout="@layout/glance_default_loading_layout" />

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

@@ -0,0 +1,40 @@
+package de.jeanlucmakiola.calendula.domain
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.testEvent
+import kotlinx.datetime.TimeZone
+import org.junit.jupiter.api.Test
+import kotlin.time.Instant
+
+class HasEndedTest {
+
+    private val newYork = TimeZone.of("America/New_York")
+
+    // All-day Oct 28, stored as UTC midnights.
+    private val holiday = testEvent(
+        title = "Holiday",
+        start = Instant.parse("2026-10-28T00:00:00Z"),
+        end = Instant.parse("2026-10-29T00:00:00Z"),
+        isAllDay = true,
+    )
+
+    @Test
+    fun `an all-day event runs until local midnight west of UTC`() {
+        // 20:00 in New York, past the stored UTC end.
+        assertThat(holiday.hasEnded(Instant.parse("2026-10-29T00:00:00Z"), newYork)).isFalse()
+        assertThat(holiday.hasEnded(Instant.parse("2026-10-29T04:00:00Z"), newYork)).isTrue()
+    }
+
+    @Test
+    fun `an all-day event ends at local midnight east of UTC`() {
+        val berlin = TimeZone.of("Europe/Berlin")
+        assertThat(holiday.hasEnded(Instant.parse("2026-10-28T23:30:00Z"), berlin)).isTrue()
+    }
+
+    @Test
+    fun `a timed event ends at its own end`() {
+        val call = holiday.copy(isAllDay = false, end = Instant.parse("2026-10-28T15:00:00Z"))
+        assertThat(call.hasEnded(Instant.parse("2026-10-28T15:00:00Z"), newYork)).isTrue()
+        assertThat(call.hasEnded(Instant.parse("2026-10-28T14:59:00Z"), newYork)).isFalse()
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/widget/countdown/CountdownTest.kt

@@ -27,6 +27,11 @@ class CountdownTest {
         start = start, end = end, isAllDay = allDay, color = 0, location = null, response = response,
     )
 
+    @Test
+    fun `the last half hour before the day mark still reads 23 h`() {
+        assertThat(countdownLabel(event(now + 23.hours + 40.minutes), now, zone)).isEqualTo(CountdownLabel(false, CountdownUnit.HOURS, 23))
+    }
+
     @Test
     fun `labels step from days to hours to minutes to now`() {
         assertThat(countdownLabel(event(now + 30.seconds), now, zone)).isEqualTo(CountdownLabel(false, CountdownUnit.NOW, 0))