diff --git a/.run/SeforimApp [run].run.xml b/.run/SeforimApp [run].run.xml
index 058c9f76b..e807760bf 100644
--- a/.run/SeforimApp [run].run.xml
+++ b/.run/SeforimApp [run].run.xml
@@ -4,7 +4,8 @@
@@ -30,4 +31,4 @@
false
-
\ No newline at end of file
+
diff --git a/CLAUDE.md b/CLAUDE.md
index dac7cc834..73d993bce 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -71,7 +71,7 @@ Configuration files:
This is a **Kotlin Multiplatform desktop application** built with:
- **UI**: Compose Multiplatform + Jewel themes for native desktop look
- **DI**: Metro dependency injection with `AppGraph` accessible via `LocalAppGraph`
-- **Navigation**: Custom RAM-efficient tab system (`TabsNavHost`)
+- **Navigation**: Custom RAM-efficient tab system (`TabsContent`)
- **Data**: SeforimLibrary composite build (core domain + dao persistence + generator tools)
- **Platform**: JVM desktop with macOS/Windows/Linux native packaging
@@ -99,11 +99,11 @@ The `SeforimLibrary` composite build provides the core functionality for Jewish
### Memory-Efficient Tab System
See `TAB_SYSTEM_README.md` for complete details. Key points:
-- Each tab owns its own `NavHostController` and stays alive while tab exists
+- Each tab owns its own `SimpleTabViewModelOwner` (ViewModel lifecycle), which stays alive while the tab exists
- `TabStateManager` persists lightweight state for cold-boot restoration
- `TabsViewModel` manages tab lifecycle (create/select/close/replace)
- Use `TabAwareViewModel` base class for screens needing state persistence
-- Classic tabs mode keeps all tabs in memory; RAM saver mode (configurable) uses single NavHost
+- `TabsContent` renders without Compose Navigation and keeps an LRU of up to `MAX_RETAINED_TAB_COMPOSITIONS` (3) tab compositions; others are torn down and rebuilt from saved state on switch
### Dependency Injection (Metro)
- App-wide graph: `AppGraph` created with `createGraph()`
@@ -170,7 +170,7 @@ See `TAB_SYSTEM_README.md` for complete details. Key points:
### State Management
- **Tab State**: Use `TabAwareViewModel` + `saveState()`/`getState()` for restoration
- **Global State**: Avoid; prefer dependency injection and proper component lifecycle
-- **RAM Optimization**: Enable via `AppSettings.setRamSaverEnabled(true)` if needed
+- **RAM Optimization**: Built-in; only the selected tab plus an LRU of `MAX_RETAINED_TAB_COMPOSITIONS` (3) compositions are kept active (`TabsContent`)
### Security & Configuration
- **Secrets**: Never commit to repository; use `local.properties` for machine-specific settings
@@ -219,7 +219,7 @@ class MyViewModel(
### Performance
- **Hot Reload**: Use `hotRunJvm` + `reload` for fast iteration
-- **Memory**: Monitor tab count; use RAM saver mode for many tabs
+- **Memory**: Bounded by design — at most the selected tab + 3 retained compositions stay active regardless of open tab count
- **Large Datasets**: Leverage Paging 3 for efficient data loading
## File Locations Reference
diff --git a/SeforimApp/build.gradle.kts b/SeforimApp/build.gradle.kts
index 85d1930f4..6b0cc65c3 100644
--- a/SeforimApp/build.gradle.kts
+++ b/SeforimApp/build.gradle.kts
@@ -1,7 +1,7 @@
+import dev.nucleusframework.desktop.application.dsl.ReleaseChannel
+import dev.nucleusframework.desktop.application.dsl.ReleaseType
+import dev.nucleusframework.desktop.application.dsl.TargetFormat
import io.github.kdroidfilter.buildsrc.Versioning
-import io.github.kdroidfilter.nucleus.desktop.application.dsl.ReleaseChannel
-import io.github.kdroidfilter.nucleus.desktop.application.dsl.ReleaseType
-import io.github.kdroidfilter.nucleus.desktop.application.dsl.TargetFormat
import org.jetbrains.compose.reload.gradle.ComposeHotRun
plugins {
@@ -80,12 +80,12 @@ kotlin {
// Settings & platform utils
implementation(libs.multiplatformSettings)
- implementation(libs.platformtools.core)
implementation(libs.nucleus.core.runtime)
+ implementation(libs.nucleus.application)
implementation(libs.nucleus.aot.runtime)
implementation(libs.nucleus.darkmode.detector)
implementation(libs.platformtools.appmanager)
- implementation(libs.platformtools.releasefetcher)
+ implementation(project(":releasefetcher"))
// FileKit
implementation(libs.filekit.core)
@@ -138,16 +138,19 @@ kotlin {
api(project(":jewel"))
implementation(project(":earthwidget"))
implementation(libs.nucleus.system.color)
- implementation(libs.nucleus.decorated.window)
+ implementation(libs.nucleus.decorated.window.core)
+ implementation(libs.nucleus.decorated.window.tao)
implementation(libs.nucleus.decorated.window.jewel)
implementation(libs.nucleus.graalvm.runtime)
implementation(libs.nucleus.updater.runtime)
+ implementation(libs.nucleus.native.http)
implementation(libs.nucleus.energy.manager)
implementation(libs.nucleus.launcher.macos)
implementation(libs.nucleus.launcher.windows)
implementation(libs.nucleus.launcher.linux)
implementation(libs.nucleus.menu.macos)
implementation(libs.nucleus.sf.symbols)
+ implementation(libs.nucleus.taskbar.progress.tao)
implementation(compose.desktop.currentOs) {
exclude(group = "org.jetbrains.compose.material")
}
@@ -257,7 +260,6 @@ nucleus.application {
// Package-time resources root; include files under OS-specific subfolders (common, macos, windows, linux)
appResourcesRootDir.set(layout.projectDirectory.dir("src/jvmMain/assets"))
- splashImage = "splash.png"
enableAotCache = true
homepage = "https://zayitapp.com"
licenseFile.set(File(project.rootDir, "LICENSE"))
@@ -292,6 +294,10 @@ nucleus.application {
vendor = "KDroidFilter"
cleanupNativeLibs = true
+ // Register the custom URL scheme so shareable deep links (zayit://book/...,
+ // zayit://search/...) are routed to the app by the OS on macOS, Windows and Linux.
+ protocol("Zayit", "zayit")
+
linux {
iconFile.set(project.file("desktopAppIcons/LinuxIcon.png"))
packageVersion = version
diff --git a/SeforimApp/proguard-rules.pro b/SeforimApp/proguard-rules.pro
index c49d1c0c8..15f51510d 100644
--- a/SeforimApp/proguard-rules.pro
+++ b/SeforimApp/proguard-rules.pro
@@ -229,74 +229,85 @@
# =============================================================================
# Nucleus decorated-window JNI (macOS)
--keep class io.github.kdroidfilter.nucleus.window.utils.macos.NativeMacBridge {
+-keep class dev.nucleusframework.window.utils.macos.NativeMacBridge {
native ;
}
--keep class io.github.kdroidfilter.nucleus.window.** { *; }
+-keep class dev.nucleusframework.window.** { *; }
# Nucleus darkmode-detector JNI (macOS)
# NativeDarkModeBridge is looked up by name from native code (FindClass + GetStaticMethodID)
--keep class io.github.kdroidfilter.nucleus.darkmodedetector.mac.NativeDarkModeBridge {
+-keep class dev.nucleusframework.darkmodedetector.mac.NativeDarkModeBridge {
native ;
static void onThemeChanged(boolean);
}
# Nucleus darkmode-detector JNI (Linux)
# NativeLinuxBridge is looked up by name from native code (FindClass + GetStaticMethodID)
--keep class io.github.kdroidfilter.nucleus.darkmodedetector.linux.NativeLinuxBridge {
+-keep class dev.nucleusframework.darkmodedetector.linux.NativeLinuxBridge {
native ;
static void onThemeChanged(boolean);
}
# Nucleus darkmode-detector JNI (Windows)
--keep class io.github.kdroidfilter.nucleus.darkmodedetector.windows.NativeWindowsBridge {
+-keep class dev.nucleusframework.darkmodedetector.windows.NativeWindowsBridge {
native ;
}
--keep class io.github.kdroidfilter.nucleus.darkmodedetector.** { *; }
+-keep class dev.nucleusframework.darkmodedetector.** { *; }
# Nucleus native-ssl JNI (macOS)
--keep class io.github.kdroidfilter.nucleus.nativessl.mac.NativeSslBridge {
+-keep class dev.nucleusframework.nativessl.mac.NativeSslBridge {
native ;
}
# Nucleus native-ssl JNI (Windows)
--keep class io.github.kdroidfilter.nucleus.nativessl.windows.WindowsSslBridge {
+-keep class dev.nucleusframework.nativessl.windows.WindowsSslBridge {
native ;
}
# Nucleus launcher-windows JNI (jump list)
--keep class io.github.kdroidfilter.nucleus.launcher.windows.NativeWindowsJumpListBridge {
+-keep class dev.nucleusframework.launcher.windows.NativeWindowsJumpListBridge {
native ;
}
--keep class io.github.kdroidfilter.nucleus.launcher.windows.** { *; }
+-keep class dev.nucleusframework.launcher.windows.** { *; }
# Nucleus launcher-linux D-Bus (quicklist)
--keep class io.github.kdroidfilter.nucleus.launcher.linux.** { *; }
+-keep class dev.nucleusframework.launcher.linux.** { *; }
--keep class io.github.kdroidfilter.nucleus.energymanager.** { *; }
+-keep class dev.nucleusframework.energymanager.** { *; }
# macOS
--keep class io.github.kdroidfilter.nucleus.systemcolor.mac.NativeMacSystemColorBridge {
+-keep class dev.nucleusframework.systemcolor.mac.NativeMacSystemColorBridge {
native ;
static void onAccentColorChanged(float, float, float);
static void onContrastChanged(boolean);
}
# Windows
--keep class io.github.kdroidfilter.nucleus.systemcolor.windows.NativeWindowsSystemColorBridge {
+-keep class dev.nucleusframework.systemcolor.windows.NativeWindowsSystemColorBridge {
native ;
static void onAccentColorChanged(int, int, int);
static void onHighContrastChanged(boolean);
}
# Linux
--keep class io.github.kdroidfilter.nucleus.systemcolor.linux.NativeLinuxSystemColorBridge {
+-keep class dev.nucleusframework.systemcolor.linux.NativeLinuxSystemColorBridge {
native ;
static void onAccentColorChanged(float, float, float);
static void onHighContrastChanged(boolean);
}
--keep class io.github.kdroidfilter.nucleus.systemcolor.** { *; }
+-keep class dev.nucleusframework.systemcolor.** { *; }
+
+# --- Fix: panel resize cursor (PointerIcon backed by AWT Cursor) not applied in release ---
+# ComposeSceneMediator.setPointerIcon checks `pointerIcon instanceof AwtCursor` and then
+# calls getCursor(). ProGuard optimization (class merging/inlining of this thin wrapper)
+# breaks that check, so custom cursors built via PointerIcon(java.awt.Cursor) — e.g. the
+# E_RESIZE/N_RESIZE handles in SplitPanes — silently fall back to the default arrow.
+# Keep the desktop PointerIcon/AwtCursor classes intact so the instanceof + getCursor path works.
+-keep class androidx.compose.ui.input.pointer.AwtCursor { *; }
+-keep class androidx.compose.ui.input.pointer.PointerIcon_desktopKt { *; }
+-keep class androidx.compose.ui.input.pointer.PointerIcon { *; }
+-keep class androidx.compose.ui.input.pointer.PointerIcon$Companion { *; }
# --- Sentry crash reporting SDK ---
# Sentry uses reflection for serialization and event processing.
diff --git a/SeforimApp/src/commonMain/composeResources/values/strings.xml b/SeforimApp/src/commonMain/composeResources/values/strings.xml
index 679717705..57aa3c3b3 100644
--- a/SeforimApp/src/commonMain/composeResources/values/strings.xml
+++ b/SeforimApp/src/commonMain/composeResources/values/strings.xml
@@ -92,6 +92,20 @@
גופנים
אודות
תנאים
+ ניהול נתונים
+ ייצוא הנתונים שלי
+ שמירת גיבוי של ההערות, ההדגשות וההגדרות.
+ ייצוא
+ מייצא…
+ ייבוא נתונים
+ שחזור הנתונים מקובץ גיבוי קיים.
+ ייבוא
+ מייבא…
+ הגיבוי נשמר בהצלחה: %1$s
+ הנתונים יובאו בהצלחה. האפליקציה מופעלת מחדש…
+ ייצוא הנתונים נכשל
+ ייבוא הנתונים נכשל
+ איפוס מלא של האפליקציה למצב ההתחלתי. פעולה זו תמחק את כל הנתונים שלך.
הוסף לשונית
דף הבית
סגור לשונית
@@ -101,6 +115,7 @@
סגור את הלשוניות מימין
סגור את הלשוניות משמאל
+ העתק קישור
ניווט
@@ -117,6 +132,18 @@
חפש בעמוד
העתק ללא ניקוד
העתק עם מקור
+ העתק קישור לקטע זה
+ סמן
+ הוסף הערה
+
+
+ הערות
+ ההערות שלי על הספר
+ כתוב הערה...
+ אין הערות שמורות על קטע זה
+ אין הערות על השורות שנבחרו. בחר טקסט ולחץ "הוסף הערה".
+ אין צורך לכתוב הערה על השורה כולה: ניתן לסמן מילים מסוימות, ללחוץ לחיצה ימנית ולבחור "הוסף הערה" כדי לכתוב הערה על קטע מדויק בלבד.
+ מחק הערה
כלים
@@ -313,6 +340,8 @@
סגור אוטומטית את עץ הספרים בעת בחירת ספר חדש
כאשר אפשרות זו מופעלת, עץ הניווט בצד ימין ייסגר אוטומטית לאחר בחירת ספר חדש, מה שמאפשר יותר מקום לקריאה.
כאשר אפשרות זו מופעלת, האפליקציה תשמור את הלשוניות הפתוחות ומיקום הקריאה שלך, ותשחזר אותם בהפעלה הבאה.
+ מנע כיבוי מסך בזמן קריאה
+ כאשר אפשרות זו מופעלת, המסך לא ייכבה ולא ייכנס למצב שינה כל עוד ספר פתוח בלשונית הנוכחית והחלון פעיל.
הצג זמנים הלכתיים בדף הבית
כאשר אפשרות זו מופעלת, יוצגו בדף הבית וידג'טים עם זמני היום ההלכתיים (נץ החמה, שקיעה, זמני תפילה וכו').
הצג תמונת רקע בדף הבית
@@ -475,16 +504,23 @@
גרסה: %1$s
- JDK: %1$s %2$s — %3$s (%4$s)
- נוצר על ידי Elie Gambache - KdroidFilter
+ נוצר על ידי אליהו גמבש
יישום זה הוא קוד פתוח תחת רישיון AGPL-3.0
ניתן להשתמש ולהפיץ בהתאם לתנאי הרישיון.
- גרסה חדשה זמינה
- גרסה חדשה של זית זמינה להורדה. לחץ כדי לעדכן.
גרסה %1$s זמינה להורדה
הורד עכשיו
+ עדכון זמין
+ עדכון זמין
+ גרסה %1$s של זית זמינה.
+ ייתכן שלאחר עדכון זה יהיה צורך לעדכן את מסד הנתונים (כ‑3.5 ג״ב).
+ מוריד…
+ התקן והפעל מחדש
+ מאוחר יותר
+ האפליקציה מעודכנת לגרסה האחרונה
+ בודק עדכונים…
+ לא ניתן לבדוק עדכונים — ודא שקיים חיבור לאינטרנט
בחר קטגוריה לסינון
diff --git a/SeforimApp/src/commonMain/kotlin/io/github/kdroidfilter/seforimapp/catalog/CatalogPresets.kt b/SeforimApp/src/commonMain/kotlin/io/github/kdroidfilter/seforimapp/catalog/CatalogPresets.kt
new file mode 100644
index 000000000..2a56a1414
--- /dev/null
+++ b/SeforimApp/src/commonMain/kotlin/io/github/kdroidfilter/seforimapp/catalog/CatalogPresets.kt
@@ -0,0 +1,245 @@
+// DO NOT EDIT.
+// This file is auto-generated by the catalog generator.
+// To regenerate: ./gradlew :cataloggen:generatePrecomputedCatalog
+// Manual changes will be lost.
+@file:Suppress("ktlint")
+
+package io.github.kdroidfilter.seforimapp.catalog
+
+import kotlin.Long
+import kotlin.String
+import kotlin.Suppress
+import kotlin.collections.List
+
+public data class BookRef(
+ public val id: Long,
+ public val title: String,
+)
+
+public data class TocQuickLink(
+ public val label: String,
+ public val tocEntryId: Long,
+ public val firstLineId: Long?,
+)
+
+public sealed interface DropdownSpec
+
+public data class CategoryDropdownSpec(
+ public val categoryId: Long,
+) : DropdownSpec
+
+public data class MultiCategoryDropdownSpec(
+ public val labelCategoryId: Long,
+ public val bookCategoryIds: List,
+) : DropdownSpec
+
+public data class TocQuickLinksSpec(
+ public val bookId: Long,
+ public val links: List,
+) : DropdownSpec
+
+public object CatalogPresets {
+ public object Ids {
+ public object Categories {
+ /**
+ * תנ״ך
+ */
+ public const val TANAKH: Long = 1L
+
+ /**
+ * תורה
+ */
+ public const val TORAH: Long = 2L
+
+ /**
+ * נביאים
+ */
+ public const val NEVIIM: Long = 3L
+
+ /**
+ * כתובים
+ */
+ public const val KETUVIM: Long = 4L
+
+ /**
+ * משנה
+ */
+ public const val MISHNA: Long = 5L
+
+ /**
+ * סדר זרעים
+ */
+ public const val MISHNA_ZERAIM: Long = 6L
+
+ /**
+ * סדר מועד
+ */
+ public const val MISHNA_MOED: Long = 7L
+
+ /**
+ * סדר נשים
+ */
+ public const val MISHNA_NASHIM: Long = 8L
+
+ /**
+ * סדר נזיקין
+ */
+ public const val MISHNA_NEZIKIN: Long = 9L
+
+ /**
+ * סדר קדשים
+ */
+ public const val MISHNA_KODASHIM: Long = 10L
+
+ /**
+ * סדר טהרות
+ */
+ public const val MISHNA_TAHAROT: Long = 11L
+
+ /**
+ * בבלי
+ */
+ public const val BAVLI: Long = 13L
+
+ /**
+ * סדר זרעים
+ */
+ public const val BAVLI_ZERAIM: Long = 14L
+
+ /**
+ * סדר מועד
+ */
+ public const val BAVLI_MOED: Long = 15L
+
+ /**
+ * סדר נשים
+ */
+ public const val BAVLI_NASHIM: Long = 16L
+
+ /**
+ * סדר נזיקין
+ */
+ public const val BAVLI_NEZIKIN: Long = 17L
+
+ /**
+ * סדר קדשים
+ */
+ public const val BAVLI_KODASHIM: Long = 18L
+
+ /**
+ * סדר טהרות
+ */
+ public const val BAVLI_TAHAROT: Long = 19L
+
+ /**
+ * ירושלמי
+ */
+ public const val YERUSHALMI: Long = 20L
+
+ /**
+ * סדר זרעים
+ */
+ public const val YERUSHALMI_ZERAIM: Long = 21L
+
+ /**
+ * סדר מועד
+ */
+ public const val YERUSHALMI_MOED: Long = 22L
+
+ /**
+ * סדר נשים
+ */
+ public const val YERUSHALMI_NASHIM: Long = 23L
+
+ /**
+ * סדר נזיקין
+ */
+ public const val YERUSHALMI_NEZIKIN: Long = 24L
+
+ /**
+ * סדר טהרות
+ */
+ public const val YERUSHALMI_TAHAROT: Long = 25L
+
+ /**
+ * משנה תורה
+ */
+ public const val MISHNE_TORAH: Long = 45L
+
+ /**
+ * טור
+ */
+ public const val TUR: Long = 61L
+
+ /**
+ * שולחן ערוך
+ */
+ public const val SHULCHAN_ARUCH: Long = 62L
+ }
+
+ public object Books {
+ /**
+ * טור
+ */
+ public const val TUR: Long = 380L
+ }
+
+ public object TocTexts {
+ /**
+ * אורח חיים
+ */
+ public const val ORACH_CHAIM: Long = 3_878L
+
+ /**
+ * יורה דעה
+ */
+ public const val YOREH_DEAH: Long = 4_521L
+
+ /**
+ * אבן העזר
+ */
+ public const val EVEN_HAEZER: Long = 4_522L
+
+ /**
+ * חושן משפט
+ */
+ public const val CHOSHEN_MISHPAT: Long = 4_523L
+ }
+ }
+
+ public object Dropdowns {
+ public val HOME: List = listOf(
+ MultiCategoryDropdownSpec(1L, listOf(2L, 3L, 4L)),
+ MultiCategoryDropdownSpec(5L, listOf(6L, 7L, 8L, 9L, 10L, 11L)),
+ MultiCategoryDropdownSpec(13L, listOf(14L, 15L, 16L, 17L, 18L, 19L)),
+ MultiCategoryDropdownSpec(20L, listOf(21L, 22L, 23L, 24L, 25L)),
+ CategoryDropdownSpec(62L),
+ TocQuickLinksSpec(380L, listOf(TocQuickLink("אורח חיים", 30_149L, 252_607), TocQuickLink("יורה דעה", 30_848L, 254_014), TocQuickLink("אבן העזר", 31_253L, 254_828), TocQuickLink("חושן משפט", 31_433L, 255_198))),
+ )
+
+ public val TANAKH: DropdownSpec = MultiCategoryDropdownSpec(1L, listOf(2L, 3L, 4L))
+
+ public val TORAH: DropdownSpec = CategoryDropdownSpec(2L)
+
+ public val NEVIIM: DropdownSpec = CategoryDropdownSpec(3L)
+
+ public val KETUVIM: DropdownSpec = CategoryDropdownSpec(4L)
+
+ public val MISHNA: DropdownSpec =
+ MultiCategoryDropdownSpec(5L, listOf(6L, 7L, 8L, 9L, 10L, 11L))
+
+ public val BAVLI: DropdownSpec =
+ MultiCategoryDropdownSpec(13L, listOf(14L, 15L, 16L, 17L, 18L, 19L))
+
+ public val YERUSHALMI: DropdownSpec =
+ MultiCategoryDropdownSpec(20L, listOf(21L, 22L, 23L, 24L, 25L))
+
+ public val SHULCHAN_ARUCH: DropdownSpec = CategoryDropdownSpec(62L)
+
+ public val MISHNE_TORAH: DropdownSpec =
+ MultiCategoryDropdownSpec(45L, listOf(46L, 47L, 48L, 49L, 50L, 51L, 52L, 53L, 54L, 55L, 59L, 56L, 57L, 58L, 60L))
+
+ public val TUR_QUICK_LINKS: DropdownSpec =
+ TocQuickLinksSpec(380L, listOf(TocQuickLink("אורח חיים", 30_149L, 252_607), TocQuickLink("יורה דעה", 30_848L, 254_014), TocQuickLink("אבן העזר", 31_253L, 254_828), TocQuickLink("חושן משפט", 31_433L, 255_198)))
+ }
+}
diff --git a/SeforimApp/src/commonMain/kotlin/io/github/kdroidfilter/seforimapp/catalog/PrecomputedCatalog.kt b/SeforimApp/src/commonMain/kotlin/io/github/kdroidfilter/seforimapp/catalog/PrecomputedCatalog.kt
deleted file mode 100644
index fc98976f1..000000000
--- a/SeforimApp/src/commonMain/kotlin/io/github/kdroidfilter/seforimapp/catalog/PrecomputedCatalog.kt
+++ /dev/null
@@ -1,947 +0,0 @@
-// DO NOT EDIT.
-// This file is auto-generated by the catalog generator.
-// To regenerate: ./gradlew :cataloggen:generatePrecomputedCatalog
-// Manual changes will be lost.
-package io.github.kdroidfilter.seforimapp.catalog
-
-import kotlin.Long
-import kotlin.String
-import kotlin.collections.List
-import kotlin.collections.Map
-
-public data class BookRef(
- public val id: Long,
- public val title: String,
-)
-
-public data class TocQuickLink(
- public val label: String,
- public val tocEntryId: Long,
- public val firstLineId: Long?,
-)
-
-public sealed interface DropdownSpec
-
-public data class CategoryDropdownSpec(
- public val categoryId: Long,
-) : DropdownSpec
-
-public data class MultiCategoryDropdownSpec(
- public val labelCategoryId: Long,
- public val bookCategoryIds: List,
-) : DropdownSpec
-
-public data class TocQuickLinksSpec(
- public val bookId: Long,
- public val tocTextIds: List,
-) : DropdownSpec
-
-public object PrecomputedCatalog {
- public val BOOK_TITLES: Map =
- mapOf(
- 1L to "בראשית",
- 2L to "שמות",
- 3L to "ויקרא",
- 4L to "במדבר",
- 5L to "דברים",
- 6L to "יהושע",
- 7L to "שופטים",
- 8L to "שמואל א",
- 9L to "שמואל ב",
- 10L to "מלכים א",
- 11L to "מלכים ב",
- 12L to "ישעיהו",
- 13L to "ירמיהו",
- 14L to "יחזקאל",
- 15L to "הושע",
- 16L to "יואל",
- 17L to "עמוס",
- 18L to "עובדיה",
- 19L to "יונה",
- 20L to "מיכה",
- 21L to "נחום",
- 22L to "חבקוק",
- 23L to "צפניה",
- 24L to "חגי",
- 25L to "זכריה",
- 26L to "מלאכי",
- 27L to "רות",
- 28L to "תהילים",
- 29L to "איוב",
- 30L to "משלי",
- 31L to "שיר השירים",
- 32L to "קהלת",
- 33L to "איכה",
- 34L to "אסתר",
- 35L to "דניאל",
- 36L to "עזרא",
- 37L to "נחמיה",
- 38L to "דברי הימים א",
- 39L to "דברי הימים ב",
- 40L to "משנה ברכות",
- 41L to "משנה פאה",
- 42L to "משנה דמאי",
- 43L to "משנה כלאים",
- 44L to "משנה שביעית",
- 45L to "משנה תרומות",
- 46L to "משנה מעשרות",
- 47L to "משנה מעשר שני",
- 48L to "משנה חלה",
- 49L to "משנה ערלה",
- 50L to "משנה ביכורים",
- 51L to "משנה שבת",
- 52L to "משנה עירובין",
- 53L to "משנה פסחים",
- 54L to "משנה שקלים",
- 55L to "משנה יומא",
- 56L to "משנה סוכה",
- 57L to "משנה ביצה",
- 58L to "משנה ראש השנה",
- 59L to "משנה תענית",
- 60L to "משנה מגילה",
- 61L to "משנה מועד קטן",
- 62L to "משנה חגיגה",
- 63L to "משנה יבמות",
- 64L to "משנה כתובות",
- 65L to "משנה נדרים",
- 66L to "משנה נזיר",
- 67L to "משנה סוטה",
- 68L to "משנה גיטין",
- 69L to "משנה קידושין",
- 70L to "משנה בבא קמא",
- 71L to "משנה בבא מציעא",
- 72L to "משנה בבא בתרא",
- 73L to "משנה סנהדרין",
- 74L to "משנה מכות",
- 75L to "משנה שבועות",
- 76L to "משנה עדיות",
- 77L to "משנה עבודה זרה",
- 78L to "משנה אבות",
- 79L to "משנה הוריות",
- 80L to "משנה זבחים",
- 81L to "משנה מנחות",
- 82L to "משנה חולין",
- 83L to "משנה בכורות",
- 84L to "משנה ערכין",
- 85L to "משנה תמורה",
- 86L to "משנה כריתות",
- 87L to "משנה מעילה",
- 88L to "משנה תמיד",
- 89L to "משנה מדות",
- 90L to "משנה קינים",
- 91L to "משנה כלים",
- 92L to "משנה אהלות",
- 93L to "משנה נגעים",
- 94L to "משנה פרה",
- 95L to "משנה טהרות",
- 96L to "משנה מקואות",
- 97L to "משנה נדה",
- 98L to "משנה מכשירין",
- 99L to "משנה זבים",
- 100L to "משנה טבול יום",
- 101L to "משנה ידים",
- 102L to "משנה עוקצים",
- 103L to "ברכות",
- 104L to "שבת",
- 105L to "עירובין",
- 106L to "פסחים",
- 107L to "יומא",
- 108L to "סוכה",
- 109L to "ביצה",
- 110L to "ראש השנה",
- 111L to "תענית",
- 112L to "מגילה",
- 113L to "מועד קטן",
- 114L to "חגיגה",
- 115L to "יבמות",
- 116L to "כתובות",
- 117L to "נדרים",
- 118L to "נזיר",
- 119L to "סוטה",
- 120L to "גיטין",
- 121L to "קידושין",
- 122L to "בבא קמא",
- 123L to "בבא מציעא",
- 124L to "בבא בתרא",
- 125L to "סנהדרין",
- 126L to "מכות",
- 127L to "שבועות",
- 128L to "עבודה זרה",
- 129L to "הוריות",
- 130L to "זבחים",
- 131L to "מנחות",
- 132L to "חולין",
- 133L to "בכורות",
- 134L to "ערכין",
- 135L to "תמורה",
- 136L to "כריתות",
- 137L to "מעילה",
- 138L to "תמיד",
- 139L to "נדה",
- 140L to "תלמוד ירושלמי ברכות",
- 141L to "תלמוד ירושלמי פאה",
- 142L to "תלמוד ירושלמי דמאי",
- 143L to "תלמוד ירושלמי כלאים",
- 144L to "תלמוד ירושלמי שביעית",
- 145L to "תלמוד ירושלמי תרומות",
- 146L to "תלמוד ירושלמי מעשרות",
- 147L to "תלמוד ירושלמי מעשר שני",
- 148L to "תלמוד ירושלמי חלה",
- 149L to "תלמוד ירושלמי ערלה",
- 150L to "תלמוד ירושלמי בכורים",
- 151L to "תלמוד ירושלמי שבת",
- 152L to "תלמוד ירושלמי עירובין",
- 153L to "תלמוד ירושלמי פסחים",
- 154L to "תלמוד ירושלמי שקלים",
- 155L to "תלמוד ירושלמי יומא",
- 156L to "תלמוד ירושלמי סוכה",
- 157L to "תלמוד ירושלמי ביצה",
- 158L to "תלמוד ירושלמי ראש השנה",
- 159L to "תלמוד ירושלמי תענית",
- 160L to "תלמוד ירושלמי מגילה",
- 161L to "תלמוד ירושלמי מועד קטן",
- 162L to "תלמוד ירושלמי חגיגה",
- 163L to "תלמוד ירושלמי יבמות",
- 164L to "תלמוד ירושלמי כתובות",
- 165L to "תלמוד ירושלמי נדרים",
- 166L to "תלמוד ירושלמי נזיר",
- 167L to "תלמוד ירושלמי סוטה",
- 168L to "תלמוד ירושלמי גיטין",
- 169L to "תלמוד ירושלמי קידושין",
- 170L to "תלמוד ירושלמי בבא קמא",
- 171L to "תלמוד ירושלמי בבא מציעא",
- 172L to "תלמוד ירושלמי בבא בתרא",
- 173L to "תלמוד ירושלמי סנהדרין",
- 174L to "תלמוד ירושלמי מכות",
- 175L to "תלמוד ירושלמי שבועות",
- 176L to "תלמוד ירושלמי עבודה זרה",
- 177L to "תלמוד ירושלמי הוריות",
- 178L to "תלמוד ירושלמי נדה",
- 293L to "משנה תורה, מסירת תורה שבעל פה",
- 294L to "משנה תורה, מצוות לא תעשה",
- 295L to "משנה תורה, מצוות עשה",
- 296L to "משנה תורה, תוכן החיבור",
- 297L to "משנה תורה, הלכות יסודי התורה",
- 298L to "משנה תורה, הלכות דעות",
- 299L to "משנה תורה, הלכות תלמוד תורה",
- 300L to "משנה תורה, הלכות עבודה זרה וחוקות הגויים",
- 301L to "משנה תורה, הלכות תשובה",
- 302L to "משנה תורה, הלכות קריאת שמע",
- 303L to "משנה תורה, הלכות תפילה וברכת כהנים",
- 304L to "משנה תורה, הלכות תפילין ומזוזה וספר תורה",
- 305L to "משנה תורה, הלכות ציצית",
- 306L to "משנה תורה, הלכות ברכות",
- 307L to "משנה תורה, הלכות מילה",
- 308L to "משנה תורה, סדר התפילה",
- 309L to "משנה תורה, הלכות שבת",
- 310L to "משנה תורה, הלכות עירובין",
- 311L to "משנה תורה, הלכות שקלים",
- 312L to "משנה תורה, הלכות קידוש החודש",
- 313L to "משנה תורה, הלכות תעניות",
- 314L to "משנה תורה, הלכות מגילה וחנוכה",
- 315L to "משנה תורה, הלכות שופר וסוכה ולולב",
- 316L to "משנה תורה, הלכות שביתת יום טוב",
- 317L to "משנה תורה, הלכות שביתת עשור",
- 318L to "משנה תורה, הלכות חמץ ומצה",
- 319L to "משנה תורה, הלכות אישות",
- 320L to "משנה תורה, הלכות גירושין",
- 321L to "משנה תורה, הלכות יבום וחליצה",
- 322L to "משנה תורה, הלכות סוטה",
- 323L to "משנה תורה, הלכות נערה בתולה",
- 324L to "משנה תורה, הלכות מאכלות אסורות",
- 325L to "משנה תורה, הלכות שחיטה",
- 326L to "משנה תורה, הלכות איסורי ביאה",
- 327L to "משנה תורה, הלכות נדרים",
- 328L to "משנה תורה, הלכות נזירות",
- 329L to "משנה תורה, הלכות ערכים וחרמין",
- 330L to "משנה תורה, הלכות שבועות",
- 331L to "משנה תורה, הלכות תרומות",
- 332L to "משנה תורה, הלכות מעשרות",
- 333L to "משנה תורה, הלכות מעשר שני ונטע רבעי",
- 334L to "משנה תורה, הלכות שמיטה ויובל",
- 335L to "משנה תורה, הלכות מתנות עניים",
- 336L to "משנה תורה, הלכות כלאים",
- 337L to "משנה תורה, הלכות ביכורים ושאר מתנות כהונה שבגבולין",
- 338L to "משנה תורה, הלכות בית הבחירה",
- 339L to "משנה תורה, הלכות כלי המקדש והעובדין בו",
- 340L to "משנה תורה, הלכות איסורי המזבח",
- 341L to "משנה תורה, הלכות ביאת מקדש",
- 342L to "משנה תורה, הלכות מעשה הקרבנות",
- 343L to "משנה תורה, הלכות עבודת יום הכפורים",
- 344L to "משנה תורה, הלכות פסולי המוקדשין",
- 345L to "משנה תורה, הלכות תמידים ומוספין",
- 346L to "משנה תורה, הלכות מעילה",
- 347L to "משנה תורה, הלכות בכורות",
- 348L to "משנה תורה, הלכות שגגות",
- 349L to "משנה תורה, הלכות מחוסרי כפרה",
- 350L to "משנה תורה, הלכות תמורה",
- 351L to "משנה תורה, הלכות קרבן פסח",
- 352L to "משנה תורה, הלכות חגיגה",
- 353L to "משנה תורה, הלכות נזקי ממון",
- 354L to "משנה תורה, הלכות גזילה ואבידה",
- 355L to "משנה תורה, הלכות גניבה",
- 356L to "משנה תורה, הלכות חובל ומזיק",
- 357L to "משנה תורה, הלכות רוצח ושמירת נפש",
- 358L to "משנה תורה, הלכות מכירה",
- 359L to "משנה תורה, הלכות זכייה ומתנה",
- 360L to "משנה תורה, הלכות שלוחין ושותפין",
- 361L to "משנה תורה, הלכות עבדים",
- 362L to "משנה תורה, הלכות שכנים",
- 363L to "משנה תורה, הלכות מלווה ולווה",
- 364L to "משנה תורה, הלכות שכירות",
- 365L to "משנה תורה, הלכות נחלות",
- 366L to "משנה תורה, הלכות טוען ונטען",
- 367L to "משנה תורה, הלכות שאלה ופיקדון",
- 368L to "משנה תורה, הלכות שאר אבות הטומאות",
- 369L to "משנה תורה, הלכות טומאת מת",
- 370L to "משנה תורה, הלכות טומאת צרעת",
- 371L to "משנה תורה, הלכות מטמאי משכב ומושב",
- 372L to "משנה תורה, הלכות טומאת אוכלים",
- 373L to "משנה תורה, הלכות פרה אדומה",
- 374L to "משנה תורה, הלכות מקואות",
- 375L to "משנה תורה, הלכות כלים",
- 376L to "משנה תורה, הלכות סנהדרין והעונשין המסורין להם",
- 377L to "משנה תורה, הלכות עדות",
- 378L to "משנה תורה, הלכות ממרים",
- 379L to "משנה תורה, הלכות אבל",
- 380L to "משנה תורה, הלכות מלכים ומלחמות",
- 381L to "טור",
- 382L to "שולחן ערוך, הקדמה",
- 383L to "שולחן ערוך, אורח חיים",
- 384L to "שולחן ערוך, יורה דעה",
- 385L to "שולחן ערוך, אבן העזר",
- 386L to "שולחן ערוך, חושן משפט",
- 2_533L to "פרי מגדים על אורח חיים",
- )
-
- public val CATEGORY_TITLES: Map =
- mapOf(
- 1L to "תנ״ך",
- 2L to "תורה",
- 3L to "נביאים",
- 4L to "כתובים",
- 5L to "משנה",
- 6L to "סדר זרעים",
- 7L to "סדר מועד",
- 8L to "סדר נשים",
- 9L to "סדר נזיקין",
- 10L to "סדר קדשים",
- 11L to "סדר טהרות",
- 13L to "תלמוד בבלי",
- 14L to "סדר זרעים",
- 15L to "סדר מועד",
- 16L to "סדר נשים",
- 17L to "סדר נזיקין",
- 18L to "סדר קדשים",
- 19L to "סדר טהרות",
- 20L to "תלמוד ירושלמי",
- 21L to "סדר זרעים",
- 22L to "סדר מועד",
- 23L to "סדר נשים",
- 24L to "סדר נזיקין",
- 25L to "סדר טהרות",
- 45L to "משנה תורה",
- 46L to "הקדמה",
- 47L to "ספר מדע",
- 48L to "ספר אהבה",
- 49L to "ספר זמנים",
- 50L to "ספר נשים",
- 51L to "ספר קדושה",
- 52L to "ספר הפלאה",
- 53L to "ספר זרעים",
- 54L to "ספר עבודה",
- 55L to "ספר קורבנות",
- 56L to "ספר נזיקין",
- 57L to "ספר קניין",
- 58L to "ספר משפטים",
- 59L to "ספר טהרה",
- 60L to "ספר שופטים",
- 61L to "טור",
- 62L to "שולחן ערוך",
- )
-
- public val CATEGORY_BOOKS: Map> =
- mapOf(
- 1L to listOf(),
- 2L to listOf(BookRef(1L, "בראשית"), BookRef(2L, "שמות"), BookRef(3L, "ויקרא"), BookRef(4L, "במדבר"), BookRef(5L, "דברים")),
- 3L to
- listOf(
- BookRef(6L, "יהושע"),
- BookRef(7L, "שופטים"),
- BookRef(8L, "שמואל א"),
- BookRef(9L, "שמואל ב"),
- BookRef(10L, "מלכים א"),
- BookRef(11L, "מלכים ב"),
- BookRef(12L, "ישעיהו"),
- BookRef(13L, "ירמיהו"),
- BookRef(14L, "יחזקאל"),
- BookRef(15L, "הושע"),
- BookRef(16L, "יואל"),
- BookRef(17L, "עמוס"),
- BookRef(18L, "עובדיה"),
- BookRef(19L, "יונה"),
- BookRef(20L, "מיכה"),
- BookRef(21L, "נחום"),
- BookRef(22L, "חבקוק"),
- BookRef(23L, "צפניה"),
- BookRef(24L, "חגי"),
- BookRef(25L, "זכריה"),
- BookRef(26L, "מלאכי"),
- ),
- 4L to
- listOf(
- BookRef(28L, "תהילים"),
- BookRef(30L, "משלי"),
- BookRef(29L, "איוב"),
- BookRef(31L, "שיר השירים"),
- BookRef(27L, "רות"),
- BookRef(33L, "איכה"),
- BookRef(32L, "קהלת"),
- BookRef(34L, "אסתר"),
- BookRef(35L, "דניאל"),
- BookRef(36L, "עזרא"),
- BookRef(37L, "נחמיה"),
- BookRef(38L, "דברי הימים א"),
- BookRef(39L, "דברי הימים ב"),
- ),
- 5L to listOf(),
- 6L to
- listOf(
- BookRef(40L, "ברכות"),
- BookRef(41L, "פאה"),
- BookRef(42L, "דמאי"),
- BookRef(43L, "כלאים"),
- BookRef(44L, "שביעית"),
- BookRef(45L, "תרומות"),
- BookRef(46L, "מעשרות"),
- BookRef(47L, "מעשר שני"),
- BookRef(48L, "חלה"),
- BookRef(49L, "ערלה"),
- BookRef(50L, "ביכורים"),
- ),
- 7L to
- listOf(
- BookRef(51L, "שבת"),
- BookRef(52L, "עירובין"),
- BookRef(53L, "פסחים"),
- BookRef(54L, "שקלים"),
- BookRef(55L, "יומא"),
- BookRef(56L, "סוכה"),
- BookRef(57L, "ביצה"),
- BookRef(58L, "ראש השנה"),
- BookRef(59L, "תענית"),
- BookRef(60L, "מגילה"),
- BookRef(61L, "מועד קטן"),
- BookRef(62L, "חגיגה"),
- ),
- 8L to
- listOf(
- BookRef(63L, "יבמות"),
- BookRef(64L, "כתובות"),
- BookRef(65L, "נדרים"),
- BookRef(66L, "נזיר"),
- BookRef(67L, "סוטה"),
- BookRef(68L, "גיטין"),
- BookRef(69L, "קידושין"),
- ),
- 9L to
- listOf(
- BookRef(70L, "בבא קמא"),
- BookRef(71L, "בבא מציעא"),
- BookRef(72L, "בבא בתרא"),
- BookRef(73L, "סנהדרין"),
- BookRef(74L, "מכות"),
- BookRef(75L, "שבועות"),
- BookRef(76L, "עדיות"),
- BookRef(77L, "עבודה זרה"),
- BookRef(78L, "אבות"),
- BookRef(79L, "הוריות"),
- ),
- 10L to
- listOf(
- BookRef(80L, "זבחים"),
- BookRef(81L, "מנחות"),
- BookRef(82L, "חולין"),
- BookRef(83L, "בכורות"),
- BookRef(84L, "ערכין"),
- BookRef(85L, "תמורה"),
- BookRef(86L, "כריתות"),
- BookRef(87L, "מעילה"),
- BookRef(88L, "תמיד"),
- BookRef(89L, "מדות"),
- BookRef(90L, "קינים"),
- ),
- 11L to
- listOf(
- BookRef(91L, "כלים"),
- BookRef(92L, "אהלות"),
- BookRef(93L, "נגעים"),
- BookRef(94L, "פרה"),
- BookRef(95L, "טהרות"),
- BookRef(96L, "מקואות"),
- BookRef(97L, "נדה"),
- BookRef(98L, "מכשירין"),
- BookRef(99L, "זבים"),
- BookRef(100L, "טבול יום"),
- BookRef(101L, "ידים"),
- BookRef(102L, "עוקצים"),
- ),
- 13L to listOf(),
- 14L to listOf(BookRef(103L, "ברכות")),
- 15L to
- listOf(
- BookRef(104L, "שבת"),
- BookRef(105L, "עירובין"),
- BookRef(106L, "פסחים"),
- BookRef(110L, "ראש השנה"),
- BookRef(107L, "יומא"),
- BookRef(108L, "סוכה"),
- BookRef(109L, "ביצה"),
- BookRef(111L, "תענית"),
- BookRef(112L, "מגילה"),
- BookRef(113L, "מועד קטן"),
- BookRef(114L, "חגיגה"),
- ),
- 16L to
- listOf(
- BookRef(115L, "יבמות"),
- BookRef(116L, "כתובות"),
- BookRef(117L, "נדרים"),
- BookRef(118L, "נזיר"),
- BookRef(119L, "סוטה"),
- BookRef(120L, "גיטין"),
- BookRef(121L, "קידושין"),
- ),
- 17L to
- listOf(
- BookRef(122L, "בבא קמא"),
- BookRef(123L, "בבא מציעא"),
- BookRef(124L, "בבא בתרא"),
- BookRef(125L, "סנהדרין"),
- BookRef(126L, "מכות"),
- BookRef(127L, "שבועות"),
- BookRef(128L, "עבודה זרה"),
- BookRef(129L, "הוריות"),
- ),
- 18L to
- listOf(
- BookRef(130L, "זבחים"),
- BookRef(131L, "מנחות"),
- BookRef(132L, "חולין"),
- BookRef(133L, "בכורות"),
- BookRef(134L, "ערכין"),
- BookRef(135L, "תמורה"),
- BookRef(136L, "כריתות"),
- BookRef(137L, "מעילה"),
- BookRef(138L, "תמיד"),
- ),
- 19L to listOf(BookRef(139L, "נדה")),
- 20L to listOf(),
- 21L to
- listOf(
- BookRef(140L, "ירושלמי ברכות"),
- BookRef(141L, "ירושלמי פאה"),
- BookRef(142L, "ירושלמי דמאי"),
- BookRef(143L, "ירושלמי כלאים"),
- BookRef(144L, "ירושלמי שביעית"),
- BookRef(145L, "ירושלמי תרומות"),
- BookRef(146L, "ירושלמי מעשרות"),
- BookRef(147L, "ירושלמי מעשר שני"),
- BookRef(148L, "ירושלמי חלה"),
- BookRef(149L, "ירושלמי ערלה"),
- BookRef(150L, "ירושלמי בכורים"),
- ),
- 22L to
- listOf(
- BookRef(151L, "ירושלמי שבת"),
- BookRef(152L, "ירושלמי עירובין"),
- BookRef(153L, "ירושלמי פסחים"),
- BookRef(155L, "ירושלמי יומא"),
- BookRef(154L, "ירושלמי שקלים"),
- BookRef(156L, "ירושלמי סוכה"),
- BookRef(158L, "ירושלמי ראש השנה"),
- BookRef(157L, "ירושלמי ביצה"),
- BookRef(159L, "ירושלמי תענית"),
- BookRef(160L, "ירושלמי מגילה"),
- BookRef(162L, "ירושלמי חגיגה"),
- BookRef(161L, "ירושלמי מועד קטן"),
- ),
- 23L to
- listOf(
- BookRef(163L, "ירושלמי יבמות"),
- BookRef(167L, "ירושלמי סוטה"),
- BookRef(164L, "ירושלמי כתובות"),
- BookRef(165L, "ירושלמי נדרים"),
- BookRef(166L, "ירושלמי נזיר"),
- BookRef(168L, "ירושלמי גיטין"),
- BookRef(169L, "ירושלמי קידושין"),
- ),
- 24L to
- listOf(
- BookRef(170L, "ירושלמי בבא קמא"),
- BookRef(171L, "ירושלמי בבא מציעא"),
- BookRef(172L, "ירושלמי בבא בתרא"),
- BookRef(173L, "ירושלמי סנהדרין"),
- BookRef(175L, "ירושלמי שבועות"),
- BookRef(176L, "ירושלמי עבודה זרה"),
- BookRef(174L, "ירושלמי מכות"),
- BookRef(177L, "ירושלמי הוריות"),
- ),
- 25L to listOf(BookRef(178L, "ירושלמי נדה")),
- 45L to listOf(),
- 46L to
- listOf(
- BookRef(293L, "מסירת תורה שבעל פה"),
- BookRef(295L, "מצוות עשה"),
- BookRef(294L, "מצוות לא תעשה"),
- BookRef(296L, "תוכן החיבור"),
- ),
- 47L to
- listOf(
- BookRef(297L, "הלכות יסודי התורה"),
- BookRef(298L, "הלכות דעות"),
- BookRef(299L, "הלכות תלמוד תורה"),
- BookRef(300L, "הלכות עבודה זרה וחוקות הגויים"),
- BookRef(301L, "הלכות תשובה"),
- ),
- 48L to
- listOf(
- BookRef(302L, "הלכות קריאת שמע"),
- BookRef(303L, "הלכות תפילה וברכת כהנים"),
- BookRef(304L, "הלכות תפילין ומזוזה וספר תורה"),
- BookRef(305L, "הלכות ציצית"),
- BookRef(306L, "הלכות ברכות"),
- BookRef(307L, "הלכות מילה"),
- BookRef(308L, "סדר התפילה"),
- ),
- 49L to
- listOf(
- BookRef(309L, "הלכות שבת"),
- BookRef(310L, "הלכות עירובין"),
- BookRef(317L, "הלכות שביתת עשור"),
- BookRef(316L, "הלכות שביתת יום טוב"),
- BookRef(318L, "הלכות חמץ ומצה"),
- BookRef(315L, "הלכות שופר וסוכה ולולב"),
- BookRef(311L, "הלכות שקלים"),
- BookRef(312L, "הלכות קידוש החודש"),
- BookRef(313L, "הלכות תעניות"),
- BookRef(314L, "הלכות מגילה וחנוכה"),
- ),
- 50L to
- listOf(
- BookRef(319L, "הלכות אישות"),
- BookRef(320L, "הלכות גירושין"),
- BookRef(321L, "הלכות יבום וחליצה"),
- BookRef(323L, "הלכות נערה בתולה"),
- BookRef(322L, "הלכות סוטה"),
- ),
- 51L to listOf(BookRef(326L, "הלכות איסורי ביאה"), BookRef(324L, "הלכות מאכלות אסורות"), BookRef(325L, "הלכות שחיטה")),
- 52L to
- listOf(
- BookRef(330L, "הלכות שבועות"),
- BookRef(327L, "הלכות נדרים"),
- BookRef(328L, "הלכות נזירות"),
- BookRef(329L, "הלכות ערכים וחרמין"),
- ),
- 53L to
- listOf(
- BookRef(336L, "הלכות כלאים"),
- BookRef(335L, "הלכות מתנות עניים"),
- BookRef(331L, "הלכות תרומות"),
- BookRef(332L, "הלכות מעשרות"),
- BookRef(333L, "הלכות מעשר שני ונטע רבעי"),
- BookRef(337L, "הלכות ביכורים ושאר מתנות כהונה שבגבולין"),
- BookRef(334L, "הלכות שמיטה ויובל"),
- ),
- 54L to
- listOf(
- BookRef(338L, "הלכות בית הבחירה"),
- BookRef(339L, "הלכות כלי המקדש והעובדין בו"),
- BookRef(341L, "הלכות ביאת מקדש"),
- BookRef(340L, "הלכות איסורי המזבח"),
- BookRef(342L, "הלכות מעשה הקרבנות"),
- BookRef(345L, "הלכות תמידים ומוספין"),
- BookRef(344L, "הלכות פסולי המוקדשין"),
- BookRef(343L, "הלכות עבודת יום הכפורים"),
- BookRef(346L, "הלכות מעילה"),
- ),
- 55L to
- listOf(
- BookRef(351L, "הלכות קרבן פסח"),
- BookRef(352L, "הלכות חגיגה"),
- BookRef(347L, "הלכות בכורות"),
- BookRef(348L, "הלכות שגגות"),
- BookRef(349L, "הלכות מחוסרי כפרה"),
- BookRef(350L, "הלכות תמורה"),
- ),
- 56L to
- listOf(
- BookRef(353L, "הלכות נזקי ממון"),
- BookRef(355L, "הלכות גניבה"),
- BookRef(354L, "הלכות גזילה ואבידה"),
- BookRef(356L, "הלכות חובל ומזיק"),
- BookRef(357L, "הלכות רוצח ושמירת נפש"),
- ),
- 57L to
- listOf(
- BookRef(358L, "הלכות מכירה"),
- BookRef(359L, "הלכות זכייה ומתנה"),
- BookRef(362L, "הלכות שכנים"),
- BookRef(360L, "הלכות שלוחין ושותפין"),
- BookRef(361L, "הלכות עבדים"),
- ),
- 58L to
- listOf(
- BookRef(364L, "הלכות שכירות"),
- BookRef(367L, "הלכות שאלה ופיקדון"),
- BookRef(363L, "הלכות מלווה ולווה"),
- BookRef(366L, "הלכות טוען ונטען"),
- BookRef(365L, "הלכות נחלות"),
- ),
- 59L to
- listOf(
- BookRef(369L, "הלכות טומאת מת"),
- BookRef(373L, "הלכות פרה אדומה"),
- BookRef(370L, "הלכות טומאת צרעת"),
- BookRef(371L, "הלכות מטמאי משכב ומושב"),
- BookRef(368L, "הלכות שאר אבות הטומאות"),
- BookRef(372L, "הלכות טומאת אוכלים"),
- BookRef(375L, "הלכות כלים"),
- BookRef(374L, "הלכות מקואות"),
- ),
- 60L to
- listOf(
- BookRef(376L, "הלכות סנהדרין והעונשין המסורין להם"),
- BookRef(377L, "הלכות עדות"),
- BookRef(378L, "הלכות ממרים"),
- BookRef(379L, "הלכות אבל"),
- BookRef(380L, "הלכות מלכים ומלחמות"),
- ),
- 61L to listOf(BookRef(381L, "טור")),
- 62L to
- listOf(
- BookRef(382L, "הקדמה"),
- BookRef(383L, "אורח חיים"),
- BookRef(384L, "יורה דעה"),
- BookRef(385L, "אבן העזר"),
- BookRef(386L, "חושן משפט"),
- BookRef(2_533L, "פרי מגדים על אורח חיים"),
- ),
- )
-
- public val TOC_BY_TOC_TEXT_ID: Map> =
- mapOf(
- 381L to
- mapOf(
- 3_768L to TocQuickLink("אורח חיים", 30_015L, 252_674),
- 4_411L to TocQuickLink("יורה דעה", 30_714L, 254_081),
- 4_412L to TocQuickLink("אבן העזר", 31_119L, 254_895),
- 4_413L to TocQuickLink("חושן משפט", 31_299L, 255_265),
- ),
- )
-
- public object Ids {
- public object Categories {
- /**
- * תנ״ך
- */
- public const val TANAKH: Long = 1L
-
- /**
- * תורה
- */
- public const val TORAH: Long = 2L
-
- /**
- * נביאים
- */
- public const val NEVIIM: Long = 3L
-
- /**
- * כתובים
- */
- public const val KETUVIM: Long = 4L
-
- /**
- * משנה
- */
- public const val MISHNA: Long = 5L
-
- /**
- * סדר זרעים
- */
- public const val MISHNA_ZERAIM: Long = 6L
-
- /**
- * סדר מועד
- */
- public const val MISHNA_MOED: Long = 7L
-
- /**
- * סדר נשים
- */
- public const val MISHNA_NASHIM: Long = 8L
-
- /**
- * סדר נזיקין
- */
- public const val MISHNA_NEZIKIN: Long = 9L
-
- /**
- * סדר קדשים
- */
- public const val MISHNA_KODASHIM: Long = 10L
-
- /**
- * סדר טהרות
- */
- public const val MISHNA_TAHAROT: Long = 11L
-
- /**
- * תלמוד בבלי
- */
- public const val BAVLI: Long = 13L
-
- /**
- * סדר זרעים
- */
- public const val BAVLI_ZERAIM: Long = 14L
-
- /**
- * סדר מועד
- */
- public const val BAVLI_MOED: Long = 15L
-
- /**
- * סדר נשים
- */
- public const val BAVLI_NASHIM: Long = 16L
-
- /**
- * סדר נזיקין
- */
- public const val BAVLI_NEZIKIN: Long = 17L
-
- /**
- * סדר קדשים
- */
- public const val BAVLI_KODASHIM: Long = 18L
-
- /**
- * סדר טהרות
- */
- public const val BAVLI_TAHAROT: Long = 19L
-
- /**
- * תלמוד ירושלמי
- */
- public const val YERUSHALMI: Long = 20L
-
- /**
- * סדר זרעים
- */
- public const val YERUSHALMI_ZERAIM: Long = 21L
-
- /**
- * סדר מועד
- */
- public const val YERUSHALMI_MOED: Long = 22L
-
- /**
- * סדר נשים
- */
- public const val YERUSHALMI_NASHIM: Long = 23L
-
- /**
- * סדר נזיקין
- */
- public const val YERUSHALMI_NEZIKIN: Long = 24L
-
- /**
- * סדר טהרות
- */
- public const val YERUSHALMI_TAHAROT: Long = 25L
-
- /**
- * משנה תורה
- */
- public const val MISHNE_TORAH: Long = 45L
-
- /**
- * טור
- */
- public const val TUR: Long = 61L
-
- /**
- * שולחן ערוך
- */
- public const val SHULCHAN_ARUCH: Long = 62L
- }
-
- public object Books {
- /**
- * טור
- */
- public const val TUR: Long = 381L
- }
-
- public object TocTexts {
- /**
- * אורח חיים
- */
- public const val ORACH_CHAIM: Long = 3_768L
-
- /**
- * יורה דעה
- */
- public const val YOREH_DEAH: Long = 4_411L
-
- /**
- * אבן העזר
- */
- public const val EVEN_HAEZER: Long = 4_412L
-
- /**
- * חושן משפט
- */
- public const val CHOSHEN_MISHPAT: Long = 4_413L
- }
- }
-
- public object Dropdowns {
- public val HOME: List =
- listOf(
- MultiCategoryDropdownSpec(1L, listOf(2L, 3L, 4L)),
- MultiCategoryDropdownSpec(5L, listOf(6L, 7L, 8L, 9L, 10L, 11L)),
- MultiCategoryDropdownSpec(13L, listOf(14L, 15L, 16L, 17L, 18L, 19L)),
- MultiCategoryDropdownSpec(20L, listOf(21L, 22L, 23L, 24L, 25L)),
- CategoryDropdownSpec(62L),
- TocQuickLinksSpec(381L, listOf(3_768L, 4_411L, 4_412L, 4_413L)),
- )
-
- public val TANAKH: DropdownSpec = MultiCategoryDropdownSpec(1L, listOf(2L, 3L, 4L))
-
- public val TORAH: DropdownSpec = CategoryDropdownSpec(2L)
-
- public val NEVIIM: DropdownSpec = CategoryDropdownSpec(3L)
-
- public val KETUVIM: DropdownSpec = CategoryDropdownSpec(4L)
-
- public val MISHNA: DropdownSpec =
- MultiCategoryDropdownSpec(5L, listOf(6L, 7L, 8L, 9L, 10L, 11L))
-
- public val BAVLI: DropdownSpec =
- MultiCategoryDropdownSpec(13L, listOf(14L, 15L, 16L, 17L, 18L, 19L))
-
- public val YERUSHALMI: DropdownSpec =
- MultiCategoryDropdownSpec(20L, listOf(21L, 22L, 23L, 24L, 25L))
-
- public val SHULCHAN_ARUCH: DropdownSpec = CategoryDropdownSpec(62L)
-
- public val MISHNE_TORAH: DropdownSpec =
- MultiCategoryDropdownSpec(45L, listOf(46L, 47L, 48L, 49L, 50L, 51L, 52L, 53L, 54L, 55L, 59L, 56L, 57L, 58L, 60L))
-
- public val TUR_QUICK_LINKS: DropdownSpec =
- TocQuickLinksSpec(381L, listOf(3_768L, 4_411L, 4_412L, 4_413L))
- }
-}
diff --git a/SeforimApp/src/commonMain/sqldelight/io/github/kdroidfilter/seforimapp/db/UserHighlights.sq b/SeforimApp/src/commonMain/sqldelight/io/github/kdroidfilter/seforimapp/db/UserHighlights.sq
new file mode 100644
index 000000000..7e00b4e94
--- /dev/null
+++ b/SeforimApp/src/commonMain/sqldelight/io/github/kdroidfilter/seforimapp/db/UserHighlights.sq
@@ -0,0 +1,38 @@
+-- Position-based user highlights.
+-- Keyed by (bookId, lineId, offsets): Line ids are stable across DB rebuilds,
+-- so highlights survive books-DB delta updates.
+CREATE TABLE IF NOT EXISTS user_highlights (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ bookId INTEGER NOT NULL,
+ lineId INTEGER NOT NULL,
+ startOffset INTEGER NOT NULL,
+ endOffset INTEGER NOT NULL,
+ colorArgb INTEGER NOT NULL,
+ createdAt INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_highlights_book ON user_highlights(bookId);
+CREATE INDEX IF NOT EXISTS idx_highlights_line ON user_highlights(bookId, lineId);
+
+selectAllForBook:
+SELECT * FROM user_highlights WHERE bookId = ?;
+
+selectForLine:
+SELECT * FROM user_highlights WHERE bookId = ? AND lineId = ?;
+
+insert:
+INSERT INTO user_highlights(bookId, lineId, startOffset, endOffset, colorArgb, createdAt)
+VALUES (?, ?, ?, ?, ?, ?);
+
+lastInsertedId:
+SELECT last_insert_rowid();
+
+deleteOverlapping:
+DELETE FROM user_highlights
+WHERE bookId = ? AND lineId = ? AND startOffset < :endOffset AND endOffset > :startOffset;
+
+deleteById:
+DELETE FROM user_highlights WHERE id = ?;
+
+deleteForBook:
+DELETE FROM user_highlights WHERE bookId = ?;
diff --git a/SeforimApp/src/commonMain/sqldelight/io/github/kdroidfilter/seforimapp/db/UserNotes.sq b/SeforimApp/src/commonMain/sqldelight/io/github/kdroidfilter/seforimapp/db/UserNotes.sq
new file mode 100644
index 000000000..07d982eee
--- /dev/null
+++ b/SeforimApp/src/commonMain/sqldelight/io/github/kdroidfilter/seforimapp/db/UserNotes.sq
@@ -0,0 +1,42 @@
+-- Position-based user notes: several notes per line, each anchored to a character range
+-- (a single word or a whole phrase), keyed by (bookId, lineId, offsets) — same scheme as
+-- user_highlights, so notes survive books-DB delta updates and stay valid across diacritics
+-- display changes.
+-- [quote] stores the anchored passage (the selected text) so the notes pane keeps showing it,
+-- including after the note is saved. Defaulted so the column can be added to pre-existing DBs.
+CREATE TABLE IF NOT EXISTS user_notes (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ bookId INTEGER NOT NULL,
+ lineId INTEGER NOT NULL,
+ startOffset INTEGER NOT NULL,
+ endOffset INTEGER NOT NULL,
+ note TEXT NOT NULL,
+ quote TEXT NOT NULL DEFAULT '',
+ createdAt INTEGER NOT NULL,
+ updatedAt INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_user_notes_book ON user_notes(bookId);
+CREATE INDEX IF NOT EXISTS idx_user_notes_line ON user_notes(bookId, lineId);
+
+selectAllForBook:
+SELECT * FROM user_notes WHERE bookId = ?;
+
+selectForLine:
+SELECT * FROM user_notes WHERE bookId = ? AND lineId = ?;
+
+insert:
+INSERT INTO user_notes(bookId, lineId, startOffset, endOffset, note, quote, createdAt, updatedAt)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?);
+
+lastInsertRowId:
+SELECT last_insert_rowid();
+
+updateNote:
+UPDATE user_notes SET note = ?, updatedAt = ? WHERE id = ?;
+
+deleteById:
+DELETE FROM user_notes WHERE id = ?;
+
+deleteForBook:
+DELETE FROM user_notes WHERE bookId = ?;
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/MainAppState.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/MainAppState.kt
index a592ec41b..3613b582d 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/MainAppState.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/MainAppState.kt
@@ -10,12 +10,12 @@ import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
/**
- * Application-level state holder for theme, onboarding, and update status.
+ * Application-level state holder for theme and onboarding.
* Injected as a singleton via Metro DI.
*/
@Stable
class MainAppState {
- private val _theme = MutableStateFlow(IntUiThemes.System)
+ private val _theme = MutableStateFlow(AppSettings.getThemeMode())
val theme: StateFlow = _theme.asStateFlow()
fun setTheme(theme: IntUiThemes) {
@@ -45,20 +45,4 @@ class MainAppState {
fun setShowOnBoarding(value: Boolean?) {
_showOnboarding.value = value
}
-
- // App update state
- private val _updateAvailable = MutableStateFlow(null)
- val updateAvailable: StateFlow = _updateAvailable.asStateFlow()
-
- private val _updateCheckDone = MutableStateFlow(false)
- val updateCheckDone: StateFlow = _updateCheckDone.asStateFlow()
-
- fun setUpdateAvailable(version: String?) {
- _updateAvailable.value = version
- _updateCheckDone.value = true
- }
-
- fun markUpdateCheckDone() {
- _updateCheckDone.value = true
- }
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/annotations/HighlightSelectionResolver.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/annotations/HighlightSelectionResolver.kt
new file mode 100644
index 000000000..2157c2feb
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/annotations/HighlightSelectionResolver.kt
@@ -0,0 +1,98 @@
+package io.github.kdroidfilter.seforimapp.core.annotations
+
+import io.github.kdroidfilter.seforimapp.core.presentation.text.stripNikudTeamimWithMap
+
+/**
+ * Resolves the character range a highlight should cover, given the selected text and a
+ * line's plain text.
+ *
+ * Offsets are returned in the line's ORIGINAL coordinates (with diacritics), so a stored
+ * highlight stays valid regardless of the current diacritics display setting.
+ *
+ * [linePlainText] MUST be the plain text of the rendered line WITH diacritics (i.e.
+ * `buildAnnotatedFromHtml(line.content, ...).text`) so offsets align with what
+ * [io.github.kdroidfilter.seforimapp.core.presentation.text.applyUserHighlights] applies.
+ *
+ * Returns null when the selection cannot be located within the line (e.g. a multi-line
+ * selection whose text is longer than this line); the caller decides how to degrade.
+ */
+fun resolveHighlightRange(
+ linePlainText: String,
+ selectedText: String,
+ showDiacritics: Boolean,
+): IntRange? {
+ val needle = selectedText.trim()
+ if (needle.isEmpty() || linePlainText.isEmpty()) return null
+
+ if (showDiacritics) {
+ val start = linePlainText.indexOf(needle)
+ if (start < 0) return null
+ return start until (start + needle.length)
+ }
+
+ // Diacritics hidden: the selection is in stripped space (matching the rendered text, which
+ // keeps ׳ ״). Locate it there, then map the bounds back to original coordinates for storage.
+ val (strippedText, strippedToOriginal) = stripNikudTeamimWithMap(linePlainText)
+ val start = strippedText.indexOf(needle)
+ if (start < 0) return null
+ val end = start + needle.length
+ val originalStart = if (start < strippedToOriginal.size) strippedToOriginal[start] else linePlainText.length
+ val originalEnd = if (end < strippedToOriginal.size) strippedToOriginal[end] else linePlainText.length
+ if (originalEnd <= originalStart) return null
+ return originalStart until originalEnd
+}
+
+/** A resolved highlight range for one line, in original (with-diacritics) coordinates. */
+data class LineHighlightRange(
+ val lineId: Long,
+ val range: IntRange,
+)
+
+/**
+ * Resolves the highlight ranges for a (possibly multi-line) selection.
+ *
+ * The platform joins selected lines with '\n', so [selectedText] is split into per-line
+ * segments. [sortedVisibleLines] are all currently materialized lines as
+ * (lineId, plain-text-with-diacritics), ordered by line index. The first segment is anchored
+ * on the visible line that ends with it; each following segment maps to the next consecutive
+ * line. Each (line, segment) pair is then resolved with [resolveHighlightRange], so the first
+ * line keeps its selected suffix, inner lines are full, and the last line keeps its prefix.
+ *
+ * Offsets are returned in original (with-diacritics) coordinates.
+ */
+fun resolveHighlightRangesForSelection(
+ sortedVisibleLines: List>,
+ selectedText: String,
+ showDiacritics: Boolean,
+): List {
+ if (sortedVisibleLines.isEmpty()) return emptyList()
+
+ val segments = selectedText.split('\n').map { it.trim() }.filter { it.isNotEmpty() }
+ if (segments.isEmpty()) return emptyList()
+
+ fun displayed(plain: String): String = if (showDiacritics) plain else stripNikudTeamimWithMap(plain).first
+
+ if (segments.size == 1) {
+ val seg = segments.first()
+ val line = sortedVisibleLines.firstOrNull { displayed(it.second).contains(seg) } ?: return emptyList()
+ val range = resolveHighlightRange(line.second, seg, showDiacritics) ?: return emptyList()
+ return listOf(LineHighlightRange(line.first, range))
+ }
+
+ // Anchor the first segment on the line whose displayed text ends with it (full first line
+ // ends with the whole segment too); fall back to containment.
+ val firstSeg = segments.first()
+ var startIndex = sortedVisibleLines.indexOfFirst { displayed(it.second).trimEnd().endsWith(firstSeg) }
+ if (startIndex < 0) startIndex = sortedVisibleLines.indexOfFirst { displayed(it.second).contains(firstSeg) }
+ if (startIndex < 0) return emptyList()
+
+ val result = mutableListOf()
+ for (offset in segments.indices) {
+ val lineIndex = startIndex + offset
+ if (lineIndex > sortedVisibleLines.lastIndex) break
+ val (lineId, plain) = sortedVisibleLines[lineIndex]
+ val range = resolveHighlightRange(plain, segments[offset], showDiacritics) ?: (0 until plain.length)
+ result += LineHighlightRange(lineId, range)
+ }
+ return result
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/annotations/HighlightStore.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/annotations/HighlightStore.kt
new file mode 100644
index 000000000..83d1d3690
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/annotations/HighlightStore.kt
@@ -0,0 +1,152 @@
+package io.github.kdroidfilter.seforimapp.core.annotations
+
+import androidx.compose.runtime.Stable
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.text.TextRange
+import io.github.kdroidfilter.seforimapp.db.UserSettingsDb
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.withContext
+
+/**
+ * A single position-based user highlight.
+ *
+ * @property id Database row id (0 before persistence).
+ * @property lineId Id of the line carrying this highlight.
+ * @property startOffset Inclusive start offset in the line's plain text.
+ * @property endOffset Exclusive end offset in the line's plain text.
+ * @property color Highlight color.
+ */
+@Stable
+data class UserHighlight(
+ val id: Long,
+ val lineId: Long,
+ val startOffset: Int,
+ val endOffset: Int,
+ val color: Color,
+) {
+ val textRange: TextRange get() = TextRange(startOffset, endOffset)
+}
+
+/** Palette offered to the user. [Transparent] acts as the "clear highlight" action. */
+object HighlightColors {
+ val Yellow = Color(0xFFFFEB3B)
+ val Green = Color(0xFF4CAF50)
+ val Blue = Color(0xFF2196F3)
+ val Pink = Color(0xFFE91E63)
+ val Orange = Color(0xFFFF9800)
+
+ val all = listOf(Yellow, Green, Blue, Pink, Orange)
+ val allWithClear = all + Color.Transparent
+}
+
+/**
+ * Persists position-based highlights in the local user database and exposes them
+ * as a per-book in-memory cache for the render hot path.
+ *
+ * Reads hit SQLite only once per book ([loadBook]); the rendering path reads the
+ * cached [StateFlow] map (O(1) per line). Writes are rare, explicit user actions.
+ */
+class HighlightStore(
+ database: UserSettingsDb,
+) {
+ private val queries = database.userHighlightsQueries
+
+ private val _highlightsByBook = MutableStateFlow>>(emptyMap())
+ val highlightsByBook: StateFlow>> = _highlightsByBook.asStateFlow()
+
+ private val loadedBooks = mutableSetOf()
+
+ /** Loads a book's highlights into the cache once. Subsequent calls are no-ops. */
+ suspend fun loadBook(bookId: Long): Unit =
+ withContext(Dispatchers.IO) {
+ if (bookId in loadedBooks) return@withContext
+ refreshBook(bookId)
+ loadedBooks += bookId
+ }
+
+ /** Highlights of a single line; safe to call from composition (cache lookup). */
+ fun highlightsForLine(
+ bookId: Long,
+ lineId: Long,
+ ): List = _highlightsByBook.value[bookId].orEmpty().filter { it.lineId == lineId }
+
+ /**
+ * Adds a highlight, replacing any existing highlight overlapping the same range
+ * on the same line. No-op for an empty/inverted range.
+ */
+ suspend fun addHighlight(
+ bookId: Long,
+ lineId: Long,
+ startOffset: Int,
+ endOffset: Int,
+ color: Color,
+ timestamp: Long,
+ ): Unit =
+ withContext(Dispatchers.IO) {
+ if (startOffset >= endOffset) return@withContext
+ queries.transaction {
+ queries.deleteOverlapping(
+ bookId = bookId,
+ lineId = lineId,
+ endOffset = endOffset.toLong(),
+ startOffset = startOffset.toLong(),
+ )
+ queries.insert(
+ bookId = bookId,
+ lineId = lineId,
+ startOffset = startOffset.toLong(),
+ endOffset = endOffset.toLong(),
+ colorArgb = color.toArgb().toLong(),
+ createdAt = timestamp,
+ )
+ }
+ refreshBook(bookId)
+ }
+
+ /** Removes a previously persisted highlight. */
+ suspend fun removeHighlight(
+ bookId: Long,
+ highlight: UserHighlight,
+ ): Unit =
+ withContext(Dispatchers.IO) {
+ queries.deleteById(highlight.id)
+ refreshBook(bookId)
+ }
+
+ /** Removes any highlight on [lineId] overlapping the given range (the "clear" action). */
+ suspend fun removeOverlapping(
+ bookId: Long,
+ lineId: Long,
+ startOffset: Int,
+ endOffset: Int,
+ ): Unit =
+ withContext(Dispatchers.IO) {
+ queries.deleteOverlapping(
+ bookId = bookId,
+ lineId = lineId,
+ endOffset = endOffset.toLong(),
+ startOffset = startOffset.toLong(),
+ )
+ refreshBook(bookId)
+ }
+
+ /** Re-reads the book's highlights from SQLite and replaces the cache entry. */
+ private fun refreshBook(bookId: Long) {
+ val list =
+ queries.selectAllForBook(bookId).executeAsList().map { row ->
+ UserHighlight(
+ id = row.id,
+ lineId = row.lineId,
+ startOffset = row.startOffset.toInt(),
+ endOffset = row.endOffset.toInt(),
+ color = Color(row.colorArgb.toInt()),
+ )
+ }
+ _highlightsByBook.update { it + (bookId to list) }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/annotations/NoteStore.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/annotations/NoteStore.kt
new file mode 100644
index 000000000..3cc4ea654
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/annotations/NoteStore.kt
@@ -0,0 +1,136 @@
+package io.github.kdroidfilter.seforimapp.core.annotations
+
+import androidx.compose.runtime.Stable
+import io.github.kdroidfilter.seforimapp.db.UserSettingsDb
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.withContext
+
+/**
+ * A single position-based user note, anchored to a character range on a line. A line may carry
+ * several notes (a word, a phrase…), possibly overlapping.
+ *
+ * @property id Database row id.
+ * @property lineId Id of the annotated line.
+ * @property startOffset Inclusive start offset in the line's plain text.
+ * @property endOffset Exclusive end offset in the line's plain text.
+ * @property note Free-text note body.
+ * @property quote The anchored passage (selected text) shown in the notes pane.
+ */
+@Stable
+data class UserNote(
+ val id: Long,
+ val lineId: Long,
+ val startOffset: Int,
+ val endOffset: Int,
+ val note: String,
+ val quote: String = "",
+)
+
+/**
+ * Persists position-based notes in the local user database and exposes them as a per-book
+ * in-memory cache for the render hot path. Mirrors [HighlightStore]: reads hit SQLite once per
+ * book ([loadBook]); the rendering path reads the cached [StateFlow] map.
+ */
+class NoteStore(
+ database: UserSettingsDb,
+) {
+ private val queries = database.userNotesQueries
+
+ private val _notesByBook = MutableStateFlow>>(emptyMap())
+ val notesByBook: StateFlow>> = _notesByBook.asStateFlow()
+
+ private val loadedBooks = mutableSetOf()
+
+ /** Loads a book's notes into the cache once. Subsequent calls are no-ops. */
+ suspend fun loadBook(bookId: Long): Unit =
+ withContext(Dispatchers.IO) {
+ if (bookId in loadedBooks) return@withContext
+ refreshBook(bookId)
+ loadedBooks += bookId
+ }
+
+ /** Notes of a single line; safe to call from composition (cache lookup). */
+ fun notesForLine(
+ bookId: Long,
+ lineId: Long,
+ ): List = _notesByBook.value[bookId].orEmpty().filter { it.lineId == lineId }
+
+ /**
+ * Adds a note anchored to [startOffset, endOffset) and returns its new row id, or `null` for an
+ * empty/inverted range or a blank body (the insert is then skipped).
+ */
+ suspend fun addNote(
+ bookId: Long,
+ lineId: Long,
+ startOffset: Int,
+ endOffset: Int,
+ note: String,
+ timestamp: Long,
+ quote: String = "",
+ ): Long? =
+ withContext(Dispatchers.IO) {
+ if (startOffset >= endOffset || note.isBlank()) return@withContext null
+ val id =
+ queries.transactionWithResult {
+ queries.insert(
+ bookId = bookId,
+ lineId = lineId,
+ startOffset = startOffset.toLong(),
+ endOffset = endOffset.toLong(),
+ note = note,
+ quote = quote,
+ createdAt = timestamp,
+ updatedAt = timestamp,
+ )
+ queries.lastInsertRowId().executeAsOne()
+ }
+ refreshBook(bookId)
+ id
+ }
+
+ /** Updates a note's text; a blank text deletes it instead. */
+ suspend fun updateNote(
+ bookId: Long,
+ noteId: Long,
+ note: String,
+ timestamp: Long,
+ ): Unit =
+ withContext(Dispatchers.IO) {
+ if (note.isBlank()) {
+ queries.deleteById(noteId)
+ } else {
+ queries.updateNote(note = note, updatedAt = timestamp, id = noteId)
+ }
+ refreshBook(bookId)
+ }
+
+ /** Removes a note. */
+ suspend fun removeNote(
+ bookId: Long,
+ noteId: Long,
+ ): Unit =
+ withContext(Dispatchers.IO) {
+ queries.deleteById(noteId)
+ refreshBook(bookId)
+ }
+
+ /** Re-reads the book's notes from SQLite and replaces the cache entry. */
+ private fun refreshBook(bookId: Long) {
+ val list =
+ queries.selectAllForBook(bookId).executeAsList().map { row ->
+ UserNote(
+ id = row.id,
+ lineId = row.lineId,
+ startOffset = row.startOffset.toInt(),
+ endOffset = row.endOffset.toInt(),
+ note = row.note,
+ quote = row.quote,
+ )
+ }
+ _notesByBook.update { it + (bookId to list) }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/catalog/CatalogAccess.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/catalog/CatalogAccess.kt
new file mode 100644
index 000000000..85fd0a3f3
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/catalog/CatalogAccess.kt
@@ -0,0 +1,175 @@
+package io.github.kdroidfilter.seforimapp.core.catalog
+
+import io.github.kdroidfilter.seforimapp.catalog.BookRef
+import io.github.kdroidfilter.seforimapp.catalog.CatalogPresets
+import io.github.kdroidfilter.seforimlibrary.core.models.CatalogCategory
+import io.github.kdroidfilter.seforimlibrary.core.models.PrecomputedCatalog
+
+/**
+ * Runtime access to per-category titles and book lists, sourced from the lib's
+ * [PrecomputedCatalog] (catalog.pb). Applies the display transformations that
+ * `cataloggen` used to bake into PrecomputedCatalog.kt:
+ * - "תלמוד" prefix on Bavli/Yerushalmi category titles
+ * - "מפרשים" filter inside Mishneh Torah and its direct children
+ * - "הקדמה" / "פרי מגדים" filter inside Shulchan Aruch and its direct children
+ * - ancestor-label prefix stripping on book display titles
+ */
+class CatalogAccess(
+ private val catalogProvider: () -> PrecomputedCatalog?,
+) {
+ private data class Indices(
+ val source: PrecomputedCatalog,
+ val categoryTitles: Map,
+ val bookTitles: Map,
+ val booksByCategory: Map>,
+ )
+
+ @Volatile
+ private var indices: Indices? = null
+
+ private fun resolve(): Indices? {
+ val catalog = catalogProvider() ?: return null
+ val current = indices
+ if (current != null && current.source === catalog) return current
+ val built = build(catalog)
+ indices = built
+ return built
+ }
+
+ fun categoryTitle(id: Long): String? = resolve()?.categoryTitles?.get(id)
+
+ fun bookTitle(id: Long): String? = resolve()?.bookTitles?.get(id)
+
+ fun booksFor(categoryId: Long): List = resolve()?.booksByCategory?.get(categoryId).orEmpty()
+
+ private fun build(catalog: PrecomputedCatalog): Indices {
+ val rawCategoryTitles = LinkedHashMap()
+ val parentIdByCategory = HashMap()
+ val bookTitles = HashMap()
+
+ fun walk(cat: CatalogCategory) {
+ rawCategoryTitles[cat.id] = cat.title
+ parentIdByCategory[cat.id] = cat.parentId
+ cat.books.forEach { bookTitles[it.id] = it.title }
+ cat.subcategories.forEach { walk(it) }
+ }
+ catalog.rootCategories.forEach { walk(it) }
+
+ val categoryTitles = LinkedHashMap(rawCategoryTitles.size)
+ rawCategoryTitles.forEach { (id, title) ->
+ categoryTitles[id] = displayCategoryTitle(id, title, rawCategoryTitles, parentIdByCategory)
+ }
+
+ val booksByCategory = HashMap>()
+ val ancestorTitlesCache = HashMap>()
+
+ fun walkBooks(cat: CatalogCategory) {
+ val excludedPrefixes = excludedBookPrefixesFor(cat.id, parentIdByCategory)
+ val ancestorLabels =
+ ancestorTitlesCache.getOrPut(cat.id) {
+ collectAncestorTitles(cat.id, rawCategoryTitles, parentIdByCategory)
+ }
+ // Strip ancestor labels first, then exclude books whose display title starts with
+ // a forbidden prefix (e.g. שולחן ערוך, הקדמה → הקדמה → filtered).
+ val refs =
+ cat.books.mapNotNull { book ->
+ val display = stripAnyLabelPrefix(ancestorLabels, book.title)
+ val trimmed = display.trimStart()
+ if (excludedPrefixes.any { trimmed.startsWith(it) }) {
+ null
+ } else {
+ BookRef(book.id, display)
+ }
+ }
+ booksByCategory[cat.id] = refs
+ cat.subcategories.forEach { walkBooks(it) }
+ }
+ catalog.rootCategories.forEach { walkBooks(it) }
+
+ return Indices(catalog, categoryTitles, bookTitles, booksByCategory)
+ }
+
+ /**
+ * Returns the book-title prefixes to exclude in the given category context, or empty if none.
+ * Mirrors the legacy display rules previously baked into the codegen:
+ * - Mishneh Torah (root or direct child): drop "מפרשים".
+ * - Shulchan Aruch (root or direct child): drop "הקדמה" and "פרי מגדים".
+ */
+ private fun excludedBookPrefixesFor(
+ categoryId: Long,
+ parents: Map,
+ ): List {
+ val parentId = parents[categoryId]
+ val mishnehTorahId = CatalogPresets.Ids.Categories.MISHNE_TORAH
+ val shulchanAruchId = CatalogPresets.Ids.Categories.SHULCHAN_ARUCH
+ return when {
+ categoryId == mishnehTorahId || parentId == mishnehTorahId -> listOf(MEFARSHIM_PREFIX)
+ categoryId == shulchanAruchId || parentId == shulchanAruchId -> SHULCHAN_ARUCH_EXCLUDED_PREFIXES
+ else -> emptyList()
+ }
+ }
+
+ private fun displayCategoryTitle(
+ id: Long,
+ rawTitle: String,
+ rawTitles: Map,
+ parents: Map,
+ ): String {
+ val needsTalmudPrefix = id == CatalogPresets.Ids.Categories.BAVLI || id == CatalogPresets.Ids.Categories.YERUSHALMI
+ if (!needsTalmudPrefix) return rawTitle
+ val parentTitle = parents[id]?.let { rawTitles[it] }?.takeIf { it.isNotBlank() } ?: TALMUD_FALLBACK
+ return "$parentTitle $rawTitle"
+ }
+
+ private fun collectAncestorTitles(
+ categoryId: Long,
+ titles: Map,
+ parents: Map,
+ ): List {
+ val labels = mutableListOf()
+ var current: Long? = categoryId
+ var guard = 0
+ while (current != null && guard++ < MAX_ANCESTOR_WALK) {
+ titles[current]?.takeIf { it.isNotBlank() }?.let { labels += it }
+ current = parents[current]
+ }
+ return labels.distinct()
+ }
+
+ private fun stripAnyLabelPrefix(
+ labels: List,
+ title: String,
+ ): String {
+ var result = title
+ for (label in labels) result = stripLabelPrefix(label, result)
+ return result
+ }
+
+ private fun stripLabelPrefix(
+ label: String,
+ title: String,
+ ): String {
+ if (label.isBlank()) return title
+ val prefix = Regex.escape(label)
+ val patterns =
+ listOf(
+ Regex("^$prefix\\s*,\\s*"),
+ Regex("^$prefix,\\s*"),
+ Regex("^$prefix\\s*[:–—-]\\s*"),
+ Regex("^$prefix\\s*\\+\\s*"),
+ Regex("^$prefix\\s+"),
+ )
+ for (p in patterns) {
+ val replaced = title.replaceFirst(p, "")
+ if (replaced !== title) return replaced.trimStart()
+ }
+ return title
+ }
+
+ private companion object {
+ const val MEFARSHIM_PREFIX = "מפרשים"
+ const val TALMUD_FALLBACK = "תלמוד"
+ const val MAX_ANCESTOR_WALK = 50
+ val SHULCHAN_ARUCH_EXCLUDED_PREFIXES = listOf("הקדמה", "פרי מגדים")
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/coroutines/EfficiencyCoreDispatcher.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/coroutines/EfficiencyCoreDispatcher.kt
index ec6ab7b14..1f493516a 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/coroutines/EfficiencyCoreDispatcher.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/coroutines/EfficiencyCoreDispatcher.kt
@@ -1,6 +1,6 @@
package io.github.kdroidfilter.seforimapp.core.coroutines
-import io.github.kdroidfilter.nucleus.energymanager.EnergyManager
+import dev.nucleusframework.energymanager.EnergyManager
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.asCoroutineDispatcher
import java.util.concurrent.Executors
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/deeplink/ContentDeepLinkHandler.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/deeplink/ContentDeepLinkHandler.kt
new file mode 100644
index 000000000..1c27f3614
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/deeplink/ContentDeepLinkHandler.kt
@@ -0,0 +1,46 @@
+package io.github.kdroidfilter.seforimapp.core.deeplink
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.rememberUpdatedState
+import io.github.kdroidfilter.seforim.tabs.TabsDestination
+import io.github.kdroidfilter.seforim.tabs.TabsViewModel
+import io.github.kdroidfilter.seforimapp.logger.warnln
+import io.github.kdroidfilter.seforimlibrary.dao.repository.SeforimRepository
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.filterNotNull
+
+/**
+ * Resolves incoming zayit:// content deep links and opens them in a new tab.
+ *
+ * Cross-platform (unlike [AppJumpList], which is Windows-only): the transport — cold-start CLI
+ * arg, single-instance relay, macOS Apple Events — is provided by Nucleus and surfaced through
+ * [pendingDeepLink]. Internal seforim:// jump-list URIs are ignored here and left to [AppJumpList].
+ */
+@Composable
+fun ContentDeepLinkHandler(
+ tabsViewModel: TabsViewModel,
+ repository: SeforimRepository,
+ pendingDeepLink: StateFlow,
+ onClearDeepLink: () -> Unit,
+) {
+ val currentClear by rememberUpdatedState(onClearDeepLink)
+ LaunchedEffect(Unit) {
+ pendingDeepLink.filterNotNull().collect { raw ->
+ val destination = parseZayitDeepLink(raw) ?: return@collect
+ // Guard against dangling references (e.g. a link from a future database version).
+ val resolvable =
+ when (destination) {
+ is TabsDestination.BookContent -> repository.getBookCore(destination.bookId) != null
+ else -> true
+ }
+ if (resolvable) {
+ tabsViewModel.openTab(destination)
+ } else {
+ warnln { "Ignoring deep link to unknown reference: $raw" }
+ }
+ currentClear()
+ }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/deeplink/ZayitDeepLink.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/deeplink/ZayitDeepLink.kt
new file mode 100644
index 000000000..b2f41208a
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/deeplink/ZayitDeepLink.kt
@@ -0,0 +1,79 @@
+package io.github.kdroidfilter.seforimapp.core.deeplink
+
+import io.github.kdroidfilter.seforim.tabs.TabsDestination
+import java.net.URLDecoder
+import java.net.URLEncoder
+import java.nio.charset.StandardCharsets
+import java.util.UUID
+
+/**
+ * Public, shareable deep link scheme for Zayit.
+ *
+ * Links reference the stable book / line database identifiers, so a link resolves to the
+ * same content on any machine running the same database version:
+ *
+ * - zayit://book/ -> open the book
+ * - zayit://book//line/ -> open the book scrolled to a precise line
+ * - zayit://search/ -> open a search
+ */
+const val ZAYIT_SCHEME = "zayit"
+
+private const val PREFIX = "$ZAYIT_SCHEME://"
+private const val HOST_BOOK = "book"
+private const val HOST_SEARCH = "search"
+private const val SEGMENT_LINE = "line"
+
+/** Builds a shareable link to a book, optionally pinned to a precise line. */
+fun bookShareLink(
+ bookId: Long,
+ lineId: Long? = null,
+): String =
+ buildString {
+ append(PREFIX).append(HOST_BOOK).append('/').append(bookId)
+ if (lineId != null && lineId > 0) append('/').append(SEGMENT_LINE).append('/').append(lineId)
+ }
+
+/** Builds a shareable link to a search query. */
+fun searchShareLink(query: String): String = PREFIX + HOST_SEARCH + "/" + URLEncoder.encode(query, StandardCharsets.UTF_8)
+
+/**
+ * Returns a shareable link for this destination, or null when there is nothing worth sharing
+ * (the Home screen, or a book that has not finished loading — bookId not yet assigned).
+ */
+fun TabsDestination.toShareLink(): String? =
+ when (this) {
+ is TabsDestination.BookContent -> if (bookId > 0) bookShareLink(bookId, lineId) else null
+ is TabsDestination.Search -> searchShareLink(searchQuery)
+ is TabsDestination.Home -> null
+ }
+
+/**
+ * Parses a zayit:// deep link into a navigable destination carrying a fresh tabId, or null when
+ * the URI does not match a known content scheme. Resolution against the database (e.g. checking
+ * the book exists) is the caller's responsibility.
+ */
+fun parseZayitDeepLink(uri: String): TabsDestination? {
+ if (!uri.startsWith(PREFIX)) return null
+ val path = uri.removePrefix(PREFIX)
+ val segments = path.split('/').filter { it.isNotEmpty() }
+ if (segments.isEmpty()) return null
+ val newTabId = UUID.randomUUID().toString()
+ return when (segments[0]) {
+ HOST_BOOK -> {
+ val bookId = segments.getOrNull(1)?.toLongOrNull() ?: return null
+ val lineId =
+ if (segments.getOrNull(2) == SEGMENT_LINE) {
+ segments.getOrNull(3)?.toLongOrNull() ?: return null
+ } else {
+ null
+ }
+ TabsDestination.BookContent(bookId = bookId, tabId = newTabId, lineId = lineId)
+ }
+ HOST_SEARCH -> {
+ val encoded = path.substringAfter("$HOST_SEARCH/", "")
+ if (encoded.isEmpty()) return null
+ TabsDestination.Search(searchQuery = URLDecoder.decode(encoded, StandardCharsets.UTF_8), tabId = newTabId)
+ }
+ else -> null
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AccentMarkdownView.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AccentMarkdownView.kt
index 3af174db4..0642f19e9 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AccentMarkdownView.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AccentMarkdownView.kt
@@ -24,6 +24,7 @@ import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.style.TextDecoration
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.UrlOpener
import org.jetbrains.compose.resources.Font
import org.jetbrains.jewel.foundation.ExperimentalJewelApi
import org.jetbrains.jewel.foundation.code.highlighting.NoOpCodeHighlighter
@@ -45,8 +46,6 @@ import org.jetbrains.jewel.ui.component.scrollbarContentSafePadding
import org.jetbrains.jewel.ui.typography
import seforimapp.seforimapp.generated.resources.Res
import seforimapp.seforimapp.generated.resources.notoserifhebrew
-import java.awt.Desktop.getDesktop
-import java.net.URI.create
/**
* Renders a markdown resource file with accent-colored links and the app's Hebrew font.
@@ -157,7 +156,7 @@ fun AccentMarkdownView(
blockRenderer.RenderBlock(
block = block,
enabled = true,
- onUrlClick = { url: String -> getDesktop().browse(create(url)) },
+ onUrlClick = { url: String -> UrlOpener.open(url) },
modifier = Modifier.fillMaxWidth(),
)
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppDockMenu.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppDockMenu.kt
index 4fa78f46d..6fd2d97d6 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppDockMenu.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppDockMenu.kt
@@ -6,9 +6,9 @@ import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import com.kdroid.gematria.converter.toHebrewNumeral
-import io.github.kdroidfilter.nucleus.launcher.macos.DockMenuItem
-import io.github.kdroidfilter.nucleus.launcher.macos.DockMenuListener
-import io.github.kdroidfilter.nucleus.launcher.macos.MacOsDockMenu
+import dev.nucleusframework.launcher.macos.DockMenuItem
+import dev.nucleusframework.launcher.macos.DockMenuListener
+import dev.nucleusframework.launcher.macos.MacOsDockMenu
import io.github.kdroidfilter.seforim.tabs.TabType
import io.github.kdroidfilter.seforim.tabs.TabsEvents
import io.github.kdroidfilter.seforim.tabs.TabsViewModel
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppJumpList.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppJumpList.kt
index e9a361bc8..3bfcc335e 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppJumpList.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppJumpList.kt
@@ -7,9 +7,9 @@ import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.rememberUpdatedState
import com.kdroid.gematria.converter.toHebrewNumeral
-import io.github.kdroidfilter.nucleus.launcher.windows.JumpListCategory
-import io.github.kdroidfilter.nucleus.launcher.windows.JumpListItem
-import io.github.kdroidfilter.nucleus.launcher.windows.WindowsJumpListManager
+import dev.nucleusframework.launcher.windows.JumpListCategory
+import dev.nucleusframework.launcher.windows.JumpListItem
+import dev.nucleusframework.launcher.windows.WindowsJumpListManager
import io.github.kdroidfilter.seforim.tabs.TabType
import io.github.kdroidfilter.seforim.tabs.TabsEvents
import io.github.kdroidfilter.seforim.tabs.TabsViewModel
@@ -58,21 +58,38 @@ fun AppJumpList(
// Re-register handler when nextDesktopName changes so the captured name stays current
LaunchedEffect(nextDesktopName) {
pendingDeepLink.filterNotNull().collect { action ->
- when {
- action.startsWith(SCHEME_TAB) -> {
- val index = action.removePrefix(SCHEME_TAB).toIntOrNull() ?: return@collect
- val tabs = tabsViewModel.state.value.tabs
- if (index in tabs.indices) tabsViewModel.onEvent(TabsEvents.OnSelect(index))
- }
- action.startsWith(SCHEME_DESKTOP) -> {
- val index = action.removePrefix(SCHEME_DESKTOP).toIntOrNull() ?: return@collect
- val desktop = desktopManager.desktops.value.getOrNull(index)
- if (desktop != null) desktopManager.switchTo(desktop.id)
+ // Only handle (and clear) seforim:// jump-list actions. Other schemes — notably
+ // shareable zayit:// content links — belong to ContentDeepLinkHandler; clearing them
+ // here would race that collector and swallow the link (StateFlow is conflated).
+ val handled =
+ when {
+ action.startsWith(SCHEME_TAB) -> {
+ val index = action.removePrefix(SCHEME_TAB).toIntOrNull()
+ if (index != null) {
+ val tabs = tabsViewModel.state.value.tabs
+ if (index in tabs.indices) tabsViewModel.onEvent(TabsEvents.OnSelect(index))
+ }
+ true
+ }
+ action.startsWith(SCHEME_DESKTOP) -> {
+ val index = action.removePrefix(SCHEME_DESKTOP).toIntOrNull()
+ if (index != null) {
+ val desktop = desktopManager.desktops.value.getOrNull(index)
+ if (desktop != null) desktopManager.switchTo(desktop.id)
+ }
+ true
+ }
+ action == SCHEME_NEW_TAB -> {
+ tabsViewModel.onEvent(TabsEvents.OnAdd)
+ true
+ }
+ action == SCHEME_NEW_DESKTOP -> {
+ desktopManager.createDesktop(nextDesktopName)
+ true
+ }
+ else -> false
}
- action == SCHEME_NEW_TAB -> tabsViewModel.onEvent(TabsEvents.OnAdd)
- action == SCHEME_NEW_DESKTOP -> desktopManager.createDesktop(nextDesktopName)
- }
- currentClearDeepLink()
+ if (handled) currentClearDeepLink()
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppLinuxQuicklist.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppLinuxQuicklist.kt
index a6e67e08a..51dd610c5 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppLinuxQuicklist.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppLinuxQuicklist.kt
@@ -7,10 +7,10 @@ import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import com.kdroid.gematria.converter.toHebrewNumeral
-import io.github.kdroidfilter.nucleus.launcher.linux.DbusmenuItem
-import io.github.kdroidfilter.nucleus.launcher.linux.LauncherProperties
-import io.github.kdroidfilter.nucleus.launcher.linux.LinuxLauncherEntry
-import io.github.kdroidfilter.nucleus.launcher.linux.LinuxQuicklist
+import dev.nucleusframework.launcher.linux.DbusmenuItem
+import dev.nucleusframework.launcher.linux.LauncherProperties
+import dev.nucleusframework.launcher.linux.LinuxLauncherEntry
+import dev.nucleusframework.launcher.linux.LinuxQuicklist
import io.github.kdroidfilter.seforim.tabs.TabType
import io.github.kdroidfilter.seforim.tabs.TabsEvents
import io.github.kdroidfilter.seforim.tabs.TabsViewModel
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppNativeMenuBar.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppNativeMenuBar.kt
index 98990a519..6c593a29a 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppNativeMenuBar.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/AppNativeMenuBar.kt
@@ -3,12 +3,12 @@ package io.github.kdroidfilter.seforimapp.core.presentation.components
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
-import io.github.kdroidfilter.nucleus.menu.macos.NativeKeyShortcut
-import io.github.kdroidfilter.nucleus.menu.macos.NativeMenuBar
-import io.github.kdroidfilter.nucleus.menu.macos.NsMenuItemImage
-import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolGeneral
-import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolStatus
-import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolTextFormatting
+import dev.nucleusframework.menu.macos.NativeKeyShortcut
+import dev.nucleusframework.menu.macos.NativeMenuBar
+import dev.nucleusframework.menu.macos.NsMenuItemImage
+import dev.nucleusframework.sfsymbols.SFSymbolGeneral
+import dev.nucleusframework.sfsymbols.SFSymbolStatus
+import dev.nucleusframework.sfsymbols.SFSymbolTextFormatting
import io.github.kdroidfilter.seforim.tabs.TabsDestination
import io.github.kdroidfilter.seforim.tabs.TabsEvents
import io.github.kdroidfilter.seforim.tabs.TabsViewModel
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/CatalogDropdown.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/CatalogDropdown.kt
index f85466a1a..93a8c88e7 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/CatalogDropdown.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/CatalogDropdown.kt
@@ -20,10 +20,10 @@ import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
+import io.github.kdroidfilter.seforimapp.catalog.CatalogPresets
import io.github.kdroidfilter.seforimapp.catalog.CategoryDropdownSpec
import io.github.kdroidfilter.seforimapp.catalog.DropdownSpec
import io.github.kdroidfilter.seforimapp.catalog.MultiCategoryDropdownSpec
-import io.github.kdroidfilter.seforimapp.catalog.PrecomputedCatalog
import io.github.kdroidfilter.seforimapp.catalog.TocQuickLinksSpec
import io.github.kdroidfilter.seforimapp.core.coroutines.runSuspendCatching
import io.github.kdroidfilter.seforimapp.features.bookcontent.BookContentEvent
@@ -48,6 +48,7 @@ fun CatalogDropdown(
maxPopupHeight: Dp? = null,
) {
val repo = LocalAppGraph.current.repository
+ val catalogAccess = LocalAppGraph.current.catalogAccess
val scope = rememberCoroutineScope()
fun selectBook(
@@ -63,22 +64,26 @@ fun CatalogDropdown(
when (spec) {
is CategoryDropdownSpec -> {
val categoryId = spec.categoryId
- val categoryTitle = remember(categoryId) { PrecomputedCatalog.CATEGORY_TITLES[categoryId] }
- val precomputedBooks = remember(categoryId) { PrecomputedCatalog.CATEGORY_BOOKS[categoryId] }
+ val categoryTitle = remember(categoryId, catalogAccess) { catalogAccess.categoryTitle(categoryId) }
+ val precomputedBooks = remember(categoryId, catalogAccess) { catalogAccess.booksFor(categoryId) }
- if (categoryTitle != null && !precomputedBooks.isNullOrEmpty()) {
+ if (categoryTitle != null && precomputedBooks.isNotEmpty()) {
val baseMax: Dp = 360.dp
val minHeight: Dp =
minPopupHeight ?: when (categoryId) {
- PrecomputedCatalog.Ids.Categories.TORAH -> 160.dp
- PrecomputedCatalog.Ids.Categories.SHULCHAN_ARUCH -> 120.dp
+ CatalogPresets.Ids.Categories.TORAH -> 160.dp
else -> Dp.Unspecified
}
val desiredMax: Dp = maxPopupHeight ?: baseMax
val effectiveMax: Dp = if (minHeight != Dp.Unspecified && minHeight > desiredMax) minHeight else desiredMax
+ val popupWidth =
+ popupWidthMultiplier ?: when (categoryId) {
+ CatalogPresets.Ids.Categories.SHULCHAN_ARUCH -> 1.1f
+ else -> 1.5f
+ }
DropdownButton(
- modifier = modifier.widthIn(max = 280.dp),
- popupWidthMultiplier = popupWidthMultiplier ?: 1.5f,
+ modifier = modifier,
+ popupWidthMultiplier = popupWidth,
maxPopupHeight = effectiveMax,
minPopupHeight = minHeight,
content = { Text(text = categoryTitle) },
@@ -124,20 +129,23 @@ fun CatalogDropdown(
}
}
is MultiCategoryDropdownSpec -> {
- val labelTitle = remember(spec.labelCategoryId) { PrecomputedCatalog.CATEGORY_TITLES[spec.labelCategoryId] }
+ val labelTitle =
+ remember(spec.labelCategoryId, catalogAccess) {
+ catalogAccess.categoryTitle(spec.labelCategoryId)
+ }
val sections =
- remember(spec.bookCategoryIds) {
+ remember(spec.bookCategoryIds, catalogAccess) {
spec.bookCategoryIds.mapNotNull { cid ->
- val t = PrecomputedCatalog.CATEGORY_TITLES[cid]
- val list = PrecomputedCatalog.CATEGORY_BOOKS[cid]
- if (t != null && !list.isNullOrEmpty()) t to list else null
+ val t = catalogAccess.categoryTitle(cid) ?: return@mapNotNull null
+ val list = catalogAccess.booksFor(cid)
+ if (list.isNotEmpty()) t to list else null
}
}
if (labelTitle != null && sections.any { it.second.isNotEmpty() }) {
val popupWidth =
popupWidthMultiplier ?: when (spec.labelCategoryId) {
- PrecomputedCatalog.Ids.Categories.BAVLI,
- PrecomputedCatalog.Ids.Categories.YERUSHALMI,
+ CatalogPresets.Ids.Categories.BAVLI,
+ CatalogPresets.Ids.Categories.YERUSHALMI,
-> 1.1f
else -> 1.5f
}
@@ -146,7 +154,7 @@ fun CatalogDropdown(
val desiredMax: Dp = maxPopupHeight ?: baseMax
val effectiveMax: Dp = if (minHeight != Dp.Unspecified && minHeight > desiredMax) minHeight else desiredMax
DropdownButton(
- modifier = modifier.widthIn(max = 280.dp),
+ modifier = modifier,
popupWidthMultiplier = popupWidth,
maxPopupHeight = effectiveMax,
minPopupHeight = minHeight,
@@ -209,9 +217,9 @@ fun CatalogDropdown(
}
}
is TocQuickLinksSpec -> {
- TocJumpDropdownByIds(
+ TocJumpDropdownForBook(
bookId = spec.bookId,
- tocTextIds = spec.tocTextIds.toImmutableList(),
+ links = spec.links.toImmutableList(),
onEvent = onEvent,
modifier = modifier,
popupWidthMultiplier = popupWidthMultiplier ?: 1.5f,
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/InstallerWindow.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/InstallerWindow.kt
new file mode 100644
index 000000000..8f53c52b8
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/InstallerWindow.kt
@@ -0,0 +1,160 @@
+package io.github.kdroidfilter.seforimapp.core.presentation.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.rememberNavController
+import dev.nucleusframework.application.NucleusApplicationScope
+import dev.nucleusframework.taskbarprogress.tao.hideTaskbarProgress
+import dev.nucleusframework.taskbarprogress.tao.showTaskbarProgress
+import dev.nucleusframework.window.BasicTitleBar
+import dev.nucleusframework.window.ControlButtonsDirection
+import dev.nucleusframework.window.TitleBarLayoutPolicy
+import dev.nucleusframework.window.jewel.JewelDecoratedWindow
+import dev.nucleusframework.window.newFullscreenControls
+import dev.nucleusframework.window.styling.LocalTitleBarStyle
+import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.getCenteredWindowState
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.rememberWindowViewModelStoreOwner
+import io.github.kdroidfilter.seforimapp.framework.platform.PlatformInfo
+import kotlinx.coroutines.flow.StateFlow
+import org.jetbrains.compose.resources.painterResource
+import org.jetbrains.compose.resources.stringResource
+import org.jetbrains.jewel.foundation.modifier.trackActivation
+import org.jetbrains.jewel.foundation.theme.JewelTheme
+import org.jetbrains.jewel.foundation.theme.LocalContentColor
+import org.jetbrains.jewel.ui.component.Icon
+import org.jetbrains.jewel.ui.component.IconButton
+import org.jetbrains.jewel.ui.component.Text
+import org.jetbrains.jewel.ui.icons.AllIconsKeys
+import seforimapp.seforimapp.generated.resources.AppIcon
+import seforimapp.seforimapp.generated.resources.Res
+import seforimapp.seforimapp.generated.resources.app_name
+
+/**
+ * Fixed-size decorated window shared by the onboarding and database-update flows.
+ * Provides the window-scoped [androidx.lifecycle.ViewModelStoreOwner], a title bar with
+ * a contextual icon/label and an automatic back button, and a NavHost-ready content area.
+ *
+ * The OS taskbar/dock progress indicator is kept in sync with [progress]: it mirrors
+ * the value while in `(0f, 1f]` and is cleared at 0 and on window disposal.
+ *
+ * @param titleBarIcon icon shown next to the title bar label
+ * @param titleBarText title bar label
+ * @param progress installation progress in `[0f, 1f]`, mirrored to the taskbar
+ * @param content receives the [NavHostController] backing the window's navigation graph
+ */
+@Composable
+fun NucleusApplicationScope.InstallerWindow(
+ titleBarIcon: ImageVector,
+ titleBarText: String,
+ progress: StateFlow,
+ content: @Composable (navController: NavHostController) -> Unit,
+) {
+ val windowState = remember { getCenteredWindowState(720, 420) }
+ JewelDecoratedWindow(
+ onCloseRequest = { exitApplication() },
+ title = stringResource(Res.string.app_name),
+ icon = if (PlatformInfo.isMacOS) null else painterResource(Res.drawable.AppIcon),
+ state = windowState,
+ visible = true,
+ resizable = false,
+ ) {
+ // Mirror the in-app progress bar onto the OS taskbar/dock indicator.
+ val taskbarWindow = nucleusWindow
+ val taskbarProgress by progress.collectAsState()
+ LaunchedEffect(taskbarWindow, taskbarProgress) {
+ if (taskbarProgress > 0f) {
+ taskbarWindow.showTaskbarProgress(taskbarProgress.toDouble())
+ } else {
+ taskbarWindow.hideTaskbarProgress()
+ }
+ }
+ DisposableEffect(taskbarWindow) {
+ onDispose { taskbarWindow.hideTaskbarProgress() }
+ }
+
+ val windowViewModelOwner = rememberWindowViewModelStoreOwner()
+ CompositionLocalProvider(
+ LocalWindowViewModelStoreOwner provides windowViewModelOwner,
+ LocalViewModelStoreOwner provides windowViewModelOwner,
+ ) {
+ val navController = rememberNavController()
+ var canNavigateBack by remember { mutableStateOf(false) }
+ LaunchedEffect(navController) {
+ navController.currentBackStackEntryFlow.collect {
+ canNavigateBack = navController.previousBackStackEntry != null
+ }
+ }
+
+ val titleBarStyle = LocalTitleBarStyle.current
+ BasicTitleBar(
+ modifier = Modifier.newFullscreenControls(),
+ gradientStartColor = ThemeUtils.titleBarGradientColor(),
+ style = titleBarStyle,
+ controlButtonsDirection = ControlButtonsDirection.SystemNative,
+ layoutPolicy = TitleBarLayoutPolicy.Default,
+ ) {
+ CompositionLocalProvider(LocalContentColor provides titleBarStyle.colors.content) {
+ if (canNavigateBack) {
+ IconButton(
+ modifier =
+ Modifier
+ .align(Alignment.Start)
+ .padding(start = 8.dp)
+ .size(24.dp),
+ onClick = { navController.navigateUp() },
+ ) {
+ Icon(AllIconsKeys.Actions.Back, null, modifier = Modifier.rotate(180f))
+ }
+ }
+ Row(
+ modifier = Modifier.align(Alignment.CenterHorizontally),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.Center,
+ ) {
+ Icon(
+ titleBarIcon,
+ contentDescription = null,
+ tint = JewelTheme.globalColors.text.normal,
+ modifier = Modifier.size(16.dp),
+ )
+ Spacer(Modifier.size(8.dp))
+ Text(titleBarText)
+ }
+ }
+ }
+ Column(
+ modifier =
+ Modifier
+ .trackActivation()
+ .fillMaxSize()
+ .background(JewelTheme.globalColors.panelBackground),
+ ) {
+ content(navController)
+ }
+ }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/MainTitleBar.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/MainTitleBar.kt
index db77e6d7b..4630ac762 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/MainTitleBar.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/MainTitleBar.kt
@@ -5,21 +5,24 @@ import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.width
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
-import io.github.kdroidfilter.nucleus.window.ControlButtonsDirection
-import io.github.kdroidfilter.nucleus.window.DecoratedWindowScope
-import io.github.kdroidfilter.nucleus.window.jewel.JewelTitleBar
-import io.github.kdroidfilter.nucleus.window.macOSLargeCornerRadius
-import io.github.kdroidfilter.nucleus.window.newFullscreenControls
-import io.github.kdroidfilter.nucleus.window.styling.LocalTitleBarStyle
-import io.github.kdroidfilter.platformtools.OperatingSystem
+import dev.nucleusframework.core.runtime.Platform
+import dev.nucleusframework.window.ControlButtonsDirection
+import dev.nucleusframework.window.DecoratedWindowScope
+import dev.nucleusframework.window.jewel.JewelTitleBar
+import dev.nucleusframework.window.macOSLargeCornerRadius
+import dev.nucleusframework.window.newFullscreenControls
+import dev.nucleusframework.window.styling.LocalTitleBarStyle
import io.github.kdroidfilter.seforimapp.core.presentation.tabs.TabsView
import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
+import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import io.github.kdroidfilter.seforimapp.framework.platform.PlatformInfo
+import io.github.kdroidfilter.seforimapp.framework.update.showTitleBarIcon
@Composable
fun DecoratedWindowScope.MainTitleBar() {
@@ -34,19 +37,25 @@ fun DecoratedWindowScope.MainTitleBar() {
val windowControlButtonWidth = LocalTitleBarStyle.current.metrics.titlePaneButtonSize.width
val windowControlCount =
when (PlatformInfo.currentOS) {
- OperatingSystem.MACOS -> 0 // native traffic lights, not in Compose layout
+ Platform.MacOS -> 0 // native traffic lights, not in Compose layout
else -> 3 // close + maximize/restore + minimize
}
+ // The update badge is an extra action button shown only for PROMPT updates; it must be
+ // counted so the reserved icons-area width (and thus tabsAreaWidth) stays correct.
+ val updateIconVisible =
+ LocalAppGraph.current.appUpdateService.state
+ .collectAsState()
+ .value.showTitleBarIcon
BoxWithConstraints(modifier = Modifier.align(Alignment.Start)) {
val windowWidth = maxWidth
- val actionButtonCount = if (PlatformInfo.isMacOS) 2 else 4
+ val actionButtonCount = (if (PlatformInfo.isMacOS) 2 else 4) + if (updateIconVisible) 1 else 0
val iconWidth: Dp = 40.dp
val desktopSwitcherWidth: Dp = DESKTOP_SWITCHER_WIDTH
val actionButtonsWidth = iconWidth * actionButtonCount + desktopSwitcherWidth
val iconsAreaWidth: Dp =
when (PlatformInfo.currentOS) {
- OperatingSystem.MACOS -> actionButtonsWidth + iconWidth * 2 // traffic lights space
- OperatingSystem.WINDOWS -> actionButtonsWidth + iconWidth * 3.5f // window controls
+ Platform.MacOS -> actionButtonsWidth + iconWidth * 2 // traffic lights space
+ Platform.Windows -> actionButtonsWidth + iconWidth * 3.5f // window controls
else -> actionButtonsWidth + windowControlButtonWidth * windowControlCount
}
val tabsAreaWidth: Dp = (windowWidth - iconsAreaWidth).coerceAtLeast(0.dp)
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/ProgressBarController.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/ProgressBarController.kt
new file mode 100644
index 000000000..eb4ef08de
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/ProgressBarController.kt
@@ -0,0 +1,27 @@
+package io.github.kdroidfilter.seforimapp.core.presentation.components
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Reactive holder for the [0f, 1f] progress shown by the installer/update windows.
+ * Subclassed by the per-flow singletons so each window keeps its own progress while
+ * sharing the underlying state plumbing.
+ */
+open class ProgressBarController {
+ private val _progress = MutableStateFlow(0f)
+ val progress: StateFlow = _progress.asStateFlow()
+
+ fun setProgress(progress: Float) {
+ _progress.value = progress.coerceIn(0f, 1f)
+ }
+
+ fun resetProgress() {
+ _progress.value = 0f
+ }
+
+ fun improveBy(value: Float) {
+ _progress.value = (_progress.value + value).coerceIn(0f, 1f)
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TextWithLink.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TextWithLink.kt
index fe74b3e52..f09c89aca 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TextWithLink.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TextWithLink.kt
@@ -6,9 +6,8 @@ import androidx.compose.ui.Modifier
import androidx.compose.ui.input.pointer.PointerIcon
import androidx.compose.ui.input.pointer.pointerHoverIcon
import androidx.compose.ui.text.style.TextDecoration
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.UrlOpener
import org.jetbrains.jewel.ui.component.Text
-import java.awt.Desktop
-import java.net.URI.create
@Composable
fun TextWithLink(
@@ -20,7 +19,7 @@ fun TextWithLink(
textDecoration = TextDecoration.Underline,
modifier =
Modifier.pointerHoverIcon(PointerIcon.Hand).clickable {
- Desktop.getDesktop().browse(create(link))
+ UrlOpener.open(link)
},
)
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TitleBarActionsButtonsView.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TitleBarActionsButtonsView.kt
index 0fad2c966..9ed0d2f1f 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TitleBarActionsButtonsView.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TitleBarActionsButtonsView.kt
@@ -8,21 +8,35 @@ import io.github.kdroidfilter.seforim.tabs.TabsViewModel
import io.github.kdroidfilter.seforimapp.core.presentation.theme.IntUiThemes
import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
-import io.github.kdroidfilter.seforimapp.features.settings.SettingsWindow
import io.github.kdroidfilter.seforimapp.features.settings.SettingsWindowEvents
import io.github.kdroidfilter.seforimapp.features.settings.SettingsWindowViewModel
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import io.github.kdroidfilter.seforimapp.framework.platform.PlatformInfo
+import io.github.kdroidfilter.seforimapp.framework.update.showTitleBarIcon
import org.jetbrains.compose.resources.stringResource
+import org.jetbrains.jewel.ui.icon.PathIconKey
import org.jetbrains.jewel.ui.icons.AllIconsKeys
import seforimapp.seforimapp.generated.resources.*
+// AllIconsKeys.MeetNewUi.SystemTheme was removed in Jewel 0.37 and the SVG
+// dropped from IntelliJ Platform icons 262, so the asset is shipped locally.
+private object SystemThemeIconAnchor
+
+private val SystemTheme = PathIconKey("icons/system_theme.svg", SystemThemeIconAnchor::class.java)
+
@Composable
fun TitleBarActionsButtonsView() {
val appGraph = LocalAppGraph.current
val mainAppState = appGraph.mainAppState
val theme = mainAppState.theme.collectAsState().value
+ // Update badge: shown only for PROMPT updates (MINOR/MAJOR any OS, or Linux PATCH).
+ // Silent Win/Mac PATCH updates apply on close and never surface here.
+ val updateState =
+ appGraph.appUpdateService.state
+ .collectAsState()
+ .value
+
// Use ViewModel-driven settings window visibility to respect MVVM conventions
val settingsViewModel: SettingsWindowViewModel =
metroViewModel(viewModelStoreOwner = LocalWindowViewModelStoreOwner.current)
@@ -80,6 +94,15 @@ fun TitleBarActionsButtonsView() {
stringResource(Res.string.shortcut_settings_windows)
}
+ if (updateState.showTitleBarIcon) {
+ TitleBarActionButton(
+ key = AllIconsKeys.Ide.Notification.IdeUpdate,
+ contentDescription = stringResource(Res.string.update_titlebar_tooltip),
+ onClick = { appGraph.appUpdateService.openDialog() },
+ tooltipText = stringResource(Res.string.update_titlebar_tooltip),
+ )
+ }
+
TitleBarActionButton(
key = AllIconsKeys.Nodes.HomeFolder,
contentDescription = stringResource(Res.string.home),
@@ -129,7 +152,7 @@ fun TitleBarActionsButtonsView() {
when (theme) {
IntUiThemes.Light -> AllIconsKeys.MeetNewUi.LightTheme
IntUiThemes.Dark -> AllIconsKeys.MeetNewUi.DarkTheme
- IntUiThemes.System -> AllIconsKeys.MeetNewUi.SystemTheme
+ IntUiThemes.System -> SystemTheme
},
contentDescription = iconDescription,
onClick = {
@@ -154,10 +177,6 @@ fun TitleBarActionsButtonsView() {
)
}
- if (settingsState.isVisible) {
- SettingsWindow(
- onClose = { settingsViewModel.onEvent(SettingsWindowEvents.OnClose) },
- initialDestination = settingsState.initialDestination,
- )
- }
+ // SettingsWindow is hoisted to main.kt where NucleusApplicationScope is available
+ // (JewelDecoratedDialog is an extension on NucleusApplicationScope in Nucleus 2.0).
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TocJumpDropdown.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TocJumpDropdown.kt
index 633c94af4..8fc0ff6cd 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TocJumpDropdown.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/components/TocJumpDropdown.kt
@@ -21,14 +21,15 @@ import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
-import io.github.kdroidfilter.seforimapp.catalog.PrecomputedCatalog
import io.github.kdroidfilter.seforimapp.core.coroutines.runSuspendCatching
import io.github.kdroidfilter.seforimapp.features.bookcontent.BookContentEvent
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import kotlinx.collections.immutable.ImmutableList
import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
import org.jetbrains.jewel.foundation.theme.JewelTheme
import org.jetbrains.jewel.ui.component.Text
+import io.github.kdroidfilter.seforimapp.catalog.TocQuickLink as PresetTocQuickLink
/** Quick TOC jump menu for a specific book. */
data class TocQuickLink(
@@ -114,58 +115,27 @@ fun TocJumpDropdown(
}
@Composable
-fun TocJumpDropdownByIds(
- title: String,
+fun TocJumpDropdownForBook(
bookId: Long,
- tocTextIds: ImmutableList,
+ links: ImmutableList,
onEvent: (BookContentEvent) -> Unit,
modifier: Modifier = Modifier,
popupWidthMultiplier: Float = 1.5f,
minPopupHeight: Dp = Dp.Unspecified,
maxPopupHeight: Dp = 360.dp,
) {
- val loader: suspend () -> List = {
- val bookMap = PrecomputedCatalog.TOC_BY_TOC_TEXT_ID[bookId].orEmpty()
- tocTextIds.mapNotNull { tx ->
- val ql = bookMap[tx] ?: return@mapNotNull null
- TocQuickLink(ql.label, ql.tocEntryId, ql.firstLineId)
- }
- }
+ val catalogAccess = LocalAppGraph.current.catalogAccess
+ val title = catalogAccess.bookTitle(bookId) ?: return
+ val items = links.map { TocQuickLink(it.label, it.tocEntryId, it.firstLineId) }.toImmutableList()
TocJumpDropdown(
title = title,
bookId = bookId,
onEvent = onEvent,
modifier = modifier,
- items = persistentListOf(),
+ items = items,
popupWidthMultiplier = popupWidthMultiplier,
minPopupHeight = minPopupHeight,
maxPopupHeight = maxPopupHeight,
- prepareItems = loader,
)
}
-
-@Composable
-fun TocJumpDropdownByIds(
- bookId: Long,
- tocTextIds: ImmutableList,
- onEvent: (BookContentEvent) -> Unit,
- modifier: Modifier = Modifier,
- popupWidthMultiplier: Float = 1.5f,
- minPopupHeight: Dp = Dp.Unspecified,
- maxPopupHeight: Dp = 360.dp,
-) {
- val t = PrecomputedCatalog.BOOK_TITLES[bookId]
- if (t != null) {
- TocJumpDropdownByIds(
- title = t,
- bookId = bookId,
- tocTextIds = tocTextIds,
- onEvent = onEvent,
- modifier = modifier,
- popupWidthMultiplier = popupWidthMultiplier,
- minPopupHeight = minPopupHeight,
- maxPopupHeight = maxPopupHeight,
- )
- }
-}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/navigation/NoAnimatedComposable.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/navigation/NoAnimatedComposable.kt
new file mode 100644
index 000000000..b7462cd4a
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/navigation/NoAnimatedComposable.kt
@@ -0,0 +1,22 @@
+package io.github.kdroidfilter.seforimapp.core.presentation.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.compose.composable
+import io.github.kdroidfilter.seforim.navigation.NavigationAnimations
+
+/**
+ * Registers a type-safe destination with all navigation animations disabled.
+ * Shared by the onboarding and database-update navigation graphs.
+ */
+inline fun NavGraphBuilder.noAnimatedComposable(noinline content: @Composable (NavBackStackEntry) -> Unit) {
+ composable(
+ enterTransition = { NavigationAnimations.enterTransition(this) },
+ exitTransition = { NavigationAnimations.exitTransition(this) },
+ popEnterTransition = { NavigationAnimations.popEnterTransition(this) },
+ popExitTransition = { NavigationAnimations.popExitTransition(this) },
+ ) {
+ content(it)
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/tabs/TabsContent.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/tabs/TabsContent.kt
index 479791c73..51b5ecb4b 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/tabs/TabsContent.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/tabs/TabsContent.kt
@@ -9,14 +9,14 @@ import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.compositionLocalOf
-import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.saveable.rememberSaveableStateHolder
import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.zIndex
+import androidx.compose.ui.layout.layout
import androidx.lifecycle.DEFAULT_ARGS_KEY
import androidx.lifecycle.HasDefaultViewModelProviderFactory
import androidx.lifecycle.Lifecycle
@@ -60,9 +60,29 @@ import org.jetbrains.jewel.foundation.theme.JewelTheme
*/
val LocalTabSelected = compositionLocalOf { true }
+/**
+ * Stable, rename-safe discriminator for a destination, used to key the per-tab
+ * saveable UI state so it resets when a tab navigates to a different destination type.
+ */
+private fun TabsDestination.typeKey(): String =
+ when (this) {
+ is TabsDestination.Home -> "home"
+ is TabsDestination.Search -> "search"
+ is TabsDestination.BookContent -> "book"
+ }
+
+private fun saveableKeyFor(destination: TabsDestination): String = "${destination.tabId}:${destination.typeKey()}"
+
+private fun saveableKeysFor(tabId: String): List = listOf("$tabId:home", "$tabId:search", "$tabId:book")
+
/**
* Simplified tab content renderer without Compose Navigation.
- * Each tab renders its content directly based on destination type.
+ *
+ * Every open tab is composed and kept alive; switching never tears a tab down. Only the selected
+ * tab is measured and placed, so hidden tabs incur no layout/draw cost while their ViewModel,
+ * paging flow and scroll state stay hot. This is what makes switching instant and glitch-free:
+ * the paged content list is never re-collected from empty, so there is no reload-and-jump and no
+ * need for any alpha/crossfade masking. The cost is RAM proportional to the number of open tabs.
*/
@Composable
fun TabsContent() {
@@ -81,15 +101,8 @@ fun TabsContent() {
val searchUi by remember(searchHomeViewModel) { searchHomeViewModel.uiState }.collectAsState()
val scope = rememberCoroutineScope()
- // Helper to get current tab ID
- val currentTabId by remember {
- derivedStateOf {
- tabsState.tabs
- .getOrNull(tabsState.selectedTabIndex)
- ?.destination
- ?.tabId
- }
- }
+ val currentTabId = tabs.getOrNull(selectedTabIndex)?.destination?.tabId
+ val latestCurrentTabId by rememberUpdatedState(currentTabId)
fun launchSubmitSearch(
@StructuredScope scope: CoroutineScope,
@@ -114,11 +127,11 @@ fun TabsContent() {
onFilterChange = searchHomeViewModel::onFilterChange,
onGlobalExtendedChange = searchHomeViewModel::onGlobalExtendedChange,
onSubmitTextSearch = { query ->
- val tabId = currentTabId ?: return@HomeSearchCallbacks
+ val tabId = latestCurrentTabId ?: return@HomeSearchCallbacks
launchSubmitSearch(scope, query, tabId)
},
onOpenReference = {
- val tabId = currentTabId ?: return@HomeSearchCallbacks
+ val tabId = latestCurrentTabId ?: return@HomeSearchCallbacks
launchOpenReference(scope, tabId)
},
onPickCategory = searchHomeViewModel::onPickCategory,
@@ -161,17 +174,24 @@ fun TabsContent() {
}
}
- // ViewModel owners per tab - manages lifecycle and state
+ // ViewModel owners per tab - manages lifecycle and state. Owners survive while the
+ // tab is open so re-selecting a tab needs no DB refetch (data is hot in the ViewModel).
val tabOwners = remember { mutableMapOf() }
+ val knownTabIds = remember { mutableSetOf() }
+ // Holds per-tab saveable UI state across the teardown/rebuild that happens on switch.
+ val saveableStateHolder = rememberSaveableStateHolder()
// Cleanup removed tabs
LaunchedEffect(tabs) {
val activeTabIds = tabs.map { it.destination.tabId }.toSet()
- val removed = tabOwners.keys.toSet() - activeTabIds
+ val removed = (knownTabIds + tabOwners.keys) - activeTabIds
removed.forEach { tabId ->
tabOwners.remove(tabId)?.clear()
persistedStore.remove(tabId)
+ saveableKeysFor(tabId).forEach(saveableStateHolder::removeState)
}
+ knownTabIds.clear()
+ knownTabIds.addAll(activeTabIds)
}
DisposableEffect(Unit) {
@@ -190,7 +210,6 @@ fun TabsContent() {
}
}
- // Render all tabs with visibility control
val isIslands = ThemeUtils.isIslandsStyle()
val canvasBg =
if (isIslands) {
@@ -206,50 +225,68 @@ fun TabsContent() {
.fillMaxSize()
.background(canvasBg),
) {
- tabs.forEachIndexed { index, tabItem ->
- key(tabItem.id) {
- val isSelected = index == selectedTabIndex
- val tabId = tabItem.destination.tabId
-
- Box(
- modifier =
- Modifier
- .fillMaxSize()
- .graphicsLayer { alpha = if (isSelected) 1f else 0f }
- .zIndex(if (isSelected) 1f else 0f),
- ) {
+ // Keep every open tab's composition alive; a tab is never torn down on switch. Each tab is
+ // measured and drawn only while selected — hidden tabs stay composed (their ViewModel,
+ // paging flow and LazyListState all hot) but are not measured or placed, so they cost no
+ // layout/draw. Crucially, because nothing is disposed, the paged content list never reloads
+ // from empty: switching back is instant, with no reload-and-jump and no alpha/crossfade
+ // masking. The trade-off is RAM proportional to the number of open tabs.
+ tabs.forEach { tabItem ->
+ val tabId = tabItem.destination.tabId
+ val isSelected = tabId == currentTabId
+ val saveableKey = saveableKeyFor(tabItem.destination)
+ key(saveableKey) {
+ saveableStateHolder.SaveableStateProvider(saveableKey) {
+ val tabOwner = tabOwners.getOrPut(tabId) { SimpleTabViewModelOwner(tabId) }
CompositionLocalProvider(LocalTabSelected provides isSelected) {
- val tabOwner = tabOwners.getOrPut(tabId) { SimpleTabViewModelOwner(tabId) }
-
- when (val destination = tabItem.destination) {
- is TabsDestination.Home -> {
- HomeTabContent(
- tabOwner = tabOwner,
- tabId = tabId,
- isSelected = isSelected,
- isRestoringSession = isTransitioning,
- searchUi = searchUi,
- searchCallbacks = homeSearchCallbacks,
- )
- }
-
- is TabsDestination.Search -> {
- SearchTabContent(
- tabOwner = tabOwner,
- destination = destination,
- isSelected = isSelected,
- )
- }
-
- is TabsDestination.BookContent -> {
- BookContentTabContent(
- tabOwner = tabOwner,
- destination = destination,
- isSelected = isSelected,
- isRestoringSession = isTransitioning,
- searchUi = searchUi,
- searchCallbacks = homeSearchCallbacks,
- )
+ Box(
+ modifier =
+ Modifier
+ .fillMaxSize()
+ .layout { measurable, constraints ->
+ // Selected: measure + place normally. Hidden: skip both so
+ // the subtree stays composed (alive) but incurs no layout
+ // or draw cost.
+ if (isSelected) {
+ val placeable = measurable.measure(constraints)
+ layout(placeable.width, placeable.height) {
+ placeable.place(0, 0)
+ }
+ } else {
+ layout(0, 0) {}
+ }
+ },
+ ) {
+ when (val destination = tabItem.destination) {
+ is TabsDestination.Home -> {
+ HomeTabContent(
+ tabOwner = tabOwner,
+ tabId = tabId,
+ isSelected = isSelected,
+ isRestoringSession = isTransitioning,
+ searchUi = searchUi,
+ searchCallbacks = homeSearchCallbacks,
+ )
+ }
+
+ is TabsDestination.Search -> {
+ SearchTabContent(
+ tabOwner = tabOwner,
+ destination = destination,
+ isSelected = isSelected,
+ )
+ }
+
+ is TabsDestination.BookContent -> {
+ BookContentTabContent(
+ tabOwner = tabOwner,
+ destination = destination,
+ isSelected = isSelected,
+ isRestoringSession = isTransitioning,
+ searchUi = searchUi,
+ searchCallbacks = homeSearchCallbacks,
+ )
+ }
}
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/tabs/TabsView.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/tabs/TabsView.kt
index 13548832a..f3d325563 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/tabs/TabsView.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/tabs/TabsView.kt
@@ -48,12 +48,14 @@ import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.PopupPositionProvider
import androidx.compose.ui.window.PopupProperties
import io.github.kdroidfilter.seforim.tabs.*
+import io.github.kdroidfilter.seforimapp.core.deeplink.toShareLink
import io.github.kdroidfilter.seforimapp.core.presentation.components.TitleBarActionButton
import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import io.github.kdroidfilter.seforimapp.framework.platform.PlatformInfo
import io.github.kdroidfilter.seforimapp.icons.CloseAll
+import io.github.kdroidfilter.seforimapp.icons.Link
import io.github.kdroidfilter.seforimapp.icons.Tab_close
import io.github.kdroidfilter.seforimapp.icons.Tab_close_right
import io.github.kdroidfilter.seforimapp.icons.bookOpenTabs
@@ -81,6 +83,8 @@ import org.jetbrains.jewel.ui.theme.menuStyle
import org.jetbrains.jewel.ui.theme.tooltipStyle
import seforimapp.seforimapp.generated.resources.*
import sh.calvin.reorderable.ReorderableRow
+import java.awt.Toolkit
+import java.awt.datatransfer.StringSelection
import kotlin.math.roundToInt
import kotlin.ranges.coerceAtLeast
import kotlin.ranges.coerceAtMost
@@ -97,6 +101,8 @@ private data class TabEntry(
val onCloseOthers: () -> Unit,
val onCloseLeft: () -> Unit,
val onCloseRight: () -> Unit,
+ // null when the destination has nothing shareable (e.g. Home, or a book still loading)
+ val onCopyLink: (() -> Unit)?,
)
private val TabTooltipWidthThreshold = 140.dp
@@ -200,6 +206,7 @@ private fun DefaultTabShowcase(
// RTL: visual "left" corresponds to higher indices (right of actual index)
onCloseLeft = { onEvents(TabsEvents.CloseRight(actualIndex)) },
onCloseRight = { onEvents(TabsEvents.CloseLeft(actualIndex)) },
+ onCopyLink = tabItem.destination.toShareLink()?.let { link -> { copyToClipboard(link) } },
)
}.toImmutableList()
} else {
@@ -268,6 +275,7 @@ private fun DefaultTabShowcase(
onCloseOthers = { onEvents(TabsEvents.CloseOthers(index)) },
onCloseLeft = { onEvents(TabsEvents.CloseLeft(index)) },
onCloseRight = { onEvents(TabsEvents.CloseRight(index)) },
+ onCopyLink = tabItem.destination.toShareLink()?.let { link -> { copyToClipboard(link) } },
)
}.toImmutableList()
}
@@ -482,6 +490,7 @@ private fun RtlAwareTabStripContent(
onCloseOthers = tabEntry.onCloseOthers,
onCloseLeft = tabEntry.onCloseLeft,
onCloseRight = tabEntry.onCloseRight,
+ onCopyLink = tabEntry.onCopyLink,
animateWidth = !isNew,
enterFromSmall = isNew,
enterDurationMs = enterDurationMs,
@@ -565,6 +574,7 @@ private fun RtlAwareTab(
onCloseLeft: () -> Unit,
onCloseRight: () -> Unit,
modifier: Modifier = Modifier,
+ onCopyLink: (() -> Unit)? = null,
animateWidth: Boolean = true,
enterFromSmall: Boolean = false,
enterDurationMs: Int = 200,
@@ -827,12 +837,23 @@ private fun RtlAwareTab(
val closeOthersLabel = stringResource(Res.string.close_other_tabs)
val closeLeftLabel = stringResource(Res.string.close_tabs_left)
val closeRightLabel = stringResource(Res.string.close_tabs_right)
+ val copyLinkLabel = stringResource(Res.string.copy_tab_link)
TabContextMenu(
anchorOffset = anchorOffset,
contextClickOffset = contextClickOffset,
onDismissRequest = { contextMenuOpen = false },
) {
+ if (onCopyLink != null) {
+ tabContextMenuItem(
+ label = copyLinkLabel,
+ icon = Link,
+ onClick = {
+ contextMenuOpen = false
+ onCopyLink()
+ },
+ )
+ }
tabContextMenuItem(
label = closeAllLabel,
icon = CloseAll,
@@ -976,6 +997,10 @@ private fun TabContextMenu(
}
}
+private fun copyToClipboard(text: String) {
+ Toolkit.getDefaultToolkit().systemClipboard.setContents(StringSelection(text), null)
+}
+
private fun MenuScope.tabContextMenuItem(
label: String,
icon: ImageVector,
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/HebrewSearch.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/HebrewSearch.kt
index 29eff9f5c..cdb32c10f 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/HebrewSearch.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/HebrewSearch.kt
@@ -7,19 +7,21 @@ package io.github.kdroidfilter.seforimapp.core.presentation.text
* so we can highlight the right character ranges.
*/
+/** True for nikud (vowel points) and ta'amim (cantillation) characters. */
+private fun isNikudOrTeamim(c: Char): Boolean =
+ (c.code in 0x0591..0x05AF) ||
+ // teamim
+ (c.code in 0x05B0..0x05BD) ||
+ // nikud + meteg
+ (c == '\u05C1') ||
+ (c == '\u05C2') ||
+ (c == '\u05C7')
+
/**
* Returns the string without nikud+teamim and an index map from plain index -> original index.
*/
-internal fun stripDiacriticsWithMap(src: String): Pair {
- val nikudOrTeamim: (Char) -> Boolean = { c ->
- (c.code in 0x0591..0x05AF) ||
- // teamim
- (c.code in 0x05B0..0x05BD) ||
- // nikud + meteg
- (c == '\u05C1') ||
- (c == '\u05C2') ||
- (c == '\u05C7')
- }
+fun stripDiacriticsWithMap(src: String): Pair {
+ val nikudOrTeamim: (Char) -> Boolean = { c -> isNikudOrTeamim(c) }
val out = StringBuilder(src.length)
val map = IntArray(src.length)
var count = 0
@@ -37,6 +39,30 @@ internal fun stripDiacriticsWithMap(src: String): Pair {
return out.toString() to arr
}
+/**
+ * Strips ONLY nikud+teamim (keeping geresh/gershayim ׳ ״), mirroring
+ * [io.github.kdroidfilter.seforimlibrary.core.text.HebrewTextUtils.removeAllDiacritics] — the
+ * function that produces the text actually rendered when diacritics are hidden. Returns the
+ * stripped string plus an index map from stripped index -> original index.
+ *
+ * Use this (not [stripDiacriticsWithMap], which also drops ׳ ״ for search matching) whenever
+ * offsets must line up with the displayed, diacritics-hidden text.
+ */
+fun stripNikudTeamimWithMap(src: String): Pair {
+ val out = StringBuilder(src.length)
+ val map = IntArray(src.length)
+ var count = 0
+ for (i in src.indices) {
+ val ch = src[i]
+ if (!isNikudOrTeamim(ch)) {
+ out.append(ch)
+ map[count++] = i
+ }
+ }
+ val arr = if (count == map.size) map else map.copyOf(count)
+ return out.toString() to arr
+}
+
internal fun replaceFinalsWithBase(text: String): String =
text
.replace('\u05DA', '\u05DB') // ך -> כ
@@ -71,6 +97,43 @@ internal fun mapToOrigIndex(
return mapToOrig[idx]
}
+/**
+ * Maps original index -> stripped index for the diacritics-hidden display text. Strips ONLY
+ * nikud+teamim (keeps ׳ ״), matching `HebrewTextUtils.removeAllDiacritics` so offsets line up
+ * with what is rendered. `result[origIndex]` is the stripped index, or -1 if that character
+ * was stripped.
+ */
+fun createOriginalToStrippedMap(src: String): IntArray {
+ val result = IntArray(src.length) { -1 }
+ var strippedIndex = 0
+ for (i in src.indices) {
+ if (!isNikudOrTeamim(src[i])) {
+ result[i] = strippedIndex
+ strippedIndex++
+ }
+ }
+ return result
+}
+
+/**
+ * Maps an [originalOffset] (with diacritics) to the stripped text. If it points to a
+ * stripped character, returns the next valid stripped position.
+ */
+fun mapOriginalToStripped(
+ originalOffset: Int,
+ originalToStrippedMap: IntArray,
+): Int {
+ if (originalToStrippedMap.isEmpty()) return originalOffset
+ val strippedLength = originalToStrippedMap.count { it >= 0 }
+ if (originalOffset >= originalToStrippedMap.size) return strippedLength
+ val safeOffset = originalOffset.coerceAtLeast(0)
+ if (originalToStrippedMap[safeOffset] >= 0) return originalToStrippedMap[safeOffset]
+ for (i in safeOffset until originalToStrippedMap.size) {
+ if (originalToStrippedMap[i] >= 0) return originalToStrippedMap[i]
+ }
+ return strippedLength
+}
+
/**
* Find all diacritic-insensitive matches of [query] in [text], returning original
* character index ranges [start, end) suitable for highlighting.
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Highlighting.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Highlighting.kt
index 6fe6674b6..1f4f97fae 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Highlighting.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Highlighting.kt
@@ -3,6 +3,7 @@ package io.github.kdroidfilter.seforimapp.core.presentation.text
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.SpanStyle
+import io.github.kdroidfilter.seforimapp.core.annotations.UserHighlight
/**
* Returns a copy of [annotated] with background highlight applied to all
@@ -107,3 +108,45 @@ fun highlightAnnotatedWithTerms(
}
return builder.toAnnotatedString()
}
+
+/**
+ * Applies persisted user [highlights] (belonging to a single line) to [annotated].
+ *
+ * Highlight offsets are stored relative to the original text (with diacritics). When
+ * diacritics are hidden, [originalText] is used to remap offsets onto the stripped
+ * text that is actually displayed.
+ */
+fun applyUserHighlights(
+ annotated: AnnotatedString,
+ highlights: List,
+ originalText: String? = null,
+ showDiacritics: Boolean = true,
+ highlightAlpha: Float = 0.4f,
+): AnnotatedString {
+ if (highlights.isEmpty()) return annotated
+
+ val originalToStrippedMap =
+ if (!showDiacritics && originalText != null) createOriginalToStrippedMap(originalText) else null
+
+ val builder = AnnotatedString.Builder()
+ builder.append(annotated)
+ for (highlight in highlights) {
+ val (start, end) =
+ if (originalToStrippedMap != null) {
+ mapOriginalToStripped(highlight.startOffset, originalToStrippedMap) to
+ mapOriginalToStripped(highlight.endOffset, originalToStrippedMap)
+ } else {
+ highlight.startOffset to highlight.endOffset
+ }
+ val clampedStart = start.coerceIn(0, annotated.length)
+ val clampedEnd = end.coerceAtMost(annotated.length)
+ if (clampedEnd > clampedStart) {
+ builder.addStyle(
+ SpanStyle(background = highlight.color.copy(alpha = highlightAlpha)),
+ clampedStart,
+ clampedEnd,
+ )
+ }
+ }
+ return builder.toAnnotatedString()
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Notes.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Notes.kt
new file mode 100644
index 000000000..4e986f4fd
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Notes.kt
@@ -0,0 +1,70 @@
+package io.github.kdroidfilter.seforimapp.core.presentation.text
+
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.PathEffect
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.text.TextLayoutResult
+import io.github.kdroidfilter.seforimapp.core.annotations.UserNote
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * Maps user [notes] (offsets stored against the original, with-diacritics text) to character
+ * ranges in the displayed text. When diacritics are hidden, [originalText] is used to remap
+ * offsets onto the stripped text. Returned ranges are `start until end`, clamped to [displayLength].
+ */
+fun noteDisplayRanges(
+ notes: List,
+ originalText: String?,
+ showDiacritics: Boolean,
+ displayLength: Int,
+): List {
+ if (notes.isEmpty()) return emptyList()
+ val originalToStrippedMap =
+ if (!showDiacritics && originalText != null) createOriginalToStrippedMap(originalText) else null
+ return notes.mapNotNull { note ->
+ val start =
+ if (originalToStrippedMap != null) mapOriginalToStripped(note.startOffset, originalToStrippedMap) else note.startOffset
+ val end =
+ if (originalToStrippedMap != null) mapOriginalToStripped(note.endOffset, originalToStrippedMap) else note.endOffset
+ val clampedStart = start.coerceIn(0, displayLength)
+ val clampedEnd = end.coerceAtMost(displayLength)
+ if (clampedEnd > clampedStart) clampedStart until clampedEnd else null
+ }
+}
+
+/**
+ * Draws a dotted grey underline under each note [ranges] using [layout]. Handles wrapped lines and
+ * RTL text (the horizontal bounds are normalized per visual line).
+ */
+fun DrawScope.drawNoteUnderlines(
+ layout: TextLayoutResult,
+ ranges: List,
+ color: Color,
+) {
+ if (ranges.isEmpty()) return
+ val stroke = density // 1.dp in px
+ val dash = PathEffect.dashPathEffect(floatArrayOf(2f * stroke, 3f * stroke), 0f)
+ for (range in ranges) {
+ val startOffset = range.first
+ val endOffset = range.last + 1
+ if (endOffset <= startOffset || startOffset >= layout.layoutInput.text.length) continue
+ val firstLine = layout.getLineForOffset(startOffset)
+ val lastLine = layout.getLineForOffset((endOffset - 1).coerceAtLeast(startOffset))
+ for (line in firstLine..lastLine) {
+ val segStart = if (line == firstLine) startOffset else layout.getLineStart(line)
+ val segEnd = if (line == lastLine) endOffset else layout.getLineEnd(line, visibleEnd = true)
+ val x1 = layout.getHorizontalPosition(segStart, usePrimaryDirection = true)
+ val x2 = layout.getHorizontalPosition(segEnd, usePrimaryDirection = true)
+ val y = layout.getLineBottom(line) - stroke
+ drawLine(
+ color = color,
+ start = Offset(min(x1, x2), y),
+ end = Offset(max(x1, x2), y),
+ strokeWidth = stroke,
+ pathEffect = dash,
+ )
+ }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/theme/AccentColor.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/theme/AccentColor.kt
index 49a9c894c..7bdfb7774 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/theme/AccentColor.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/theme/AccentColor.kt
@@ -2,7 +2,7 @@ package io.github.kdroidfilter.seforimapp.core.presentation.theme
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
-import io.github.kdroidfilter.nucleus.systemcolor.systemAccentColor
+import dev.nucleusframework.systemcolor.systemAccentColor
import org.jetbrains.jewel.intui.core.theme.IntUiDarkTheme
import org.jetbrains.jewel.intui.core.theme.IntUiLightTheme
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/theme/ThemeUtils.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/theme/ThemeUtils.kt
index 09b1165d2..9d8cb1321 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/theme/ThemeUtils.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/theme/ThemeUtils.kt
@@ -5,7 +5,7 @@ import androidx.compose.runtime.collectAsState
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
-import io.github.kdroidfilter.nucleus.darkmodedetector.isSystemInDarkMode
+import dev.nucleusframework.darkmodedetector.isSystemInDarkMode
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import org.jetbrains.compose.resources.Font
import org.jetbrains.jewel.foundation.BorderColors
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/utils/TouchMode.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/utils/TouchMode.kt
new file mode 100644
index 000000000..f63650beb
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/utils/TouchMode.kt
@@ -0,0 +1,39 @@
+package io.github.kdroidfilter.seforimapp.core.presentation.utils
+
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.PointerType
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.util.fastAll
+
+/**
+ * Whether the user is currently interacting by touch rather than with a mouse.
+ *
+ * Mirrors foundation's internal `isInTouchMode`: it turns `true` on a touch /
+ * stylus event and flips back to `false` on the next mouse event. Hover-gated
+ * affordances (e.g. the pane close buttons that only appear on mouse hover) read
+ * this to stay visible under touch, where there is no persistent hover.
+ *
+ * The value is detected once near the window root via [Modifier.detectTouchMode]
+ * and published here; read it anywhere with `LocalIsTouchMode.current`.
+ */
+val LocalIsTouchMode = staticCompositionLocalOf { false }
+
+/**
+ * Observes the active pointer modality on the [PointerEventPass.Initial] pass
+ * (without consuming events, so children still receive them) and reports it via
+ * [onChange]. Apply once on a window-spanning layout, then provide the value
+ * through [LocalIsTouchMode].
+ */
+fun Modifier.detectTouchMode(onChange: (Boolean) -> Unit): Modifier =
+ pointerInput(Unit) {
+ awaitPointerEventScope {
+ while (true) {
+ val event = awaitPointerEvent(PointerEventPass.Initial)
+ // "Touch" = not an all-mouse event, exactly like foundation's
+ // PointerEvent.isMouseOrTouchPad() negated.
+ onChange(!event.changes.fastAll { it.type == PointerType.Mouse })
+ }
+ }
+ }
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/utils/UrlOpener.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/utils/UrlOpener.kt
new file mode 100644
index 000000000..d94b53ae5
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/utils/UrlOpener.kt
@@ -0,0 +1,45 @@
+package io.github.kdroidfilter.seforimapp.core.presentation.utils
+
+import io.github.kdroidfilter.seforimapp.logger.errorln
+import java.awt.Desktop
+import java.net.URI
+
+/**
+ * Opens an external URL without blocking the UI thread.
+ *
+ * `Desktop.browse` is synchronous and, on Linux, blocks the calling thread until the system
+ * handler (`xdg-open`) responds — calling it from the Compose/Skiko render thread freezes the app.
+ * This runs the open on a short-lived daemon thread and falls back to the platform opener command
+ * when AWT Desktop is unavailable (common on Linux).
+ */
+object UrlOpener {
+ fun open(url: String) {
+ Thread {
+ runCatching { browseOrFallback(url) }
+ .onFailure { error -> errorln { "[url] failed to open $url: ${error.message}" } }
+ }.apply {
+ isDaemon = true
+ name = "url-opener"
+ }.start()
+ }
+
+ private fun browseOrFallback(url: String) {
+ val desktop = if (Desktop.isDesktopSupported()) Desktop.getDesktop() else null
+ if (desktop != null && desktop.isSupported(Desktop.Action.BROWSE)) {
+ desktop.browse(URI.create(url))
+ } else {
+ fallback(url)
+ }
+ }
+
+ private fun fallback(url: String) {
+ val os = System.getProperty("os.name").orEmpty().lowercase()
+ val command =
+ when {
+ os.contains("mac") -> listOf("open", url)
+ os.contains("win") -> listOf("rundll32", "url.dll,FileProtocolHandler", url)
+ else -> listOf("xdg-open", url)
+ }
+ ProcessBuilder(command).start()
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/selection/SelectionContext.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/selection/SelectionContext.kt
index a104f0ab1..738f193b9 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/selection/SelectionContext.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/selection/SelectionContext.kt
@@ -17,6 +17,17 @@ data class ActiveBook(
val rootTitle: String?,
)
+/**
+ * A commentary line, identified by its own target book/line so a highlight created from a
+ * commentary selection is stored against that book (and therefore shows up when the commentary
+ * is opened as a main book). [content] is the raw HTML used to resolve selection offsets.
+ */
+data class CommentaryLineRef(
+ val bookId: Long,
+ val lineId: Long,
+ val content: String,
+)
+
/**
* App-wide read/write surface that bridges Compose-side state (current selection, active book,
* paged-line snapshot) to Compose-free consumers (AWT keyboard dispatchers in particular).
@@ -33,10 +44,28 @@ interface SelectionContext {
val activeBook: StateFlow
val visibleLines: StateFlow
+ /**
+ * Visible commentary lines (ordered) of the column under the last right-click. Empty means
+ * the last right-click was not in the comments pane. Used to anchor (possibly multi-line)
+ * highlights in the comments pane.
+ */
+ val activeCommentaryColumn: StateFlow>
+
+ /**
+ * Id of the line most recently targeted by a right-click. Transient: it is refreshed on every
+ * secondary press, which always precedes the context menu opening, so the menu reads a fresh
+ * value even when no text is selected. 0 means "no line targeted yet".
+ */
+ val currentLineId: StateFlow
+
fun setSelectedText(text: String)
fun clearSelectedText()
+ fun setCurrentLineId(lineId: Long)
+
+ fun setActiveCommentaryColumn(lines: List)
+
fun setActiveBook(
tabId: String,
book: Book?,
@@ -76,14 +105,28 @@ class DefaultSelectionContext : SelectionContext {
private val _visibleLines = MutableStateFlow(VisibleLines.EMPTY)
override val visibleLines: StateFlow = _visibleLines.asStateFlow()
+ private val _currentLineId = MutableStateFlow(0L)
+ override val currentLineId: StateFlow = _currentLineId.asStateFlow()
+
+ private val _activeCommentaryColumn = MutableStateFlow>(emptyList())
+ override val activeCommentaryColumn: StateFlow> = _activeCommentaryColumn.asStateFlow()
+
override fun setSelectedText(text: String) {
_selectedText.value = text
}
+ override fun setActiveCommentaryColumn(lines: List) {
+ _activeCommentaryColumn.value = lines
+ }
+
override fun clearSelectedText() {
_selectedText.value = ""
}
+ override fun setCurrentLineId(lineId: Long) {
+ _currentLineId.value = lineId
+ }
+
override fun setActiveBook(
tabId: String,
book: Book?,
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/settings/AppSettings.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/settings/AppSettings.kt
index 3cbd257b3..374785dbf 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/settings/AppSettings.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/settings/AppSettings.kt
@@ -46,6 +46,7 @@ object AppSettings {
private const val KEY_CLOSE_TREE_ON_NEW_BOOK = "close_tree_on_new_book"
private const val KEY_DATABASE_PATH = "database_path"
private const val KEY_PERSIST_SESSION = "persist_session"
+ private const val KEY_KEEP_SCREEN_AWAKE_ON_BOOK = "keep_screen_awake_on_book"
private const val KEY_FONT_BOOK = "font_book"
private const val KEY_FONT_COMMENTARY = "font_commentary"
private const val KEY_FONT_TARGUM = "font_targum"
@@ -97,6 +98,7 @@ object AppSettings {
_closeTreeOnNewBookFlow.value = getCloseBookTreeOnNewBookSelected()
_databasePathFlow.value = getDatabasePath()
_persistSessionFlow.value = isPersistSessionEnabled()
+ _keepScreenAwakeOnBookFlow.value = isKeepScreenAwakeOnBookEnabled()
_bookFontCodeFlow.value = getBookFontCode()
_commentaryFontCodeFlow.value = getCommentaryFontCode()
_targumFontCodeFlow.value = getTargumFontCode()
@@ -127,6 +129,10 @@ object AppSettings {
private val _persistSessionFlow = MutableStateFlow(isPersistSessionEnabled())
val persistSessionFlow: StateFlow = _persistSessionFlow.asStateFlow()
+ // StateFlow for keep-screen-awake-while-reading setting
+ private val _keepScreenAwakeOnBookFlow = MutableStateFlow(isKeepScreenAwakeOnBookEnabled())
+ val keepScreenAwakeOnBookFlow: StateFlow = _keepScreenAwakeOnBookFlow.asStateFlow()
+
// StateFlow for zmanim widgets visibility
private val _showZmanimWidgetsFlow = MutableStateFlow(isShowZmanimWidgetsEnabled())
val showZmanimWidgetsFlow: StateFlow = _showZmanimWidgetsFlow.asStateFlow()
@@ -309,6 +315,14 @@ object AppSettings {
}
}
+ // Keep the screen awake while a book is open and the window is focused (enabled by default)
+ fun isKeepScreenAwakeOnBookEnabled(): Boolean = settings[KEY_KEEP_SCREEN_AWAKE_ON_BOOK, true]
+
+ fun setKeepScreenAwakeOnBookEnabled(enabled: Boolean) {
+ settings[KEY_KEEP_SCREEN_AWAKE_ON_BOOK] = enabled
+ _keepScreenAwakeOnBookFlow.value = enabled
+ }
+
// Zmanim widgets visibility
fun isShowZmanimWidgetsEnabled(): Boolean = settings[KEY_SHOW_ZMANIM_WIDGETS, true]
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentEvent.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentEvent.kt
index f61041dbb..eb4bc5a86 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentEvent.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentEvent.kt
@@ -39,6 +39,14 @@ sealed interface BookContentEvent {
data object ToggleToc : BookContentEvent
+ // Notes pane
+ data object ToggleNotes : BookContentEvent
+
+ data class NotesScrolled(
+ val index: Int,
+ val offset: Int,
+ ) : BookContentEvent
+
data class TocScrolled(
val index: Int,
val offset: Int,
@@ -139,6 +147,7 @@ sealed interface BookContentEvent {
val commentatorId: Long,
val index: Int,
val offset: Int,
+ val persist: Boolean = false,
) : BookContentEvent
data class CommentariesPageChanged(
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentScreen.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentScreen.kt
index f9954c2af..ddf763183 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentScreen.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentScreen.kt
@@ -6,17 +6,24 @@ import androidx.compose.foundation.ContextMenuState
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.LocalContextMenuRepresentation
import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.LocalTextContextMenu
import androidx.compose.foundation.text.TextContextMenu
import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.focus.FocusDirection
import androidx.compose.ui.focus.FocusManager
+import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.InputMode
import androidx.compose.ui.input.InputModeManager
import androidx.compose.ui.input.key.Key
@@ -30,9 +37,17 @@ import androidx.compose.ui.input.key.key
import androidx.compose.ui.input.key.nativeKeyCode
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.key.type
+import androidx.compose.ui.input.pointer.PointerEventType
+import androidx.compose.ui.input.pointer.onPointerEvent
import androidx.compose.ui.unit.dp
+import io.github.kdroidfilter.seforim.htmlparser.buildAnnotatedFromHtml
+import io.github.kdroidfilter.seforimapp.core.annotations.HighlightColors
+import io.github.kdroidfilter.seforimapp.core.annotations.HighlightStore
+import io.github.kdroidfilter.seforimapp.core.annotations.resolveHighlightRangesForSelection
import io.github.kdroidfilter.seforimapp.core.buildCopyWithSourcePayload
+import io.github.kdroidfilter.seforimapp.core.deeplink.bookShareLink
import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
+import io.github.kdroidfilter.seforimapp.core.resolveLineRangeFromSelection
import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
import io.github.kdroidfilter.seforimapp.features.bookcontent.state.BookContentState
import io.github.kdroidfilter.seforimapp.features.bookcontent.state.SplitDefaults
@@ -44,15 +59,21 @@ import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.bookcont
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.bookcontent.views.HomeSearchCallbacks
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.booktoc.BookTocPanel
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.categorytree.CategoryTreePanel
+import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.notes.NoteDraftAnchor
+import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.notes.NotesPanel
import io.github.kdroidfilter.seforimapp.features.search.SearchHomeUiState
import io.github.kdroidfilter.seforimapp.framework.database.CatalogCache
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
+import io.github.kdroidfilter.seforimapp.icons.Ink_pen
import io.github.kdroidfilter.seforimlibrary.core.text.HebrewTextUtils
+import io.github.santimattius.structured.annotations.StructuredScope
+import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.FlowPreview
import kotlinx.coroutines.flow.debounce
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
import org.jetbrains.compose.resources.stringResource
import org.jetbrains.compose.splitpane.ExperimentalSplitPaneApi
import org.jetbrains.compose.splitpane.SplitPaneState
@@ -60,6 +81,7 @@ import org.jetbrains.jewel.foundation.InternalJewelApi
import org.jetbrains.jewel.foundation.theme.JewelTheme
import org.jetbrains.jewel.ui.component.ContextMenuItemOption
import org.jetbrains.jewel.ui.component.DefaultMenuController
+import org.jetbrains.jewel.ui.component.Icon
import org.jetbrains.jewel.ui.component.LocalMenuController
import org.jetbrains.jewel.ui.component.MenuContent
import org.jetbrains.jewel.ui.component.MenuController
@@ -73,9 +95,12 @@ import org.jetbrains.jewel.ui.icons.AllIconsKeys
import org.jetbrains.jewel.ui.theme.menuStyle
import org.jetbrains.skiko.hostOs
import seforimapp.seforimapp.generated.resources.Res
+import seforimapp.seforimapp.generated.resources.context_menu_add_note
+import seforimapp.seforimapp.generated.resources.context_menu_copy_link
import seforimapp.seforimapp.generated.resources.context_menu_copy_with_source
import seforimapp.seforimapp.generated.resources.context_menu_copy_without_nikud
import seforimapp.seforimapp.generated.resources.context_menu_find_in_page
+import seforimapp.seforimapp.generated.resources.context_menu_highlight
import seforimapp.seforimapp.generated.resources.context_menu_search_selected_text
import java.awt.Toolkit
import java.awt.datatransfer.StringSelection
@@ -94,6 +119,13 @@ private class ContextMenuItemOptionWithKeybinding(
action: () -> Unit,
) : ContextMenuItem(label, action)
+/** Context-menu entry rendering a row of highlight color swatches (last item, plus a "clear"). */
+private class ContextMenuHighlightColorPicker(
+ val colors: List,
+ val onColorSelected: (Color) -> Unit,
+ val onDismiss: () -> Unit,
+) : ContextMenuItem("highlight", {})
+
@OptIn(InternalJewelApi::class)
private object BookContentContextMenuRepresentationWithKeybindings : ComposeContextMenuRepresentation {
@Composable
@@ -167,6 +199,19 @@ private fun MenuScope.contextItems(items: List) {
when (item) {
is org.jetbrains.jewel.ui.component.ContextMenuDivider -> separator()
is org.jetbrains.jewel.ui.component.ContextSubmenu -> submenu(submenu = { contextItems(item.submenu()) }) { Text(item.label) }
+ is ContextMenuHighlightColorPicker -> {
+ separator()
+ passiveItem {
+ HighlightColorPickerRow(
+ colors = item.colors,
+ onSelect = { color ->
+ item.onColorSelected(color)
+ item.onDismiss()
+ },
+ )
+ }
+ }
+
is ContextMenuItemOptionWithKeybinding ->
selectableItem(
selected = false,
@@ -194,6 +239,152 @@ private fun MenuScope.contextItems(items: List) {
}
}
+/** A row of color swatches (plus a "clear" cross) for highlighting the current selection. */
+@Composable
+private fun HighlightColorPickerRow(
+ colors: List,
+ onSelect: (Color) -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ val highlightLabel = stringResource(Res.string.context_menu_highlight)
+ // passiveItem does not provide LocalContentColor, so read the menu item color explicitly.
+ val contentColor = JewelTheme.menuStyle.colors.itemColors.content
+ Row(
+ modifier = modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 4.dp),
+ verticalAlignment = Alignment.CenterVertically,
+ ) {
+ Icon(imageVector = Ink_pen, contentDescription = null, tint = contentColor, modifier = Modifier.size(16.dp))
+ Text(text = highlightLabel, color = contentColor, modifier = Modifier.padding(horizontal = 8.dp))
+ colors.forEach { color ->
+ HighlightColorSwatch(color = color, onClick = { onSelect(color) })
+ }
+ }
+}
+
+/** A single hover-aware swatch; [Color.Transparent] renders a "clear" cross. */
+@OptIn(ExperimentalComposeUiApi::class)
+@Composable
+private fun HighlightColorSwatch(
+ color: Color,
+ onClick: () -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ var isHovered by remember { mutableStateOf(false) }
+ val hoverBackground = JewelTheme.menuStyle.colors.itemColors.backgroundHovered
+ Box(
+ modifier =
+ modifier
+ .clip(RoundedCornerShape(4.dp))
+ .background(if (isHovered) hoverBackground else Color.Transparent)
+ .onPointerEvent(PointerEventType.Enter) { isHovered = true }
+ .onPointerEvent(PointerEventType.Exit) { isHovered = false }
+ .clickable { onClick() }
+ .padding(6.dp),
+ contentAlignment = Alignment.Center,
+ ) {
+ if (color == Color.Transparent) {
+ Icon(key = AllIconsKeys.Windows.Close, contentDescription = null, modifier = Modifier.size(16.dp))
+ } else {
+ Box(modifier = Modifier.size(18.dp).clip(RoundedCornerShape(4.dp)).background(color))
+ }
+ }
+}
+
+/**
+ * Resolves the selected text to (line, offset range) pairs and persists/clears highlights.
+ * Offsets are computed against plain text WITH diacritics so they stay valid regardless of the
+ * current diacritics setting.
+ *
+ * [commentaryColumn] is the discriminator: it holds the visible commentary lines of the column
+ * under the last right-click (set in the comments pane, cleared on a main-pane right-click), so a
+ * non-empty value means the selection is in the comments pane. Comments-pane highlights are
+ * stored against the commentary's own book, so they also show when that commentary is opened as a
+ * main book. The selection may span several consecutive commentary entries. No-op if unresolved.
+ */
+private fun applyHighlightFromSelection(
+ selectedText: String,
+ lines: List,
+ bookId: Long,
+ commentaryColumn: List,
+ color: Color,
+ showDiacritics: Boolean,
+ store: HighlightStore,
+ @StructuredScope scope: CoroutineScope,
+) {
+ // Comments pane: resolve over the column's visible lines (in display order). A column is a
+ // single commentator, so all its lines share one target book.
+ if (commentaryColumn.isNotEmpty()) {
+ val commentaryBookId = commentaryColumn.first().bookId
+ val sorted = commentaryColumn.map { it.lineId to buildAnnotatedFromHtml(it.content, baseTextSize = 16f, boldScale = 1f).text }
+ val ranges = resolveHighlightRangesForSelection(sorted, selectedText, showDiacritics)
+ persistHighlights(commentaryBookId, ranges, color, store, scope)
+ return
+ }
+
+ // Main book: all materialized lines (ordered, plain text WITH diacritics so offsets match
+ // what the renderer applies). The resolver splits the selection per line and anchors it.
+ val mainSorted =
+ lines
+ .sortedBy { it.lineIndex }
+ .map { it.id to buildAnnotatedFromHtml(it.content, baseTextSize = 16f, boldScale = 1f).text }
+ val mainRanges = resolveHighlightRangesForSelection(mainSorted, selectedText, showDiacritics)
+ persistHighlights(bookId, mainRanges, color, store, scope)
+}
+
+private fun persistHighlights(
+ bookId: Long,
+ ranges: List,
+ color: Color,
+ store: HighlightStore,
+ @StructuredScope scope: CoroutineScope,
+) {
+ if (ranges.isEmpty()) return
+ scope.launch {
+ ranges.forEach { (lineId, range) ->
+ if (color == Color.Transparent) {
+ store.removeOverlapping(bookId, lineId, range.first, range.last + 1)
+ } else {
+ store.addHighlight(bookId, lineId, range.first, range.last + 1, color, System.currentTimeMillis())
+ }
+ }
+ }
+}
+
+/**
+ * Resolves the selected text to a single note anchor on a main-pane line. Notes are only created
+ * from the main book pane (not the comments pane), so the resolved line id matches the book the
+ * notes pane is keyed to. Returns null when the selection cannot be located.
+ */
+private fun resolveNoteDraft(
+ selectedText: String,
+ lines: List,
+ showDiacritics: Boolean,
+): NoteDraftAnchor? {
+ val sorted =
+ lines
+ .sortedBy { it.lineIndex }
+ .map { it.id to buildAnnotatedFromHtml(it.content, baseTextSize = 16f, boldScale = 1f).text }
+ val range = resolveHighlightRangesForSelection(sorted, selectedText, showDiacritics).firstOrNull() ?: return null
+ return NoteDraftAnchor(
+ lineId = range.lineId,
+ startOffset = range.range.first,
+ endOffset = range.range.last + 1,
+ quote = selectedText.trim().substringBefore('\n').trim(),
+ )
+}
+
+/** Builds a note anchor covering the whole right-clicked line (used when no text is selected). */
+private fun resolveWholeLineNoteDraft(
+ lineId: Long,
+ lines: List,
+): NoteDraftAnchor? {
+ if (lineId <= 0) return null
+ val line = lines.firstOrNull { it.id == lineId } ?: return null
+ val plain = buildAnnotatedFromHtml(line.content, baseTextSize = 16f, boldScale = 1f).text
+ if (plain.isEmpty()) return null
+ return NoteDraftAnchor(lineId = lineId, startOffset = 0, endOffset = plain.length, quote = plain.trim())
+}
+
private fun handlePopupMenuOnKeyEvent(
keyEvent: KeyEvent,
focusManager: FocusManager,
@@ -271,6 +462,8 @@ fun BookContentScreen(
val findInPageLabel = stringResource(Res.string.context_menu_find_in_page)
val copyWithoutNikudLabel = stringResource(Res.string.context_menu_copy_without_nikud)
val copyWithSourceLabel = stringResource(Res.string.context_menu_copy_with_source)
+ val copyLinkLabel = stringResource(Res.string.context_menu_copy_link)
+ val addNoteLabel = stringResource(Res.string.context_menu_add_note)
val baseTextContextMenu = LocalTextContextMenu.current
val tabId = uiState.tabId
val selectedBook = uiState.navigation.selectedBook
@@ -278,6 +471,26 @@ fun BookContentScreen(
val selectionContext = LocalAppGraph.current.selectionContext
// Always read the latest values inside the context-menu actions, without rebuilding the menu.
val currentSelectedBook by rememberUpdatedState(selectedBook)
+ val currentNotesVisible by rememberUpdatedState(uiState.notes.isVisible)
+ val currentPrimaryLineId by rememberUpdatedState(uiState.content.primaryLine?.id)
+
+ // User-highlight persistence (separate local user DB).
+ val highlightStore = LocalAppGraph.current.highlightStore
+ val highlightScope = rememberCoroutineScope()
+ val bookId = selectedBook?.id ?: 0L
+
+ // User notes: a pending draft (anchored, not yet saved) opened from the context menu and
+ // edited inline in the notes pane (Google-Docs style).
+ val noteStore = LocalAppGraph.current.noteStore
+ var noteDraft by remember { mutableStateOf(null) }
+ // Primary line captured when the draft was opened. Selecting a different line drops the unsaved
+ // explicit draft so the editor reflects the newly selected line instead of the stale anchor.
+ var noteDraftBaselineLine by remember { mutableStateOf(null) }
+ LaunchedEffect(uiState.content.primaryLine?.id) {
+ if (noteDraft != null && uiState.content.primaryLine?.id != noteDraftBaselineLine) {
+ noteDraft = null
+ }
+ }
// Publish the active book + its root category to the SelectionContext so the Ctrl+Alt+C
// dispatcher and the context-menu action can apply per-tradition formatting. Lifecycle
@@ -304,8 +517,10 @@ fun BookContentScreen(
findInPageLabel,
copyWithoutNikudLabel,
copyWithSourceLabel,
+ copyLinkLabel,
showDiacritics,
bookHasDiacritics,
+ bookId,
) {
object : TextContextMenu {
@OptIn(ExperimentalFoundationApi::class)
@@ -375,6 +590,30 @@ fun BookContentScreen(
},
)
}
+ // Copy a shareable deep link. Available whenever a book is active,
+ // with or without a text selection: when nothing is selected it falls
+ // back to the right-clicked line recorded in the SelectionContext.
+ if (bookForCopy != null) {
+ add(
+ ContextMenuItemOption(
+ icon = AllIconsKeys.ToolbarDecorator.AddLink,
+ label = copyLinkLabel,
+ ) {
+ val lineId =
+ if (selectedText.isNotBlank()) {
+ resolveLineRangeFromSelection(
+ selectedText,
+ selectionContext.visibleLines.value.lines,
+ )?.first?.id
+ } else {
+ selectionContext.currentLineId.value.takeIf { it > 0 }
+ }
+ val link = bookShareLink(bookForCopy.id, lineId)
+ val clipboard = Toolkit.getDefaultToolkit().systemClipboard
+ clipboard.setContents(StringSelection(link), null)
+ },
+ )
+ }
if (query.isNotBlank()) {
add(
ContextMenuItemOption(
@@ -402,6 +641,55 @@ fun BookContentScreen(
AppSettings.openFindBar(tabId)
},
)
+ // Add note (main pane only): anchors a note to the selected text,
+ // or to the whole right-clicked line when nothing is selected.
+ if (bookId > 0 &&
+ selectionContext.activeCommentaryColumn.value
+ .isEmpty() &&
+ (selectedText.isNotBlank() || selectionContext.currentLineId.value > 0)
+ ) {
+ add(
+ ContextMenuItemOptionWithKeybinding(
+ icon = AllIconsKeys.Actions.Annotate,
+ label = addNoteLabel,
+ ) {
+ val lines = selectionContext.visibleLines.value.lines
+ val draft =
+ if (selectedText.isNotBlank()) {
+ resolveNoteDraft(selectedText, lines, showDiacritics)
+ } else {
+ resolveWholeLineNoteDraft(selectionContext.currentLineId.value, lines)
+ }
+ if (draft != null) {
+ noteDraft = draft
+ noteDraftBaselineLine = currentPrimaryLineId
+ if (!currentNotesVisible) onEvent(BookContentEvent.ToggleNotes)
+ }
+ },
+ )
+ }
+ // Highlight color picker (last item): persists a position-based
+ // highlight for the selected text on its resolved line.
+ if (selectedText.isNotBlank() && bookId > 0) {
+ add(
+ ContextMenuHighlightColorPicker(
+ colors = HighlightColors.allWithClear,
+ onColorSelected = { color ->
+ applyHighlightFromSelection(
+ selectedText = selectedText,
+ lines = selectionContext.visibleLines.value.lines,
+ bookId = bookId,
+ commentaryColumn = selectionContext.activeCommentaryColumn.value,
+ color = color,
+ showDiacritics = showDiacritics,
+ store = highlightStore,
+ scope = highlightScope,
+ )
+ },
+ onDismiss = { state.status = ContextMenuState.Status.Closed },
+ ),
+ )
+ }
}
},
) {
@@ -428,6 +716,11 @@ fun BookContentScreen(
isVisible = uiState.toc.isVisible,
positionFilter = { it > 0 },
),
+ SplitPaneConfig(
+ splitState = uiState.layout.notesSplitState,
+ isVisible = uiState.notes.isVisible,
+ positionFilter = { it > 0 },
+ ),
SplitPaneConfig(
splitState = uiState.layout.contentSplitState,
isVisible = uiState.content.showCommentaries,
@@ -531,15 +824,38 @@ fun BookContentScreen(
}
},
secondContent = {
- BookContentPanel(
- uiState = uiState,
- onEvent = onEvent,
- showDiacritics = showDiacritics,
- isRestoringSession = isRestoringSession,
- searchUi = searchUi,
- searchCallbacks = searchCallbacks,
- isSelected = isSelected,
- bookCharCounts = bookCharCounts,
+ EnhancedHorizontalSplitPane(
+ splitPaneState = uiState.layout.notesSplitState.asStable(),
+ firstMinSize = if (uiState.notes.isVisible) SplitDefaults.MIN_NOTES else 0f,
+ firstContent = {
+ if (uiState.notes.isVisible) {
+ NotesPanel(
+ uiState = uiState,
+ onEvent = onEvent,
+ bookId = bookId,
+ noteStore = noteStore,
+ selectedLineIds = uiState.content.selectedLineIds,
+ primarySelectedLine = uiState.content.primaryLine,
+ draft = noteDraft,
+ onConsumeDraft = { noteDraft = null },
+ modifier = panelCardModifier,
+ )
+ }
+ },
+ secondContent = {
+ BookContentPanel(
+ uiState = uiState,
+ onEvent = onEvent,
+ showDiacritics = showDiacritics,
+ isRestoringSession = isRestoringSession,
+ searchUi = searchUi,
+ searchCallbacks = searchCallbacks,
+ isSelected = isSelected,
+ bookCharCounts = bookCharCounts,
+ noteDraft = noteDraft,
+ )
+ },
+ showSplitter = uiState.notes.isVisible,
)
},
showSplitter = uiState.toc.isVisible,
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentViewModel.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentViewModel.kt
index c7029c6cb..50232f59f 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentViewModel.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentViewModel.kt
@@ -79,6 +79,7 @@ class BookContentViewModel(
private val navigationUseCase = useCaseFactory.createNavigationUseCase(stateManager)
private val contentUseCase = useCaseFactory.createContentUseCase(stateManager)
private val tocUseCase = useCaseFactory.createTocUseCase(stateManager)
+ private val notesUseCase = useCaseFactory.createNotesUseCase(stateManager)
private val altTocUseCase = useCaseFactory.createAltTocUseCase(stateManager)
private val commentariesUseCase = useCaseFactory.createCommentariesUseCase(stateManager, viewModelScope)
private val categoryDisplaySettingsUseCase = useCaseFactory.createCategoryDisplaySettingsUseCase()
@@ -144,6 +145,7 @@ class BookContentViewModel(
getAvailableCommentatorsForLine = commentariesUseCase::getAvailableCommentators,
getCommentatorGroupsForLine = commentariesUseCase::getCommentatorGroups,
loadLineConnections = commentariesUseCase::loadLineConnections,
+ prefetchCommentaries = commentariesUseCase::prefetchCommentaries,
buildLinksPagerFor = commentariesUseCase::buildLinksPager,
getAvailableLinksForLine = commentariesUseCase::getAvailableLinks,
buildSourcesPagerFor = commentariesUseCase::buildSourcesPager,
@@ -206,6 +208,7 @@ class BookContentViewModel(
getAvailableCommentatorsForLine = commentariesUseCase::getAvailableCommentators,
getCommentatorGroupsForLine = commentariesUseCase::getCommentatorGroups,
loadLineConnections = commentariesUseCase::loadLineConnections,
+ prefetchCommentaries = commentariesUseCase::prefetchCommentaries,
buildLinksPagerFor = commentariesUseCase::buildLinksPager,
getAvailableLinksForLine = commentariesUseCase::getAvailableLinks,
buildSourcesPagerFor = commentariesUseCase::buildSourcesPager,
@@ -386,6 +389,12 @@ class BookContentViewModel(
is BookContentEvent.TocScrolled ->
tocUseCase.updateTocScrollPosition(event.index, event.offset)
+ BookContentEvent.ToggleNotes ->
+ notesUseCase.toggleNotes()
+
+ is BookContentEvent.NotesScrolled ->
+ notesUseCase.updateNotesScrollPosition(event.index, event.offset)
+
is BookContentEvent.AltTocEntryExpanded ->
altTocUseCase.toggleAltTocEntry(event.entry)
@@ -508,11 +517,16 @@ class BookContentViewModel(
commentariesUseCase.updateCommentatorsListScrollPosition(event.index, event.offset)
is BookContentEvent.CommentaryColumnScrolled ->
- commentariesUseCase.updateCommentaryColumnScrollPosition(
- event.commentatorId,
- event.index,
- event.offset,
- )
+ run {
+ commentariesUseCase.updateCommentaryColumnScrollPosition(
+ event.commentatorId,
+ event.index,
+ event.offset,
+ )
+ if (event.persist) {
+ stateManager.saveAllStates()
+ }
+ }
is BookContentEvent.CommentariesPageChanged ->
stateManager.updateContent(save = false) {
@@ -739,6 +753,13 @@ class BookContentViewModel(
val state = stateManager.state.value
// Always prefer an explicit anchor when present (e.g., opening from a commentary link)
val shouldUseAnchor = state.content.anchorId != -1L
+ val savedScrollAnchorId =
+ if (!shouldUseAnchor && state.content.scrollIndex > 0) {
+ runSuspendCatching { repository.getLineByIndex(book.id, state.content.scrollIndex)?.id }
+ .getOrNull()
+ } else {
+ null
+ }
// Resolve initial line anchor if any, otherwise fall back to the first TOC's first line
// so that opening a book from the category tree selects the first meaningful section.
@@ -750,6 +771,7 @@ class BookContentViewModel(
when {
forceAnchorId != null -> forceAnchorId
shouldUseAnchor -> state.content.anchorId
+ savedScrollAnchorId != null -> savedScrollAnchorId
currentPrimaryLine != null -> currentPrimaryLine.id
else -> {
// Compute from TOC: take the first root TOC entry (or its first leaf) and
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/BookContentState.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/BookContentState.kt
index 7ec46e3a8..95ba1f660 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/BookContentState.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/BookContentState.kt
@@ -20,6 +20,8 @@ data class Providers(
val getAvailableCommentatorsForLine: suspend (Long) -> Map,
val getCommentatorGroupsForLine: suspend (Long) -> List,
val loadLineConnections: suspend (List) -> Map,
+ // Warms the first page of the given line's open commentators (used to warm a background tab ahead of display).
+ val prefetchCommentaries: suspend (Long, Set) -> Unit,
val buildLinksPagerFor: (Long, Long?) -> Flow>,
val getAvailableLinksForLine: suspend (Long) -> Map,
val buildSourcesPagerFor: (Long, Long?) -> Flow>,
@@ -77,6 +79,7 @@ data class BookContentState
val tabId: String = "",
val navigation: NavigationState = NavigationState(),
val toc: TocState = TocState(),
+ val notes: NotesState = NotesState(),
val altToc: AltTocState = AltTocState(),
val content: ContentState = ContentState(),
val layout: LayoutState = LayoutState(),
@@ -114,6 +117,14 @@ data class TocState(
val scrollOffset: Int = 0,
)
+@Immutable
+data class NotesState(
+ // UI only: the notes themselves live in NoteStore's per-book cache.
+ val isVisible: Boolean = false,
+ val scrollIndex: Int = 0,
+ val scrollOffset: Int = 0,
+)
+
@Immutable
data class ContentState(
// Data
@@ -187,6 +198,7 @@ data class LayoutState
constructor(
val mainSplitState: SplitPaneState = SplitPaneState(initialPositionPercentage = SplitDefaults.MAIN, moveEnabled = true),
val tocSplitState: SplitPaneState = SplitPaneState(initialPositionPercentage = SplitDefaults.TOC, moveEnabled = true),
+ val notesSplitState: SplitPaneState = SplitPaneState(initialPositionPercentage = SplitDefaults.NOTES, moveEnabled = true),
val contentSplitState: SplitPaneState = SplitPaneState(initialPositionPercentage = SplitDefaults.CONTENT, moveEnabled = true),
val targumSplitState: SplitPaneState = SplitPaneState(initialPositionPercentage = 0.8f, moveEnabled = true),
val previousPositions: PreviousPositions = PreviousPositions(),
@@ -196,6 +208,7 @@ data class LayoutState
data class PreviousPositions(
val main: Float = SplitDefaults.MAIN,
val toc: Float = SplitDefaults.TOC,
+ val notes: Float = SplitDefaults.NOTES,
val content: Float = SplitDefaults.CONTENT,
val sources: Float = SplitDefaults.SOURCES,
val links: Float = 0.8f,
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/BookContentStateManager.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/BookContentStateManager.kt
index 0edf3c6e3..ec0c40dab 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/BookContentStateManager.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/BookContentStateManager.kt
@@ -31,6 +31,7 @@ class BookContentStateManager(
// Derive visibility flags so split pane positions match from the first frame
val navVisible = persisted.isBookTreeVisible
val tocVisible = persisted.isTocVisible
+ val notesVisible = persisted.isNotesVisible
val bottomPaneVisible = persisted.showCommentaries || persisted.showSources
val targumVisible = persisted.showTargum
@@ -57,6 +58,12 @@ class BookContentStateManager(
scrollIndex = persisted.tocScrollIndex,
scrollOffset = persisted.tocScrollOffset,
),
+ notes =
+ NotesState(
+ isVisible = notesVisible,
+ scrollIndex = persisted.notesScrollIndex,
+ scrollOffset = persisted.notesScrollOffset,
+ ),
altToc = AltTocState(),
content =
ContentState(
@@ -101,6 +108,11 @@ class BookContentStateManager(
initialPositionPercentage = if (tocVisible) persisted.tocSplitPosition else 0f,
moveEnabled = tocVisible,
),
+ notesSplitState =
+ SplitPaneState(
+ initialPositionPercentage = if (notesVisible) persisted.notesSplitPosition else 0f,
+ moveEnabled = notesVisible,
+ ),
contentSplitState =
SplitPaneState(
initialPositionPercentage = if (bottomPaneVisible) persisted.contentSplitPosition else 1f,
@@ -115,6 +127,7 @@ class BookContentStateManager(
PreviousPositions(
main = persisted.previousMainSplitPosition,
toc = persisted.previousTocSplitPosition,
+ notes = persisted.previousNotesSplitPosition,
content = persisted.previousContentSplitPosition,
sources = persisted.previousSourcesSplitPosition,
links = persisted.previousTargumSplitPosition,
@@ -156,6 +169,16 @@ class BookContentStateManager(
update(save) { copy(toc = toc.transform()) }
}
+ /**
+ * Updates the notes pane state only.
+ */
+ fun updateNotes(
+ save: Boolean = true,
+ transform: NotesState.() -> NotesState,
+ ) {
+ update(save) { copy(notes = notes.transform()) }
+ }
+
/**
* Met à jour uniquement le contenu
*/
@@ -238,6 +261,9 @@ class BookContentStateManager(
selectedTocEntryId = currentState.toc.selectedEntryId ?: -1L,
tocScrollIndex = currentState.toc.scrollIndex,
tocScrollOffset = currentState.toc.scrollOffset,
+ isNotesVisible = currentState.notes.isVisible,
+ notesScrollIndex = currentState.notes.scrollIndex,
+ notesScrollOffset = currentState.notes.scrollOffset,
selectedLineIds = currentState.content.selectedLineIds,
primarySelectedLineId = currentState.content.primarySelectedLineId ?: -1L,
isTocEntrySelection = currentState.content.isTocEntrySelection,
@@ -268,10 +294,12 @@ class BookContentStateManager(
selectedSourcesByBook = currentState.content.selectedSourcesByBook,
mainSplitPosition = currentState.layout.mainSplitState.positionPercentage,
tocSplitPosition = currentState.layout.tocSplitState.positionPercentage,
+ notesSplitPosition = currentState.layout.notesSplitState.positionPercentage,
contentSplitPosition = currentState.layout.contentSplitState.positionPercentage,
targumSplitPosition = currentState.layout.targumSplitState.positionPercentage,
previousMainSplitPosition = currentState.layout.previousPositions.main,
previousTocSplitPosition = currentState.layout.previousPositions.toc,
+ previousNotesSplitPosition = currentState.layout.previousPositions.notes,
previousContentSplitPosition = currentState.layout.previousPositions.content,
previousSourcesSplitPosition = currentState.layout.previousPositions.sources,
previousTargumSplitPosition = currentState.layout.previousPositions.links,
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/SplitDefaults.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/SplitDefaults.kt
index dc46e36c1..a9c22184e 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/SplitDefaults.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/state/SplitDefaults.kt
@@ -9,10 +9,12 @@ object SplitDefaults {
// Default position percentages
const val MAIN: Float = 0.05f // default for mainSplitState (Category panel)
const val TOC: Float = 0.05f // default for tocSplitState (TOC panel)
+ const val NOTES: Float = 0.18f // default for notesSplitState (Notes panel)
const val CONTENT: Float = 0.7f // default for contentSplitState (Commentaries panel)
const val SOURCES: Float = 0.85f // default for Sources panel (smaller than Commentaries)
// Minimum sizes (pixels) for the first pane of each split
const val MIN_MAIN: Float = 150f
const val MIN_TOC: Float = 120f
+ const val MIN_NOTES: Float = 220f
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/components/PaneHeader.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/components/PaneHeader.kt
index 76d22299c..09ac843d2 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/components/PaneHeader.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/components/PaneHeader.kt
@@ -25,6 +25,7 @@ import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import io.github.kdroidfilter.seforimapp.core.presentation.components.HorizontalDivider
import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalIsTouchMode
import io.github.kdroidfilter.seforimapp.theme.PreviewContainer
import org.jetbrains.compose.resources.stringResource
import org.jetbrains.jewel.foundation.theme.JewelTheme
@@ -43,6 +44,9 @@ fun PaneHeader(
) {
val headerHoverSource = interactionSource ?: remember { MutableInteractionSource() }
val isHovered by headerHoverSource.collectIsHoveredAsState()
+ // Touch has no persistent hover, so reveal the actions whenever the user is
+ // interacting by touch (see [LocalIsTouchMode]).
+ val isTouchMode = LocalIsTouchMode.current
val isIslands = ThemeUtils.isIslandsStyle()
val headerBackground =
if (isIslands) {
@@ -76,7 +80,7 @@ fun PaneHeader(
}
AnimatedVisibility(
- visible = isHovered,
+ visible = isHovered || isTouchMode,
enter = fadeIn(),
exit = fadeOut(),
) {
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/components/VerticalBars.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/components/VerticalBars.kt
index 6d51d3abf..c37e3dfb1 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/components/VerticalBars.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/components/VerticalBars.kt
@@ -46,30 +46,16 @@ fun StartVerticalBar(
}
},
bottomContent = {
-// SelectableIconButtonWithToolip(
-// toolTipText = stringResource(Res.string.my_bookmarks),
-// onClick = { },
-// isSelected = false,
-// icon = JournalBookmark,
-// iconDescription = stringResource(Res.string.bookmarks),
-// label = stringResource(Res.string.bookmarks)
-// )
-// SelectableIconButtonWithToolip(
-// toolTipText = stringResource(Res.string.my_commentaries),
-// onClick = { },
-// isSelected = false,
-// icon = JournalText,
-// iconDescription = stringResource(Res.string.my_commentaries_label),
-// label = stringResource(Res.string.my_commentaries_label)
-// )
-// SelectableIconButtonWithToolip(
-// toolTipText = stringResource(Res.string.write_note_tooltip),
-// onClick = { },
-// isSelected = false,
-// icon = NotebookPen,
-// iconDescription = stringResource(Res.string.write_note),
-// label = stringResource(Res.string.write_note)
-// )
+ if (uiState.navigation.selectedBook != null) {
+ SelectableIconButtonWithToolip(
+ toolTipText = stringResource(Res.string.notes_pane_tooltip),
+ onClick = { onEvent(BookContentEvent.ToggleNotes) },
+ isSelected = uiState.notes.isVisible,
+ icon = NotebookPen,
+ iconDescription = stringResource(Res.string.notes_pane),
+ label = stringResource(Res.string.notes_pane),
+ )
+ }
},
)
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/BookContentPanel.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/BookContentPanel.kt
index e54be6e1a..cc8d74fe5 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/BookContentPanel.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/BookContentPanel.kt
@@ -5,9 +5,14 @@ import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateMapOf
+import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
@@ -25,7 +30,9 @@ import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.components.Enha
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.components.asStable
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.bookcontent.views.*
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.bookcontent.views.HomeSearchCallbacks
+import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.notes.NoteDraftAnchor
import io.github.kdroidfilter.seforimapp.features.search.SearchHomeUiState
+import io.github.kdroidfilter.seforimapp.logger.warnln
import io.github.kdroidfilter.seforimlibrary.core.models.ConnectionType
import io.github.santimattius.structured.annotations.StructuredScope
import kotlinx.coroutines.CoroutineScope
@@ -57,6 +64,7 @@ fun BookContentPanel(
),
isSelected: Boolean = true,
bookCharCounts: IntArray? = null,
+ noteDraft: NoteDraftAnchor? = null,
) {
val isIslands = ThemeUtils.isIslandsStyle()
val homeCardModifier =
@@ -101,6 +109,7 @@ fun BookContentPanel(
showDiacritics = showDiacritics,
isSelected = isSelected,
bookCharCounts = bookCharCounts,
+ noteDraft = noteDraft,
)
}
}
@@ -115,9 +124,11 @@ private fun BookContentPanelContent(
showDiacritics: Boolean,
isSelected: Boolean,
bookCharCounts: IntArray?,
+ noteDraft: NoteDraftAnchor? = null,
) {
val providers = uiState.providers ?: return
val selectedBook = uiState.navigation.selectedBook ?: return
+ var isBookContentZoomInProgress by remember { mutableStateOf(false) }
// Create LazyListState AFTER loading check, so anchorId is correctly set
// When restoring with an anchor, use the computed anchorIndex which accounts for
@@ -138,26 +149,46 @@ private fun BookContentPanelContent(
}
val prefetchScope = rememberCoroutineScope()
+ // Line ids whose connections load is currently in flight. The completed-only `connectionsCache`
+ // check is not enough: two requests that arrive before the first load resolves both see the id
+ // as missing and each launch a redundant DB load (the race). Guarding on this set both detects
+ // (logged) and dedups concurrent loads. Mutated only on the composition (Main) thread.
+ val inFlight = remember(selectedBook.id) { mutableSetOf() }
+
fun prefetch(
@StructuredScope scope: CoroutineScope,
missing: List,
) {
+ inFlight.addAll(missing)
scope.launch {
runSuspendCatching { providers.loadLineConnections(missing) }
- .onSuccess { connectionsCache.putAll(it) }
+ .onSuccess { result -> connectionsCache.putAll(result) }
+ .onFailure { e -> warnln { "connections load failed for=$missing: $e" } }
+ inFlight.removeAll(missing.toSet())
}
}
val prefetchConnections =
- remember(providers, connectionsCache) {
+ remember(providers, connectionsCache, inFlight) {
{ ids: List ->
if (ids.isEmpty()) return@remember
- val missing = ids.filterNot { connectionsCache.containsKey(it) }.distinct()
+ // Dedup against in-flight loads so concurrent requests don't launch duplicate DB queries.
+ val missing = ids.filterNot { connectionsCache.containsKey(it) || it in inFlight }.distinct()
if (missing.isEmpty()) return@remember
prefetch(prefetchScope, missing)
}
}
+ // Warm the text of the commentators that were open for the selected line, so that a background
+ // tab (composed but not displayed) has its open commentaries ready and the on-demand pager load
+ // is instant once the tab is shown. Gated on the pane actually being open.
+ val openCommentatorIds = uiState.content.selectedCommentatorIds
+ LaunchedEffect(uiState.content.primarySelectedLineId, openCommentatorIds, uiState.content.showCommentaries) {
+ val lineId = uiState.content.primarySelectedLineId ?: return@LaunchedEffect
+ if (!uiState.content.showCommentaries || openCommentatorIds.isEmpty()) return@LaunchedEffect
+ providers.prefetchCommentaries(lineId, openCommentatorIds)
+ }
+
val isIslands = ThemeUtils.isIslandsStyle()
val hasBottomPane = uiState.content.showCommentaries || uiState.content.showSources
val panelBackground = JewelTheme.globalColors.panelBackground
@@ -182,104 +213,108 @@ private fun BookContentPanelContent(
// Collect paging data here to keep BookContentView skippable
val lazyPagingItems = providers.linesPagingData.collectAsLazyPagingItems()
- Column(modifier = Modifier.fillMaxSize()) {
- EnhancedVerticalSplitPane(
- splitPaneState = uiState.layout.contentSplitState.asStable(),
- modifier = Modifier.weight(1f),
- firstContent = {
- EnhancedHorizontalSplitPane(
- splitPaneState = uiState.layout.targumSplitState.asStable(),
- firstContent = {
- BookContentView(
- bookId = selectedBook.id,
- lazyPagingItems = lazyPagingItems,
- selectedLineIds = uiState.content.selectedLineIds,
- primarySelectedLineId = uiState.content.primarySelectedLineId,
- isTocEntrySelection = uiState.content.isTocEntrySelection,
- onLineSelect = { line, isModifier ->
- onEvent(BookContentEvent.LineSelected(line, isModifier))
- },
- onEvent = onEvent,
- tabId = uiState.tabId,
- showDiacritics = showDiacritics,
- modifier = topPaneCardModifier,
- preservedListState = bookListState,
- scrollIndex = uiState.content.scrollIndex,
- scrollOffset = uiState.content.scrollOffset,
- scrollToLineTimestamp = uiState.content.scrollToLineTimestamp,
- anchorId = uiState.content.anchorId,
- anchorIndex = uiState.content.anchorIndex,
- topAnchorLineId = uiState.content.topAnchorLineId,
- topAnchorTimestamp = uiState.content.topAnchorRequestTimestamp,
- onScroll = { anchorId, anchorIndex, scrollIndex, scrollOffset ->
- onEvent(
- BookContentEvent.ContentScrolled(
- anchorId = anchorId,
- anchorIndex = anchorIndex,
- scrollIndex = scrollIndex,
- scrollOffset = scrollOffset,
- ),
- )
+ CompositionLocalProvider(LocalBookContentZoomInProgress provides isBookContentZoomInProgress) {
+ Column(modifier = Modifier.fillMaxSize()) {
+ EnhancedVerticalSplitPane(
+ splitPaneState = uiState.layout.contentSplitState.asStable(),
+ modifier = Modifier.weight(1f),
+ firstContent = {
+ EnhancedHorizontalSplitPane(
+ splitPaneState = uiState.layout.targumSplitState.asStable(),
+ firstContent = {
+ BookContentView(
+ bookId = selectedBook.id,
+ lazyPagingItems = lazyPagingItems,
+ selectedLineIds = uiState.content.selectedLineIds,
+ primarySelectedLineId = uiState.content.primarySelectedLineId,
+ isTocEntrySelection = uiState.content.isTocEntrySelection,
+ onLineSelect = { line, isModifier ->
+ onEvent(BookContentEvent.LineSelected(line, isModifier))
+ },
+ onEvent = onEvent,
+ tabId = uiState.tabId,
+ showDiacritics = showDiacritics,
+ draftNote = noteDraft,
+ modifier = topPaneCardModifier,
+ preservedListState = bookListState,
+ scrollIndex = uiState.content.scrollIndex,
+ scrollOffset = uiState.content.scrollOffset,
+ scrollToLineTimestamp = uiState.content.scrollToLineTimestamp,
+ anchorId = uiState.content.anchorId,
+ anchorIndex = uiState.content.anchorIndex,
+ topAnchorLineId = uiState.content.topAnchorLineId,
+ topAnchorTimestamp = uiState.content.topAnchorRequestTimestamp,
+ onScroll = { anchorId, anchorIndex, scrollIndex, scrollOffset ->
+ onEvent(
+ BookContentEvent.ContentScrolled(
+ anchorId = anchorId,
+ anchorIndex = anchorIndex,
+ scrollIndex = scrollIndex,
+ scrollOffset = scrollOffset,
+ ),
+ )
+ },
+ altHeadingsByLineId = uiState.altToc.lineHeadingsByLineId.asStableAltHeadings(),
+ lineConnections = connectionsCache,
+ onPrefetchLineConnections = prefetchConnections,
+ isSelected = isSelected,
+ bookCharCounts = bookCharCounts,
+ onPointerZoomInProgressChange = { isBookContentZoomInProgress = it },
+ )
+ },
+ secondContent =
+ if (uiState.content.showTargum) {
+ {
+ TargumPane(
+ uiState = uiState,
+ onEvent = onEvent,
+ lineConnections = connectionsCache,
+ showDiacritics = showDiacritics,
+ modifier = topPaneCardModifier,
+ )
+ }
+ } else {
+ null
},
- altHeadingsByLineId = uiState.altToc.lineHeadingsByLineId.asStableAltHeadings(),
- lineConnections = connectionsCache,
- onPrefetchLineConnections = prefetchConnections,
- isSelected = isSelected,
- bookCharCounts = bookCharCounts,
- )
- },
- secondContent =
- if (uiState.content.showTargum) {
+ )
+ },
+ secondContent =
+ when {
+ uiState.content.showCommentaries -> {
{
- TargumPane(
+ CommentsPane(
uiState = uiState,
onEvent = onEvent,
lineConnections = connectionsCache,
showDiacritics = showDiacritics,
- modifier = topPaneCardModifier,
+ modifier = bottomPaneCardModifier,
)
}
- } else {
- null
- },
- )
- },
- secondContent =
- when {
- uiState.content.showCommentaries -> {
- {
- CommentsPane(
- uiState = uiState,
- onEvent = onEvent,
- lineConnections = connectionsCache,
- showDiacritics = showDiacritics,
- modifier = bottomPaneCardModifier,
- )
}
- }
- uiState.content.showSources -> {
- {
- SourcesPane(
- uiState = uiState,
- onEvent = onEvent,
- lineConnections = connectionsCache,
- showDiacritics = showDiacritics,
- modifier = bottomPaneCardModifier,
- )
+ uiState.content.showSources -> {
+ {
+ SourcesPane(
+ uiState = uiState,
+ onEvent = onEvent,
+ lineConnections = connectionsCache,
+ showDiacritics = showDiacritics,
+ modifier = bottomPaneCardModifier,
+ )
+ }
}
- }
- else -> null
- },
- )
+ else -> null
+ },
+ )
- BreadcrumbSection(
- uiState = uiState,
- onEvent = onEvent,
- verticalPadding = 8.dp,
- isIslands = isIslands,
- )
+ BreadcrumbSection(
+ uiState = uiState,
+ onEvent = onEvent,
+ verticalPadding = 8.dp,
+ isIslands = isIslands,
+ )
+ }
}
}
@@ -288,8 +323,8 @@ private fun LoaderPanel(modifier: Modifier = Modifier) {
Box(
modifier =
modifier
- .fillMaxSize()
- .wrapContentSize(Alignment.Center),
+ .fillMaxSize(),
+ contentAlignment = Alignment.Center,
) {
CircularProgressIndicator()
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/components/CatalogRow.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/components/CatalogRow.kt
index 5fab1ba44..7a371db7d 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/components/CatalogRow.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/components/CatalogRow.kt
@@ -14,7 +14,7 @@ import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.zIndex
-import io.github.kdroidfilter.seforimapp.catalog.PrecomputedCatalog
+import io.github.kdroidfilter.seforimapp.catalog.CatalogPresets
import io.github.kdroidfilter.seforimapp.core.presentation.components.CatalogDropdown
import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
import io.github.kdroidfilter.seforimapp.features.bookcontent.BookContentEvent
@@ -43,46 +43,45 @@ fun CatalogRow(
val buttonModifier = Modifier.widthIn(max = 130.dp)
CatalogDropdown(
- spec = PrecomputedCatalog.Dropdowns.TANAKH,
+ spec = CatalogPresets.Dropdowns.TANAKH,
onEvent = onEvent,
modifier = buttonModifier,
popupWidthMultiplier = 1.50f,
)
CatalogDropdown(
- spec = PrecomputedCatalog.Dropdowns.MISHNA,
+ spec = CatalogPresets.Dropdowns.MISHNA,
onEvent = onEvent,
modifier = buttonModifier,
)
CatalogDropdown(
- spec = PrecomputedCatalog.Dropdowns.BAVLI,
+ spec = CatalogPresets.Dropdowns.BAVLI,
onEvent = onEvent,
modifier = buttonModifier,
popupWidthMultiplier = 1.1f,
)
CatalogDropdown(
- spec = PrecomputedCatalog.Dropdowns.YERUSHALMI,
+ spec = CatalogPresets.Dropdowns.YERUSHALMI,
onEvent = onEvent,
modifier = buttonModifier,
popupWidthMultiplier = 1.1f,
)
CatalogDropdown(
- spec = PrecomputedCatalog.Dropdowns.MISHNE_TORAH,
+ spec = CatalogPresets.Dropdowns.MISHNE_TORAH,
onEvent = onEvent,
modifier = buttonModifier,
popupWidthMultiplier = 1.5f,
)
CatalogDropdown(
- spec = PrecomputedCatalog.Dropdowns.TUR_QUICK_LINKS,
+ spec = CatalogPresets.Dropdowns.TUR_QUICK_LINKS,
onEvent = onEvent,
modifier = buttonModifier,
maxPopupHeight = 130.dp,
)
CatalogDropdown(
- spec = PrecomputedCatalog.Dropdowns.SHULCHAN_ARUCH,
+ spec = CatalogPresets.Dropdowns.SHULCHAN_ARUCH,
onEvent = onEvent,
modifier = buttonModifier,
- maxPopupHeight = 160.dp,
- popupWidthMultiplier = 1.1f,
+ maxPopupHeight = 130.dp,
)
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/AsyncHtmlAnnotation.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/AsyncHtmlAnnotation.kt
new file mode 100644
index 000000000..e2412008a
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/AsyncHtmlAnnotation.kt
@@ -0,0 +1,141 @@
+package io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.bookcontent.views
+
+import androidx.compose.foundation.text.InlineTextContent
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.text.AnnotatedString
+import io.github.kdroidfilter.seforim.htmlparser.HtmlImageContentBuilder
+import io.github.kdroidfilter.seforim.htmlparser.SkiaHtmlImageBuilder
+import io.github.kdroidfilter.seforim.htmlparser.buildAnnotatedFromHtml
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+private const val PLACEHOLDER_CHARS_PER_LINE = 72
+private const val MAX_PLACEHOLDER_LINES = 32
+
+@Stable
+internal data class LineAnnotation(
+ val annotated: AnnotatedString,
+ val inlineContent: Map,
+)
+
+internal data class HtmlAnnotationCacheKey(
+ val itemId: Long,
+ val contentHash: Int,
+ val contentLength: Int,
+ val baseTextSize: Float,
+ val boldScale: Float,
+ val footnoteMarkerColor: Color,
+ val invertImages: Boolean,
+)
+
+@Stable
+internal class StableAnnotatedCache(
+ private val cache: MutableMap,
+) {
+ fun get(key: HtmlAnnotationCacheKey): LineAnnotation? = cache[key]
+
+ fun put(
+ key: HtmlAnnotationCacheKey,
+ value: LineAnnotation,
+ ) {
+ cache[key] = value
+ }
+}
+
+@Composable
+internal fun rememberAsyncHtmlAnnotation(
+ cacheKey: HtmlAnnotationCacheKey,
+ html: String,
+ baseTextSize: Float,
+ boldScale: Float,
+ footnoteMarkerColor: Color,
+ imageColorFilter: @Composable () -> ColorFilter?,
+ annotatedCache: StableAnnotatedCache,
+): LineAnnotation? {
+ val cached = annotatedCache.get(cacheKey)
+ val imageContentBuilder = remember(imageColorFilter) { SkiaHtmlImageBuilder.build(imageColorFilter) }
+ val annotation by produceState(
+ initialValue = cached,
+ cacheKey,
+ html,
+ imageContentBuilder,
+ annotatedCache,
+ ) {
+ value = cached
+ if (cached != null) return@produceState
+
+ val built =
+ withContext(Dispatchers.Default) {
+ buildLineAnnotation(
+ html = html,
+ baseTextSize = baseTextSize,
+ boldScale = boldScale,
+ footnoteMarkerColor = footnoteMarkerColor,
+ imageContentBuilder = imageContentBuilder,
+ )
+ }
+ annotatedCache.put(cacheKey, built)
+ value = built
+ }
+ return annotation
+}
+
+/**
+ * Builds the cache key for an HTML line annotation. Shared by [LineItem] composition and the
+ * off-screen prefetcher so both produce byte-identical keys (a mismatch would defeat the cache).
+ */
+internal fun htmlAnnotationCacheKey(
+ lineId: Long,
+ processedContent: String,
+ baseTextSize: Float,
+ boldScale: Float,
+ footnoteMarkerColor: Color,
+ invertImages: Boolean,
+): HtmlAnnotationCacheKey =
+ HtmlAnnotationCacheKey(
+ itemId = lineId,
+ contentHash = processedContent.hashCode(),
+ contentLength = processedContent.length,
+ baseTextSize = baseTextSize,
+ boldScale = boldScale,
+ footnoteMarkerColor = footnoteMarkerColor,
+ invertImages = invertImages,
+ )
+
+internal fun htmlAnnotationPlaceholderText(contentLength: Int): String {
+ val lineCount =
+ ((contentLength + PLACEHOLDER_CHARS_PER_LINE - 1) / PLACEHOLDER_CHARS_PER_LINE)
+ .coerceIn(1, MAX_PLACEHOLDER_LINES)
+ return buildString {
+ repeat(lineCount) { index ->
+ append(' ')
+ if (index < lineCount - 1) append('\n')
+ }
+ }
+}
+
+internal fun buildLineAnnotation(
+ html: String,
+ baseTextSize: Float,
+ boldScale: Float,
+ footnoteMarkerColor: Color,
+ imageContentBuilder: HtmlImageContentBuilder,
+): LineAnnotation {
+ val inline = mutableMapOf()
+ val annotated =
+ buildAnnotatedFromHtml(
+ html,
+ baseTextSize,
+ boldScale = if (boldScale < 1f) 1f else boldScale,
+ footnoteMarkerColor = footnoteMarkerColor,
+ inlineContent = inline,
+ imageContentBuilder = imageContentBuilder,
+ )
+ return LineAnnotation(annotated, inline.toMap())
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentView.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentView.kt
index eb34ef6a3..a8e07ddf2 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentView.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentView.kt
@@ -14,11 +14,11 @@ import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.InlineTextContent
import androidx.compose.foundation.text.input.TextFieldState
import androidx.compose.runtime.*
import androidx.compose.runtime.mutableStateMapOf
import androidx.compose.ui.Alignment
+import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.drawBehind
@@ -31,12 +31,18 @@ import androidx.compose.ui.graphics.ColorFilter
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.input.key.*
import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.PointerEventType
+import androidx.compose.ui.input.pointer.PointerInputChange
+import androidx.compose.ui.input.pointer.PointerType
import androidx.compose.ui.input.pointer.isCtrlPressed
import androidx.compose.ui.input.pointer.isMetaPressed
import androidx.compose.ui.input.pointer.isPrimaryPressed
+import androidx.compose.ui.input.pointer.isSecondaryPressed
+import androidx.compose.ui.input.pointer.onPointerEvent
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.TextLayoutResult
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.rememberTextMeasurer
@@ -50,15 +56,21 @@ import androidx.paging.compose.LazyPagingItems
import androidx.paging.compose.itemKey
import io.github.kdroidfilter.seforim.htmlparser.SkiaHtmlImageBuilder
import io.github.kdroidfilter.seforim.htmlparser.buildAnnotatedFromHtml
+import io.github.kdroidfilter.seforimapp.core.annotations.UserHighlight
+import io.github.kdroidfilter.seforimapp.core.annotations.UserNote
import io.github.kdroidfilter.seforimapp.core.presentation.components.CountBadge
import io.github.kdroidfilter.seforimapp.core.presentation.components.FindInPageBar
import io.github.kdroidfilter.seforimapp.core.presentation.tabs.LocalTabSelected
+import io.github.kdroidfilter.seforimapp.core.presentation.text.applyUserHighlights
+import io.github.kdroidfilter.seforimapp.core.presentation.text.drawNoteUnderlines
import io.github.kdroidfilter.seforimapp.core.presentation.text.findAllMatchesOriginal
+import io.github.kdroidfilter.seforimapp.core.presentation.text.noteDisplayRanges
import io.github.kdroidfilter.seforimapp.core.presentation.typography.FontCatalog
import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
import io.github.kdroidfilter.seforimapp.features.bookcontent.BookContentEvent
import io.github.kdroidfilter.seforimapp.features.bookcontent.state.LineConnectionsSnapshot
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.components.SafeSelectionContainer
+import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.notes.NoteDraftAnchor
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import io.github.kdroidfilter.seforimapp.framework.platform.PlatformInfo
import io.github.kdroidfilter.seforimapp.logger.debugln
@@ -67,16 +79,24 @@ import io.github.kdroidfilter.seforimlibrary.core.models.Line
import io.github.kdroidfilter.seforimlibrary.core.text.HebrewTextUtils
import io.github.santimattius.structured.annotations.StructuredScope
import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.FlowPreview
+import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
+import kotlinx.coroutines.ensureActive
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeoutOrNull
import org.jetbrains.jewel.foundation.theme.JewelTheme
import org.jetbrains.jewel.ui.component.CircularProgressIndicator
import org.jetbrains.jewel.ui.component.Text
+import kotlin.math.abs
+import kotlin.math.exp
+import kotlin.time.Duration.Companion.milliseconds
-@OptIn(FlowPreview::class)
+@OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class, ExperimentalComposeUiApi::class)
@Suppress(
"ComposeUnstableCollections",
"ParamsComparedByRef",
@@ -92,6 +112,7 @@ fun BookContentView(
tabId: String,
showDiacritics: Boolean,
modifier: Modifier = Modifier,
+ draftNote: NoteDraftAnchor? = null,
isTocEntrySelection: Boolean = false,
preservedListState: LazyListState? = null,
scrollIndex: Int = 0,
@@ -107,6 +128,7 @@ fun BookContentView(
onPrefetchLineConnections: (List) -> Unit = {},
isSelected: Boolean = true,
bookCharCounts: IntArray? = null,
+ onPointerZoomInProgressChange: (Boolean) -> Unit = {},
) {
// Don't use the saved scroll position initially if we have an anchor
// The restoration will be handled after pagination loads
@@ -126,11 +148,128 @@ fun BookContentView(
// Collect text size from settings
val rawTextSize by AppSettings.textSizeFlow.collectAsState()
val isTabSelected = LocalTabSelected.current
+ val currentOnPointerZoomInProgressChange by rememberUpdatedState(onPointerZoomInProgressChange)
+ val pointerZoomScope = rememberCoroutineScope()
+ var pointerZoomRenderJob by remember { mutableStateOf(null) }
+ var pointerZoomCommitJob by remember { mutableStateOf(null) }
+ var pointerZoomEndJob by remember { mutableStateOf(null) }
+ var isPointerZooming by remember { mutableStateOf(false) }
+ var pointerZoomRenderedTextSize by remember { mutableFloatStateOf(rawTextSize) }
+ val pointerZoomAccumulator = remember { PointerZoomAccumulator(rawTextSize) }
+
+ fun setPointerZooming(value: Boolean) {
+ if (isPointerZooming != value) {
+ isPointerZooming = value
+ currentOnPointerZoomInProgressChange(value)
+ }
+ }
+
+ fun beginPointerZoom() {
+ if (!isPointerZooming) {
+ val currentTextSize = AppSettings.textSizeFlow.value
+ pointerZoomAccumulator.targetTextSize = currentTextSize
+ pointerZoomRenderedTextSize = currentTextSize
+ setPointerZooming(true)
+ }
+ pointerZoomEndJob?.cancel()
+ pointerZoomEndJob = null
+ }
+
+ fun applyPointerZoomTargetToMainContent() {
+ val targetTextSize =
+ pointerZoomAccumulator.targetTextSize.coerceIn(AppSettings.MIN_TEXT_SIZE, AppSettings.MAX_TEXT_SIZE)
+ if (abs(targetTextSize - pointerZoomRenderedTextSize) >= 0.01f) {
+ pointerZoomRenderedTextSize = targetTextSize
+ }
+ }
+
+ fun schedulePointerZoomRenderUpdate() {
+ if (pointerZoomRenderJob?.isActive == true) return
+
+ pointerZoomRenderJob =
+ pointerZoomScope.launch {
+ withFrameNanos { }
+ applyPointerZoomTargetToMainContent()
+ pointerZoomRenderJob = null
+ }
+ }
+
+ fun finishPointerZoom() {
+ pointerZoomEndJob?.cancel()
+ pointerZoomEndJob =
+ pointerZoomScope.launch {
+ delay(50.milliseconds)
+ setPointerZooming(false)
+ }
+ }
+
+ fun commitPointerZoom(cancelPendingJob: Boolean = true) {
+ if (!isPointerZooming) return
+ if (cancelPendingJob) {
+ pointerZoomCommitJob?.cancel()
+ }
+ pointerZoomCommitJob = null
+ pointerZoomRenderJob?.cancel()
+ pointerZoomRenderJob = null
+
+ val targetTextSize =
+ pointerZoomAccumulator.targetTextSize.coerceIn(AppSettings.MIN_TEXT_SIZE, AppSettings.MAX_TEXT_SIZE)
+ if (abs(targetTextSize - pointerZoomRenderedTextSize) >= 0.01f) {
+ pointerZoomRenderedTextSize = targetTextSize
+ }
+ if (abs(targetTextSize - AppSettings.textSizeFlow.value) >= 0.01f) {
+ AppSettings.setTextSize(targetTextSize)
+ }
+ pointerZoomAccumulator.targetTextSize = targetTextSize
+ finishPointerZoom()
+ }
+
+ fun schedulePointerZoomCommit() {
+ pointerZoomCommitJob?.cancel()
+ pointerZoomCommitJob =
+ pointerZoomScope.launch {
+ delay(120.milliseconds)
+ commitPointerZoom(cancelPendingJob = false)
+ }
+ }
+
+ fun applyPointerZoomFactor(factor: Float) {
+ if (!factor.isFinite() || factor <= 0f) return
+
+ beginPointerZoom()
+ val currentTextSize = pointerZoomAccumulator.targetTextSize
+ val newTextSize =
+ (currentTextSize * factor)
+ .coerceIn(AppSettings.MIN_TEXT_SIZE, AppSettings.MAX_TEXT_SIZE)
+
+ if (abs(newTextSize - currentTextSize) >= 0.01f) {
+ pointerZoomAccumulator.targetTextSize = newTextSize
+ schedulePointerZoomRenderUpdate()
+ }
+ }
+
+ val applyPointerZoomFactorState = rememberUpdatedState<(Float) -> Unit> { factor -> applyPointerZoomFactor(factor) }
+
+ LaunchedEffect(rawTextSize, isPointerZooming) {
+ if (!isPointerZooming) {
+ pointerZoomAccumulator.targetTextSize = rawTextSize
+ pointerZoomRenderedTextSize = rawTextSize
+ }
+ }
+
+ DisposableEffect(Unit) {
+ onDispose {
+ pointerZoomRenderJob?.cancel()
+ pointerZoomCommitJob?.cancel()
+ pointerZoomEndJob?.cancel()
+ currentOnPointerZoomInProgressChange(false)
+ }
+ }
// Animate text size changes only for the active tab; background tabs snap instantly
val textSize by animateFloatAsState(
- targetValue = rawTextSize,
- animationSpec = if (isTabSelected) tween(durationMillis = 300) else snap(),
+ targetValue = if (isPointerZooming) pointerZoomRenderedTextSize else rawTextSize,
+ animationSpec = if (isTabSelected && !isPointerZooming) tween(durationMillis = 300) else snap(),
label = "textSizeAnimation",
)
@@ -154,7 +293,11 @@ fun BookContentView(
if (PlatformInfo.isMacOS && lacksBold) 1.08f else 1.0f
}
- // Track restoration state per book
+ // Track restoration state per book. Plain remember: a tab is kept alive across switches and is
+ // never rebuilt on a switch, so this only resets when the composition is actually torn down
+ // (the tab navigates to a different book/destination, or is closed). In that case we WANT the
+ // masking below to replay, because the paged list reloads from empty and would otherwise show
+ // the top then jump to the saved position.
var hasRestored by remember(bookId) { mutableStateOf(false) }
// Track the restored anchor to avoid re-restoration
@@ -163,14 +306,16 @@ fun BookContentView(
// Track if this is the initial book open (vs changing TOC within same book)
var isInitialBookOpen by remember(bookId) { mutableStateOf(true) }
- // Hide content until initial scroll is complete to prevent visual glitch
- // Only apply on initial book open, not when changing TOC entries
- val needsInitialPositioning = isInitialBookOpen && topAnchorLineId != -1L && !hasRestored
- val contentAlpha by animateFloatAsState(
- targetValue = if (needsInitialPositioning) 0f else 1f,
- animationSpec = tween(durationMillis = if (needsInitialPositioning) 0 else 50),
- label = "contentAlpha",
- )
+ // Hide content until initial scroll is complete to prevent a visual glitch (showing the top
+ // then jumping to the saved position). The reveal is instant (no fade). It only runs on a cold
+ // open / session restore; a tab switch keeps the list alive and positioned, so nothing masks.
+ val hasSavedInitialPosition = anchorId != -1L || scrollIndex > 0 || scrollOffset > 0
+ val hasTopAnchorRequest = topAnchorTimestamp != 0L && topAnchorLineId != -1L
+ val needsInitialPositioning =
+ isInitialBookOpen &&
+ !hasRestored &&
+ (hasTopAnchorRequest || (topAnchorTimestamp == 0L && hasSavedInitialPosition))
+ val contentAlpha = if (needsInitialPositioning) 0f else 1f
// selectedLineId is now passed as a parameter for stability
@@ -187,12 +332,39 @@ fun BookContentView(
}
snapshotFlow { lazyPagingItems.itemSnapshotList.items }
.distinctUntilChanged()
+ .catch { e -> debugln { "visible-lines flow failed: $e" } }
.collect { items -> selectionContext.setVisibleLines(tabId, items) }
}
DisposableEffect(tabId, selectionContext) {
onDispose { selectionContext.clearVisibleLinesIfOwnedBy(tabId) }
}
+ // Persisted user highlights for this book: loaded once into the store's per-book cache,
+ // then read from memory on the render hot path (no per-line DB access). Grouped by line so
+ // a single highlight change only recomposes the affected line — unhighlighted lines receive
+ // the stable emptyList() singleton and are skipped by strong skipping.
+ val highlightStore = LocalAppGraph.current.highlightStore
+ LaunchedEffect(bookId, highlightStore) { highlightStore.loadBook(bookId) }
+ val highlightsByBook by highlightStore.highlightsByBook.collectAsState()
+ val highlightsByLine =
+ remember(highlightsByBook, bookId) {
+ highlightsByBook[bookId].orEmpty().groupBy { it.lineId }
+ }
+
+ // Persisted user notes for this book: same per-book cache + group-by-line strategy as
+ // highlights. Noted ranges are underlined on the line; the notes pane shows the bodies.
+ val noteStore = LocalAppGraph.current.noteStore
+ LaunchedEffect(bookId, noteStore) { noteStore.loadBook(bookId) }
+ val notesByBook by noteStore.notesByBook.collectAsState()
+ val notesByLine =
+ remember(notesByBook, bookId, draftNote) {
+ val persisted = notesByBook[bookId].orEmpty().groupBy { it.lineId }
+ // Underline the pending draft range immediately, before it is saved.
+ val d = draftNote ?: return@remember persisted
+ val transient = UserNote(id = -1L, lineId = d.lineId, startOffset = d.startOffset, endOffset = d.endOffset, note = "")
+ persisted + (d.lineId to (persisted[d.lineId].orEmpty() + transient))
+ }
+
// Prefetch connection data for visible lines to avoid per-line DB calls
LaunchedEffect(listState, lazyPagingItems, onPrefetchLineConnections) {
snapshotFlow {
@@ -211,14 +383,18 @@ fun BookContentView(
}.map { ids -> ids.distinct() }
.filter { it.isNotEmpty() }
.distinctUntilChanged()
- .debounce(150)
- .collect { ids -> onPrefetchLineConnections(ids) }
+ .debounce(150.milliseconds)
+ .catch { e -> debugln { "prefetch-connections flow failed: $e" } }
+ .collect { ids ->
+ onPrefetchLineConnections(ids)
+ }
}
// Ensure the selected line is prefetched even if it is not visible yet
LaunchedEffect(primarySelectedLineId, lineConnections) {
val id = primarySelectedLineId ?: return@LaunchedEffect
- if (lineConnections[id] == null) {
+ val alreadyCached = lineConnections[id] != null
+ if (!alreadyCached) {
onPrefetchLineConnections(listOf(id))
}
}
@@ -227,6 +403,11 @@ fun BookContentView(
// Only scrolls if the line is outside the visible viewport.
LaunchedEffect(scrollToLineTimestamp, primarySelectedLineId, topAnchorTimestamp, topAnchorLineId) {
if (primarySelectedLineId == null) return@LaunchedEffect
+ // Skip while this tab isn't the selected one (composed but not displayed): the initial
+ // bring-into-view must not override the anchor restoration. isTabSelected is intentionally
+ // NOT a key here, so becoming selected doesn't re-trigger a jump — real selection events
+ // (new timestamp) still run.
+ if (!isTabSelected) return@LaunchedEffect
// Skip minimal bring-into-view when a top-anchoring request is active for this selection
val isTopAnchorRequest =
@@ -234,7 +415,7 @@ fun BookContentView(
if (isTopAnchorRequest) return@LaunchedEffect
while (lazyPagingItems.loadState.refresh is LoadState.Loading) {
- delay(16)
+ delay(16.milliseconds)
}
val snapshot = lazyPagingItems.itemSnapshotList
@@ -268,7 +449,7 @@ fun BookContentView(
// Wait for any ongoing refresh to complete
while (lazyPagingItems.loadState.refresh is LoadState.Loading) {
- delay(16)
+ delay(16.milliseconds)
}
// Helper to locate the target index in the current snapshot
@@ -279,18 +460,19 @@ fun BookContentView(
var targetIndex = currentTargetIndex()
if (targetIndex == null) {
- debugln { "Top-anchor target $topAnchorLineId not yet in snapshot; waiting" }
- withTimeoutOrNull(1500L) {
+ withTimeoutOrNull(1500L.milliseconds) {
snapshotFlow { lazyPagingItems.itemSnapshotList.items }
- .map { items -> items.indices.firstOrNull { items[it].id == topAnchorLineId } }
- .filterNotNull()
- .first()
+ .mapNotNull { items ->
+ items.indices.firstOrNull {
+ items[it].id ==
+ topAnchorLineId
+ }
+ }.first()
.also { idx -> targetIndex = idx }
}
}
targetIndex?.let { idx ->
- debugln { "Top-anchoring to index $idx for line $topAnchorLineId" }
listState.scrollToItem(idx, 0)
restoredAnchorId = topAnchorLineId
hasRestored = true
@@ -304,10 +486,13 @@ fun BookContentView(
LaunchedEffect(bookId, topAnchorTimestamp, anchorId, scrollIndex, scrollOffset) {
if (topAnchorTimestamp != 0L) return@LaunchedEffect
if (hasRestored) return@LaunchedEffect
+ // On a cold open / session restore this positions the list and the contentAlpha reveal
+ // plays once. A tab switch no longer re-runs this — the tab stays composed and the list
+ // keeps its position.
// Wait for initial page load to complete
while (lazyPagingItems.loadState.refresh is LoadState.Loading) {
- delay(16)
+ delay(16.milliseconds)
}
if (lazyPagingItems.itemCount <= 0) return@LaunchedEffect
@@ -321,20 +506,22 @@ fun BookContentView(
var idx = currentAnchorIndex()
if (idx == null) {
- debugln { "Saved anchor $anchorId not yet in snapshot; waiting" }
- withTimeoutOrNull(1500L) {
+ withTimeoutOrNull(1500L.milliseconds) {
snapshotFlow { lazyPagingItems.itemSnapshotList }
- .map { snapshot -> snapshot.indices.firstOrNull { snapshot[it]?.id == anchorId } }
- .filterNotNull()
- .first()
+ .mapNotNull { snapshot ->
+ snapshot.indices.firstOrNull {
+ snapshot[it]?.id ==
+ anchorId
+ }
+ }.first()
.also { resolved -> idx = resolved }
}
}
idx?.let { resolved ->
- debugln { "Restoring by saved anchor: idx=$resolved, offset=$scrollOffset" }
listState.scrollToItem(resolved, scrollOffset.coerceAtLeast(0))
hasRestored = true
+ isInitialBookOpen = false
restoredAnchorId = anchorId
return@LaunchedEffect
}
@@ -345,10 +532,14 @@ fun BookContentView(
val itemCount = lazyPagingItems.itemCount
val targetIndex = scrollIndex.coerceIn(0, maxOf(0, itemCount - 1))
val targetOffset = scrollOffset.coerceAtLeast(0)
- debugln { "Restoring by index/offset: index=$targetIndex, offset=$targetOffset" }
listState.scrollToItem(targetIndex, targetOffset)
hasRestored = true
+ isInitialBookOpen = false
+ return@LaunchedEffect
}
+
+ hasRestored = true
+ isInitialBookOpen = false
}
// Save scroll position with anchor information - optimized with derivedStateOf
@@ -386,31 +577,43 @@ fun BookContentView(
val savedAnchorIdUpdated by rememberUpdatedState(anchorId)
val savedAnchorIndexUpdated by rememberUpdatedState(anchorIndex)
- LaunchedEffect(listState, lazyPagingItems) {
- fun maybeSave(data: AnchorData) {
- // Guard: on cold-boot restore, don't overwrite the persisted position with an initial transient emission
- // before the restoration effect has applied the saved anchor/offset.
- val hasPersistedPosition =
- savedAnchorIdUpdated > 0 || savedScrollIndexUpdated > 0 || savedScrollOffsetUpdated > 0
- if (!hasRestoredUpdated && hasPersistedPosition) {
- return
- }
+ fun maybeSave(data: AnchorData) {
+ // Guard: on cold-boot restore, don't overwrite the persisted position with an initial transient emission
+ // before the restoration effect has applied the saved anchor/offset.
+ val hasPersistedPosition =
+ savedAnchorIdUpdated > 0 || savedScrollIndexUpdated > 0 || savedScrollOffsetUpdated > 0
+ if (!hasRestoredUpdated && hasPersistedPosition) {
+ return
+ }
- // Avoid wiping a previously known anchor when the list hasn't resolved item keys yet (e.g., while loading).
- val stableAnchorId = data.anchorId.takeIf { it > 0 } ?: savedAnchorIdUpdated
- val stableAnchorIndex = if (data.anchorId > 0) data.anchorIndex else savedAnchorIndexUpdated
+ // Avoid wiping a previously known anchor when the list hasn't resolved item keys yet (e.g., while loading).
+ val stableAnchorId = data.anchorId.takeIf { it > 0 } ?: savedAnchorIdUpdated
+ val stableAnchorIndex = if (data.anchorId > 0) data.anchorIndex else savedAnchorIndexUpdated
- debugln {
- "Saving scroll: anchor=$stableAnchorId, index=${data.scrollIndex}, offset=${data.scrollOffset}"
- }
- onScrollUpdated(stableAnchorId, stableAnchorIndex, data.scrollIndex, data.scrollOffset)
- }
+ onScrollUpdated(stableAnchorId, stableAnchorIndex, data.scrollIndex, data.scrollOffset)
+ }
+ DisposableEffect(listState, lazyPagingItems) {
+ onDispose { maybeSave(scrollData.value) }
+ }
+
+ LaunchedEffect(listState, lazyPagingItems) {
// While scrolling, sample periodically so a close during an active scroll still restores closely.
+ // Gated by isScrollInProgress so the `sample` ticker only runs during an active scroll —
+ // otherwise its fixedPeriodTicker keeps the FlushCoroutineDispatcher waking up at 5 Hz forever
+ // and the Compose scene re-renders every tick even at idle.
launch {
- snapshotFlow { scrollData.value }
+ snapshotFlow { listState.isScrollInProgress }
.distinctUntilChanged()
- .sample(200)
+ .flatMapLatest { inProgress ->
+ if (inProgress) {
+ snapshotFlow { scrollData.value }
+ .distinctUntilChanged()
+ .sample(200.milliseconds)
+ } else {
+ emptyFlow()
+ }
+ }.catch { e -> debugln { "scroll-save flow failed: $e" } }
.collect { data -> maybeSave(data) }
}
@@ -419,6 +622,7 @@ fun BookContentView(
snapshotFlow { listState.isScrollInProgress }
.distinctUntilChanged()
.filter { inProgress -> !inProgress }
+ .catch { e -> debugln { "scroll-stop flush flow failed: $e" } }
.collect {
// Wait one frame so layoutInfo/visibleItemsInfo reflect the final settled position.
withFrameNanos { }
@@ -440,7 +644,7 @@ fun BookContentView(
}
// Smart mode: get highlight terms from search engine with dictionary expansion
- val appGraph = io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph.current
+ val appGraph = LocalAppGraph.current
val smartHighlightTerms by remember(smartModeEnabled, findState) {
derivedStateOf {
if (smartModeEnabled) {
@@ -460,11 +664,84 @@ fun BookContentView(
var currentMatchLineId by remember { mutableStateOf(null) }
var currentMatchStart by remember { mutableIntStateOf(-1) }
val plainTextCache = remember(bookId) { mutableStateMapOf() }
+
+ // Theme-derived inputs to the HTML annotation, hoisted here so the off-screen prefetcher
+ // can build keys/annotations identical to those produced inside LineItem.
+ val isDarkTheme = JewelTheme.isDark
+ val footnoteMarkerColor = JewelTheme.globalColors.outlines.focused
+ val prefetchImageBuilder =
+ remember(isDarkTheme) {
+ SkiaHtmlImageBuilder.build { if (isDarkTheme) SkiaHtmlImageBuilder.InvertColorFilter else null }
+ }
+
+ // Backed by a ConcurrentHashMap: the prefetcher writes from Dispatchers.Default while
+ // LineItem reads during composition on the main thread.
val stableAnnotatedCache =
remember(bookId, textSize, boldScaleForPlatform, showDiacritics) {
- StableAnnotatedCache(mutableStateMapOf())
+ StableAnnotatedCache(java.util.concurrent.ConcurrentHashMap())
}
+ // Warm the annotation cache for lines just outside the viewport so they render straight from
+ // cache (no async placeholder flash, no height reflow) by the time they scroll into view.
+ // conflate() (not collectLatest) keeps the latest viewport range without cancelling an
+ // in-flight build batch — so fast scrolling still makes forward progress on parsing.
+ LaunchedEffect(
+ listState,
+ lazyPagingItems,
+ stableAnnotatedCache,
+ prefetchImageBuilder,
+ textSize,
+ boldScaleForPlatform,
+ showDiacritics,
+ footnoteMarkerColor,
+ isDarkTheme,
+ ) {
+ snapshotFlow {
+ val visible = listState.layoutInfo.visibleItemsInfo
+ if (visible.isEmpty()) {
+ IntRange.EMPTY
+ } else {
+ (visible.first().index - HTML_PREFETCH_BEHIND)..(visible.last().index + HTML_PREFETCH_AHEAD)
+ }
+ }.distinctUntilChanged()
+ .conflate()
+ .catch { e -> debugln { "annotation-prefetch flow failed: $e" } }
+ .collect { range ->
+ if (range.isEmpty()) return@collect
+ val count = lazyPagingItems.itemCount
+ // Snapshot candidate lines on the main thread; peek() never triggers a page load.
+ val lines = range.mapNotNull { i -> if (i in 0 until count) lazyPagingItems.peek(i) else null }
+ if (lines.isEmpty()) return@collect
+ withContext(Dispatchers.Default) {
+ for (line in lines) {
+ ensureActive()
+ val processed =
+ if (showDiacritics) line.content else HebrewTextUtils.removeAllDiacritics(line.content)
+ val key =
+ htmlAnnotationCacheKey(
+ lineId = line.id,
+ processedContent = processed,
+ baseTextSize = textSize,
+ boldScale = boldScaleForPlatform,
+ footnoteMarkerColor = footnoteMarkerColor,
+ invertImages = isDarkTheme,
+ )
+ if (stableAnnotatedCache.get(key) != null) continue
+ stableAnnotatedCache.put(
+ key,
+ buildLineAnnotation(
+ html = processed,
+ baseTextSize = textSize,
+ boldScale = boldScaleForPlatform,
+ footnoteMarkerColor = footnoteMarkerColor,
+ imageContentBuilder = prefetchImageBuilder,
+ ),
+ )
+ }
+ }
+ }
+ }
+
// Navigate to next/previous line containing the query (wrap-around)
val scope = rememberCoroutineScope()
@@ -588,7 +865,56 @@ fun BookContentView(
modifier
.fillMaxSize()
.graphicsLayer { alpha = contentAlpha } // Hide until positioned to prevent glitch
- .focusRequester(focusRequester)
+ .onPointerEvent(PointerEventType.Scroll) { event ->
+ val isZoomScroll = event.keyboardModifiers.isCtrlPressed || event.keyboardModifiers.isMetaPressed
+ if (!isZoomScroll) return@onPointerEvent
+
+ val scrollDelta = event.changes.firstOrNull()?.scrollDelta ?: Offset.Zero
+ val zoomDelta =
+ if (abs(scrollDelta.y) >= abs(scrollDelta.x)) {
+ scrollDelta.y
+ } else {
+ scrollDelta.x
+ }
+ if (zoomDelta == 0f) return@onPointerEvent
+
+ val exponent = (-zoomDelta * 0.08f).coerceIn(-0.25f, 0.25f)
+ applyPointerZoomFactorState.value(exp(exponent.toDouble()).toFloat())
+ schedulePointerZoomCommit()
+ event.changes.forEach { it.consume() }
+ }.pointerInput(Unit) {
+ awaitEachGesture {
+ var previousDistance = 0f
+ var hasZoomed = false
+
+ do {
+ val event = awaitPointerEvent(PointerEventPass.Main)
+ val pressedChanges = event.changes.filter { it.pressed }
+
+ if (pressedChanges.size >= 2) {
+ val distance = averageDistanceToCentroid(pressedChanges)
+ if (previousDistance > 0f && distance > 0f) {
+ val zoomFactor = (distance / previousDistance).coerceIn(0.85f, 1.18f)
+ if (abs(zoomFactor - 1f) > 0.002f) {
+ applyPointerZoomFactorState.value(zoomFactor)
+ hasZoomed = true
+ }
+ }
+ previousDistance = distance
+
+ if (hasZoomed) {
+ event.changes.forEach { it.consume() }
+ }
+ } else {
+ previousDistance = 0f
+ }
+ } while (event.changes.any { it.pressed })
+
+ if (hasZoomed) {
+ commitPointerZoom()
+ }
+ }
+ }.focusRequester(focusRequester)
.onPreviewKeyEvent(previewKeyHandler)
.focusable(),
) {
@@ -680,9 +1006,15 @@ fun BookContentView(
}
}
Box(modifier = Modifier.padding(vertical = LineItemVerticalPaddingPerSide)) {
+ // Stable per-line list: unhighlighted lines get the emptyList()
+ // singleton, so only lines whose highlights changed recompose.
+ val lineHighlights = highlightsByLine[line.id] ?: emptyList()
+ val lineNotes = notesByLine[line.id] ?: emptyList()
LineItem(
lineId = line.id,
lineContent = line.content,
+ userHighlights = lineHighlights,
+ userNotes = lineNotes,
fontFamily = hebrewFontFamily,
onClick = { isModifier -> onLineSelect(line, isModifier) },
isSelected = isCurrentSelected,
@@ -702,6 +1034,12 @@ fun BookContentView(
textLayoutWidthPx = width
}
},
+ onContextClick = {
+ selectionContext.setCurrentLineId(line.id)
+ // Drop any stale comments-pane anchor so a main-pane
+ // highlight never lands on a commentary line.
+ selectionContext.setActiveCommentaryColumn(emptyList())
+ },
)
}
}
@@ -867,6 +1205,11 @@ fun BookContentView(
// changing this value updates both the layout and the scrollbar metrics.
internal val LineItemVerticalPaddingPerSide = 8.dp
+// How many lines to pre-parse on either side of the viewport. Forward gets a larger buffer
+// since scrolling down is the dominant direction in a reading app.
+private const val HTML_PREFETCH_AHEAD = 16
+private const val HTML_PREFETCH_BEHIND = 8
+
// Data class for anchor information
private data class AnchorData(
val anchorId: Long,
@@ -875,6 +1218,28 @@ private data class AnchorData(
val scrollOffset: Int,
)
+private fun averageDistanceToCentroid(changes: List): Float {
+ if (changes.isEmpty()) return 0f
+
+ var centroid = Offset.Zero
+ changes.forEach { change ->
+ centroid += change.position
+ }
+ centroid /= changes.size.toFloat()
+
+ var totalDistance = 0f
+ changes.forEach { change ->
+ totalDistance += (change.position - centroid).getDistance()
+ }
+ return totalDistance / changes.size.toFloat()
+}
+
+private class PointerZoomAccumulator(
+ initialTextSize: Float,
+) {
+ var targetTextSize: Float = initialTextSize
+}
+
/**
* Stable wrapper for alt headings map to avoid unnecessary recompositions.
* The map content is considered stable once created.
@@ -892,29 +1257,6 @@ class StableAltHeadings(
fun Map>.asStableAltHeadings(): StableAltHeadings = StableAltHeadings(this)
-/**
- * Paired output of [buildAnnotatedFromHtml]: styled text plus the inline-content map
- * required to display inline images (base64 data URIs embedded by the Sefaria pipeline).
- */
-@Stable
-data class LineAnnotation(
- val annotated: AnnotatedString,
- val inlineContent: Map,
-)
-
-/**
- * Stable wrapper for annotated string cache to avoid unnecessary recompositions.
- */
-@Stable
-class StableAnnotatedCache(
- val cache: MutableMap,
-) {
- fun getOrPut(
- lineId: Long,
- defaultValue: () -> LineAnnotation,
- ): LineAnnotation = cache.getOrPut(lineId, defaultValue)
-}
-
@Composable
private fun AltHeadingItem(
entryId: Long,
@@ -948,7 +1290,7 @@ private fun AltHeadingItem(
}
}
-@OptIn(ExperimentalFoundationApi::class)
+@OptIn(ExperimentalFoundationApi::class, ExperimentalComposeUiApi::class)
@Composable
private fun LineItem(
lineId: Long,
@@ -965,7 +1307,10 @@ private fun LineItem(
currentMatchStart: Int? = null,
annotatedCache: StableAnnotatedCache? = null,
showDiacritics: Boolean = true,
+ userHighlights: List = emptyList(),
+ userNotes: List = emptyList(),
onLayoutWidthMeasure: (Int) -> Unit = {},
+ onContextClick: () -> Unit = {},
) {
// Process content: remove diacritics if setting is disabled
val processedContent =
@@ -987,27 +1332,82 @@ private fun LineItem(
{ if (isDarkTheme) SkiaHtmlImageBuilder.InvertColorFilter else null }
}
- // Memoize the annotated string with proper keys
- val lineAnnotation =
- remember(lineId, processedContent, baseTextSize, boldScale, annotatedCache, showDiacritics, footnoteMarkerColor) {
- fun build(): LineAnnotation {
- val inline = mutableMapOf()
- val annotated =
- buildAnnotatedFromHtml(
- processedContent,
- baseTextSize,
- boldScale = if (boldScale < 1f) 1f else boldScale,
- footnoteMarkerColor = footnoteMarkerColor,
- inlineContent = inline,
- imageContentBuilder = SkiaHtmlImageBuilder.build(imageColorFilter),
- )
- return LineAnnotation(annotated, inline)
+ val textModifier =
+ remember(lineId) {
+ Modifier.fillMaxWidth()
+ }.pointerInput(lineId) {
+ awaitEachGesture {
+ // Wait for press and capture keyboard modifiers from the event.
+ // Mouse reports a primary button; touch contacts have an empty
+ // button mask (PointerType.Touch, like iOS), so accept either.
+ val downEvent = awaitPointerEvent(PointerEventPass.Main)
+ val isTouchDown = downEvent.changes.any { it.type == PointerType.Touch && it.pressed }
+ if (!downEvent.buttons.isPrimaryPressed && !isTouchDown) return@awaitEachGesture
+ val isModifier = downEvent.keyboardModifiers.isCtrlPressed || downEvent.keyboardModifiers.isMetaPressed
+ // Wait for release
+ val up = waitForUpOrCancellation()
+ if (up != null && !up.isConsumed) {
+ onClick(isModifier)
+ }
}
- annotatedCache?.getOrPut(lineId) { build() } ?: build()
+ }.onPointerEvent(PointerEventType.Press) { event ->
+ // Record this line as the right-click target so the context menu can offer a
+ // "copy link to this line" action even when no text is selected.
+ if (event.buttons.isSecondaryPressed) onContextClick()
+ }
+
+ val localAnnotatedCache = remember { StableAnnotatedCache(mutableStateMapOf()) }
+ val annotationCache = annotatedCache ?: localAnnotatedCache
+ val annotationCacheKey =
+ remember(lineId, processedContent, baseTextSize, boldScale, footnoteMarkerColor, isDarkTheme) {
+ htmlAnnotationCacheKey(
+ lineId = lineId,
+ processedContent = processedContent,
+ baseTextSize = baseTextSize,
+ boldScale = boldScale,
+ footnoteMarkerColor = footnoteMarkerColor,
+ invertImages = isDarkTheme,
+ )
}
+
+ val lineAnnotation =
+ rememberAsyncHtmlAnnotation(
+ cacheKey = annotationCacheKey,
+ html = processedContent,
+ baseTextSize = baseTextSize,
+ boldScale = boldScale,
+ footnoteMarkerColor = footnoteMarkerColor,
+ imageColorFilter = imageColorFilter,
+ annotatedCache = annotationCache,
+ )
+
+ if (lineAnnotation == null) {
+ Text(
+ text = htmlAnnotationPlaceholderText(processedContent.length),
+ textAlign = TextAlign.Justify,
+ fontFamily = fontFamily,
+ fontSize = baseTextSize.sp,
+ lineHeight = (baseTextSize * lineHeight).sp,
+ modifier = textModifier,
+ onTextLayout = { result ->
+ val cw = result.layoutInput.constraints.maxWidth
+ if (cw > 0 && cw != Int.MAX_VALUE) onLayoutWidthMeasure(cw)
+ },
+ )
+ return
+ }
+
val annotated = lineAnnotation.annotated
val inlineImageContent = lineAnnotation.inlineContent
+ // Plain text of the line WITH diacritics: user-highlight offsets are stored against this
+ // representation, so it is needed to remap them when diacritics are hidden. The text is
+ // independent of font size, so [lineContent] alone is a safe cache key.
+ val originalPlainText =
+ remember(lineContent) {
+ buildAnnotatedFromHtml(lineContent, baseTextSize, boldScale = 1f).text
+ }
+
// Build highlighted text when a query is active (>= 2 chars)
val baseHl =
JewelTheme.globalColors.outlines.focused
@@ -1016,11 +1416,30 @@ private fun LineItem(
JewelTheme.globalColors.outlines.focused
.copy(alpha = 0.42f)
val displayText: AnnotatedString =
- remember(annotated, highlightQuery, highlightTerms, currentMatchStart, baseHl, currentHl) {
+ remember(
+ annotated,
+ highlightQuery,
+ highlightTerms,
+ currentMatchStart,
+ baseHl,
+ currentHl,
+ userHighlights,
+ showDiacritics,
+ originalPlainText,
+ ) {
+ // User highlights first, then search highlights on top. Note markers are drawn
+ // separately (dotted underline) in drawBehind, not baked into the AnnotatedString.
+ val withUserHighlights =
+ applyUserHighlights(
+ annotated = annotated,
+ highlights = userHighlights,
+ originalText = originalPlainText,
+ showDiacritics = showDiacritics,
+ )
if (!highlightTerms.isNullOrEmpty()) {
// Smart mode: highlight multiple terms from dictionary expansion
io.github.kdroidfilter.seforimapp.core.presentation.text.highlightAnnotatedWithTerms(
- annotated = annotated,
+ annotated = withUserHighlights,
terms = highlightTerms,
currentStart = currentMatchStart?.takeIf { it >= 0 },
baseColor = baseHl,
@@ -1029,7 +1448,7 @@ private fun LineItem(
} else {
// Normal mode: highlight single query
io.github.kdroidfilter.seforimapp.core.presentation.text.highlightAnnotatedWithCurrent(
- annotated = annotated,
+ annotated = withUserHighlights,
query = highlightQuery,
currentStart = currentMatchStart?.takeIf { it >= 0 },
currentLength = highlightQuery?.length,
@@ -1039,31 +1458,27 @@ private fun LineItem(
}
}
- val textModifier =
- remember(lineId) {
- Modifier.fillMaxWidth()
- }.pointerInput(lineId) {
- awaitEachGesture {
- // Wait for press and capture keyboard modifiers from the event
- val downEvent = awaitPointerEvent(PointerEventPass.Main)
- if (!downEvent.buttons.isPrimaryPressed) return@awaitEachGesture
- val isModifier = downEvent.keyboardModifiers.isCtrlPressed || downEvent.keyboardModifiers.isMetaPressed
- // Wait for release
- val up = waitForUpOrCancellation()
- if (up != null && !up.isConsumed) {
- onClick(isModifier)
- }
- }
+ // Dotted grey underline marking the noted ranges (drawn from the text layout so it supports
+ // wrapping and RTL). Offsets are remapped to the displayed text when diacritics are hidden.
+ val noteRanges =
+ remember(userNotes, originalPlainText, showDiacritics, displayText) {
+ noteDisplayRanges(userNotes, originalPlainText, showDiacritics, displayText.length)
}
+ val noteUnderlineColor = JewelTheme.globalColors.text.info
+ var noteLayout by remember { mutableStateOf(null) }
Text(
text = displayText,
textAlign = TextAlign.Justify,
fontFamily = fontFamily,
lineHeight = (baseTextSize * lineHeight).sp,
- modifier = textModifier,
+ modifier =
+ textModifier.drawBehind {
+ noteLayout?.let { drawNoteUnderlines(it, noteRanges, noteUnderlineColor) }
+ },
inlineContent = inlineImageContent,
onTextLayout = { result ->
+ noteLayout = result
val cw = result.layoutInput.constraints.maxWidth
if (cw > 0 && cw != Int.MAX_VALUE) onLayoutWidthMeasure(cw)
},
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentZoomInteraction.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentZoomInteraction.kt
new file mode 100644
index 000000000..42e5d7050
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentZoomInteraction.kt
@@ -0,0 +1,5 @@
+package io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.bookcontent.views
+
+import androidx.compose.runtime.compositionLocalOf
+
+internal val LocalBookContentZoomInProgress = compositionLocalOf { false }
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/CommentatorsGrid.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/CommentatorsGrid.kt
index 832125650..6b25cdf48 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/CommentatorsGrid.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/CommentatorsGrid.kt
@@ -27,6 +27,7 @@ import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
@@ -242,7 +243,7 @@ internal fun CommentatorsGridScaffold(
VerticalPager(
state = pagerState,
modifier = Modifier.weight(1f).fillMaxHeight(),
- beyondViewportPageCount = 0,
+ beyondViewportPageCount = 1,
// Navigation is driven solely by indicator clicks to avoid swallowing the
// LazyColumn scrolls rendered inside each commentator cell.
userScrollEnabled = false,
@@ -287,14 +288,16 @@ private fun CommentatorPageGrid(
) {
rowNames.forEach { name ->
val id = config.titleToIdMap[name] ?: return@forEach
- CommentatorCell(
- name = name,
- commentTextSize = config.textSizes.commentTextSize,
- isRecentlyAdded = name == recentlyAdded,
- onTitleClick = { config.onOpenCommentatorBook(id) },
- modifier = Modifier.weight(1f).fillMaxHeight().padding(horizontal = 4.dp),
- ) {
- column(id)
+ key(id) {
+ CommentatorCell(
+ name = name,
+ commentTextSize = config.textSizes.commentTextSize,
+ isRecentlyAdded = name == recentlyAdded,
+ onTitleClick = { config.onOpenCommentatorBook(id) },
+ modifier = Modifier.weight(1f).fillMaxHeight().padding(horizontal = 4.dp),
+ ) {
+ column(id)
+ }
}
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/ContentScrollbar.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/ContentScrollbar.kt
index 6a7cca77f..d32ebd1c0 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/ContentScrollbar.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/ContentScrollbar.kt
@@ -98,7 +98,7 @@ fun ContentScrollbar(
// the loaded pager window emits a target into this flow; the collector throttles
// emissions to one rebuild every [FAR_DRAG_THROTTLE], with `DROP_OLDEST` so only
// the latest target survives. This keeps the displayed text catching up to fast
- // drags (~5 Hz) without spamming `buildLinesPager` on every frame. The latest
+ // drags (~60 Hz) without spamming `buildLinesPager` on every frame. The latest
// target is also stashed in [pendingFarDragTarget] so we can flush it once more
// on `onDragStopped` — guaranteeing the final landing spot is exact even if the
// last throttled emission was dropped.
@@ -179,9 +179,9 @@ fun ContentScrollbar(
}
// Minimum gap between two pager-rebuild emissions during a drag. Keeps the visible
-// text catching up to fast drags (~10 Hz) without spamming `buildLinesPager` on every
+// text catching up to fast drags (~60 Hz) without spamming `buildLinesPager` on every
// frame. Final exact target is flushed on `onDragStopped` regardless.
-private val FAR_DRAG_THROTTLE = 100.milliseconds
+private val FAR_DRAG_THROTTLE = 16.milliseconds
/**
* Book-wide thumb position in `[0, 1]`, in pixel-space.
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/LineCommentsView.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/LineCommentsView.kt
index 10318f287..5402ed6ce 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/LineCommentsView.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/LineCommentsView.kt
@@ -12,17 +12,21 @@ import androidx.compose.foundation.hoverable
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.foundation.text.InlineTextContent
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
+import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.ColorFilter
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.graphics.vector.rememberVectorPainter
+import androidx.compose.ui.input.pointer.PointerEventType
import androidx.compose.ui.input.pointer.isCtrlPressed
import androidx.compose.ui.input.pointer.isMetaPressed
import androidx.compose.ui.input.pointer.isPrimaryPressed
+import androidx.compose.ui.input.pointer.isSecondaryPressed
+import androidx.compose.ui.input.pointer.onPointerEvent
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.LocalWindowInfo
@@ -40,11 +44,14 @@ import androidx.paging.PagingData
import androidx.paging.compose.collectAsLazyPagingItems
import io.github.kdroidfilter.seforim.htmlparser.SkiaHtmlImageBuilder
import io.github.kdroidfilter.seforim.htmlparser.buildAnnotatedFromHtml
+import io.github.kdroidfilter.seforimapp.core.annotations.UserHighlight
import io.github.kdroidfilter.seforimapp.core.coroutines.runSuspendCatching
import io.github.kdroidfilter.seforimapp.core.presentation.components.HorizontalDivider
import io.github.kdroidfilter.seforimapp.core.presentation.tabs.LocalTabSelected
+import io.github.kdroidfilter.seforimapp.core.presentation.text.applyUserHighlights
import io.github.kdroidfilter.seforimapp.core.presentation.text.highlightAnnotated
import io.github.kdroidfilter.seforimapp.core.presentation.typography.FontCatalog
+import io.github.kdroidfilter.seforimapp.core.selection.CommentaryLineRef
import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
import io.github.kdroidfilter.seforimapp.features.bookcontent.BookContentEvent
import io.github.kdroidfilter.seforimapp.features.bookcontent.state.BookContentState
@@ -56,6 +63,7 @@ import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.components.Enha
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.components.PaneHeader
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.components.SafeSelectionContainer
import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.components.asStable
+import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import io.github.kdroidfilter.seforimapp.framework.platform.PlatformInfo
import io.github.kdroidfilter.seforimapp.icons.LayoutSidebarRight
import io.github.kdroidfilter.seforimapp.icons.LayoutSidebarRightOff
@@ -67,6 +75,7 @@ import kotlinx.coroutines.FlowPreview
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.debounce
import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.drop
import org.jetbrains.compose.resources.stringResource
import org.jetbrains.compose.splitpane.ExperimentalSplitPaneApi
import org.jetbrains.compose.splitpane.rememberSplitPaneState
@@ -99,6 +108,24 @@ fun LineCommentsView(
// TOC entry selection = afficher commentaires seulement de la ligne primaire
val isManualMultiSelection = selectedLineIds.size > 1 && !contentState.isTocEntrySelection
+ // Pass only stable slices below — never the whole `uiState`. `providers` is equals-stable
+ // across emissions, and these `content` fields keep their reference across an unrelated
+ // `content.copy(...)` (e.g. main-list scroll), so the commentaries subtree no longer
+ // recomposes on every scroll/paging churn of the book pane.
+ val providers = uiState.providers
+ val primarySelectedLineId = contentState.primarySelectedLineId
+ val selectedCommentatorIds = contentState.selectedCommentatorIds
+ val commentatorsListScrollIndex = contentState.commentatorsListScrollIndex
+ val commentatorsListScrollOffset = contentState.commentatorsListScrollOffset
+ val columnScroll =
+ CommentariesColumnScroll(
+ pageIndex = contentState.commentariesPageIndex,
+ fallbackScrollIndex = contentState.commentariesScrollIndex,
+ fallbackScrollOffset = contentState.commentariesScrollOffset,
+ indexByCommentator = contentState.commentariesColumnScrollIndexByCommentator,
+ offsetByCommentator = contentState.commentariesColumnScrollOffsetByCommentator,
+ )
+
// Animation settings with stable memorization
val textSizes = rememberAnimatedTextSettings()
val findQuery by AppSettings.findQueryFlow(uiState.tabId).collectAsState("")
@@ -126,10 +153,17 @@ fun LineCommentsView(
CenteredMessage(stringResource(Res.string.select_line_for_commentaries))
}
+ providers == null -> Unit
+
isManualMultiSelection -> {
MultiLineCommentariesContent(
selectedLineIds = selectedLineIds,
- uiState = uiState,
+ providers = providers,
+ primarySelectedLineId = primarySelectedLineId,
+ selectedCommentatorIds = selectedCommentatorIds,
+ commentatorsListScrollIndex = commentatorsListScrollIndex,
+ commentatorsListScrollOffset = commentatorsListScrollOffset,
+ columnScroll = columnScroll,
onEvent = onEvent,
textSizes = textSizes,
findQueryText = activeQuery,
@@ -139,14 +173,19 @@ fun LineCommentsView(
}
else -> {
+ val prefetched = lineConnections[selectedLine.id]?.commentatorGroups
CommentariesContent(
selectedLineId = selectedLine.id,
- uiState = uiState,
+ providers = providers,
+ selectedCommentatorIds = selectedCommentatorIds,
+ commentatorsListScrollIndex = commentatorsListScrollIndex,
+ commentatorsListScrollOffset = commentatorsListScrollOffset,
+ columnScroll = columnScroll,
onEvent = onEvent,
textSizes = textSizes,
findQueryText = activeQuery,
isCommentatorsListVisible = contentState.isCommentatorsListVisible,
- prefetchedGroups = lineConnections[selectedLine.id]?.commentatorGroups,
+ prefetchedGroups = prefetched,
showDiacritics = showDiacritics,
)
}
@@ -159,7 +198,11 @@ fun LineCommentsView(
@Composable
private fun CommentariesContent(
selectedLineId: Long,
- uiState: BookContentState,
+ providers: Providers,
+ selectedCommentatorIds: Set,
+ commentatorsListScrollIndex: Int,
+ commentatorsListScrollOffset: Int,
+ columnScroll: CommentariesColumnScroll,
onEvent: (BookContentEvent) -> Unit,
textSizes: AnimatedTextSizes,
findQueryText: String,
@@ -167,9 +210,6 @@ private fun CommentariesContent(
prefetchedGroups: List?,
showDiacritics: Boolean,
) {
- val providers = uiState.providers ?: return
- val contentState = uiState.content
-
val commentatorSelection =
rememberCommentarySelectionData(
lineId = selectedLineId,
@@ -195,7 +235,7 @@ private fun CommentariesContent(
val selectedCommentators =
rememberSelectedCommentators(
availableCommentators = commentatorsInDisplayOrder,
- initiallySelectedIds = contentState.selectedCommentatorIds,
+ initiallySelectedIds = selectedCommentatorIds,
titleToIdMap = titleToIdMap,
onSelectionChange = { ids ->
onEvent(BookContentEvent.SelectedCommentatorsChanged(selectedLineId, ids))
@@ -222,8 +262,8 @@ private fun CommentariesContent(
CommentatorsList(
groups = commentatorGroups,
selectedCommentators = selectedCommentators.value,
- initialScrollIndex = uiState.content.commentatorsListScrollIndex,
- initialScrollOffset = uiState.content.commentatorsListScrollOffset,
+ initialScrollIndex = commentatorsListScrollIndex,
+ initialScrollOffset = commentatorsListScrollOffset,
onScroll = { index, offset ->
onEvent(BookContentEvent.CommentatorsListScrolled(index, offset))
},
@@ -249,7 +289,8 @@ private fun CommentariesContent(
selectedCommentators = selectedInDisplayOrder,
titleToIdMap = titleToIdMap,
selection = LineSelection.Single(selectedLineId),
- uiState = uiState,
+ providers = providers,
+ columnScroll = columnScroll,
onEvent = onEvent,
textSizes = textSizes,
findQueryText = findQueryText,
@@ -267,16 +308,19 @@ private fun CommentariesContent(
@Composable
private fun MultiLineCommentariesContent(
selectedLineIds: ImmutableList,
- uiState: BookContentState,
+ providers: Providers,
+ primarySelectedLineId: Long?,
+ selectedCommentatorIds: Set,
+ commentatorsListScrollIndex: Int,
+ commentatorsListScrollOffset: Int,
+ columnScroll: CommentariesColumnScroll,
onEvent: (BookContentEvent) -> Unit,
textSizes: AnimatedTextSizes,
findQueryText: String,
isCommentatorsListVisible: Boolean,
showDiacritics: Boolean,
) {
- val providers = uiState.providers ?: return
- val contentState = uiState.content
- val primaryLineId = contentState.primarySelectedLineId ?: selectedLineIds.firstOrNull() ?: return
+ val primaryLineId = primarySelectedLineId ?: selectedLineIds.firstOrNull() ?: return
// Use multi-line provider to get aggregated commentator groups
val commentatorGroups by produceState>(emptyList(), selectedLineIds) {
@@ -301,7 +345,7 @@ private fun MultiLineCommentariesContent(
val selectedCommentators =
rememberSelectedCommentators(
availableCommentators = commentatorsInDisplayOrder,
- initiallySelectedIds = contentState.selectedCommentatorIds,
+ initiallySelectedIds = selectedCommentatorIds,
titleToIdMap = titleToIdMap,
onSelectionChange = { ids ->
onEvent(BookContentEvent.SelectedCommentatorsChanged(primaryLineId, ids))
@@ -328,8 +372,8 @@ private fun MultiLineCommentariesContent(
CommentatorsList(
groups = commentatorGroups,
selectedCommentators = selectedCommentators.value,
- initialScrollIndex = uiState.content.commentatorsListScrollIndex,
- initialScrollOffset = uiState.content.commentatorsListScrollOffset,
+ initialScrollIndex = commentatorsListScrollIndex,
+ initialScrollOffset = commentatorsListScrollOffset,
onScroll = { index, offset ->
onEvent(BookContentEvent.CommentatorsListScrolled(index, offset))
},
@@ -353,7 +397,8 @@ private fun MultiLineCommentariesContent(
selectedCommentators = selectedInDisplayOrder,
titleToIdMap = titleToIdMap,
selection = LineSelection.Multi(selectedLineIds),
- uiState = uiState,
+ providers = providers,
+ columnScroll = columnScroll,
onEvent = onEvent,
textSizes = textSizes,
findQueryText = findQueryText,
@@ -448,7 +493,8 @@ private fun CommentariesDisplay(
selectedCommentators: ImmutableList,
titleToIdMap: Map,
selection: LineSelection,
- uiState: BookContentState,
+ providers: Providers,
+ columnScroll: CommentariesColumnScroll,
onEvent: (BookContentEvent) -> Unit,
textSizes: AnimatedTextSizes,
findQueryText: String,
@@ -475,7 +521,8 @@ private fun CommentariesDisplay(
CommentatorsGrid(
config = layoutConfig,
selection = selection,
- uiState = uiState,
+ providers = providers,
+ columnScroll = columnScroll,
onEvent = onEvent,
)
}
@@ -484,32 +531,53 @@ private fun CommentariesDisplay(
private fun CommentatorsGrid(
config: CommentariesLayoutConfig,
selection: LineSelection,
- uiState: BookContentState,
+ providers: Providers,
+ columnScroll: CommentariesColumnScroll,
onEvent: (BookContentEvent) -> Unit,
) {
- val providers = uiState.providers ?: return
+ val pagerFlowCache = remember(selection) { mutableMapOf>>() }
+ val listStateCache = remember(selection) { mutableMapOf() }
+ val restoredCommentatorIds = remember(selection) { mutableStateMapOf() }
+
CommentatorsGridScaffold(
config = config,
- initialPage = uiState.content.commentariesPageIndex,
+ initialPage = columnScroll.pageIndex,
onPageChange = { page -> onEvent(BookContentEvent.CommentariesPageChanged(page)) },
onFlushPersist = { onEvent(BookContentEvent.FlushCommentariesState) },
) { commentatorId ->
val pagerFlow =
- remember(selection, commentatorId) {
- providers.buildCommentariesPagerFor(selection, commentatorId)
+ remember(commentatorId, pagerFlowCache) {
+ // The open commentator's TEXT is built lazily here, on first display — it is NOT
+ // covered by the connections prefetch (which only loads the commentator list).
+ pagerFlowCache.getOrPut(commentatorId) {
+ providers.buildCommentariesPagerFor(selection, commentatorId)
+ }
}
val initialIndex =
- uiState.content.commentariesColumnScrollIndexByCommentator[commentatorId]
- ?: uiState.content.commentariesScrollIndex
+ columnScroll.indexByCommentator[commentatorId]
+ ?: columnScroll.fallbackScrollIndex
val initialOffset =
- uiState.content.commentariesColumnScrollOffsetByCommentator[commentatorId]
- ?: uiState.content.commentariesScrollOffset
+ columnScroll.offsetByCommentator[commentatorId]
+ ?: columnScroll.fallbackScrollOffset
+ val listState =
+ remember(commentatorId, listStateCache) {
+ listStateCache.getOrPut(commentatorId) {
+ LazyListState(
+ firstVisibleItemIndex = initialIndex.coerceAtLeast(0),
+ firstVisibleItemScrollOffset = initialOffset.coerceAtLeast(0),
+ )
+ }
+ }
+
CommentariesPagedList(
pagerFlow = pagerFlow,
+ listState = listState,
initialIndex = initialIndex,
initialOffset = initialOffset,
- onScroll = { i, o ->
- onEvent(BookContentEvent.CommentaryColumnScrolled(commentatorId, i, o))
+ shouldRestore = restoredCommentatorIds[commentatorId] != true,
+ onRestore = { restoredCommentatorIds[commentatorId] = true },
+ onScrollSettle = { i, o ->
+ onEvent(BookContentEvent.CommentaryColumnScrolled(commentatorId, i, o, persist = true))
},
config = config,
selection = selection,
@@ -534,17 +602,41 @@ private fun CommentatorsGrid(
@Composable
private fun CommentariesPagedList(
pagerFlow: Flow>,
+ listState: LazyListState,
initialIndex: Int,
initialOffset: Int,
- onScroll: (Int, Int) -> Unit,
+ shouldRestore: Boolean,
+ onRestore: () -> Unit,
+ onScrollSettle: (Int, Int) -> Unit,
config: CommentariesLayoutConfig,
selection: LineSelection,
commentatorId: Long,
getCharCountsForLine: suspend (Long, Long) -> List,
getCharCountsForLines: suspend (List, Long) -> List,
) {
- val currentOnScroll by rememberUpdatedState(onScroll)
+ val currentOnRestore by rememberUpdatedState(onRestore)
+ val currentOnScrollSettle by rememberUpdatedState(onScrollSettle)
val lazyPagingItems = pagerFlow.collectAsLazyPagingItems()
+ val annotationCache = remember(selection, commentatorId) { StableAnnotatedCache(mutableStateMapOf()) }
+
+ // User highlights for the commentary books currently shown. Commentary lines belong to
+ // their own target book, so highlights are keyed by (targetBookId, targetLineId) — the same
+ // key used when that commentary is opened as a main book, so they stay in sync.
+ val highlightStore = LocalAppGraph.current.highlightStore
+ val selectionContext = LocalAppGraph.current.selectionContext
+ val highlightsByBook by highlightStore.highlightsByBook.collectAsState()
+ LaunchedEffect(lazyPagingItems, highlightStore) {
+ snapshotFlow {
+ lazyPagingItems.itemSnapshotList.items
+ .map { it.link.targetBookId }
+ .toSet()
+ }.distinctUntilChanged()
+ .collect { bookIds -> bookIds.forEach { highlightStore.loadBook(it) } }
+ }
+ val highlightsByBookLine =
+ remember(highlightsByBook) {
+ highlightsByBook.mapValues { (_, lines) -> lines.groupBy { it.lineId } }
+ }
// Ordered char-count vector for every commentary matching this selection ×
// commentator (same filter + order as the pager). The scrollbar converts every
@@ -602,29 +694,34 @@ private fun CommentariesPagedList(
}
}
- val listState =
- rememberLazyListState(
- initialFirstVisibleItemIndex = initialIndex,
- initialFirstVisibleItemScrollOffset = initialOffset,
- )
-
- var hasRestored by remember(pagerFlow) { mutableStateOf(false) }
- LaunchedEffect(pagerFlow, lazyPagingItems.loadState.refresh, initialIndex, initialOffset) {
- if (!hasRestored && lazyPagingItems.loadState.refresh !is LoadState.Loading) {
+ val restoreIndex = remember(pagerFlow) { initialIndex }
+ val restoreOffset = remember(pagerFlow) { initialOffset }
+ LaunchedEffect(pagerFlow, lazyPagingItems.loadState.refresh, shouldRestore) {
+ if (shouldRestore && lazyPagingItems.loadState.refresh !is LoadState.Loading) {
if (lazyPagingItems.itemCount > 0) {
- val safeIndex = initialIndex.coerceIn(0, lazyPagingItems.itemCount - 1)
- val safeOffset = initialOffset.coerceAtLeast(0)
+ val safeIndex = restoreIndex.coerceIn(0, lazyPagingItems.itemCount - 1)
+ val safeOffset = restoreOffset.coerceAtLeast(0)
listState.scrollToItem(safeIndex, safeOffset)
- hasRestored = true
+ currentOnRestore()
}
}
}
LaunchedEffect(listState) {
- snapshotFlow { listState.firstVisibleItemIndex to listState.firstVisibleItemScrollOffset }
- .distinctUntilChanged()
+ snapshotFlow {
+ Triple(
+ listState.firstVisibleItemIndex,
+ listState.firstVisibleItemScrollOffset,
+ listState.isScrollInProgress,
+ )
+ }.distinctUntilChanged()
+ .drop(1)
.debounce(SCROLL_DEBOUNCE)
- .collect { (i, o) -> currentOnScroll(i, o) }
+ .collect { (i, o, isScrollInProgress) ->
+ if (!isScrollInProgress) {
+ currentOnScrollSettle(i, o)
+ }
+ }
}
SafeSelectionContainer(modifier = Modifier.fillMaxSize()) {
@@ -638,6 +735,10 @@ private fun CommentariesPagedList(
key = { index -> lazyPagingItems[index]?.link?.id ?: index },
) { index ->
lazyPagingItems[index]?.let { commentary ->
+ // Stable per-line list; non-highlighted lines get the emptyList() singleton.
+ val lineHighlights =
+ highlightsByBookLine[commentary.link.targetBookId]
+ ?.get(commentary.link.targetLineId) ?: emptyList()
CommentaryItem(
linkId = commentary.link.id,
targetText = commentary.targetText,
@@ -646,6 +747,21 @@ private fun CommentariesPagedList(
boldScale = config.boldScale,
highlightQuery = config.highlightQuery,
showDiacritics = config.showDiacritics,
+ annotationCache = annotationCache,
+ userHighlights = lineHighlights,
+ onSecondaryClick = {
+ // Publish the whole column (ordered) so a multi-line selection
+ // can be resolved across consecutive commentary entries.
+ selectionContext.setActiveCommentaryColumn(
+ lazyPagingItems.itemSnapshotList.items.map {
+ CommentaryLineRef(
+ bookId = it.link.targetBookId,
+ lineId = it.link.targetLineId,
+ content = it.targetText,
+ )
+ },
+ )
+ },
onClick = { config.onCommentClick(commentary) },
onLayoutWidthMeasure = { width ->
if (textLayoutWidthPx == 0 && width > 0) {
@@ -675,6 +791,7 @@ private fun CommentariesPagedList(
}
}
+@OptIn(ExperimentalComposeUiApi::class)
@Composable
private fun CommentaryItem(
linkId: Long,
@@ -683,8 +800,11 @@ private fun CommentaryItem(
fontFamily: FontFamily,
highlightQuery: String,
showDiacritics: Boolean,
+ annotationCache: StableAnnotatedCache,
onClick: () -> Unit,
boldScale: Float = 1.0f,
+ userHighlights: List = emptyList(),
+ onSecondaryClick: () -> Unit = {},
onLayoutWidthMeasure: (Int) -> Unit = {},
) {
Column(
@@ -692,7 +812,11 @@ private fun CommentaryItem(
Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp, vertical = CommentaryItemVerticalPaddingPerSide)
- .pointerInput(onClick) {
+ .onPointerEvent(PointerEventType.Press) { event ->
+ // Record this commentary line as the highlight target (analogous to the main
+ // pane's onContextClick) so the shared context menu can anchor here.
+ if (event.buttons.isSecondaryPressed) onSecondaryClick()
+ }.pointerInput(onClick) {
awaitEachGesture {
val down = awaitFirstDown(requireUnconsumed = false)
val modifiers = currentEvent.keyboardModifiers
@@ -723,51 +847,81 @@ private fun CommentaryItem(
remember(isDarkTheme) {
{ if (isDarkTheme) SkiaHtmlImageBuilder.InvertColorFilter else null }
}
- val annotatedWithImages =
- remember(
- linkId,
- processedText,
- textSizes.commentTextSize,
- boldScale,
- showDiacritics,
- footnoteMarkerColor,
- imageColorFilter,
- ) {
- val inline = mutableMapOf()
- val annotated =
- buildAnnotatedFromHtml(
- processedText,
- textSizes.commentTextSize,
- boldScale = if (boldScale < 1f) 1f else boldScale,
- footnoteMarkerColor = footnoteMarkerColor,
- inlineContent = inline,
- imageContentBuilder = SkiaHtmlImageBuilder.build(imageColorFilter),
- )
- annotated to inline.toMap()
+
+ val annotationCacheKey =
+ remember(linkId, processedText, textSizes.commentTextSize, boldScale, footnoteMarkerColor, isDarkTheme) {
+ HtmlAnnotationCacheKey(
+ itemId = linkId,
+ contentHash = processedText.hashCode(),
+ contentLength = processedText.length,
+ baseTextSize = textSizes.commentTextSize,
+ boldScale = boldScale,
+ footnoteMarkerColor = footnoteMarkerColor,
+ invertImages = isDarkTheme,
+ )
}
- val annotated = annotatedWithImages.first
- val inlineImageContent = annotatedWithImages.second
-
- val display: AnnotatedString =
- remember(annotated, highlightQuery) {
- if (highlightQuery.isBlank()) {
- annotated
- } else {
- highlightAnnotated(annotated, highlightQuery)
+ val annotation =
+ rememberAsyncHtmlAnnotation(
+ cacheKey = annotationCacheKey,
+ html = processedText,
+ baseTextSize = textSizes.commentTextSize,
+ boldScale = boldScale,
+ footnoteMarkerColor = footnoteMarkerColor,
+ imageColorFilter = imageColorFilter,
+ annotatedCache = annotationCache,
+ )
+
+ if (annotation == null) {
+ Text(
+ text = htmlAnnotationPlaceholderText(processedText.length),
+ textAlign = TextAlign.Justify,
+ fontSize = textSizes.commentTextSize.sp,
+ fontFamily = fontFamily,
+ lineHeight = (textSizes.commentTextSize * textSizes.lineHeight).sp,
+ onTextLayout = { result ->
+ val cw = result.layoutInput.constraints.maxWidth
+ if (cw > 0 && cw != Int.MAX_VALUE) onLayoutWidthMeasure(cw)
+ },
+ )
+ } else {
+ val annotated = annotation.annotated
+ val inlineImageContent = annotation.inlineContent
+
+ // Plain text WITH diacritics for offset remapping (see LineItem in BookContentView).
+ val originalPlainText =
+ remember(targetText) {
+ buildAnnotatedFromHtml(targetText, textSizes.commentTextSize, boldScale = 1f).text
}
- }
- Text(
- text = display,
- textAlign = TextAlign.Justify,
- fontFamily = fontFamily,
- lineHeight = (textSizes.commentTextSize * textSizes.lineHeight).sp,
- inlineContent = inlineImageContent,
- onTextLayout = { result ->
- val cw = result.layoutInput.constraints.maxWidth
- if (cw > 0 && cw != Int.MAX_VALUE) onLayoutWidthMeasure(cw)
- },
- )
+ val display: AnnotatedString =
+ remember(annotated, highlightQuery, userHighlights, showDiacritics, originalPlainText) {
+ // User highlights first, then search highlight on top.
+ val withUserHighlights =
+ applyUserHighlights(
+ annotated = annotated,
+ highlights = userHighlights,
+ originalText = originalPlainText,
+ showDiacritics = showDiacritics,
+ )
+ if (highlightQuery.isBlank()) {
+ withUserHighlights
+ } else {
+ highlightAnnotated(withUserHighlights, highlightQuery)
+ }
+ }
+
+ Text(
+ text = display,
+ textAlign = TextAlign.Justify,
+ fontFamily = fontFamily,
+ lineHeight = (textSizes.commentTextSize * textSizes.lineHeight).sp,
+ inlineContent = inlineImageContent,
+ onTextLayout = { result ->
+ val cw = result.layoutInput.constraints.maxWidth
+ if (cw > 0 && cw != Int.MAX_VALUE) onLayoutWidthMeasure(cw)
+ },
+ )
+ }
}
}
@@ -811,7 +965,8 @@ private fun ErrorMessage(error: Throwable) {
private fun rememberAnimatedTextSettings(): AnimatedTextSizes {
val rawTextSize by AppSettings.textSizeFlow.collectAsState()
val isTabSelected = LocalTabSelected.current
- val zoomAnimSpec = if (isTabSelected) tween(durationMillis = 200) else snap()
+ val isBookContentZoomInProgress = LocalBookContentZoomInProgress.current
+ val zoomAnimSpec = if (isTabSelected && !isBookContentZoomInProgress) tween(durationMillis = 200) else snap()
val commentTextSize by animateFloatAsState(
targetValue = rawTextSize * 0.875f,
animationSpec = zoomAnimSpec,
@@ -965,6 +1120,20 @@ internal data class AnimatedTextSizes(
val lineHeight: Float,
)
+/**
+ * Stable slice of the per-commentator scroll/page state passed into the commentaries grid.
+ * Holds only references that survive an unrelated `content.copy(...)` (e.g. main-list scroll),
+ * so the commentaries subtree is not recomposed by book-pane scroll/paging churn.
+ */
+@Immutable
+private data class CommentariesColumnScroll(
+ val pageIndex: Int,
+ val fallbackScrollIndex: Int,
+ val fallbackScrollOffset: Int,
+ val indexByCommentator: Map,
+ val offsetByCommentator: Map,
+)
+
/**
* Source of lines feeding a commentary view: either a single selected line or a manual
* multi-selection. Chooses which provider pager to build in [Providers.buildCommentariesPagerFor].
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/LineTargumView.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/LineTargumView.kt
index 2eb168461..73f4eed7f 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/LineTargumView.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/LineTargumView.kt
@@ -10,7 +10,6 @@ import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.text.InlineTextContent
import androidx.compose.runtime.*
import androidx.compose.runtime.getValue
import androidx.compose.runtime.produceState
@@ -37,7 +36,6 @@ import androidx.paging.PagingData
import androidx.paging.compose.LazyPagingItems
import androidx.paging.compose.collectAsLazyPagingItems
import io.github.kdroidfilter.seforim.htmlparser.SkiaHtmlImageBuilder
-import io.github.kdroidfilter.seforim.htmlparser.buildAnnotatedFromHtml
import io.github.kdroidfilter.seforimapp.core.coroutines.runSuspendCatching
import io.github.kdroidfilter.seforimapp.core.presentation.tabs.LocalTabSelected
import io.github.kdroidfilter.seforimapp.core.presentation.typography.FontCatalog
@@ -101,7 +99,8 @@ private fun SingleLineTargumView(
) {
val rawTextSize by AppSettings.textSizeFlow.collectAsState()
val isTabSelected = LocalTabSelected.current
- val zoomAnimSpec = if (isTabSelected) tween(durationMillis = 300) else snap()
+ val isBookContentZoomInProgress = LocalBookContentZoomInProgress.current
+ val zoomAnimSpec = if (isTabSelected && !isBookContentZoomInProgress) tween(durationMillis = 300) else snap()
val commentTextSize by animateFloatAsState(
targetValue = rawTextSize * 0.875f,
animationSpec = zoomAnimSpec,
@@ -187,11 +186,16 @@ private fun SingleLineTargumView(
Text(text = stringResource(emptyRes))
}
} else {
+ // Preserve insertion order from the provider — the SQL
+ // ORDER BY (l.isDeclaredBase DESC, b.isBaseBook DESC,
+ // b.id, sl.lineIndex) ranks Sefaria-declared bases
+ // first and then by canonical catalog position
+ // (Tanakh → Mishnah → Bavli → Yerushalmi → Tosefta →
+ // Halakhah → commentators). Re-sorting by title
+ // alphabet would override that semantic ordering.
val availableSources =
remember(titleToIdMap) {
- titleToIdMap.entries
- .sortedBy { it.key }
- .map { SourceMeta(it.key, it.value) }
+ titleToIdMap.entries.map { SourceMeta(it.key, it.value) }
}
val selectedSources =
@@ -218,6 +222,10 @@ private fun SingleLineTargumView(
items = lazyPagingItems,
)
}
+ val annotationCache =
+ remember(selectedLine.id, availabilityType) {
+ StableAnnotatedCache(mutableStateMapOf())
+ }
val listState =
rememberSaveable(
@@ -334,6 +342,7 @@ private fun SingleLineTargumView(
highlightQuery = highlightQuery,
onClick = { onLinkClick(item) },
showDiacritics = showDiacritics,
+ annotationCache = annotationCache,
onLayoutWidthMeasure = { width ->
if (textLayoutWidthPx == 0 && width > 0) {
textLayoutWidthPx = width
@@ -522,7 +531,8 @@ private fun MultiLineTargumView(
val rawTextSize by AppSettings.textSizeFlow.collectAsState()
val isTabSelected = LocalTabSelected.current
- val zoomAnimSpec = if (isTabSelected) tween(durationMillis = 300) else snap()
+ val isBookContentZoomInProgress = LocalBookContentZoomInProgress.current
+ val zoomAnimSpec = if (isTabSelected && !isBookContentZoomInProgress) tween(durationMillis = 300) else snap()
val commentTextSize by animateFloatAsState(
targetValue = rawTextSize * 0.875f,
animationSpec = zoomAnimSpec,
@@ -584,11 +594,14 @@ private fun MultiLineTargumView(
Text(text = stringResource(emptyRes))
}
} else {
+ // Preserve insertion order from the provider — the underlying
+ // SQL ORDER BY (l.isDeclaredBase DESC, b.orderIndex, sl.lineIndex)
+ // already ranks declared bases first and otherwise sorts by the
+ // source book's catalog position. Re-sorting by title alphabet
+ // here would override that semantic ordering.
val availableSources =
remember(titleToIdMap) {
- titleToIdMap.entries
- .sortedBy { it.key }
- .map { SourceMeta(it.key, it.value) }
+ titleToIdMap.entries.map { SourceMeta(it.key, it.value) }
}
// Build pagers for each source using multi-line provider
@@ -611,6 +624,10 @@ private fun MultiLineTargumView(
items = lazyPagingItems,
)
}
+ val annotationCache =
+ remember(selectedLineIds, availabilityType) {
+ StableAnnotatedCache(mutableStateMapOf())
+ }
val listState =
rememberSaveable(
@@ -734,6 +751,7 @@ private fun MultiLineTargumView(
}
},
showDiacritics = showDiacritics,
+ annotationCache = annotationCache,
onLayoutWidthMeasure = { width ->
if (textLayoutWidthPx == 0 && width > 0) {
textLayoutWidthPx = width
@@ -801,6 +819,7 @@ private fun LinkItem(
highlightQuery: String,
onClick: () -> Unit,
showDiacritics: Boolean,
+ annotationCache: StableAnnotatedCache,
boldScale: Float = 1.0f,
onLayoutWidthMeasure: (Int) -> Unit = {},
) {
@@ -826,48 +845,64 @@ private fun LinkItem(
remember(isDarkTheme) {
{ if (isDarkTheme) SkiaHtmlImageBuilder.InvertColorFilter else null }
}
- val annotatedWithImages =
- remember(
- linkId,
- processedText,
- commentTextSize,
- boldScale,
- showDiacritics,
- footnoteMarkerColor,
- imageColorFilter,
- ) {
- val inline = mutableMapOf()
- val annotated =
- buildAnnotatedFromHtml(
- processedText,
- commentTextSize,
- boldScale = if (boldScale < 1f) 1f else boldScale,
- footnoteMarkerColor = footnoteMarkerColor,
- inlineContent = inline,
- imageContentBuilder = SkiaHtmlImageBuilder.build(imageColorFilter),
- )
- annotated to inline.toMap()
- }
- val annotated = annotatedWithImages.first
- val inlineImageContent = annotatedWithImages.second
-
- // Highlight occurrences using the current tab's find-in-page query
- val display: AnnotatedString =
- remember(annotated, highlightQuery) {
- io.github.kdroidfilter.seforimapp.core.presentation.text
- .highlightAnnotated(annotated, highlightQuery)
+
+ val annotationCacheKey =
+ remember(linkId, processedText, commentTextSize, boldScale, footnoteMarkerColor, isDarkTheme) {
+ HtmlAnnotationCacheKey(
+ itemId = linkId,
+ contentHash = processedText.hashCode(),
+ contentLength = processedText.length,
+ baseTextSize = commentTextSize,
+ boldScale = boldScale,
+ footnoteMarkerColor = footnoteMarkerColor,
+ invertImages = isDarkTheme,
+ )
}
+ val annotation =
+ rememberAsyncHtmlAnnotation(
+ cacheKey = annotationCacheKey,
+ html = processedText,
+ baseTextSize = commentTextSize,
+ boldScale = boldScale,
+ footnoteMarkerColor = footnoteMarkerColor,
+ imageColorFilter = imageColorFilter,
+ annotatedCache = annotationCache,
+ )
+
+ if (annotation == null) {
+ Text(
+ text = htmlAnnotationPlaceholderText(processedText.length),
+ textAlign = TextAlign.Justify,
+ fontSize = commentTextSize.sp,
+ fontFamily = fontFamily,
+ lineHeight = (commentTextSize * lineHeight).sp,
+ onTextLayout = { result ->
+ val cw = result.layoutInput.constraints.maxWidth
+ if (cw > 0 && cw != Int.MAX_VALUE) onLayoutWidthMeasure(cw)
+ },
+ )
+ } else {
+ val annotated = annotation.annotated
+ val inlineImageContent = annotation.inlineContent
+
+ // Highlight occurrences using the current tab's find-in-page query
+ val display: AnnotatedString =
+ remember(annotated, highlightQuery) {
+ io.github.kdroidfilter.seforimapp.core.presentation.text
+ .highlightAnnotated(annotated, highlightQuery)
+ }
- Text(
- text = display,
- textAlign = TextAlign.Justify,
- fontFamily = fontFamily,
- lineHeight = (commentTextSize * lineHeight).sp,
- inlineContent = inlineImageContent,
- onTextLayout = { result ->
- val cw = result.layoutInput.constraints.maxWidth
- if (cw > 0 && cw != Int.MAX_VALUE) onLayoutWidthMeasure(cw)
- },
- )
+ Text(
+ text = display,
+ textAlign = TextAlign.Justify,
+ fontFamily = fontFamily,
+ lineHeight = (commentTextSize * lineHeight).sp,
+ inlineContent = inlineImageContent,
+ onTextLayout = { result ->
+ val cw = result.layoutInput.constraints.maxWidth
+ if (cw > 0 && cw != Int.MAX_VALUE) onLayoutWidthMeasure(cw)
+ },
+ )
+ }
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/notes/NotesPanel.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/notes/NotesPanel.kt
new file mode 100644
index 000000000..905c0c7ec
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/notes/NotesPanel.kt
@@ -0,0 +1,375 @@
+package io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.notes
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.LocalContextMenuRepresentation
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.hoverable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.LocalTextContextMenu
+import androidx.compose.foundation.text.input.clearText
+import androidx.compose.foundation.text.input.rememberTextFieldState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import io.github.kdroidfilter.seforim.htmlparser.buildAnnotatedFromHtml
+import io.github.kdroidfilter.seforimapp.core.annotations.NoteStore
+import io.github.kdroidfilter.seforimapp.features.bookcontent.BookContentEvent
+import io.github.kdroidfilter.seforimapp.features.bookcontent.state.BookContentState
+import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.components.PaneHeader
+import io.github.kdroidfilter.seforimlibrary.core.models.Line
+import kotlinx.coroutines.FlowPreview
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.launch
+import org.jetbrains.compose.resources.stringResource
+import org.jetbrains.jewel.foundation.theme.JewelTheme
+import org.jetbrains.jewel.ui.component.IconActionButton
+import org.jetbrains.jewel.ui.component.InlineInformationBanner
+import org.jetbrains.jewel.ui.component.Text
+import org.jetbrains.jewel.ui.component.TextArea
+import org.jetbrains.jewel.ui.icons.AllIconsKeys
+import seforimapp.seforimapp.generated.resources.Res
+import seforimapp.seforimapp.generated.resources.delete_note
+import seforimapp.seforimapp.generated.resources.no_notes_for_selection
+import seforimapp.seforimapp.generated.resources.no_notes_saved
+import seforimapp.seforimapp.generated.resources.note_body_placeholder
+import seforimapp.seforimapp.generated.resources.notes_info_word_level
+import seforimapp.seforimapp.generated.resources.notes_pane
+import org.jetbrains.jewel.ui.component.ContextMenuRepresentation as JewelContextMenuRepresentation
+import org.jetbrains.jewel.ui.component.TextContextMenu as JewelTextContextMenu
+
+/**
+ * A pending (not-yet-persisted) note anchored to a resolved character range. Created from the
+ * "add note" context-menu action, or implicitly as a blank whole-line note when the selected line
+ * carries none yet.
+ *
+ * @property quote The anchored passage, shown as a greyed preview above the editor.
+ */
+data class NoteDraftAnchor(
+ val lineId: Long,
+ val startOffset: Int,
+ val endOffset: Int,
+ val quote: String,
+)
+
+/**
+ * Side pane showing the notes of the currently selected line(s) — same scoping as the commentaries
+ * pane (a TOC selection or a multi-selection surfaces all their notes). Notes live in [noteStore].
+ * Editing auto-saves (debounced); a trash button deletes. The draft editor keeps editing the note
+ * it creates in place (no focus jump), and its trash removes that note and clears the field.
+ */
+@Composable
+fun NotesPanel(
+ uiState: BookContentState,
+ onEvent: (BookContentEvent) -> Unit,
+ bookId: Long,
+ noteStore: NoteStore,
+ selectedLineIds: Set,
+ primarySelectedLine: Line?,
+ draft: NoteDraftAnchor?,
+ onConsumeDraft: () -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ val paneHoverSource = remember { MutableInteractionSource() }
+ val scope = rememberCoroutineScope()
+ val currentOnEvent by rememberUpdatedState(onEvent)
+ val focusManager = LocalFocusManager.current
+
+ // Idempotent: keeps the pane self-contained instead of relying on BookContentView's load.
+ LaunchedEffect(bookId, noteStore) { noteStore.loadBook(bookId) }
+
+ val notesByBook by noteStore.notesByBook.collectAsState()
+ val allNotes =
+ remember(notesByBook, bookId, selectedLineIds) {
+ notesByBook[bookId]
+ .orEmpty()
+ .filter { it.lineId in selectedLineIds }
+ .sortedWith(compareBy({ it.lineId }, { it.startOffset }))
+ }
+
+ val primaryLineId = primarySelectedLine?.id
+
+ // The note the draft editor has created. It is excluded from the list and kept inside the draft
+ // editor so editing it does not tear down/recreate the field (which would drop focus). Reset
+ // when the line or the explicit draft changes.
+ var draftCreatedId by remember(primaryLineId, draft) { mutableStateOf(null) }
+
+ val notes = remember(allNotes, draftCreatedId) { allNotes.filter { it.id != draftCreatedId } }
+
+ // With no explicit draft and no saved note (other than the one being drafted), offer a blank
+ // whole-line note on the primary selected line, ready to edit. Never persisted until typed.
+ val autoDraft =
+ remember(draft, notes, primarySelectedLine) {
+ if (draft != null || notes.isNotEmpty() || primarySelectedLine == null) {
+ null
+ } else {
+ val plain = buildAnnotatedFromHtml(primarySelectedLine.content, baseTextSize = 16f, boldScale = 1f).text
+ if (plain.isEmpty()) null else NoteDraftAnchor(primarySelectedLine.id, 0, plain.length, plain.trim())
+ }
+ }
+ val effectiveDraft = draft ?: autoDraft
+ val isExplicitDraft = draft != null
+
+ Column(
+ modifier =
+ modifier
+ .fillMaxHeight()
+ .hoverable(paneHoverSource)
+ // A tap anywhere in the pane outside the field clears focus, which flushes the
+ // pending note via the editor's focus-loss save.
+ .pointerInput(Unit) { detectTapGestures { focusManager.clearFocus() } },
+ ) {
+ PaneHeader(
+ label = stringResource(Res.string.notes_pane),
+ interactionSource = paneHoverSource,
+ onHide = { onEvent(BookContentEvent.ToggleNotes) },
+ )
+
+ Box(modifier = Modifier.weight(1f).fillMaxWidth()) {
+ if (notes.isEmpty() && effectiveDraft == null) {
+ Box(
+ modifier = Modifier.fillMaxSize().padding(16.dp),
+ contentAlignment = Alignment.Center,
+ ) {
+ Text(text = stringResource(Res.string.no_notes_for_selection), textAlign = TextAlign.Center)
+ }
+ } else {
+ val listState =
+ rememberLazyListState(
+ initialFirstVisibleItemIndex = uiState.notes.scrollIndex,
+ initialFirstVisibleItemScrollOffset = uiState.notes.scrollOffset,
+ )
+ LaunchedEffect(listState) {
+ snapshotFlow { listState.firstVisibleItemIndex to listState.firstVisibleItemScrollOffset }
+ .distinctUntilChanged()
+ .catch { }
+ .collect { (index, offset) -> currentOnEvent(BookContentEvent.NotesScrolled(index, offset)) }
+ }
+
+ LazyColumn(
+ state = listState,
+ modifier = Modifier.fillMaxSize().padding(horizontal = 8.dp, vertical = 4.dp),
+ ) {
+ if (effectiveDraft != null) {
+ item(
+ key =
+ "draft-${effectiveDraft.lineId}-${effectiveDraft.startOffset}-${effectiveDraft.endOffset}",
+ ) {
+ NoteCard(quote = effectiveDraft.quote.takeIf { it.isNotBlank() }) {
+ NoteEditor(
+ initialText = "",
+ autoFocus = isExplicitDraft,
+ clearOnDelete = true,
+ onPersist = { text ->
+ scope.launch {
+ val id = draftCreatedId
+ val now = System.currentTimeMillis()
+ when {
+ text.isBlank() && id != null -> {
+ noteStore.removeNote(bookId, id)
+ draftCreatedId = null
+ }
+ text.isNotBlank() && id == null -> {
+ draftCreatedId =
+ noteStore.addNote(
+ bookId = bookId,
+ lineId = effectiveDraft.lineId,
+ startOffset = effectiveDraft.startOffset,
+ endOffset = effectiveDraft.endOffset,
+ note = text,
+ timestamp = now,
+ quote = effectiveDraft.quote,
+ )
+ }
+ text.isNotBlank() && id != null -> {
+ noteStore.updateNote(bookId, id, text, now)
+ }
+ }
+ }
+ },
+ onDelete = {
+ scope.launch {
+ draftCreatedId?.let { noteStore.removeNote(bookId, it) }
+ draftCreatedId = null
+ }
+ if (isExplicitDraft) onConsumeDraft()
+ },
+ )
+ }
+ }
+ }
+ items(notes, key = { it.id }) { note ->
+ NoteCard(quote = note.quote.takeIf { it.isNotBlank() }) {
+ NoteEditor(
+ initialText = note.note,
+ autoFocus = false,
+ clearOnDelete = false,
+ onPersist = { text ->
+ scope.launch {
+ // A blank body deletes the note (NoteStore.updateNote contract).
+ noteStore.updateNote(bookId, note.id, text, System.currentTimeMillis())
+ }
+ },
+ onDelete = { scope.launch { noteStore.removeNote(bookId, note.id) } },
+ )
+ }
+ }
+ }
+ }
+ }
+
+ // Hint shown while drafting the first note of a line. Skipped when no line is selected
+ // (effectiveDraft == null) — the centered "no selection" message already covers that, so
+ // the two empty-state messages never stack.
+ if (allNotes.isEmpty() && effectiveDraft != null) {
+ Text(
+ text = stringResource(Res.string.no_notes_saved),
+ textAlign = TextAlign.Center,
+ modifier = Modifier.fillMaxWidth().padding(8.dp),
+ )
+ InlineInformationBanner(
+ text = stringResource(Res.string.notes_info_word_level),
+ modifier = Modifier.fillMaxWidth().padding(8.dp),
+ )
+ }
+ }
+}
+
+@Composable
+private fun NoteCard(
+ quote: String? = null,
+ content: @Composable () -> Unit,
+) {
+ Column(
+ modifier =
+ Modifier
+ .fillMaxWidth()
+ .padding(vertical = 4.dp)
+ .clip(RoundedCornerShape(8.dp))
+ .background(JewelTheme.globalColors.panelBackground)
+ .padding(8.dp),
+ ) {
+ if (quote != null) {
+ Text(
+ text = "\"$quote\"",
+ fontStyle = FontStyle.Italic,
+ color = JewelTheme.globalColors.text.info,
+ textAlign = TextAlign.Justify,
+ modifier = Modifier.fillMaxWidth().padding(bottom = 6.dp),
+ )
+ }
+ content()
+ }
+}
+
+/**
+ * Auto-saving note editor: a multi-line field plus a trash button. Text changes are debounced and
+ * pushed to [onPersist] (no explicit save). [onDelete] removes the note (or the draft's created
+ * note); when [clearOnDelete] is true the field is also emptied so the draft editor stays in place.
+ */
+@OptIn(FlowPreview::class, ExperimentalFoundationApi::class)
+@Composable
+private fun NoteEditor(
+ initialText: String,
+ autoFocus: Boolean,
+ clearOnDelete: Boolean,
+ onPersist: (String) -> Unit,
+ onDelete: () -> Unit,
+) {
+ val state = rememberTextFieldState(initialText)
+ val focusRequester = remember { FocusRequester() }
+ val currentOnPersist by rememberUpdatedState(onPersist)
+ var hadFocus by remember { mutableStateOf(false) }
+ if (autoFocus) {
+ LaunchedEffect(Unit) { focusRequester.requestFocus() }
+ }
+ LaunchedEffect(Unit) {
+ snapshotFlow { state.text.toString() }
+ .drop(1) // skip the initial value; only react to edits
+ .debounce(500)
+ .distinctUntilChanged()
+ .catch { }
+ .collect { currentOnPersist(it) }
+ }
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(4.dp),
+ ) {
+ // Restore Jewel's default text context menu (copy/cut/paste, with icons and shortcuts):
+ // inside the editor the book-content menu (highlight, add-note…) is irrelevant. Both the
+ // items and the representation are reset, since the screen overrides both.
+ CompositionLocalProvider(
+ LocalTextContextMenu provides JewelTextContextMenu,
+ LocalContextMenuRepresentation provides JewelContextMenuRepresentation,
+ ) {
+ TextArea(
+ state = state,
+ placeholder = { Text(stringResource(Res.string.note_body_placeholder)) },
+ // A bounded max height is required inside the LazyColumn (infinite incoming height).
+ modifier =
+ Modifier
+ .weight(1f)
+ .heightIn(min = 64.dp, max = 220.dp)
+ .focusRequester(focusRequester)
+ // Persist immediately when the field loses focus (clicking outside it),
+ // instead of waiting for the debounce.
+ .onFocusChanged { focusState ->
+ if (hadFocus && !focusState.isFocused) {
+ currentOnPersist(state.text.toString())
+ }
+ hadFocus = focusState.isFocused
+ },
+ )
+ }
+ // Hide the trash while the body is empty, but keep it laid out so the field never resizes.
+ val canDelete = state.text.isNotBlank()
+ IconActionButton(
+ key = AllIconsKeys.General.Delete,
+ onClick = {
+ if (clearOnDelete) state.clearText()
+ onDelete()
+ },
+ contentDescription = stringResource(Res.string.delete_note),
+ enabled = canDelete,
+ focusable = canDelete,
+ modifier = Modifier.alpha(if (canDelete) 1f else 0f),
+ )
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/BookContentUseCaseFactory.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/BookContentUseCaseFactory.kt
index 6dc7e7026..3399bd588 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/BookContentUseCaseFactory.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/BookContentUseCaseFactory.kt
@@ -26,6 +26,11 @@ class BookContentUseCaseFactory(
*/
fun createTocUseCase(stateManager: BookContentStateManager): TocUseCase = TocUseCase(repository, stateManager)
+ /**
+ * Creates a [NotesUseCase] for managing the Notes side pane layout.
+ */
+ fun createNotesUseCase(stateManager: BookContentStateManager): NotesUseCase = NotesUseCase(stateManager)
+
/**
* Creates a [ContentUseCase] for managing book content and line navigation.
*/
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/CommentariesUseCase.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/CommentariesUseCase.kt
index 062c354ab..bcd7eaea2 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/CommentariesUseCase.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/CommentariesUseCase.kt
@@ -2,6 +2,7 @@ package io.github.kdroidfilter.seforimapp.features.bookcontent.usecases
import androidx.paging.Pager
import androidx.paging.PagingData
+import androidx.paging.PagingSource
import androidx.paging.cachedIn
import io.github.kdroidfilter.seforimapp.core.coroutines.runSuspendCatching
import io.github.kdroidfilter.seforimapp.features.bookcontent.state.BookContentStateManager
@@ -46,6 +47,33 @@ class CommentariesUseCase(
private val commentatorBookCache: MutableMap = ConcurrentHashMap()
private val defaultTargumCache: MutableMap> = ConcurrentHashMap()
+ // Memoizes the cached pager flows per (kind, line(s), commentator) so the SAME cachedIn flow
+ // is reused whenever the same commentator column is requested again (re-selecting a line,
+ // toggling the commentaries pane, or an actual composition teardown). Without this, each
+ // request builds a fresh cachedIn flow and reloads commentaries from the DB — the cause of the
+ // visible delay before commentaries reappear. Bounded (access-order LRU) so visited-but-stale
+ // pagers don't accumulate unbounded heap.
+ private val pagerFlowCache =
+ object : LinkedHashMap>>(16, 0.75f, true) {
+ override fun removeEldestEntry(eldest: MutableMap.MutableEntry>>?): Boolean =
+ size > MAX_CACHED_PAGERS
+ }
+
+ // Read-through cache of commentator GROUPS per base line. Survives tab switches (the use
+ // case lives in viewModelScope), so returning to a tab no longer re-queries the DB for the
+ // groups. Bounded (access-order LRU).
+ private val lineConnectionsCache =
+ object : LinkedHashMap(16, 0.75f, true) {
+ override fun removeEldestEntry(eldest: MutableMap.MutableEntry?): Boolean =
+ size > MAX_CACHED_LINE_CONNECTIONS
+ }
+
+ @Synchronized
+ private fun cachedPager(
+ key: String,
+ create: () -> Flow>,
+ ): Flow> = pagerFlowCache.getOrPut(key, create)
+
private data class BaseLineResolution(
val baseLineIds: List,
val headingTocEntryId: Long? = null,
@@ -61,7 +89,9 @@ class CommentariesUseCase(
localCache[bookId] = cached
return cached
}
- val loaded = runSuspendCatching { repository.getBookWithPubDates(bookId) }.getOrNull() ?: return null
+ // Load authors + pubDates so commentator ordering can use canonical author ranks
+ // before falling back to publication-date heuristics.
+ val loaded = runSuspendCatching { repository.getBook(bookId) }.getOrNull() ?: return null
commentatorBookCache[bookId] = loaded
localCache[bookId] = loaded
return loaded
@@ -73,15 +103,41 @@ class CommentariesUseCase(
fun buildCommentariesPager(
lineId: Long,
commentatorId: Long? = null,
- ): Flow> {
- val ids = commentatorId?.let { setOf(it) } ?: emptySet()
-
- return Pager(
- config = PagingDefaults.COMMENTS.config(placeholders = false),
- pagingSourceFactory = {
- CommentsForLineOrTocPagingSource(repository, lineId, ids)
- },
- ).flow.cachedIn(scope)
+ ): Flow> =
+ cachedPager("com:$lineId:${commentatorId ?: -1L}") {
+ val ids = commentatorId?.let { setOf(it) } ?: emptySet()
+ Pager(
+ config = PagingDefaults.COMMENTS.config(placeholders = false),
+ pagingSourceFactory = {
+ CommentsForLineOrTocPagingSource(repository, lineId, ids)
+ },
+ ).flow.cachedIn(scope)
+ }
+
+ /**
+ * Warms the first page of each open commentator's column for [lineId] ahead of display
+ * (e.g. for a background tab not yet displayed). Reuses the exact [CommentsForLineOrTocPagingSource]
+ * the UI builds so the TOC-section resolution and SQL query are identical — the rows land in
+ * SQLite's page cache, making the on-demand pager load instant once the tab is shown.
+ */
+ suspend fun prefetchCommentaries(
+ lineId: Long,
+ commentatorIds: Set,
+ ) {
+ if (lineId <= 0 || commentatorIds.isEmpty()) return
+ for (commentatorId in commentatorIds) {
+ currentCoroutineContext().ensureActive()
+ runSuspendCatching {
+ CommentsForLineOrTocPagingSource(repository, lineId, setOf(commentatorId))
+ .load(
+ PagingSource.LoadParams.Refresh(
+ key = 0,
+ loadSize = PagingDefaults.COMMENTS.INITIAL_LOAD_SIZE,
+ placeholdersEnabled = false,
+ ),
+ )
+ }
+ }
}
/**
@@ -90,30 +146,30 @@ class CommentariesUseCase(
fun buildLinksPager(
lineId: Long,
sourceBookId: Long? = null,
- ): Flow> {
- val ids = sourceBookId?.let { setOf(it) } ?: emptySet()
-
- return Pager(
- config = PagingDefaults.COMMENTS.config(placeholders = false),
- pagingSourceFactory = {
- LineTargumPagingSource(repository, lineId, ids, setOf(ConnectionType.TARGUM))
- },
- ).flow.cachedIn(scope)
- }
+ ): Flow> =
+ cachedPager("tgm:$lineId:${sourceBookId ?: -1L}") {
+ val ids = sourceBookId?.let { setOf(it) } ?: emptySet()
+ Pager(
+ config = PagingDefaults.COMMENTS.config(placeholders = false),
+ pagingSourceFactory = {
+ LineTargumPagingSource(repository, lineId, ids, setOf(ConnectionType.TARGUM))
+ },
+ ).flow.cachedIn(scope)
+ }
fun buildSourcesPager(
lineId: Long,
sourceBookId: Long? = null,
- ): Flow> {
- val ids = sourceBookId?.let { setOf(it) } ?: emptySet()
-
- return Pager(
- config = PagingDefaults.COMMENTS.config(placeholders = false),
- pagingSourceFactory = {
- LineTargumPagingSource(repository, lineId, ids, setOf(ConnectionType.SOURCE))
- },
- ).flow.cachedIn(scope)
- }
+ ): Flow> =
+ cachedPager("src:$lineId:${sourceBookId ?: -1L}") {
+ val ids = sourceBookId?.let { setOf(it) } ?: emptySet()
+ Pager(
+ config = PagingDefaults.COMMENTS.config(placeholders = false),
+ pagingSourceFactory = {
+ LineTargumPagingSource(repository, lineId, ids, setOf(ConnectionType.SOURCE))
+ },
+ ).flow.cachedIn(scope)
+ }
// ========== Multi-line pagers for multi-selection ==========
@@ -123,16 +179,16 @@ class CommentariesUseCase(
fun buildCommentariesPagerForLines(
lineIds: List,
commentatorId: Long? = null,
- ): Flow> {
- val ids = commentatorId?.let { setOf(it) } ?: emptySet()
-
- return Pager(
- config = PagingDefaults.COMMENTS.config(placeholders = false),
- pagingSourceFactory = {
- MultiLineCommentsPagingSource(repository, lineIds, ids)
- },
- ).flow.cachedIn(scope)
- }
+ ): Flow> =
+ cachedPager("comL:${lineIds.joinToString(",")}:${commentatorId ?: -1L}") {
+ val ids = commentatorId?.let { setOf(it) } ?: emptySet()
+ Pager(
+ config = PagingDefaults.COMMENTS.config(placeholders = false),
+ pagingSourceFactory = {
+ MultiLineCommentsPagingSource(repository, lineIds, ids)
+ },
+ ).flow.cachedIn(scope)
+ }
/**
* Construit un Pager pour les liens/targum de plusieurs lignes
@@ -140,16 +196,16 @@ class CommentariesUseCase(
fun buildLinksPagerForLines(
lineIds: List,
sourceBookId: Long? = null,
- ): Flow> {
- val ids = sourceBookId?.let { setOf(it) } ?: emptySet()
-
- return Pager(
- config = PagingDefaults.COMMENTS.config(placeholders = false),
- pagingSourceFactory = {
- MultiLineLinksPagingSource(repository, lineIds, ids, setOf(ConnectionType.TARGUM))
- },
- ).flow.cachedIn(scope)
- }
+ ): Flow> =
+ cachedPager("tgmL:${lineIds.joinToString(",")}:${sourceBookId ?: -1L}") {
+ val ids = sourceBookId?.let { setOf(it) } ?: emptySet()
+ Pager(
+ config = PagingDefaults.COMMENTS.config(placeholders = false),
+ pagingSourceFactory = {
+ MultiLineLinksPagingSource(repository, lineIds, ids, setOf(ConnectionType.TARGUM))
+ },
+ ).flow.cachedIn(scope)
+ }
/**
* Construit un Pager pour les sources de plusieurs lignes
@@ -157,16 +213,16 @@ class CommentariesUseCase(
fun buildSourcesPagerForLines(
lineIds: List,
sourceBookId: Long? = null,
- ): Flow> {
- val ids = sourceBookId?.let { setOf(it) } ?: emptySet()
-
- return Pager(
- config = PagingDefaults.COMMENTS.config(placeholders = false),
- pagingSourceFactory = {
- MultiLineLinksPagingSource(repository, lineIds, ids, setOf(ConnectionType.SOURCE))
- },
- ).flow.cachedIn(scope)
- }
+ ): Flow> =
+ cachedPager("srcL:${lineIds.joinToString(",")}:${sourceBookId ?: -1L}") {
+ val ids = sourceBookId?.let { setOf(it) } ?: emptySet()
+ Pager(
+ config = PagingDefaults.COMMENTS.config(placeholders = false),
+ pagingSourceFactory = {
+ MultiLineLinksPagingSource(repository, lineIds, ids, setOf(ConnectionType.SOURCE))
+ },
+ ).flow.cachedIn(scope)
+ }
/**
* Ordered char-count vector for the commentary pager built from a single base line
@@ -306,21 +362,35 @@ class CommentariesUseCase(
}
/**
- * Récupère les sources disponibles pour plusieurs lignes (union)
+ * Récupère les sources disponibles pour plusieurs lignes (union).
+ *
+ * Issues a single inverse-direction repository query against the union of
+ * all base lines so the order returned by the underlying SQL
+ * (`l.isDeclaredBase DESC, b.orderIndex, sl.lineIndex`) is respected
+ * globally. Per-lineId iteration would interleave per-source-book entries
+ * by lineId rather than by catalog position.
*/
suspend fun getAvailableSourcesForLines(lineIds: List): Map {
if (lineIds.isEmpty()) return emptyMap()
return runSuspendCatching {
- val map = LinkedHashMap()
- for (lineId in lineIds) {
- val sources = getAvailableSources(lineId)
- sources.forEach { (name, id) ->
- if (!map.containsKey(name)) {
- map[name] = id
- }
- }
- }
- map
+ val selectedBook =
+ stateManager.state
+ .first()
+ .navigation.selectedBook
+ if (selectedBook?.hasSourceConnection != true) return@runSuspendCatching emptyMap()
+
+ val allBaseIds =
+ lineIds
+ .flatMap { resolveBaseLineIds(it) }
+ .distinct()
+ if (allBaseIds.isEmpty()) return@runSuspendCatching emptyMap()
+
+ val links =
+ repository
+ .getCommentarySummariesForLines(allBaseIds, includeSources = true)
+ .filter { it.link.connectionType == ConnectionType.SOURCE }
+
+ buildSourceMap(links, selectedBook.title.trim())
}.getOrElse { emptyMap() }
}
@@ -370,13 +440,29 @@ class CommentariesUseCase(
return loaded
}
+ // Collect the full ancestor chain (book.categoryId → root). Cap depth as
+ // a safety net against accidental cycles in the closure table.
+ val chain = mutableListOf()
var currentId: Long? = book.categoryId
- while (currentId != null) {
+ var depth = 0
+ while (currentId != null && depth < 32) {
+ currentCoroutineContext().ensureActive()
+ val cat = loadCategory(currentId) ?: break
+ chain.add(cat)
+ currentId = cat.parentId
+ depth++
+ }
+ if (chain.isEmpty()) return ""
+
+ // Pass 1: the strongest, most-informative bucket — "X על Y" labels
+ // anchored on a primary corpus (Tanakh / Talmud / Mishna / Shas) win
+ // over everything else, scanned across the whole ancestor chain. This
+ // is important because a sub-commentary on Rif (chain:
+ // `מפרשים < רי״ף < ראשונים על התלמוד`) must surface as
+ // `ראשונים על התלמוד`, NOT as `מפרשים על רי״ף`.
+ for (category in chain) {
currentCoroutineContext().ensureActive()
- val category = loadCategory(currentId) ?: break
val title = category.title
-
- // Prefer high-level "commentaries on ..." buckets
if (
title.contains("על התנ״ך") ||
title.contains("על התלמוד") ||
@@ -387,41 +473,302 @@ class CommentariesUseCase(
) {
return title
}
+ }
- // Broad families (e.g., חסידות, מילונים, מחברי זמננו)
- if (title == "חסידות" || title.contains("חסידות")) {
- return title
- }
- if (title.contains("מילונים")) {
- return title
- }
- if (title == "ראשונים") {
- return title
- }
- if (title == "מחברי זמננו") {
- return title
- }
- if (title == "ביאור חברותא" || title == "הערות על ביאור חברותא") {
- return "חברותא"
- }
+ // Pass 2: hard-coded multi-book families (chevruta, dictionaries,
+ // contemporary authors).
+ for (category in chain) {
+ currentCoroutineContext().ensureActive()
+ val title = category.title
+ if (title == "ביאור חברותא" || title == "הערות על ביאור חברותא") return "חברותא"
+ if (title.contains("מילונים")) return title
+ if (title == "מחברי זמננו") return title
+ }
- // Generic "מפרשים" bucket (e.g., for משנה תורה)
- if (title == "מפרשים") {
- val parent =
- category.parentId?.let { parentId ->
- loadCategory(parentId)
+ // Pass 3: "מפרשים" — only when no higher-level "X על Y" anchor exists
+ // (e.g. Mishneh Torah's super-commentaries). Check if the parent's
+ // ancestors include a corpus reference. If so, use that. Otherwise use
+ // immediate parent.
+ for ((idx, category) in chain.withIndex()) {
+ currentCoroutineContext().ensureActive()
+ if (category.title == "מפרשים") {
+ // Check if "ראשונים" appears further up the chain; if so, use its corpus parent.
+ for (ancestorIdx in (idx + 1) until chain.size) {
+ val ancestor = chain[ancestorIdx]
+ if (ancestor.title == "ראשונים") {
+ // Found "ראשונים" — use its parent corpus
+ val corpus = chain.getOrNull(ancestorIdx + 1)
+ if (corpus != null) {
+ return "ראשונים על ${when (corpus.title) {
+ "בבלי", "בבל" -> "התלמוד"
+ "תנ״ך", "תנך" -> "התנ״ך"
+ "משנה" -> "המשנה"
+ "ש\"ס", "ש״ס", "שס" -> "הש\"ס"
+ else -> corpus.title
+ }}"
+ }
+ break
}
+ }
+ // Fallback: use immediate parent
+ val parent = chain.getOrNull(idx + 1)
if (parent != null && parent.title.isNotBlank()) {
return "מפרשים על ${parent.title}"
}
+ return "מפרשים"
+ }
+ }
+
+ // Pass 4: bare "ראשונים" / "אחרונים" anywhere in the chain. Look for corpus
+ // references further up; if found, use those. Otherwise use immediate parent.
+ for ((idx, category) in chain.withIndex()) {
+ currentCoroutineContext().ensureActive()
+ val title = category.title
+ if (title == "ראשונים" || title == "אחרונים") {
+ // Check ancestors for corpus references (בבלי, תנ״ך, משנה, etc.)
+ for (ancestorIdx in (idx + 1) until chain.size) {
+ val ancestor = chain[ancestorIdx]
+ val corpusLabel =
+ when (ancestor.title) {
+ "בבלי", "בבל" -> "התלמוד"
+ "תנ״ך", "תנך" -> "התנ״ך"
+ "משנה" -> "המשנה"
+ "ש\"ס", "ש״ס", "שס" -> "הש\"ס"
+ else -> null
+ }
+ if (corpusLabel != null) {
+ return "$title על $corpusLabel"
+ }
+ }
+ // Fallback: use immediate parent
+ val parent = chain.getOrNull(idx + 1)
+ if (parent != null && parent.title.isNotBlank()) {
+ val parentLabel =
+ when (parent.title) {
+ "תנ״ך", "תנך" -> "התנ״ך"
+ "תלמוד" -> "התלמוד"
+ "משנה" -> "המשנה"
+ "ש\"ס", "ש״ס", "שס" -> "הש\"ס"
+ else -> parent.title
+ }
+ return "$title על $parentLabel"
+ }
return title
}
+ }
+
+ // Second pass: collapse fragmented sub-trees (Targumim, Midrash, Kabbalah, Chasidut)
+ // into a single top-level bucket so multi-volume editorial families don't
+ // create one group per book.
+ for (category in chain) {
+ currentCoroutineContext().ensureActive()
+ val title = category.title
+ // Targums: "תורה < תרגום אונקלוס < תרגומים < תנ״ך"; also bare "תרגום ירושלמי" etc.
+ if (title == "תרגומים" || title.startsWith("תרגום ") || title.startsWith("תפסיר ")) {
+ return "תרגומים"
+ }
+ // Midrash: "מדרש לקח טוב < אגדה < מדרש", "מדרש רבה < אגדה < מדרש".
+ if (title == "מדרש") return "מדרש"
+ // Kabbalah: "ספרי קבלה נוספים < קבלה", "זהר < קבלה".
+ if (title == "קבלה") return "קבלה"
+ // Chasidut sub-tree.
+ if (title == "חסידות" || title.contains("חסידות")) return "חסידות"
+ }
- currentId = category.parentId
+ // Fallback: use the deepest reasonable bucket from the root side
+ // (avoid single-author categories like חזקוני/מהר״ל that produce singleton groups).
+ val rootLevel = chain.lastOrNull()?.title
+ return rootLevel ?: chain.first().title
+ }
+
+ /**
+ * Canonical editorial rank for top-level commentator groups. Lower wins.
+ * Anything not listed falls into [GROUP_RANK_DEFAULT] and is sorted by
+ * pub-date / alphabet within that bucket.
+ */
+ private fun groupRank(label: String): Int {
+ // Tanach buckets
+ if (label == "תרגומים") return 10
+ if (label.startsWith("ראשונים על המשנה")) return 20
+ if (label.startsWith("ראשונים על התלמוד") || label.startsWith("ראשונים על הש")) return 25
+ if (label.startsWith("ראשונים על התנ״ך")) return 30
+ if (label.startsWith("אחרונים על המשנה")) return 40
+ if (label.startsWith("אחרונים על התלמוד") || label.startsWith("אחרונים על הש")) return 45
+ if (label.startsWith("אחרונים על התנ״ך")) return 50
+ if (label.startsWith("מפרשים על")) return 55
+ if (label == "ראשונים") return 60
+ if (label == "אחרונים") return 65
+ if (label.startsWith("ראשונים על ")) return 67
+ if (label.startsWith("אחרונים על ")) return 68
+ if (label == "מדרש") return 70
+ if (label == "חסידות") return 80
+ if (label == "קבלה") return 90
+ if (label == "חברותא") return 100
+ if (label.contains("מילונים")) return 110
+ if (label == "מחברי זמננו") return 120
+ return GROUP_RANK_DEFAULT
+ }
+
+ /**
+ * Approximate canonical year (birth) for major Rishonim/Acharonim. Used as the
+ * primary intra-group sort key — the printed first-edition dates stored in
+ * `pub_date` are too noisy (Rashi at 1476, Hadar Zekenim at 1840) to give a
+ * stable chronological order on their own.
+ *
+ * Match against [Book.authors] first, then against [Book.title] / displayName.
+ */
+ private fun canonicalRank(
+ book: Book?,
+ displayName: String,
+ ): Int? {
+ if (book == null) return null
+
+ fun normalize(s: String): String = s.replace('"', '״').replace('\'', '׳').trim()
+
+ val authorNames = book.authors.map { normalize(it.name) }
+ for (author in authorNames) {
+ CANONICAL_AUTHOR_YEAR[author]?.let { return it }
+ }
+ val title = normalize(book.title)
+ for ((pattern, year) in CANONICAL_TITLE_YEAR) {
+ if (title.contains(pattern)) return year
}
+ val display = normalize(displayName)
+ for ((pattern, year) in CANONICAL_TITLE_YEAR) {
+ if (display.contains(pattern)) return year
+ }
+ return null
+ }
+
+ private companion object {
+ const val GROUP_RANK_DEFAULT = 1_000
+
+ // Upper bound on memoized commentary/link/source pager flows (across all lines and
+ // commentators visited in this book tab). Each retains its loaded pages, so keep it
+ // modest; the least-recently-used pager is evicted past this size.
+ const val MAX_CACHED_PAGERS = 32
+
+ // Upper bound on cached commentator-group snapshots (one per base line). Snapshots are
+ // light (group/commentator metadata, no commentary text), so this can be generous.
+ const val MAX_CACHED_LINE_CONNECTIONS = 512
+
+ // Canonical (approximate) author birth years for the dominant Rishonim
+ // and Acharonim that ship with the corpus. Keys are normalized to gershayim
+ // form (״). Add to this list when new "VIP" commentators surface.
+ val CANONICAL_AUTHOR_YEAR: Map =
+ mapOf(
+ // Geonim
+ "ר' סעדיה גאון" to 882,
+ "סעדיה גאון" to 882,
+ "רב סעדיה גאון" to 882,
+ // Rishonim – Ashkenaz / Tsarfat
+ "רש״י" to 1040,
+ "רשב״ם" to 1085,
+ "ר' יוסף קרא" to 1065,
+ "יוסף בכור שור" to 1140,
+ "אבן עזרא" to 1089,
+ "ר' אברהם אבן עזרא" to 1089,
+ "רד״ק" to 1160,
+ "רמב״ן" to 1194,
+ "חזקוני" to 1240,
+ "רא״ש" to 1250,
+ "רבנו בחיי" to 1255,
+ "בחיי בן אשר" to 1255,
+ "יעקב בן אשר" to 1269,
+ "רלב״ג" to 1288,
+ "מנחם ריקנטי" to 1290,
+ "אברבנאל" to 1437,
+ "עובדיה מברטנורא" to 1445,
+ "אליהו בן אברהם מזרחי" to 1455,
+ "ספורנו" to 1475,
+ // Acharonim
+ "אלשיך" to 1508,
+ "מהר״ל" to 1520,
+ "שלמה אפרים מלונטשיץ" to 1550,
+ "ש״ך" to 1622,
+ "חיים בן עטר" to 1696,
+ "אליהו בן שלמה זלמן מווילנה" to 1720,
+ "משה סופר" to 1762,
+ "נתן נטע שפירא" to 1585,
+ "יעקב צבי מקלנבורג" to 1785,
+ "מלבי״ם" to 1809,
+ "נפתלי צבי יהודה ברלין" to 1816,
+ "יוסף חיים" to 1834,
+ "מאיר שמחה הכהן" to 1843,
+ "רב יוסף דוב הלוי סולובייצ'ק" to 1903,
+ )
- val baseCategory = loadCategory(book.categoryId)
- return baseCategory?.title ?: ""
+ // Title fragments (normalized to gershayim) → canonical year. Acts as a
+ // fallback when the author table is sparse for older works.
+ val CANONICAL_TITLE_YEAR: List> =
+ listOf(
+ "רס״ג" to 882,
+ "ר' סעדיה גאון" to 882,
+ "רש״י" to 1040,
+ "רשב״ם" to 1085,
+ "אבן עזרא" to 1089,
+ "אב״ע" to 1089,
+ "ראב״ע" to 1089,
+ "בכור שור" to 1140,
+ "רד״ק" to 1160,
+ "רמב״ן" to 1194,
+ "חזקוני" to 1240,
+ "רא״ש" to 1250,
+ "רבנו בחיי" to 1255,
+ "רבינו בחיי" to 1255,
+ "בעל הטורים" to 1269,
+ "הטור הארוך" to 1269,
+ "רלב״ג" to 1288,
+ "פענח רזא" to 1295,
+ "ריקנטי" to 1290,
+ "רקנאטי" to 1290,
+ "דעת זקנים" to 1290,
+ "הדר זקנים" to 1290,
+ "אברבנאל" to 1437,
+ "ברטנורא" to 1445,
+ "מזרחי" to 1455,
+ "ספורנו" to 1475,
+ "צרור המור" to 1440,
+ "תולדות יצחק" to 1458,
+ "אלשיך" to 1508,
+ "מהר״ל" to 1520,
+ "גור אריה" to 1520,
+ "כלי יקר" to 1550,
+ "שפתי כהן" to 1622,
+ "אור החיים" to 1696,
+ "מנחת שי" to 1565,
+ "שפתי חכמים" to 1641,
+ "אבי עזר" to 1750,
+ "אדרת אליהו" to 1720,
+ "הגר״א" to 1720,
+ "חתם סופר" to 1762,
+ "הכתב והקבלה" to 1785,
+ "תפארת יהונתן" to 1690,
+ "אהבת יהונתן" to 1690,
+ "מלבי״ם" to 1809,
+ "העמק דבר" to 1816,
+ "נצי״ב" to 1816,
+ "רש״ר הירש" to 1808,
+ "בן איש חי" to 1834,
+ "תורה תמימה" to 1860,
+ "פרדס יוסף" to 1880,
+ "משך חכמה" to 1843,
+ "בית הלוי" to 1820,
+ "נתינה לגר" to 1875,
+ "תרגום אונקלוס" to -100,
+ "תרגום יונתן" to 100,
+ "תרגום ירושלמי" to 200,
+ "תפסיר רס״ג" to 882,
+ "מדרש" to 500,
+ "בראשית רבה" to 400,
+ "שמות רבה" to 400,
+ "ויקרא רבה" to 400,
+ "מדרש תנחומא" to 500,
+ "תנחומא בובר" to 500,
+ "פסיקתא" to 600,
+ "מכילתא" to 200,
+ "ספרי" to 200,
+ )
}
private fun sanitizeCommentatorName(
@@ -502,30 +849,40 @@ class CommentariesUseCase(
data class TempGroup(
val label: String,
+ val rank: Int,
val entries: List,
val earliestYear: Int,
)
+ // Resolve a chronological year per entry, falling back through:
+ // 1. canonicalRank() — hand-curated author/title → birth year table.
+ // 2. earliest pub_date year — first known printing.
+ // 3. Int.MAX_VALUE — pushes undated entries to the tail.
+ fun entryYear(entry: CommentatorEntry): Int {
+ canonicalRank(entry.book, entry.displayName)?.let { return it }
+ entry.book
+ ?.pubDates
+ ?.let { extractEarliestYear(it) }
+ ?.let { return it }
+ return Int.MAX_VALUE
+ }
+
val tempGroups =
groupsByLabel.map { (label, groupEntries) ->
val sortedEntries =
groupEntries.sortedWith(
compareBy(
+ // "הערות על X" companion notes always trail their parent book.
{ if (categoryCache[it.book?.categoryId]?.title?.startsWith("הערות על") == true) 1 else 0 },
- { it.book?.pubDates?.let { d -> extractEarliestYear(d) } ?: Int.MAX_VALUE },
+ { entryYear(it) },
{ it.displayName },
),
)
- val groupEarliestYear =
- sortedEntries
- .firstOrNull()
- ?.book
- ?.pubDates
- ?.let { extractEarliestYear(it) }
- ?: Int.MAX_VALUE
+ val groupEarliestYear = sortedEntries.minOfOrNull { entryYear(it) } ?: Int.MAX_VALUE
TempGroup(
label = label,
+ rank = groupRank(label),
entries = sortedEntries,
earliestYear = groupEarliestYear,
)
@@ -533,7 +890,10 @@ class CommentariesUseCase(
return tempGroups
.sortedWith(
- compareBy { it.earliestYear }
+ // Editorial rank dominates (Targums → Rishonim → Acharonim → Midrash → …);
+ // within the same rank, earliest year then label keep results deterministic.
+ compareBy { it.rank }
+ .thenBy { it.earliestYear }
.thenBy { it.label },
).map { group ->
CommentatorGroup(
@@ -662,45 +1022,63 @@ class CommentariesUseCase(
suspend fun getAvailableSources(lineId: Long): Map =
runSuspendCatching {
+ val selectedBook =
+ stateManager.state
+ .first()
+ .navigation.selectedBook
+ // Fast path: book has no inbound oriented links — no need to hit DB.
+ if (selectedBook?.hasSourceConnection != true) return@runSuspendCatching emptyMap()
+
val baseIds = resolveBaseLineIds(lineId)
val links =
repository
.getCommentarySummariesForLines(baseIds)
.filter { it.link.connectionType == ConnectionType.SOURCE }
- val currentBookTitle =
- stateManager.state
- .first()
- .navigation.selectedBook
- ?.title
- ?.trim()
- .orEmpty()
-
+ val currentBookTitle = selectedBook.title.trim()
buildSourceMap(links, currentBookTitle)
}.getOrElse { emptyMap() }
suspend fun loadLineConnections(lineIds: List): Map {
if (lineIds.isEmpty()) return emptyMap()
-
val distinctIds = lineIds.distinct()
+
+ // Read-through cache: only query the DB for lines we have not resolved yet.
+ val cached = LinkedHashMap()
+ val missing = ArrayList()
+ synchronized(lineConnectionsCache) {
+ distinctIds.forEach { id ->
+ val hit = lineConnectionsCache[id]
+ if (hit != null) cached[id] = hit else missing.add(id)
+ }
+ }
+ if (missing.isEmpty()) return cached
+
+ fun storeAndMerge(loaded: Map): Map {
+ synchronized(lineConnectionsCache) { loaded.forEach { (id, snap) -> lineConnectionsCache[id] = snap } }
+ return cached + loaded
+ }
+
val resolutionCache = LinkedHashMap()
val tocLinesCache = mutableMapOf>()
val headingCache = mutableMapOf()
- distinctIds.forEach { id ->
+ missing.forEach { id ->
resolutionCache[id] = resolveBaseLineResolution(id, tocLinesCache, headingCache)
}
val allBaseIds = resolutionCache.values.flatMap { it.baseLineIds }.distinct()
- if (allBaseIds.isEmpty()) return distinctIds.associateWith { LineConnectionsSnapshot() }
+ if (allBaseIds.isEmpty()) return storeAndMerge(missing.associateWith { LineConnectionsSnapshot() })
+
+ val currentState = stateManager.state.first()
+ val selectedBook = currentState.navigation.selectedBook
val allConnections = repository.getCommentarySummariesForLines(allBaseIds)
- if (allConnections.isEmpty()) return distinctIds.associateWith { LineConnectionsSnapshot() }
+ if (allConnections.isEmpty()) return storeAndMerge(missing.associateWith { LineConnectionsSnapshot() })
val connectionsBySource = allConnections.groupBy { it.link.sourceLineId }
- val currentState = stateManager.state.first()
val currentBookTitle =
- currentState.navigation.selectedBook
+ selectedBook
?.title
?.trim()
.orEmpty()
@@ -713,12 +1091,14 @@ class CommentariesUseCase(
defaultTargumByBookId[bookId] = ids.firstOrNull()
}
- return resolutionCache.mapValues { (_, resolution) ->
- val aggregated = resolution.baseLineIds.flatMap { baseId -> connectionsBySource[baseId].orEmpty() }
- val defaultTargumId = resolution.headingBookId?.let { defaultTargumByBookId[it] }
- val filtered = filterTargumConnections(aggregated, resolution, defaultTargumId)
- buildLineConnectionsSnapshot(filtered, currentBookTitle, bookCache, categoryCache)
- }
+ val snapshots =
+ resolutionCache.mapValues { (_, resolution) ->
+ val aggregated = resolution.baseLineIds.flatMap { baseId -> connectionsBySource[baseId].orEmpty() }
+ val defaultTargumId = resolution.headingBookId?.let { defaultTargumByBookId[it] }
+ val filtered = filterTargumConnections(aggregated, resolution, defaultTargumId)
+ buildLineConnectionsSnapshot(filtered, currentBookTitle, bookCache, categoryCache)
+ }
+ return storeAndMerge(snapshots)
}
/**
@@ -1139,7 +1519,14 @@ class CommentariesUseCase(
index: Int,
offset: Int,
) {
- stateManager.updateContent {
+ stateManager.updateContent(save = false) {
+ if (
+ commentariesColumnScrollIndexByCommentator[commentatorId] == index &&
+ commentariesColumnScrollOffsetByCommentator[commentatorId] == offset
+ ) {
+ return@updateContent this
+ }
+
val idxMap = commentariesColumnScrollIndexByCommentator.toMutableMap()
val offMap = commentariesColumnScrollOffsetByCommentator.toMutableMap()
idxMap[commentatorId] = index
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/NotesUseCase.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/NotesUseCase.kt
new file mode 100644
index 000000000..f725a227f
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/usecases/NotesUseCase.kt
@@ -0,0 +1,57 @@
+@file:OptIn(ExperimentalSplitPaneApi::class)
+
+package io.github.kdroidfilter.seforimapp.features.bookcontent.usecases
+
+import io.github.kdroidfilter.seforimapp.features.bookcontent.state.BookContentStateManager
+import org.jetbrains.compose.splitpane.ExperimentalSplitPaneApi
+
+/**
+ * UseCase for the Notes side pane visibility and scroll state. The notes themselves are owned by
+ * [io.github.kdroidfilter.seforimapp.core.annotations.NoteStore]; this only drives the pane layout.
+ */
+class NotesUseCase(
+ private val stateManager: BookContentStateManager,
+) {
+ /** Toggle the visibility of the Notes pane, mirroring [TocUseCase.toggleToc]. */
+ fun toggleNotes(): Boolean {
+ val currentState = stateManager.state.value
+ val isVisible = currentState.notes.isVisible
+ val newPosition: Float
+
+ if (isVisible) {
+ // Hide: save the current position first, then collapse.
+ val prev = currentState.layout.notesSplitState.positionPercentage
+ stateManager.updateLayout {
+ copy(previousPositions = previousPositions.copy(notes = prev))
+ }
+ newPosition = 0f
+ currentState.layout.notesSplitState.positionPercentage = newPosition
+ } else {
+ // Show: restore the last saved position.
+ newPosition = currentState.layout.previousPositions.notes
+ currentState.layout.notesSplitState.positionPercentage = newPosition
+ }
+
+ stateManager.updateNotes {
+ copy(isVisible = !isVisible)
+ }
+
+ return !isVisible
+ }
+
+ /** Ensures the Notes pane is visible (used when the user creates a note). */
+ fun showNotes() {
+ if (!stateManager.state.value.notes.isVisible) {
+ toggleNotes()
+ }
+ }
+
+ fun updateNotesScrollPosition(
+ index: Int,
+ offset: Int,
+ ) {
+ stateManager.updateNotes {
+ copy(scrollIndex = index, scrollOffset = offset)
+ }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/DatabaseUpdateWindow.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/DatabaseUpdateWindow.kt
index 11145a522..eca496db4 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/DatabaseUpdateWindow.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/DatabaseUpdateWindow.kt
@@ -1,128 +1,29 @@
package io.github.kdroidfilter.seforimapp.features.database.update
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.rotate
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.ApplicationScope
-import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
-import androidx.navigation.compose.rememberNavController
-import io.github.kdroidfilter.nucleus.window.ControlButtonsDirection
-import io.github.kdroidfilter.nucleus.window.jewel.JewelDecoratedWindow
-import io.github.kdroidfilter.nucleus.window.jewel.JewelTitleBar
-import io.github.kdroidfilter.nucleus.window.newFullscreenControls
-import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.getCenteredWindowState
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.rememberWindowViewModelStoreOwner
+import androidx.compose.runtime.Composable
+import dev.nucleusframework.application.NucleusApplicationScope
+import io.github.kdroidfilter.seforimapp.core.presentation.components.InstallerWindow
import io.github.kdroidfilter.seforimapp.features.database.update.navigation.DatabaseUpdateNavHost
-import io.github.kdroidfilter.seforimapp.framework.platform.PlatformInfo
+import io.github.kdroidfilter.seforimapp.features.database.update.navigation.DatabaseUpdateProgressBarState
import io.github.kdroidfilter.seforimapp.icons.Deployed_code_update
-import org.jetbrains.compose.resources.painterResource
import org.jetbrains.compose.resources.stringResource
-import org.jetbrains.jewel.foundation.modifier.trackActivation
-import org.jetbrains.jewel.foundation.theme.JewelTheme
-import org.jetbrains.jewel.ui.component.Icon
-import org.jetbrains.jewel.ui.component.IconButton
-import org.jetbrains.jewel.ui.component.Text
-import org.jetbrains.jewel.ui.icons.AllIconsKeys
-import seforimapp.seforimapp.generated.resources.AppIcon
import seforimapp.seforimapp.generated.resources.Res
-import seforimapp.seforimapp.generated.resources.app_name
import seforimapp.seforimapp.generated.resources.db_update_title_bar
@Composable
-fun ApplicationScope.DatabaseUpdateWindow(
+fun NucleusApplicationScope.DatabaseUpdateWindow(
onUpdateComplete: () -> Unit = {},
isDatabaseMissing: Boolean = false,
) {
- val updateWindowState = remember { getCenteredWindowState(720, 420) }
- JewelDecoratedWindow(
- onCloseRequest = { exitApplication() },
- title = stringResource(Res.string.app_name),
- icon = if (PlatformInfo.isMacOS) null else painterResource(Res.drawable.AppIcon),
- state = updateWindowState,
- visible = true,
- resizable = false,
- ) {
- val windowViewModelOwner = rememberWindowViewModelStoreOwner()
- CompositionLocalProvider(
- LocalWindowViewModelStoreOwner provides windowViewModelOwner,
- LocalViewModelStoreOwner provides windowViewModelOwner,
- ) {
- val isMac = PlatformInfo.isMacOS
- val isWindows = PlatformInfo.isWindows
- val navController = rememberNavController()
- var canNavigateBack by remember { mutableStateOf(false) }
-
- LaunchedEffect(navController) {
- navController.currentBackStackEntryFlow.collect {
- canNavigateBack = navController.previousBackStackEntry != null
- }
- }
-
- JewelTitleBar(
- modifier = Modifier.newFullscreenControls(),
- gradientStartColor = ThemeUtils.titleBarGradientColor(),
- controlButtonsDirection = ControlButtonsDirection.SystemNative,
- ) {
- // Keep the back button pinned to the start and
- // center the title (icon + text) regardless of OS/window controls.
- Box(
- modifier =
- Modifier
- .fillMaxWidth(if (isMac) 0.9f else 1f)
- .padding(start = if (isWindows) 70.dp else 0.dp),
- ) {
- if (canNavigateBack) {
- IconButton(
- modifier =
- Modifier
- .align(Alignment.CenterStart)
- .padding(start = 8.dp)
- .size(24.dp),
- onClick = { navController.navigateUp() },
- ) {
- Icon(AllIconsKeys.Actions.Back, null, modifier = Modifier.rotate(180f))
- }
- }
-
- val centerOffset = 40.dp
-
- Row(
- modifier =
- Modifier
- .align(Alignment.Center)
- .offset(x = centerOffset),
- verticalAlignment = Alignment.CenterVertically,
- horizontalArrangement = Arrangement.spacedBy(8.dp),
- ) {
- Icon(
- Deployed_code_update,
- contentDescription = null,
- tint = JewelTheme.globalColors.text.normal,
- modifier = Modifier.size(16.dp),
- )
- Text(stringResource(Res.string.db_update_title_bar))
- }
- }
- }
- Column(
- modifier =
- Modifier
- .trackActivation()
- .fillMaxSize()
- .background(JewelTheme.globalColors.panelBackground),
- ) {
- DatabaseUpdateNavHost(
- navController = navController,
- onUpdateComplete = onUpdateComplete,
- isDatabaseMissing = isDatabaseMissing,
- )
- }
- }
+ InstallerWindow(
+ titleBarIcon = Deployed_code_update,
+ titleBarText = stringResource(Res.string.db_update_title_bar),
+ progress = DatabaseUpdateProgressBarState.progress,
+ ) { navController ->
+ DatabaseUpdateNavHost(
+ navController = navController,
+ onUpdateComplete = onUpdateComplete,
+ isDatabaseMissing = isDatabaseMissing,
+ )
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/navigation/DatabaseUpdateNavHost.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/navigation/DatabaseUpdateNavHost.kt
index e9af1c9c6..aa8ce8683 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/navigation/DatabaseUpdateNavHost.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/navigation/DatabaseUpdateNavHost.kt
@@ -9,13 +9,10 @@ import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
-import androidx.navigation.NavBackStackEntry
-import androidx.navigation.NavGraphBuilder
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import io.github.kdroidfilter.seforim.navigation.NavigationAnimations
import io.github.kdroidfilter.seforimapp.core.presentation.components.AnimatedHorizontalProgressBar
+import io.github.kdroidfilter.seforimapp.core.presentation.navigation.noAnimatedComposable
import io.github.kdroidfilter.seforimapp.features.database.update.screens.CompletionScreen
import io.github.kdroidfilter.seforimapp.features.database.update.screens.OfflineUpdateScreen
import io.github.kdroidfilter.seforimapp.features.database.update.screens.OnlineUpdateScreen
@@ -72,16 +69,3 @@ fun DatabaseUpdateNavHost(
}
}
}
-
-inline fun NavGraphBuilder.noAnimatedComposable(
- noinline content: @Composable (NavBackStackEntry) -> Unit,
-) {
- composable(
- enterTransition = { NavigationAnimations.enterTransition(this) },
- exitTransition = { NavigationAnimations.exitTransition(this) },
- popEnterTransition = { NavigationAnimations.popEnterTransition(this) },
- popExitTransition = { NavigationAnimations.popExitTransition(this) },
- ) {
- content(it)
- }
-}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/navigation/DatabaseUpdateProgressBarState.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/navigation/DatabaseUpdateProgressBarState.kt
index 91f5c170c..2b25d97d1 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/navigation/DatabaseUpdateProgressBarState.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/navigation/DatabaseUpdateProgressBarState.kt
@@ -1,12 +1,8 @@
package io.github.kdroidfilter.seforimapp.features.database.update.navigation
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-
-object DatabaseUpdateProgressBarState {
- private var _progress = MutableStateFlow(0f)
- val progress = _progress.asStateFlow()
+import io.github.kdroidfilter.seforimapp.core.presentation.components.ProgressBarController
+object DatabaseUpdateProgressBarState : ProgressBarController() {
// Progress steps for database update
private const val VERSION_CHECK_STEP = 0.1f // 10% - Version check completed
private const val OPTIONS_SELECTED_STEP = 0.2f // 20% - Update option selected
@@ -14,18 +10,6 @@ object DatabaseUpdateProgressBarState {
private const val DOWNLOAD_COMPLETE_STEP = 0.8f // 80% - Download/extraction completed
private const val UPDATE_COMPLETE_STEP = 1.0f // 100% - Update finished
- fun setProgress(progress: Float) {
- _progress.value = progress.coerceIn(0f, 1f)
- }
-
- fun resetProgress() {
- _progress.value = 0f
- }
-
- fun improveBy(value: Float) {
- _progress.value = (_progress.value + value).coerceIn(0f, 1f)
- }
-
// Helper methods for specific steps
fun setVersionCheckComplete() {
setProgress(VERSION_CHECK_STEP)
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/screens/OfflineUpdateScreen.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/screens/OfflineUpdateScreen.kt
index bea33e3fc..718f22a05 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/screens/OfflineUpdateScreen.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/screens/OfflineUpdateScreen.kt
@@ -14,12 +14,10 @@ import io.github.kdroidfilter.seforimapp.features.database.update.navigation.Dat
import io.github.kdroidfilter.seforimapp.features.onboarding.data.OnboardingProcessRepository
import io.github.kdroidfilter.seforimapp.features.onboarding.extract.ExtractEvents
import io.github.kdroidfilter.seforimapp.features.onboarding.extract.ExtractViewModel
+import io.github.kdroidfilter.seforimapp.features.onboarding.offline.pickDatabaseParts
import io.github.kdroidfilter.seforimapp.features.onboarding.ui.components.OnBoardingScaffold
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import io.github.santimattius.structured.annotations.StructuredScope
-import io.github.vinceglb.filekit.dialogs.FileKitType
-import io.github.vinceglb.filekit.dialogs.compose.rememberFilePickerLauncher
-import io.github.vinceglb.filekit.path
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import org.jetbrains.compose.resources.stringResource
@@ -74,30 +72,14 @@ fun OfflineUpdateScreen(
}
}
- // File picker for part02 file
- val pickPart02Launcher =
- rememberFilePickerLauncher(
- type = FileKitType.File(extensions = listOf("part02")),
- ) { file ->
- val p2 = file?.path
- val p1 = part01Path
- if (!p2.isNullOrBlank() && !p1.isNullOrBlank()) {
- startUpdate(scope, p1)
- }
- }
-
- // File picker for part01 file
- val pickPart01Launcher =
- rememberFilePickerLauncher(
- type = FileKitType.File(extensions = listOf("part01")),
- ) { file ->
- part01Path = file?.path
- if (part01Path != null) {
- // Immediately ask for part02
- @Suppress("UNSTRUCTURED_COROUTINE_LAUNCH")
- pickPart02Launcher.launch()
- }
+ fun pickFiles(
+ @StructuredScope scope: CoroutineScope,
+ ) {
+ scope.launch {
+ val p1 = pickDatabaseParts { part01Path = it }
+ if (p1 != null) startUpdate(scope, p1)
}
+ }
OnBoardingScaffold(title = stringResource(Res.string.db_update_offline_title)) {
Column(
@@ -135,10 +117,7 @@ fun OfflineUpdateScreen(
}
DefaultButton(
- onClick = {
- @Suppress("UNSTRUCTURED_COROUTINE_LAUNCH")
- pickPart01Launcher.launch()
- },
+ onClick = { pickFiles(scope) },
) {
Text(stringResource(Res.string.db_update_choose_files))
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/screens/OnlineUpdateScreen.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/screens/OnlineUpdateScreen.kt
index 8b2bed960..6e2dd1fc0 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/screens/OnlineUpdateScreen.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/database/update/screens/OnlineUpdateScreen.kt
@@ -9,21 +9,16 @@ import androidx.compose.ui.unit.dp
import androidx.navigation.NavController
import dev.zacsweers.metrox.viewmodel.metroViewModel
import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.formatBytes
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.formatBytesPerSec
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.formatEta
import io.github.kdroidfilter.seforimapp.features.database.update.navigation.DatabaseUpdateDestination
import io.github.kdroidfilter.seforimapp.features.database.update.navigation.DatabaseUpdateProgressBarState
import io.github.kdroidfilter.seforimapp.features.onboarding.download.DownloadEvents
+import io.github.kdroidfilter.seforimapp.features.onboarding.download.DownloadProgressDetails
import io.github.kdroidfilter.seforimapp.features.onboarding.download.DownloadViewModel
import io.github.kdroidfilter.seforimapp.features.onboarding.extract.ExtractEvents
import io.github.kdroidfilter.seforimapp.features.onboarding.extract.ExtractViewModel
import io.github.kdroidfilter.seforimapp.features.onboarding.ui.components.OnBoardingScaffold
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import io.github.kdroidfilter.seforimapp.icons.Download_for_offline
-import io.github.kdroidfilter.seforimapp.icons.FileArrowDown
-import io.github.kdroidfilter.seforimapp.icons.Speed
-import io.github.kdroidfilter.seforimapp.icons.Timer
import org.jetbrains.compose.resources.stringResource
import org.jetbrains.jewel.foundation.theme.JewelTheme
import org.jetbrains.jewel.ui.component.*
@@ -111,74 +106,11 @@ fun OnlineUpdateScreen(
textAlign = TextAlign.Center,
)
- val downloadedText = formatBytes(downloadState.downloadedBytes)
- val totalBytes = downloadState.totalBytes
- val totalText = totalBytes?.let { formatBytes(it) }
- val speedBps = downloadState.speedBytesPerSec
- val speedText = formatBytesPerSec(speedBps)
-
- totalText?.let {
- Row(
- verticalAlignment = Alignment.CenterVertically,
- horizontalArrangement = Arrangement.spacedBy(2.dp),
- ) {
- Icon(
- FileArrowDown,
- contentDescription = null,
- tint = JewelTheme.globalColors.text.normal,
- modifier = Modifier.size(16.dp),
- )
- Text(
- text = stringResource(Res.string.onboarding_download_progress, downloadedText, it),
- modifier = Modifier.width(175.dp),
- textAlign = TextAlign.End,
- )
- }
-
- Row(
- verticalAlignment = Alignment.CenterVertically,
- horizontalArrangement = Arrangement.spacedBy(2.dp),
- ) {
- Icon(
- Speed,
- contentDescription = null,
- tint = JewelTheme.globalColors.text.normal,
- modifier = Modifier.size(16.dp),
- )
- Text(
- text = speedText,
- modifier = Modifier.width(175.dp),
- textAlign = TextAlign.End,
- )
- }
-
- val etaSeconds =
- if (speedBps > 0L) {
- val remaining = (totalBytes - downloadState.downloadedBytes).coerceAtLeast(0)
- ((remaining + speedBps - 1) / speedBps)
- } else {
- null
- }
-
- etaSeconds?.let { secs ->
- Row(
- verticalAlignment = Alignment.CenterVertically,
- horizontalArrangement = Arrangement.spacedBy(2.dp),
- ) {
- Icon(
- Timer,
- contentDescription = null,
- tint = JewelTheme.globalColors.text.normal,
- modifier = Modifier.size(15.dp),
- )
- Text(
- text = formatEta(secs),
- modifier = Modifier.width(175.dp),
- textAlign = TextAlign.End,
- )
- }
- }
- }
+ DownloadProgressDetails(
+ downloadedBytes = downloadState.downloadedBytes,
+ totalBytes = downloadState.totalBytes,
+ speedBytesPerSec = downloadState.speedBytesPerSec,
+ )
}
// Download completed: show extraction state
downloadState.completed && extractState.errorMessage == null && !extractState.completed -> {
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/OnBoardingWindow.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/OnBoardingWindow.kt
index f80208c3f..a709b5a9f 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/OnBoardingWindow.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/OnBoardingWindow.kt
@@ -1,119 +1,22 @@
package io.github.kdroidfilter.seforimapp.features.onboarding
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.rotate
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.ApplicationScope
-import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
-import androidx.navigation.compose.rememberNavController
-import io.github.kdroidfilter.nucleus.window.ControlButtonsDirection
-import io.github.kdroidfilter.nucleus.window.jewel.JewelDecoratedWindow
-import io.github.kdroidfilter.nucleus.window.jewel.JewelTitleBar
-import io.github.kdroidfilter.nucleus.window.newFullscreenControls
-import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.getCenteredWindowState
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.rememberWindowViewModelStoreOwner
+import androidx.compose.runtime.Composable
+import dev.nucleusframework.application.NucleusApplicationScope
+import io.github.kdroidfilter.seforimapp.core.presentation.components.InstallerWindow
import io.github.kdroidfilter.seforimapp.features.onboarding.navigation.OnBoardingNavHost
-import io.github.kdroidfilter.seforimapp.framework.platform.PlatformInfo
+import io.github.kdroidfilter.seforimapp.features.onboarding.navigation.ProgressBarState
import io.github.kdroidfilter.seforimapp.icons.Install_desktop
-import org.jetbrains.compose.resources.painterResource
import org.jetbrains.compose.resources.stringResource
-import org.jetbrains.jewel.foundation.modifier.trackActivation
-import org.jetbrains.jewel.foundation.theme.JewelTheme
-import org.jetbrains.jewel.ui.component.Icon
-import org.jetbrains.jewel.ui.component.IconButton
-import org.jetbrains.jewel.ui.component.Text
-import org.jetbrains.jewel.ui.icons.AllIconsKeys
-import seforimapp.seforimapp.generated.resources.AppIcon
import seforimapp.seforimapp.generated.resources.Res
-import seforimapp.seforimapp.generated.resources.app_name
import seforimapp.seforimapp.generated.resources.onboarding_title_bar
@Composable
-fun ApplicationScope.OnBoardingWindow() {
- val onboardingWindowState = remember { getCenteredWindowState(720, 420) }
- JewelDecoratedWindow(
- onCloseRequest = { exitApplication() },
- title = stringResource(Res.string.app_name),
- icon = if (PlatformInfo.isMacOS) null else painterResource(Res.drawable.AppIcon),
- state = onboardingWindowState,
- visible = true,
- resizable = false,
- ) {
- val windowViewModelOwner = rememberWindowViewModelStoreOwner()
- CompositionLocalProvider(
- LocalWindowViewModelStoreOwner provides windowViewModelOwner,
- LocalViewModelStoreOwner provides windowViewModelOwner,
- ) {
- val isMac = PlatformInfo.isMacOS
- val isWindows = PlatformInfo.isWindows
- val navController = rememberNavController()
- var canNavigateBack by remember { mutableStateOf(false) }
- LaunchedEffect(navController) {
- navController.currentBackStackEntryFlow.collect {
- canNavigateBack = navController.previousBackStackEntry != null
- }
- }
- JewelTitleBar(
- modifier = Modifier.newFullscreenControls(),
- gradientStartColor = ThemeUtils.titleBarGradientColor(),
- controlButtonsDirection = ControlButtonsDirection.SystemNative,
- ) {
- // Keep the back button pinned to the start and
- // center the title (icon + text) regardless of OS/window controls.
- Box(
- modifier =
- Modifier
- .fillMaxWidth(if (isMac) 0.9f else 1f)
- .padding(start = if (isWindows) 70.dp else 0.dp),
- ) {
- if (canNavigateBack) {
- IconButton(
- modifier =
- Modifier
- .align(Alignment.CenterStart)
- .padding(start = 8.dp)
- .size(24.dp),
- onClick = { navController.navigateUp() },
- ) {
- Icon(AllIconsKeys.Actions.Back, null, modifier = Modifier.rotate(180f))
- }
- }
-
- val centerOffset = 40.dp
-
- Row(
- modifier =
- Modifier
- .align(Alignment.Center)
- .offset(x = centerOffset),
- verticalAlignment = Alignment.CenterVertically,
- horizontalArrangement = Arrangement.spacedBy(8.dp),
- ) {
- Icon(
- Install_desktop,
- contentDescription = null,
- tint = JewelTheme.globalColors.text.normal,
- modifier = Modifier.size(16.dp),
- )
- Text(stringResource(Res.string.onboarding_title_bar))
- }
- }
- }
- Column(
- modifier =
- Modifier
- .trackActivation()
- .fillMaxSize()
- .background(JewelTheme.globalColors.panelBackground),
- ) {
- OnBoardingNavHost(navController = navController)
- }
- }
+fun NucleusApplicationScope.OnBoardingWindow() {
+ InstallerWindow(
+ titleBarIcon = Install_desktop,
+ titleBarText = stringResource(Res.string.onboarding_title_bar),
+ progress = ProgressBarState.progress,
+ ) { navController ->
+ OnBoardingNavHost(navController = navController)
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/data/DatabaseFetcher.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/data/DatabaseFetcher.kt
index 7731b4a79..3c57e01f8 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/data/DatabaseFetcher.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/data/DatabaseFetcher.kt
@@ -1,7 +1,7 @@
package io.github.kdroidfilter.seforimapp.features.onboarding.data
-import io.github.kdroidfilter.platformtools.releasefetcher.github.GitHubReleaseFetcher
import io.github.kdroidfilter.seforimapp.network.KtorConfig
+import io.github.kdroidfilter.seforimapp.releasefetcher.github.GitHubReleaseFetcher
val databaseFetcher =
GitHubReleaseFetcher(
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/diskspace/AvailableDiskSpaceUseCase.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/diskspace/AvailableDiskSpaceUseCase.kt
index dbd9e3f63..118753ecf 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/diskspace/AvailableDiskSpaceUseCase.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/diskspace/AvailableDiskSpaceUseCase.kt
@@ -1,6 +1,6 @@
package io.github.kdroidfilter.seforimapp.features.onboarding.diskspace
-import io.github.kdroidfilter.nucleus.systeminfo.SystemInfo
+import dev.nucleusframework.systeminfo.SystemInfo
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
@@ -36,13 +36,13 @@ class AvailableDiskSpaceUseCase {
companion object {
/** Total space required during installation (includes temporary files). */
- const val REQUIRED_SPACE_GB = 11L
+ const val REQUIRED_SPACE_GB = 10L
/** Temporary space needed only during installation (will be freed after). */
const val TEMPORARY_SPACE_GB = 2.5
/** Final space after installation completes. */
- const val FINAL_SPACE_GB = 8.5
+ const val FINAL_SPACE_GB = 7.5
val REQUIRED_SPACE_BYTES = REQUIRED_SPACE_GB * 1024 * 1024 * 1024
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadProgressDetails.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadProgressDetails.kt
new file mode 100644
index 000000000..ce6858765
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadProgressDetails.kt
@@ -0,0 +1,88 @@
+package io.github.kdroidfilter.seforimapp.features.onboarding.download
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.formatBytes
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.formatBytesPerSec
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.formatEta
+import io.github.kdroidfilter.seforimapp.icons.FileArrowDown
+import io.github.kdroidfilter.seforimapp.icons.Speed
+import io.github.kdroidfilter.seforimapp.icons.Timer
+import org.jetbrains.compose.resources.stringResource
+import org.jetbrains.jewel.foundation.theme.JewelTheme
+import org.jetbrains.jewel.ui.component.Icon
+import org.jetbrains.jewel.ui.component.Text
+import seforimapp.seforimapp.generated.resources.Res
+import seforimapp.seforimapp.generated.resources.onboarding_download_progress
+
+/**
+ * Download metrics rows (downloaded/total, speed, ETA) shared by the onboarding download
+ * and database-update download screens. Renders nothing until [totalBytes] is known.
+ */
+@Composable
+fun ColumnScope.DownloadProgressDetails(
+ downloadedBytes: Long,
+ totalBytes: Long?,
+ speedBytesPerSec: Long,
+) {
+ val totalText = totalBytes?.let { formatBytes(it) } ?: return
+ val downloadedText = formatBytes(downloadedBytes)
+
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(2.dp),
+ ) {
+ Icon(
+ FileArrowDown,
+ contentDescription = null,
+ tint = JewelTheme.globalColors.text.normal,
+ modifier = Modifier.size(16.dp),
+ )
+ Text(
+ text = stringResource(Res.string.onboarding_download_progress, downloadedText, totalText),
+ modifier = Modifier.width(175.dp),
+ textAlign = TextAlign.End,
+ )
+ }
+
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(2.dp),
+ ) {
+ Icon(Speed, contentDescription = null, tint = JewelTheme.globalColors.text.normal, modifier = Modifier.size(16.dp))
+ Text(
+ text = formatBytesPerSec(speedBytesPerSec),
+ modifier = Modifier.width(175.dp),
+ textAlign = TextAlign.End,
+ )
+ }
+
+ val etaSeconds =
+ if (speedBytesPerSec > 0L) {
+ val remaining = (totalBytes - downloadedBytes).coerceAtLeast(0)
+ ((remaining + speedBytesPerSec - 1) / speedBytesPerSec)
+ } else {
+ null
+ }
+ etaSeconds?.let { secs ->
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(2.dp),
+ ) {
+ Icon(Timer, contentDescription = null, tint = JewelTheme.globalColors.text.normal, modifier = Modifier.size(15.dp))
+ Text(
+ text = formatEta(secs),
+ modifier = Modifier.width(175.dp),
+ textAlign = TextAlign.End,
+ )
+ }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadScreen.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadScreen.kt
index cbfc0a167..d64512bb7 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadScreen.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadScreen.kt
@@ -2,10 +2,8 @@ package io.github.kdroidfilter.seforimapp.features.onboarding.download
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
@@ -15,31 +13,22 @@ import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.navigation.NavController
import dev.zacsweers.metrox.viewmodel.metroViewModel
import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.formatBytes
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.formatBytesPerSec
-import io.github.kdroidfilter.seforimapp.core.presentation.utils.formatEta
import io.github.kdroidfilter.seforimapp.features.onboarding.navigation.OnBoardingDestination
import io.github.kdroidfilter.seforimapp.features.onboarding.navigation.ProgressBarState
import io.github.kdroidfilter.seforimapp.features.onboarding.ui.components.OnBoardingScaffold
import io.github.kdroidfilter.seforimapp.icons.Download_for_offline
-import io.github.kdroidfilter.seforimapp.icons.FileArrowDown
-import io.github.kdroidfilter.seforimapp.icons.Speed
-import io.github.kdroidfilter.seforimapp.icons.Timer
import io.github.kdroidfilter.seforimapp.theme.PreviewContainer
import org.jetbrains.compose.resources.stringResource
import org.jetbrains.jewel.foundation.theme.JewelTheme
import org.jetbrains.jewel.ui.component.DefaultErrorBanner
import org.jetbrains.jewel.ui.component.Icon
-import org.jetbrains.jewel.ui.component.Text
import org.jetbrains.jewel.ui.theme.defaultBannerStyle
import seforimapp.seforimapp.generated.resources.Res
-import seforimapp.seforimapp.generated.resources.onboarding_download_progress
import seforimapp.seforimapp.generated.resources.onboarding_downloading_message
import seforimapp.seforimapp.generated.resources.onboarding_error_occurred
import seforimapp.seforimapp.generated.resources.onboarding_error_with_detail
@@ -129,61 +118,11 @@ fun DownloadView(
tint = JewelTheme.globalColors.text.normal,
)
- val downloadedText = formatBytes(state.downloadedBytes)
- val totalBytes = state.totalBytes
- val totalText = totalBytes?.let { formatBytes(it) }
- val speedBps = state.speedBytesPerSec
- val speedText = formatBytesPerSec(speedBps)
-
- totalText?.let {
- Row(
- verticalAlignment = Alignment.CenterVertically,
- horizontalArrangement = Arrangement.spacedBy(2.dp),
- ) {
- Icon(
- FileArrowDown,
- null,
- tint = JewelTheme.globalColors.text.normal,
- modifier = Modifier.size(16.dp),
- )
- Text(
- stringResource(Res.string.onboarding_download_progress, downloadedText, it),
- modifier = Modifier.width(175.dp),
- textAlign = TextAlign.End,
- )
- }
- Row(
- verticalAlignment = Alignment.CenterVertically,
- horizontalArrangement = Arrangement.spacedBy(2.dp),
- ) {
- Icon(Speed, null, tint = JewelTheme.globalColors.text.normal, modifier = Modifier.size(16.dp))
- Text(
- speedText,
- modifier = Modifier.width(175.dp),
- textAlign = TextAlign.End,
- )
- }
- val etaSeconds =
- if (speedBps > 0L) {
- val remaining = (totalBytes - state.downloadedBytes).coerceAtLeast(0)
- ((remaining + speedBps - 1) / speedBps)
- } else {
- null
- }
- etaSeconds?.let { secs ->
- Row(
- verticalAlignment = Alignment.CenterVertically,
- horizontalArrangement = Arrangement.spacedBy(2.dp),
- ) {
- Icon(Timer, null, tint = JewelTheme.globalColors.text.normal, modifier = Modifier.size(15.dp))
- Text(
- formatEta(secs),
- modifier = Modifier.width(175.dp),
- textAlign = TextAlign.End,
- )
- }
- }
- }
+ DownloadProgressDetails(
+ downloadedBytes = state.downloadedBytes,
+ totalBytes = state.totalBytes,
+ speedBytesPerSec = state.speedBytesPerSec,
+ )
}
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadUseCase.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadUseCase.kt
index b30090270..f1bd3afda 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadUseCase.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/download/DownloadUseCase.kt
@@ -1,7 +1,7 @@
package io.github.kdroidfilter.seforimapp.features.onboarding.download
-import io.github.kdroidfilter.platformtools.releasefetcher.github.GitHubReleaseFetcher
import io.github.kdroidfilter.seforimapp.network.HttpsConnectionFactory
+import io.github.kdroidfilter.seforimapp.releasefetcher.github.GitHubReleaseFetcher
import io.github.vinceglb.filekit.FileKit
import io.github.vinceglb.filekit.databasesDir
import io.github.vinceglb.filekit.path
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/navigation/OnBoardingNavHost.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/navigation/OnBoardingNavHost.kt
index b5b8f1fa6..cc928f0d6 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/navigation/OnBoardingNavHost.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/navigation/OnBoardingNavHost.kt
@@ -9,13 +9,10 @@ import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
-import androidx.navigation.NavBackStackEntry
-import androidx.navigation.NavGraphBuilder
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import io.github.kdroidfilter.seforim.navigation.NavigationAnimations
import io.github.kdroidfilter.seforimapp.core.presentation.components.AnimatedHorizontalProgressBar
+import io.github.kdroidfilter.seforimapp.core.presentation.navigation.noAnimatedComposable
import io.github.kdroidfilter.seforimapp.features.onboarding.diskspace.AvailableDiskSpaceScreen
import io.github.kdroidfilter.seforimapp.features.onboarding.download.DownloadScreen
import io.github.kdroidfilter.seforimapp.features.onboarding.extract.ExtractScreen
@@ -75,16 +72,3 @@ fun OnBoardingNavHost(navController: NavHostController) {
}
}
}
-
-inline fun NavGraphBuilder.noAnimatedComposable(
- noinline content: @Composable (NavBackStackEntry) -> Unit,
-) {
- composable(
- enterTransition = { NavigationAnimations.enterTransition(this) },
- exitTransition = { NavigationAnimations.exitTransition(this) },
- popEnterTransition = { NavigationAnimations.popEnterTransition(this) },
- popExitTransition = { NavigationAnimations.popExitTransition(this) },
- ) {
- content(it)
- }
-}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/navigation/ProgressBarState.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/navigation/ProgressBarState.kt
index 5bed9ab93..4660535ab 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/navigation/ProgressBarState.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/navigation/ProgressBarState.kt
@@ -1,21 +1,5 @@
package io.github.kdroidfilter.seforimapp.features.onboarding.navigation
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import io.github.kdroidfilter.seforimapp.core.presentation.components.ProgressBarController
-object ProgressBarState {
- private var _progress = MutableStateFlow(0f)
- val progress = _progress.asStateFlow()
-
- fun setProgress(progress: Float) {
- _progress.value = progress
- }
-
- fun resetProgress() {
- _progress.value = 0f
- }
-
- fun improveBy(value: Float) {
- _progress.value += value
- }
-}
+object ProgressBarState : ProgressBarController()
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/offline/DatabasePartsPicker.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/offline/DatabasePartsPicker.kt
new file mode 100644
index 000000000..87050e1d3
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/offline/DatabasePartsPicker.kt
@@ -0,0 +1,44 @@
+package io.github.kdroidfilter.seforimapp.features.onboarding.offline
+
+import io.github.vinceglb.filekit.FileKit
+import io.github.vinceglb.filekit.dialogs.FileKitType
+import io.github.vinceglb.filekit.dialogs.openFilePicker
+import io.github.vinceglb.filekit.path
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+
+/**
+ * Prompts for the split database bundle (`.tar.zst.part01` / `.part02`).
+ *
+ * The user picks the `.part01` file; the matching `.part02` is auto-detected in the
+ * same directory when present, otherwise a second picker is shown. Returns the
+ * `.part01` path once both parts are available, or `null` if the user cancelled.
+ *
+ * FileKit's compose launcher dispatches the picker on Dispatchers.Main; under the
+ * Tao backend that is the single GTK event-loop thread, and the picker's blocking
+ * D-Bus (xdg-desktop-portal) work would freeze/deadlock it. Running the suspend API
+ * on Dispatchers.IO keeps the event loop free; callers resume on their own scope.
+ *
+ * @param onPart01Picked invoked with the selected `.part01` path (or null) as soon as
+ * it is chosen, so callers can reflect the selection in the UI before part02 resolves.
+ */
+suspend fun pickDatabaseParts(onPart01Picked: (String?) -> Unit = {}): String? {
+ val part01Path =
+ withContext(Dispatchers.IO) {
+ FileKit.openFilePicker(type = FileKitType.File(extensions = listOf("part01")))
+ }?.path
+ onPart01Picked(part01Path)
+ if (part01Path.isNullOrBlank()) return null
+
+ // Part02 lives next to part01 in the common case; only prompt when it is missing.
+ val part01File = File(part01Path)
+ val part02File = File(part01File.parent, part01File.name.replace(".part01", ".part02"))
+ if (part02File.exists()) return part01Path
+
+ val part02Path =
+ withContext(Dispatchers.IO) {
+ FileKit.openFilePicker(type = FileKitType.File(extensions = listOf("part02")))
+ }?.path
+ return if (!part02Path.isNullOrBlank()) part01Path else null
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/offline/OfflineFileSelectionScreen.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/offline/OfflineFileSelectionScreen.kt
index c8ea8ffad..36491228e 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/offline/OfflineFileSelectionScreen.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/onboarding/offline/OfflineFileSelectionScreen.kt
@@ -17,16 +17,12 @@ import io.github.kdroidfilter.seforimapp.features.onboarding.navigation.Progress
import io.github.kdroidfilter.seforimapp.features.onboarding.ui.components.OnBoardingScaffold
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import io.github.santimattius.structured.annotations.StructuredScope
-import io.github.vinceglb.filekit.dialogs.FileKitType
-import io.github.vinceglb.filekit.dialogs.compose.rememberFilePickerLauncher
-import io.github.vinceglb.filekit.path
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import org.jetbrains.compose.resources.stringResource
import org.jetbrains.jewel.foundation.theme.JewelTheme
import org.jetbrains.jewel.ui.component.*
import seforimapp.seforimapp.generated.resources.*
-import java.io.File
@Composable
fun OfflineFileSelectionScreen(
@@ -71,40 +67,14 @@ fun OfflineFileSelectionScreen(
}
}
- // File picker for part02 file (only used if part02 not found automatically)
- val pickPart02Launcher =
- rememberFilePickerLauncher(
- type = FileKitType.File(extensions = listOf("part02")),
- ) { file ->
- val p2 = file?.path
- val p1 = part01Path
- if (!p2.isNullOrBlank() && !p1.isNullOrBlank()) {
- startExtraction(scope, p1)
- }
- }
-
- // File picker for part01 file
- val pickPart01Launcher =
- rememberFilePickerLauncher(
- type = FileKitType.File(extensions = listOf("part01")),
- ) { file ->
- val p1 = file?.path
- part01Path = p1
- if (!p1.isNullOrBlank()) {
- // Check if part02 exists in the same directory
- val part01File = File(p1)
- val part02File = File(part01File.parent, part01File.name.replace(".part01", ".part02"))
-
- if (part02File.exists()) {
- // Part02 found automatically, start extraction
- startExtraction(scope, p1)
- } else {
- // Part02 not found, ask user to select it
- @Suppress("UNSTRUCTURED_COROUTINE_LAUNCH")
- pickPart02Launcher.launch()
- }
- }
+ fun pickFiles(
+ @StructuredScope scope: CoroutineScope,
+ ) {
+ scope.launch {
+ val p1 = pickDatabaseParts { part01Path = it }
+ if (p1 != null) startExtraction(scope, p1)
}
+ }
OnBoardingScaffold(title = stringResource(Res.string.onboarding_file_selection)) {
Column(
@@ -139,10 +109,7 @@ fun OfflineFileSelectionScreen(
}
DefaultButton(
- onClick = {
- @Suppress("UNSTRUCTURED_COROUTINE_LAUNCH")
- pickPart01Launcher.launch()
- },
+ onClick = { pickFiles(scope) },
) {
Text(stringResource(Res.string.onboarding_choose_files))
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/SettingsWindow.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/SettingsWindow.kt
index 04d1cfd14..1a2103486 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/SettingsWindow.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/SettingsWindow.kt
@@ -14,10 +14,11 @@ import androidx.compose.ui.window.WindowPosition
import androidx.compose.ui.window.rememberDialogState
import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
import androidx.navigation.compose.rememberNavController
-import io.github.kdroidfilter.nucleus.window.ControlButtonsDirection
-import io.github.kdroidfilter.nucleus.window.jewel.JewelDecoratedDialog
-import io.github.kdroidfilter.nucleus.window.jewel.JewelDialogTitleBar
-import io.github.kdroidfilter.nucleus.window.newFullscreenControls
+import dev.nucleusframework.application.NucleusApplicationScope
+import dev.nucleusframework.window.ControlButtonsDirection
+import dev.nucleusframework.window.jewel.JewelDecoratedDialog
+import dev.nucleusframework.window.jewel.JewelDialogTitleBar
+import dev.nucleusframework.window.newFullscreenControls
import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils.buildThemeDefinition
import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
@@ -42,7 +43,7 @@ import seforimapp.seforimapp.generated.resources.settings
import seforimapp.seforimapp.generated.resources.settings_close
@Composable
-fun SettingsWindow(
+fun NucleusApplicationScope.SettingsWindow(
onClose: () -> Unit,
initialDestination: SettingsDestination? = null,
) {
@@ -53,7 +54,7 @@ fun SettingsWindow(
}
@Composable
-private fun SettingsWindowView(
+private fun NucleusApplicationScope.SettingsWindowView(
onClose: () -> Unit,
initialDestination: SettingsDestination? = null,
) {
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/data/DataSettingsState.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/data/DataSettingsState.kt
new file mode 100644
index 000000000..01476549a
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/data/DataSettingsState.kt
@@ -0,0 +1,15 @@
+package io.github.kdroidfilter.seforimapp.features.settings.data
+
+import androidx.compose.runtime.Immutable
+
+@Immutable
+data class DataSettingsState(
+ val isExporting: Boolean = false,
+ val isImporting: Boolean = false,
+ // Holds the backup file name on a successful export; null otherwise.
+ val exportedFileName: String? = null,
+ val importSucceeded: Boolean = false,
+ val exportFailed: Boolean = false,
+ val importFailed: Boolean = false,
+ val resetDone: Boolean = false,
+)
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/data/DataSettingsViewModel.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/data/DataSettingsViewModel.kt
new file mode 100644
index 000000000..be02d1fe0
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/data/DataSettingsViewModel.kt
@@ -0,0 +1,144 @@
+package io.github.kdroidfilter.seforimapp.features.settings.data
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dev.zacsweers.metro.ContributesIntoMap
+import dev.zacsweers.metro.Inject
+import dev.zacsweers.metrox.viewmodel.ViewModelKey
+import io.github.kdroidfilter.platformtools.appmanager.restartApplication
+import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
+import io.github.kdroidfilter.seforimapp.framework.database.getUserSettingsDatabasePath
+import io.github.kdroidfilter.seforimapp.framework.di.AppScope
+import io.github.vinceglb.filekit.FileKit
+import io.github.vinceglb.filekit.databasesDir
+import io.github.vinceglb.filekit.path
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+@ContributesIntoMap(AppScope::class)
+@ViewModelKey
+@Inject
+class DataSettingsViewModel : ViewModel() {
+ private val _state = MutableStateFlow(DataSettingsState())
+ val state: StateFlow = _state.asStateFlow()
+
+ fun exportToFile(exportDir: File) {
+ if (!exportDir.isDirectory) {
+ _state.update { it.copy(exportFailed = true, exportedFileName = null) }
+ return
+ }
+
+ viewModelScope.launch(Dispatchers.IO) {
+ try {
+ _state.update { it.copy(isExporting = true, exportFailed = false, exportedFileName = null) }
+ val dbFile = File(getUserSettingsDatabasePath())
+
+ if (!dbFile.exists()) {
+ _state.update { it.copy(isExporting = false, exportFailed = true) }
+ return@launch
+ }
+
+ val timestamp = SimpleDateFormat("yyyy-MM-dd_HH-mm-ss", Locale.US).format(Date())
+ val exportFile = File(exportDir, "zayit_backup_$timestamp.db")
+
+ Files.copy(
+ dbFile.toPath(),
+ exportFile.toPath(),
+ StandardCopyOption.REPLACE_EXISTING,
+ )
+
+ _state.update {
+ it.copy(isExporting = false, exportedFileName = exportFile.name)
+ }
+ } catch (e: Exception) {
+ _state.update { it.copy(isExporting = false, exportFailed = true) }
+ }
+ }
+ }
+
+ fun importFromFile(importFile: File) {
+ if (!importFile.exists()) {
+ _state.update { it.copy(importFailed = true, importSucceeded = false) }
+ return
+ }
+
+ viewModelScope.launch(Dispatchers.IO) {
+ try {
+ _state.update { it.copy(isImporting = true, importFailed = false, importSucceeded = false) }
+ val dbFile = File(getUserSettingsDatabasePath())
+
+ // Copy imported file to replace current DB
+ Files.copy(
+ importFile.toPath(),
+ dbFile.toPath(),
+ StandardCopyOption.REPLACE_EXISTING,
+ )
+
+ // The running app holds an open connection to the old DB; restart to load the imported one.
+ _state.update { it.copy(isImporting = false, importSucceeded = true) }
+ restartApplication()
+ } catch (e: Exception) {
+ _state.update { it.copy(isImporting = false, importFailed = true) }
+ }
+ }
+ }
+
+ /**
+ * Wipes everything: books database, search indexes and all personal data (notes, highlights,
+ * session) — both the managed databases directory and any custom DB location — then clears the
+ * settings and restarts the app.
+ */
+ fun resetApp() {
+ viewModelScope.launch(Dispatchers.IO) {
+ val dbDir = File(FileKit.databasesDir.path)
+ // Read the custom DB path before clearing settings (clearAll() drops it).
+ val customDbPath = runCatching { AppSettings.getDatabasePath() }.getOrNull()
+
+ AppSettings.clearAll()
+
+ // Delete every file/directory in the managed databases directory (this also holds the
+ // user settings DB with notes and highlights).
+ if (dbDir.exists()) {
+ dbDir.listFiles()?.forEach { file ->
+ runCatching {
+ if (file.isDirectory) file.deleteRecursively() else file.delete()
+ }
+ }
+ }
+
+ // Also clean a custom DB location, if the user pointed the books DB elsewhere.
+ if (!customDbPath.isNullOrBlank()) {
+ val customDbFile = File(customDbPath)
+ val customBaseDir = customDbFile.parentFile
+ runCatching { if (customDbFile.exists()) customDbFile.delete() }
+ if (customBaseDir != null && customBaseDir.exists() && customBaseDir != dbDir) {
+ listOf(
+ customDbFile.name + ".lucene",
+ customDbFile.name + ".lookup.lucene",
+ "lexical.db",
+ "catalog.pb",
+ "release_info.txt",
+ ).forEach { name ->
+ val f = File(customBaseDir, name)
+ if (f.exists()) {
+ runCatching { if (f.isDirectory) f.deleteRecursively() else f.delete() }
+ }
+ }
+ }
+ }
+
+ _state.update { it.copy(resetDone = true) }
+ restartApplication()
+ }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/dbupdate/DbDeltaUpdateSection.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/dbupdate/DbDeltaUpdateSection.kt
index 3b31871f0..cd2c57a01 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/dbupdate/DbDeltaUpdateSection.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/dbupdate/DbDeltaUpdateSection.kt
@@ -34,12 +34,11 @@ import org.jetbrains.jewel.ui.component.Text
* Jewel + Material3 LinearProgressIndicator.
*/
@Composable
-fun DbDeltaUpdateSection(
- modifier: Modifier = Modifier,
-) {
- val viewModel = metroViewModel(
- viewModelStoreOwner = LocalWindowViewModelStoreOwner.current,
- )
+fun DbDeltaUpdateSection(modifier: Modifier = Modifier) {
+ val viewModel =
+ metroViewModel(
+ viewModelStoreOwner = LocalWindowViewModelStoreOwner.current,
+ )
val state by viewModel.state.collectAsState()
val isBusy = state.phase != null
val hasMessage = state.message.isNotEmpty() || state.errorMessage != null
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/dbupdate/DbDeltaUpdateViewModel.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/dbupdate/DbDeltaUpdateViewModel.kt
index 5c700480d..f10eb137a 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/dbupdate/DbDeltaUpdateViewModel.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/dbupdate/DbDeltaUpdateViewModel.kt
@@ -33,7 +33,6 @@ class DbDeltaUpdateViewModel(
private val deltaService: DbDeltaUpdateService,
private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
) : ViewModel() {
-
private val mutableState = MutableStateFlow(DbDeltaUpdateState())
val state = mutableState.asStateFlow()
@@ -50,46 +49,55 @@ class DbDeltaUpdateViewModel(
if (current.phase != null) return // already running
viewModelScope.launch {
- mutableState.value = DbDeltaUpdateState(
- phase = DbDeltaUpdateState.Phase.CheckingForUpdates,
- message = "Checking server for new database delta…",
- )
+ mutableState.value =
+ DbDeltaUpdateState(
+ phase = DbDeltaUpdateState.Phase.CheckingForUpdates,
+ message = "Checking server for new database delta…",
+ )
try {
- val outcome = withContext(ioDispatcher) {
- deltaService.checkAndApply { _, _, status ->
- // The orchestrator pumps statuses like
- // "downloading patch files", "applying sqlite delta",
- // "updating lucene", "updating catalog", "done".
- val phase = when {
- "download" in status -> DbDeltaUpdateState.Phase.Downloading
- "sqlite" in status -> DbDeltaUpdateState.Phase.Applying
- "lucene" in status || "catalog" in status ->
- DbDeltaUpdateState.Phase.UpdatingIndex
- else -> mutableState.value.phase
+ val outcome =
+ withContext(ioDispatcher) {
+ deltaService.checkAndApply { _, _, status ->
+ // The orchestrator pumps statuses like
+ // "downloading patch files", "applying sqlite delta",
+ // "updating lucene", "updating catalog", "done".
+ val phase =
+ when {
+ "download" in status -> DbDeltaUpdateState.Phase.Downloading
+ "sqlite" in status -> DbDeltaUpdateState.Phase.Applying
+ "lucene" in status || "catalog" in status ->
+ DbDeltaUpdateState.Phase.UpdatingIndex
+ else -> mutableState.value.phase
+ }
+ mutableState.value =
+ mutableState.value.copy(
+ phase = phase,
+ message = status,
+ )
}
- mutableState.value = mutableState.value.copy(
- phase = phase,
- message = status,
- )
}
- }
- mutableState.value = when (outcome) {
- DbDeltaUpdateService.Outcome.UpToDate -> DbDeltaUpdateState(
- message = "Database is up to date.",
- )
- is DbDeltaUpdateService.Outcome.Applied -> DbDeltaUpdateState(
- message = "Applied ${outcome.deltaCount} delta(s).",
- lastAppliedCount = outcome.deltaCount,
- )
- DbDeltaUpdateService.Outcome.NeedsFullBundle -> DbDeltaUpdateState(
- message = "Your local database is too old for an incremental update — please download the full bundle.",
- needsFullBundle = true,
- )
- }
+ mutableState.value =
+ when (outcome) {
+ DbDeltaUpdateService.Outcome.UpToDate ->
+ DbDeltaUpdateState(
+ message = "Database is up to date.",
+ )
+ is DbDeltaUpdateService.Outcome.Applied ->
+ DbDeltaUpdateState(
+ message = "Applied ${outcome.deltaCount} delta(s).",
+ lastAppliedCount = outcome.deltaCount,
+ )
+ DbDeltaUpdateService.Outcome.NeedsFullBundle ->
+ DbDeltaUpdateState(
+ message = "Your local database is too old for an incremental update — please download the full bundle.",
+ needsFullBundle = true,
+ )
+ }
} catch (t: Throwable) {
- mutableState.value = DbDeltaUpdateState(
- errorMessage = "Update failed: ${t.message ?: t.javaClass.simpleName}",
- )
+ mutableState.value =
+ DbDeltaUpdateState(
+ errorMessage = "Update failed: ${t.message ?: t.javaClass.simpleName}",
+ )
}
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsEvents.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsEvents.kt
index 4e5c389cb..e4d6d8ea3 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsEvents.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsEvents.kt
@@ -9,5 +9,7 @@ sealed interface GeneralSettingsEvents {
val value: Boolean,
) : GeneralSettingsEvents
- data object ResetApp : GeneralSettingsEvents
+ data class SetKeepScreenAwakeOnBook(
+ val value: Boolean,
+ ) : GeneralSettingsEvents
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsState.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsState.kt
index 85bf24c30..f42e0740f 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsState.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsState.kt
@@ -7,7 +7,7 @@ data class GeneralSettingsState(
val databasePath: String? = null,
val closeTreeOnNewBook: Boolean = false,
val persistSession: Boolean = true,
- val resetDone: Boolean = false,
+ val keepScreenAwakeOnBook: Boolean = true,
) {
companion object {
val preview =
@@ -15,7 +15,7 @@ data class GeneralSettingsState(
databasePath = "/Users/you/.zayit/seforim.db",
closeTreeOnNewBook = true,
persistSession = true,
- resetDone = false,
+ keepScreenAwakeOnBook = true,
)
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsViewModel.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsViewModel.kt
index 58b5c23f3..76c12d091 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsViewModel.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/general/GeneralSettingsViewModel.kt
@@ -5,17 +5,12 @@ import androidx.lifecycle.viewModelScope
import dev.zacsweers.metro.ContributesIntoMap
import dev.zacsweers.metro.Inject
import dev.zacsweers.metrox.viewmodel.ViewModelKey
-import io.github.kdroidfilter.platformtools.appmanager.restartApplication
import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
import io.github.kdroidfilter.seforimapp.framework.di.AppScope
-import io.github.vinceglb.filekit.FileKit
-import io.github.vinceglb.filekit.databasesDir
-import io.github.vinceglb.filekit.path
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.stateIn
-import java.io.File
@ContributesIntoMap(AppScope::class)
@ViewModelKey
@@ -24,15 +19,15 @@ class GeneralSettingsViewModel : ViewModel() {
private val dbPath = MutableStateFlow(AppSettings.getDatabasePath())
private val closeTree = MutableStateFlow(AppSettings.getCloseBookTreeOnNewBookSelected())
private val persist = MutableStateFlow(AppSettings.isPersistSessionEnabled())
- private val resetDone = MutableStateFlow(false)
+ private val keepAwake = MutableStateFlow(AppSettings.isKeepScreenAwakeOnBookEnabled())
val state =
- combine(dbPath, closeTree, persist, resetDone) { path, c, p, r ->
+ combine(dbPath, closeTree, persist, keepAwake) { path, c, p, k ->
GeneralSettingsState(
databasePath = path,
closeTreeOnNewBook = c,
persistSession = p,
- resetDone = r,
+ keepScreenAwakeOnBook = k,
)
}.stateIn(
viewModelScope,
@@ -41,7 +36,7 @@ class GeneralSettingsViewModel : ViewModel() {
databasePath = dbPath.value,
closeTreeOnNewBook = closeTree.value,
persistSession = persist.value,
- resetDone = resetDone.value,
+ keepScreenAwakeOnBook = keepAwake.value,
),
)
@@ -55,60 +50,9 @@ class GeneralSettingsViewModel : ViewModel() {
AppSettings.setPersistSessionEnabled(event.value)
persist.value = event.value
}
- is GeneralSettingsEvents.ResetApp -> {
- // Get the databases directory
- val dbDir = File(FileKit.databasesDir.path)
-
- // Get custom DB path BEFORE clearing settings
- val customDbPath = runCatching { AppSettings.getDatabasePath() }.getOrNull()
-
- // Clear settings first
- AppSettings.clearAll()
-
- // Delete all files and directories in the databases directory
- if (dbDir.exists()) {
- dbDir.listFiles()?.forEach { file ->
- runCatching {
- if (file.isDirectory) {
- file.deleteRecursively()
- } else {
- file.delete()
- }
- }
- }
- }
-
- // Also delete database files in custom path (if user selected a different location)
- if (!customDbPath.isNullOrBlank()) {
- val customDbFile = File(customDbPath)
- val customBaseDir = customDbFile.parentFile
-
- // Delete the database file
- runCatching { if (customDbFile.exists()) customDbFile.delete() }
-
- // Delete related files in the custom directory
- if (customBaseDir != null && customBaseDir.exists() && customBaseDir != dbDir) {
- val relatedPatterns =
- listOf(
- customDbFile.name + ".lucene",
- customDbFile.name + ".lookup.lucene",
- "lexical.db",
- "catalog.pb",
- "release_info.txt",
- )
- relatedPatterns.forEach { name ->
- val f = File(customBaseDir, name)
- if (f.exists()) {
- runCatching {
- if (f.isDirectory) f.deleteRecursively() else f.delete()
- }
- }
- }
- }
- }
-
- restartApplication()
- resetDone.value = true
+ is GeneralSettingsEvents.SetKeepScreenAwakeOnBook -> {
+ AppSettings.setKeepScreenAwakeOnBookEnabled(event.value)
+ keepAwake.value = event.value
}
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/navigation/SettingsDestination.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/navigation/SettingsDestination.kt
index 26563ecf8..b76e9af44 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/navigation/SettingsDestination.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/navigation/SettingsDestination.kt
@@ -21,4 +21,7 @@ sealed interface SettingsDestination {
@Serializable
data object Conditions : SettingsDestination
+
+ @Serializable
+ data object Data : SettingsDestination
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/navigation/SettingsNavHost.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/navigation/SettingsNavHost.kt
index a4d0531bb..2301dc677 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/navigation/SettingsNavHost.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/navigation/SettingsNavHost.kt
@@ -13,6 +13,7 @@ import androidx.navigation.compose.composable
import io.github.kdroidfilter.seforim.navigation.NavigationAnimations
import io.github.kdroidfilter.seforimapp.features.settings.ui.AboutSettingsScreen
import io.github.kdroidfilter.seforimapp.features.settings.ui.ConditionsSettingsScreen
+import io.github.kdroidfilter.seforimapp.features.settings.ui.DataSettingsScreen
import io.github.kdroidfilter.seforimapp.features.settings.ui.DisplaySettingsScreen
import io.github.kdroidfilter.seforimapp.features.settings.ui.FontsSettingsScreen
import io.github.kdroidfilter.seforimapp.features.settings.ui.GeneralSettingsScreen
@@ -43,6 +44,9 @@ fun SettingsNavHost(navController: NavHostController) {
noAnimatedComposable {
ConditionsSettingsScreen()
}
+ noAnimatedComposable {
+ DataSettingsScreen()
+ }
}
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/DataSettingsScreen.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/DataSettingsScreen.kt
new file mode 100644
index 000000000..084412e98
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/DataSettingsScreen.kt
@@ -0,0 +1,256 @@
+package io.github.kdroidfilter.seforimapp.features.settings.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import dev.zacsweers.metrox.viewmodel.metroViewModel
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
+import io.github.kdroidfilter.seforimapp.features.settings.data.DataSettingsViewModel
+import io.github.vinceglb.filekit.FileKit
+import io.github.vinceglb.filekit.dialogs.FileKitType
+import io.github.vinceglb.filekit.dialogs.openDirectoryPicker
+import io.github.vinceglb.filekit.dialogs.openFilePicker
+import io.github.vinceglb.filekit.path
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.jetbrains.compose.resources.StringResource
+import org.jetbrains.compose.resources.stringResource
+import org.jetbrains.jewel.foundation.theme.JewelTheme
+import org.jetbrains.jewel.ui.component.DefaultButton
+import org.jetbrains.jewel.ui.component.InlineErrorBanner
+import org.jetbrains.jewel.ui.component.InlineSuccessBanner
+import org.jetbrains.jewel.ui.component.OutlinedButton
+import org.jetbrains.jewel.ui.component.Text
+import org.jetbrains.jewel.ui.component.VerticallyScrollableContainer
+import seforimapp.seforimapp.generated.resources.Res
+import seforimapp.seforimapp.generated.resources.data_export_action
+import seforimapp.seforimapp.generated.resources.data_export_description
+import seforimapp.seforimapp.generated.resources.data_export_error
+import seforimapp.seforimapp.generated.resources.data_export_success
+import seforimapp.seforimapp.generated.resources.data_export_title
+import seforimapp.seforimapp.generated.resources.data_exporting
+import seforimapp.seforimapp.generated.resources.data_import_action
+import seforimapp.seforimapp.generated.resources.data_import_description
+import seforimapp.seforimapp.generated.resources.data_import_error
+import seforimapp.seforimapp.generated.resources.data_import_success
+import seforimapp.seforimapp.generated.resources.data_import_title
+import seforimapp.seforimapp.generated.resources.data_importing
+import seforimapp.seforimapp.generated.resources.data_reset_description
+import seforimapp.seforimapp.generated.resources.settings_reset_app
+import seforimapp.seforimapp.generated.resources.settings_reset_confirm_no
+import seforimapp.seforimapp.generated.resources.settings_reset_confirm_yes
+import seforimapp.seforimapp.generated.resources.settings_reset_done
+import seforimapp.seforimapp.generated.resources.settings_reset_warning
+import java.io.File
+
+@Composable
+fun DataSettingsScreen() {
+ val viewModel: DataSettingsViewModel =
+ metroViewModel(viewModelStoreOwner = LocalWindowViewModelStoreOwner.current)
+ val state by viewModel.state.collectAsState()
+ val scope = rememberCoroutineScope()
+
+ VerticallyScrollableContainer(modifier = Modifier.fillMaxSize()) {
+ Column(
+ modifier =
+ Modifier
+ .fillMaxSize()
+ .padding(16.dp),
+ verticalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ DataActionCard(
+ title = Res.string.data_export_title,
+ description = Res.string.data_export_description,
+ actionLabel = if (state.isExporting) Res.string.data_exporting else Res.string.data_export_action,
+ enabled = !state.isExporting && !state.isImporting,
+ onClick = {
+ scope.launch {
+ // Run the picker off the GTK event-loop thread: under the Tao backend
+ // Dispatchers.Main is that single thread, and the picker's blocking D-Bus
+ // (xdg-desktop-portal) work would freeze it. See pickDatabaseParts.
+ val directory =
+ withContext(Dispatchers.IO) { FileKit.openDirectoryPicker() }
+ directory?.let { viewModel.exportToFile(File(it.path)) }
+ }
+ },
+ )
+
+ DataActionCard(
+ title = Res.string.data_import_title,
+ description = Res.string.data_import_description,
+ actionLabel = if (state.isImporting) Res.string.data_importing else Res.string.data_import_action,
+ enabled = !state.isExporting && !state.isImporting,
+ onClick = {
+ scope.launch {
+ // Same rationale as the export picker: keep the Tao GTK event loop free.
+ val file =
+ withContext(Dispatchers.IO) {
+ FileKit.openFilePicker(type = FileKitType.File(extensions = listOf("db")))
+ }
+ file?.let { viewModel.importFromFile(File(it.path)) }
+ }
+ },
+ )
+
+ state.exportedFileName?.let {
+ InlineSuccessBanner(
+ text = stringResource(Res.string.data_export_success, it),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ if (state.importSucceeded) {
+ InlineSuccessBanner(
+ text = stringResource(Res.string.data_import_success),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ if (state.exportFailed) {
+ InlineErrorBanner(
+ text = stringResource(Res.string.data_export_error),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ if (state.importFailed) {
+ InlineErrorBanner(
+ text = stringResource(Res.string.data_import_error),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+
+ ResetCard(
+ resetDone = state.resetDone,
+ onReset = { viewModel.resetApp() },
+ )
+ }
+ }
+}
+
+@Composable
+private fun DataActionCard(
+ title: StringResource,
+ description: StringResource,
+ actionLabel: StringResource,
+ enabled: Boolean,
+ onClick: () -> Unit,
+) {
+ val shape = RoundedCornerShape(8.dp)
+
+ Row(
+ modifier =
+ Modifier
+ .fillMaxWidth()
+ .clip(shape)
+ .border(1.dp, JewelTheme.globalColors.borders.normal, shape)
+ .background(JewelTheme.globalColors.panelBackground)
+ .padding(12.dp),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.SpaceBetween,
+ ) {
+ Column(
+ modifier = Modifier.weight(1f),
+ verticalArrangement = Arrangement.spacedBy(4.dp),
+ ) {
+ Text(text = stringResource(title), fontSize = 15.sp)
+ Text(
+ text = stringResource(description),
+ fontSize = 12.sp,
+ color = JewelTheme.globalColors.text.info,
+ )
+ }
+ OutlinedButton(onClick = onClick, enabled = enabled) {
+ Text(text = stringResource(actionLabel))
+ }
+ }
+}
+
+@Composable
+private fun ResetCard(
+ resetDone: Boolean,
+ onReset: () -> Unit,
+) {
+ val shape = RoundedCornerShape(8.dp)
+ var showConfirmation by remember { mutableStateOf(false) }
+
+ Column(
+ modifier =
+ Modifier
+ .fillMaxWidth()
+ .clip(shape)
+ .border(1.dp, JewelTheme.globalColors.borders.normal, shape)
+ .background(JewelTheme.globalColors.panelBackground)
+ .padding(12.dp),
+ verticalArrangement = Arrangement.spacedBy(8.dp),
+ ) {
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.SpaceBetween,
+ ) {
+ Column(
+ modifier = Modifier.weight(1f),
+ verticalArrangement = Arrangement.spacedBy(4.dp),
+ ) {
+ Text(text = stringResource(Res.string.settings_reset_app), fontSize = 15.sp)
+ Text(
+ text = stringResource(Res.string.data_reset_description),
+ fontSize = 12.sp,
+ color = JewelTheme.globalColors.text.info,
+ )
+ }
+ if (!showConfirmation) {
+ OutlinedButton(onClick = { showConfirmation = true }) {
+ Text(text = stringResource(Res.string.settings_reset_app))
+ }
+ }
+ }
+
+ if (showConfirmation) {
+ InlineErrorBanner(
+ text = stringResource(Res.string.settings_reset_warning),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ Row(
+ horizontalArrangement = Arrangement.spacedBy(8.dp),
+ verticalAlignment = Alignment.CenterVertically,
+ ) {
+ DefaultButton(
+ onClick = {
+ showConfirmation = false
+ onReset()
+ },
+ ) {
+ Text(text = stringResource(Res.string.settings_reset_confirm_yes))
+ }
+ OutlinedButton(onClick = { showConfirmation = false }) {
+ Text(text = stringResource(Res.string.settings_reset_confirm_no))
+ }
+ }
+ }
+
+ if (resetDone) {
+ InlineSuccessBanner(
+ text = stringResource(Res.string.settings_reset_done),
+ modifier = Modifier.fillMaxWidth(),
+ )
+ }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/GeneralSettingsScreen.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/GeneralSettingsScreen.kt
index c16f3be53..40fb5f90f 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/GeneralSettingsScreen.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/GeneralSettingsScreen.kt
@@ -16,8 +16,6 @@ import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -25,48 +23,49 @@ import androidx.compose.ui.draw.clip
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
+import dev.nucleusframework.updater.UpdateLevel
+import dev.nucleusframework.updater.UpdaterConfig
import dev.zacsweers.metrox.viewmodel.metroViewModel
-import io.github.kdroidfilter.nucleus.updater.UpdaterConfig
import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.UrlOpener
import io.github.kdroidfilter.seforimapp.features.settings.general.GeneralSettingsEvents
import io.github.kdroidfilter.seforimapp.features.settings.general.GeneralSettingsState
import io.github.kdroidfilter.seforimapp.features.settings.general.GeneralSettingsViewModel
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
+import io.github.kdroidfilter.seforimapp.framework.update.AppUpdateService
+import io.github.kdroidfilter.seforimapp.framework.update.UpdateMode
+import io.github.kdroidfilter.seforimapp.framework.update.UpdateUiState
+import io.github.kdroidfilter.seforimapp.framework.update.availableVersion
import io.github.kdroidfilter.seforimapp.theme.PreviewContainer
import org.jetbrains.compose.resources.painterResource
import org.jetbrains.compose.resources.stringResource
import org.jetbrains.jewel.foundation.theme.JewelTheme
-import org.jetbrains.jewel.ui.component.DefaultButton
import org.jetbrains.jewel.ui.component.Icon
import org.jetbrains.jewel.ui.component.IconButton
import org.jetbrains.jewel.ui.component.InlineInformationBanner
+import org.jetbrains.jewel.ui.component.InlineSuccessBanner
import org.jetbrains.jewel.ui.component.InlineWarningBanner
-import org.jetbrains.jewel.ui.component.OutlinedButton
+import org.jetbrains.jewel.ui.component.Link
import org.jetbrains.jewel.ui.component.Text
import org.jetbrains.jewel.ui.component.VerticallyScrollableContainer
import org.jetbrains.jewel.ui.icons.AllIconsKeys
-import org.jetbrains.jewel.ui.theme.inlineBannerStyle
import seforimapp.seforimapp.generated.resources.AppIcon
import seforimapp.seforimapp.generated.resources.Res
import seforimapp.seforimapp.generated.resources.close_book_tree_on_new_book
import seforimapp.seforimapp.generated.resources.close_book_tree_on_new_book_description
import seforimapp.seforimapp.generated.resources.settings_info_app_version
import seforimapp.seforimapp.generated.resources.settings_info_created_by
-import seforimapp.seforimapp.generated.resources.settings_info_jdk_version
import seforimapp.seforimapp.generated.resources.settings_info_license
import seforimapp.seforimapp.generated.resources.settings_info_license_usage
+import seforimapp.seforimapp.generated.resources.settings_keep_screen_awake
+import seforimapp.seforimapp.generated.resources.settings_keep_screen_awake_description
import seforimapp.seforimapp.generated.resources.settings_persist_session
import seforimapp.seforimapp.generated.resources.settings_persist_session_description
-import seforimapp.seforimapp.generated.resources.settings_reset_app
-import seforimapp.seforimapp.generated.resources.settings_reset_confirm
-import seforimapp.seforimapp.generated.resources.settings_reset_confirm_no
-import seforimapp.seforimapp.generated.resources.settings_reset_confirm_yes
-import seforimapp.seforimapp.generated.resources.settings_reset_done
-import seforimapp.seforimapp.generated.resources.settings_reset_warning
import seforimapp.seforimapp.generated.resources.update_available_banner
+import seforimapp.seforimapp.generated.resources.update_check_failed
+import seforimapp.seforimapp.generated.resources.update_checking
import seforimapp.seforimapp.generated.resources.update_download_action
-import java.awt.Desktop
-import java.net.URI
+import seforimapp.seforimapp.generated.resources.update_up_to_date
@Composable
fun GeneralSettingsScreen() {
@@ -74,12 +73,12 @@ fun GeneralSettingsScreen() {
metroViewModel(viewModelStoreOwner = LocalWindowViewModelStoreOwner.current)
val state by viewModel.state.collectAsState()
val version = UpdaterConfig().currentVersion
- val mainAppState = LocalAppGraph.current.mainAppState
- val updateVersion by mainAppState.updateAvailable.collectAsState()
+ val updateState by LocalAppGraph.current.appUpdateService.state
+ .collectAsState()
GeneralSettingsView(
state = state,
version = version,
- updateVersion = updateVersion,
+ updateState = updateState,
onEvent = viewModel::onEvent,
)
}
@@ -88,7 +87,7 @@ fun GeneralSettingsScreen() {
private fun GeneralSettingsView(
state: GeneralSettingsState,
version: String,
- updateVersion: String?,
+ updateState: UpdateUiState,
onEvent: (GeneralSettingsEvents) -> Unit,
) {
VerticallyScrollableContainer(modifier = Modifier.fillMaxSize()) {
@@ -99,7 +98,7 @@ private fun GeneralSettingsView(
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
- AppHeader(version = version, updateVersion = updateVersion)
+ AppHeader(version = version, updateState = updateState)
SettingCard(
title = Res.string.close_book_tree_on_new_book,
@@ -115,13 +114,11 @@ private fun GeneralSettingsView(
onCheckedChange = { onEvent(GeneralSettingsEvents.SetPersistSession(it)) },
)
- // Database delta-update panel: checks the release server for
- // a new seforim.db delta and applies it incrementally.
- io.github.kdroidfilter.seforimapp.features.settings.dbupdate.DbDeltaUpdateSection()
-
- ResetSection(
- resetDone = state.resetDone,
- onReset = { onEvent(GeneralSettingsEvents.ResetApp) },
+ SettingCard(
+ title = Res.string.settings_keep_screen_awake,
+ description = Res.string.settings_keep_screen_awake_description,
+ checked = state.keepScreenAwakeOnBook,
+ onCheckedChange = { onEvent(GeneralSettingsEvents.SetKeepScreenAwakeOnBook(it)) },
)
}
}
@@ -130,7 +127,7 @@ private fun GeneralSettingsView(
@Composable
private fun AppHeader(
version: String,
- updateVersion: String? = null,
+ updateState: UpdateUiState,
) {
val shape = RoundedCornerShape(8.dp)
@@ -144,24 +141,8 @@ private fun AppHeader(
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
- // Update available banner
- if (updateVersion != null) {
- val downloadLabel = stringResource(Res.string.update_download_action)
- InlineInformationBanner(
- style = JewelTheme.inlineBannerStyle.information,
- text = stringResource(Res.string.update_available_banner, updateVersion),
- linkActions = {
- action(
- downloadLabel,
- onClick = {
- Desktop.getDesktop().browse(
- URI(io.github.kdroidfilter.seforimapp.framework.update.AppUpdateChecker.DOWNLOAD_URL),
- )
- },
- )
- },
- )
- }
+ // Update status banner, reflecting the full check/download state.
+ UpdateStatusBanner(updateState)
Row(
verticalAlignment = Alignment.CenterVertically,
@@ -189,22 +170,9 @@ private fun AppHeader(
fontSize = 13.sp,
color = JewelTheme.globalColors.text.info,
)
- Text(
- text =
- stringResource(
- Res.string.settings_info_jdk_version,
- System.getProperty("java.runtime.name", "Unknown"),
- System.getProperty("java.version", "?"),
- System.getProperty("java.vendor", "Unknown"),
- System.getProperty("os.arch", "?"),
- ),
- fontSize = 13.sp,
- color = JewelTheme.globalColors.text.info,
- )
- Text(
+ Link(
text = stringResource(Res.string.settings_info_created_by),
- fontSize = 12.sp,
- color = JewelTheme.globalColors.text.info,
+ onClick = { UrlOpener.open("https://eliegambache.kdroidfilter.com/") },
)
}
}
@@ -231,7 +199,7 @@ private fun AppHeader(
}
IconButton(
onClick = {
- Desktop.getDesktop().browse(URI("https://github.com/kdroidFilter/Zayit"))
+ UrlOpener.open("https://github.com/kdroidFilter/Zayit")
},
modifier = Modifier.size(32.dp),
) {
@@ -246,59 +214,26 @@ private fun AppHeader(
}
@Composable
-private fun ResetSection(
- resetDone: Boolean,
- onReset: () -> Unit,
-) {
- val shape = RoundedCornerShape(8.dp)
- var showConfirmation by remember { mutableStateOf(false) }
-
- Column(
- modifier =
- Modifier
- .fillMaxWidth()
- .clip(shape)
- .border(1.dp, JewelTheme.globalColors.borders.normal, shape)
- .background(JewelTheme.globalColors.panelBackground)
- .padding(12.dp),
- verticalArrangement = Arrangement.spacedBy(12.dp),
- ) {
- if (showConfirmation) {
- Row(
- horizontalArrangement = Arrangement.spacedBy(8.dp),
- verticalAlignment = Alignment.CenterVertically,
- ) {
- Text(
- text = stringResource(Res.string.settings_reset_confirm),
- color = JewelTheme.globalColors.text.warning,
- )
- DefaultButton(onClick = {
- showConfirmation = false
- onReset()
- }) {
- Text(text = stringResource(Res.string.settings_reset_confirm_yes))
- }
- OutlinedButton(onClick = { showConfirmation = false }) {
- Text(text = stringResource(Res.string.settings_reset_confirm_no))
- }
- }
- } else {
- DefaultButton(onClick = { showConfirmation = true }) {
- Text(text = stringResource(Res.string.settings_reset_app))
- }
- }
-
- if (resetDone) {
- InlineWarningBanner(
- style = JewelTheme.inlineBannerStyle.warning,
- text = stringResource(Res.string.settings_reset_done),
- )
- } else {
- InlineWarningBanner(
- style = JewelTheme.inlineBannerStyle.warning,
- text = stringResource(Res.string.settings_reset_warning),
+private fun UpdateStatusBanner(updateState: UpdateUiState) {
+ when (updateState) {
+ is UpdateUiState.Available, is UpdateUiState.Downloading, is UpdateUiState.ReadyToInstall -> {
+ val downloadLabel = stringResource(Res.string.update_download_action)
+ InlineInformationBanner(
+ text = stringResource(Res.string.update_available_banner, updateState.availableVersion.orEmpty()),
+ linkActions = {
+ action(downloadLabel, onClick = { UrlOpener.open(AppUpdateService.DOWNLOAD_URL) })
+ },
)
}
+
+ UpdateUiState.UpToDate ->
+ InlineSuccessBanner(text = stringResource(Res.string.update_up_to_date))
+
+ is UpdateUiState.Error ->
+ InlineWarningBanner(text = stringResource(Res.string.update_check_failed))
+
+ UpdateUiState.Idle, UpdateUiState.Checking ->
+ InlineInformationBanner(text = stringResource(Res.string.update_checking))
}
}
@@ -309,7 +244,7 @@ private fun GeneralSettingsView_Preview() {
GeneralSettingsView(
state = GeneralSettingsState.preview,
version = "0.3.0",
- updateVersion = "0.4.0",
+ updateState = UpdateUiState.Available("0.4.0", UpdateLevel.MINOR, UpdateMode.PROMPT, needsDbWarning = true),
onEvent = {},
)
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/SettingsSidebar.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/SettingsSidebar.kt
index eccb10020..db917decb 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/SettingsSidebar.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/settings/ui/SettingsSidebar.kt
@@ -26,6 +26,7 @@ import androidx.navigation.NavHostController
import androidx.navigation.compose.currentBackStackEntryAsState
import io.github.kdroidfilter.seforimapp.features.settings.navigation.SettingsDestination
import io.github.kdroidfilter.seforimapp.icons.BootstrapPersonLines
+import io.github.kdroidfilter.seforimapp.icons.FileArrowDown
import io.github.kdroidfilter.seforimapp.icons.LucideInspectionPanel
import io.github.kdroidfilter.seforimapp.icons.MaterialIconsDisplay_settings
import io.github.kdroidfilter.seforimapp.icons.RadixFontRoman
@@ -38,6 +39,7 @@ import org.jetbrains.jewel.ui.component.Text
import seforimapp.seforimapp.generated.resources.Res
import seforimapp.seforimapp.generated.resources.settings_category_about
import seforimapp.seforimapp.generated.resources.settings_category_conditions
+import seforimapp.seforimapp.generated.resources.settings_category_data
import seforimapp.seforimapp.generated.resources.settings_category_display
import seforimapp.seforimapp.generated.resources.settings_category_fonts
import seforimapp.seforimapp.generated.resources.settings_category_general
@@ -83,6 +85,11 @@ fun SettingsSidebar(
destination = SettingsDestination.Fonts,
icon = RadixFontRoman,
),
+ SettingsItem(
+ label = stringResource(Res.string.settings_category_data),
+ destination = SettingsDestination.Data,
+ icon = FileArrowDown,
+ ),
SettingsItem(
label = stringResource(Res.string.settings_category_about),
destination = SettingsDestination.About,
@@ -109,6 +116,7 @@ fun SettingsSidebar(
is SettingsDestination.Fonts -> currentRoute.contains("Fonts")
is SettingsDestination.About -> currentRoute.contains("About")
is SettingsDestination.Conditions -> currentRoute.contains("Conditions")
+ is SettingsDestination.Data -> currentRoute.contains("Data")
}
SidebarItem(
label = item.label,
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/update/UpdateDialog.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/update/UpdateDialog.kt
new file mode 100644
index 000000000..a1c1214c3
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/update/UpdateDialog.kt
@@ -0,0 +1,190 @@
+package io.github.kdroidfilter.seforimapp.features.update
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.WindowPosition
+import androidx.compose.ui.window.rememberDialogState
+import dev.nucleusframework.application.NucleusApplicationScope
+import dev.nucleusframework.window.ControlButtonsDirection
+import dev.nucleusframework.window.jewel.JewelDecoratedDialog
+import dev.nucleusframework.window.jewel.JewelDialogTitleBar
+import dev.nucleusframework.window.newFullscreenControls
+import io.github.kdroidfilter.seforimapp.core.presentation.components.AnimatedHorizontalProgressBar
+import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
+import io.github.kdroidfilter.seforimapp.framework.update.AppUpdateService
+import io.github.kdroidfilter.seforimapp.framework.update.UpdateUiState
+import io.github.kdroidfilter.seforimapp.framework.update.availableVersion
+import io.github.kdroidfilter.seforimapp.icons.Download_for_offline
+import org.jetbrains.compose.resources.stringResource
+import org.jetbrains.jewel.foundation.modifier.trackActivation
+import org.jetbrains.jewel.foundation.theme.JewelTheme
+import org.jetbrains.jewel.intui.standalone.theme.IntUiTheme
+import org.jetbrains.jewel.ui.Orientation
+import org.jetbrains.jewel.ui.component.DefaultButton
+import org.jetbrains.jewel.ui.component.Divider
+import org.jetbrains.jewel.ui.component.Icon
+import org.jetbrains.jewel.ui.component.InlineWarningBanner
+import org.jetbrains.jewel.ui.component.OutlinedButton
+import org.jetbrains.jewel.ui.component.Text
+import org.jetbrains.jewel.ui.icons.AllIconsKeys
+import org.jetbrains.jewel.ui.typography
+import seforimapp.seforimapp.generated.resources.Res
+import seforimapp.seforimapp.generated.resources.update_dialog_db_warning
+import seforimapp.seforimapp.generated.resources.update_dialog_message
+import seforimapp.seforimapp.generated.resources.update_dialog_title
+import seforimapp.seforimapp.generated.resources.update_downloading
+import seforimapp.seforimapp.generated.resources.update_install_restart
+import seforimapp.seforimapp.generated.resources.update_later
+
+@Composable
+fun NucleusApplicationScope.UpdateDialog(
+ service: AppUpdateService,
+ onClose: () -> Unit,
+) {
+ IntUiTheme(
+ theme = ThemeUtils.buildThemeDefinition(),
+ styling = ThemeUtils.buildComponentStyling(),
+ ) {
+ val dialogState =
+ rememberDialogState(position = WindowPosition.Aligned(Alignment.Center), size = DpSize(440.dp, 340.dp))
+ JewelDecoratedDialog(
+ onCloseRequest = onClose,
+ title = stringResource(Res.string.update_dialog_title),
+ state = dialogState,
+ visible = true,
+ resizable = false,
+ ) {
+ JewelDialogTitleBar(
+ modifier = Modifier.newFullscreenControls(),
+ gradientStartColor = if (ThemeUtils.isIslandsStyle()) ThemeUtils.titleBarGradientColor() else Color.Unspecified,
+ controlButtonsDirection = ControlButtonsDirection.SystemNative,
+ ) {
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(8.dp),
+ ) {
+ Icon(
+ AllIconsKeys.Ide.Notification.IdeUpdate,
+ contentDescription = null,
+ tint = JewelTheme.globalColors.text.normal,
+ modifier = Modifier.size(16.dp),
+ )
+ Text(stringResource(Res.string.update_dialog_title))
+ }
+ }
+
+ val state by service.state.collectAsState()
+ val version = state.availableVersion.orEmpty()
+ val needsDbWarning =
+ (state as? UpdateUiState.Available)?.needsDbWarning
+ ?: (state as? UpdateUiState.Downloading)?.needsDbWarning
+ ?: (state as? UpdateUiState.ReadyToInstall)?.needsDbWarning
+ ?: false
+
+ Column(
+ modifier =
+ Modifier
+ .trackActivation()
+ .fillMaxSize()
+ .background(JewelTheme.globalColors.panelBackground)
+ .padding(16.dp),
+ ) {
+ // Info bar pinned at the top.
+ if (needsDbWarning) {
+ InlineWarningBanner(text = stringResource(Res.string.update_dialog_db_warning))
+ Spacer(Modifier.height(8.dp))
+ }
+
+ // Content area (hero icon + message), centered.
+ Column(
+ modifier =
+ Modifier
+ .weight(1f)
+ .fillMaxWidth(),
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(16.dp, Alignment.CenterVertically),
+ ) {
+ Icon(
+ Download_for_offline,
+ contentDescription = null,
+ modifier = Modifier.size(88.dp),
+ tint = JewelTheme.globalColors.text.normal,
+ )
+ Text(
+ text = stringResource(Res.string.update_dialog_message, version),
+ textAlign = TextAlign.Center,
+ fontSize = JewelTheme.typography.h3TextStyle.fontSize,
+ fontWeight = FontWeight.SemiBold,
+ )
+ }
+
+ // Fixed-height progress slot just above the action bar. Reserving the height
+ // unconditionally means showing/hiding the bar never shifts the centered hero above.
+ Box(
+ modifier = Modifier.fillMaxWidth().height(36.dp),
+ contentAlignment = Alignment.Center,
+ ) {
+ (state as? UpdateUiState.Downloading)?.let { downloading ->
+ Column(horizontalAlignment = Alignment.CenterHorizontally) {
+ Text(
+ "${stringResource(Res.string.update_downloading)} ${downloading.percent}%",
+ color = JewelTheme.globalColors.text.info,
+ )
+ Spacer(Modifier.height(4.dp))
+ AnimatedHorizontalProgressBar(
+ value = downloading.percent / 100f,
+ modifier = Modifier.fillMaxWidth().height(6.dp),
+ )
+ }
+ }
+ }
+
+ Spacer(Modifier.height(8.dp))
+ Divider(orientation = Orientation.Horizontal)
+ Spacer(Modifier.height(8.dp))
+
+ // Bottom action bar, aligned to the end (bottom-right).
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End),
+ verticalAlignment = Alignment.CenterVertically,
+ ) {
+ OutlinedButton(onClick = onClose) {
+ Text(stringResource(Res.string.update_later))
+ }
+ DefaultButton(
+ enabled = state !is UpdateUiState.Downloading,
+ onClick = {
+ when (state) {
+ is UpdateUiState.ReadyToInstall -> service.installAndRestart()
+ is UpdateUiState.Available -> service.startDownload()
+ else -> {}
+ }
+ },
+ ) {
+ Text(stringResource(Res.string.update_install_restart))
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/AppGraph.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/AppGraph.kt
index 96f913cb2..7da9ed611 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/AppGraph.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/AppGraph.kt
@@ -6,6 +6,9 @@ import dev.zacsweers.metrox.viewmodel.ViewModelGraph
import io.github.kdroidfilter.seforim.tabs.TabTitleUpdateManager
import io.github.kdroidfilter.seforim.tabs.TabsViewModel
import io.github.kdroidfilter.seforimapp.core.MainAppState
+import io.github.kdroidfilter.seforimapp.core.annotations.HighlightStore
+import io.github.kdroidfilter.seforimapp.core.annotations.NoteStore
+import io.github.kdroidfilter.seforimapp.core.catalog.CatalogAccess
import io.github.kdroidfilter.seforimapp.core.selection.SelectionContext
import io.github.kdroidfilter.seforimapp.core.settings.CategoryDisplaySettingsStore
import io.github.kdroidfilter.seforimapp.features.database.update.DatabaseCleanupUseCase
@@ -13,6 +16,7 @@ import io.github.kdroidfilter.seforimapp.features.onboarding.data.OnboardingProc
import io.github.kdroidfilter.seforimapp.features.search.SearchHomeViewModel
import io.github.kdroidfilter.seforimapp.framework.desktop.DesktopManager
import io.github.kdroidfilter.seforimapp.framework.session.TabPersistedStateStore
+import io.github.kdroidfilter.seforimapp.framework.update.AppUpdateService
import io.github.kdroidfilter.seforimlibrary.dao.repository.SeforimRepository
import io.github.kdroidfilter.seforimlibrary.search.SearchEngine
@@ -24,11 +28,14 @@ import io.github.kdroidfilter.seforimlibrary.search.SearchEngine
abstract class AppGraph : ViewModelGraph {
// Expose strongly-typed graph entries as abstract vals for generated implementation
abstract val mainAppState: MainAppState
+ abstract val catalogAccess: CatalogAccess
abstract val selectionContext: SelectionContext
abstract val tabPersistedStateStore: TabPersistedStateStore
abstract val tabTitleUpdateManager: TabTitleUpdateManager
abstract val settings: Settings
abstract val categoryDisplaySettingsStore: CategoryDisplaySettingsStore
+ abstract val highlightStore: HighlightStore
+ abstract val noteStore: NoteStore
abstract val repository: SeforimRepository
abstract val searchEngine: SearchEngine
abstract val tabsViewModel: TabsViewModel
@@ -40,4 +47,7 @@ abstract class AppGraph : ViewModelGraph {
/** Seforim.db delta-update facade (recoverIfNeeded + checkAndApply). */
abstract val dbDeltaUpdateService: io.github.kdroidfilter.seforimapp.framework.update.DbDeltaUpdateService
+
+ /** App self-update facade (Nucleus updater + native SSL). */
+ abstract val appUpdateService: AppUpdateService
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/AppMetroViewModelFactory.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/AppMetroViewModelFactory.kt
index d429692c0..762ceb333 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/AppMetroViewModelFactory.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/AppMetroViewModelFactory.kt
@@ -3,7 +3,6 @@ package io.github.kdroidfilter.seforimapp.framework.di
import androidx.lifecycle.ViewModel
import dev.zacsweers.metro.ContributesBinding
import dev.zacsweers.metro.Inject
-import dev.zacsweers.metro.Provider
import dev.zacsweers.metro.SingleIn
import dev.zacsweers.metrox.viewmodel.ManualViewModelAssistedFactory
import dev.zacsweers.metrox.viewmodel.MetroViewModelFactory
@@ -14,7 +13,7 @@ import kotlin.reflect.KClass
@ContributesBinding(AppScope::class)
@SingleIn(AppScope::class)
class AppMetroViewModelFactory(
- override val viewModelProviders: Map, Provider>,
- override val assistedFactoryProviders: Map, Provider>,
- override val manualAssistedFactoryProviders: Map, Provider>,
+ override val viewModelProviders: Map, () -> ViewModel>,
+ override val assistedFactoryProviders: Map, () -> ViewModelAssistedFactory>,
+ override val manualAssistedFactoryProviders: Map, () -> ManualViewModelAssistedFactory>,
) : MetroViewModelFactory()
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/modules/AppCoreBindings.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/modules/AppCoreBindings.kt
index e8569c81e..3745ba0ea 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/modules/AppCoreBindings.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/di/modules/AppCoreBindings.kt
@@ -10,11 +10,15 @@ import io.github.kdroidfilter.seforim.tabs.TabTitleUpdateManager
import io.github.kdroidfilter.seforim.tabs.TabsDestination
import io.github.kdroidfilter.seforim.tabs.TabsViewModel
import io.github.kdroidfilter.seforimapp.core.MainAppState
+import io.github.kdroidfilter.seforimapp.core.annotations.HighlightStore
+import io.github.kdroidfilter.seforimapp.core.annotations.NoteStore
+import io.github.kdroidfilter.seforimapp.core.catalog.CatalogAccess
import io.github.kdroidfilter.seforimapp.core.selection.DefaultSelectionContext
import io.github.kdroidfilter.seforimapp.core.selection.SelectionContext
import io.github.kdroidfilter.seforimapp.core.settings.CategoryDisplaySettingsStore
import io.github.kdroidfilter.seforimapp.db.UserSettingsDb
import io.github.kdroidfilter.seforimapp.features.search.SearchHomeViewModel
+import io.github.kdroidfilter.seforimapp.framework.database.CatalogCache
import io.github.kdroidfilter.seforimapp.framework.database.PersistentSqliteDriver
import io.github.kdroidfilter.seforimapp.framework.database.getDatabasePath
import io.github.kdroidfilter.seforimapp.framework.database.getUserSettingsDatabasePath
@@ -24,6 +28,7 @@ import io.github.kdroidfilter.seforimapp.framework.search.AcronymFrequencyCache
import io.github.kdroidfilter.seforimapp.framework.search.LuceneLookupSearchService
import io.github.kdroidfilter.seforimapp.framework.search.RepositorySnippetSourceProvider
import io.github.kdroidfilter.seforimapp.framework.session.TabPersistedStateStore
+import io.github.kdroidfilter.seforimapp.framework.update.AppUpdateService
import io.github.kdroidfilter.seforimlibrary.dao.repository.SeforimRepository
import io.github.kdroidfilter.seforimlibrary.search.LuceneSearchEngine
import io.github.kdroidfilter.seforimlibrary.search.SearchEngine
@@ -37,6 +42,10 @@ object AppCoreBindings {
@SingleIn(AppScope::class)
fun provideMainAppState(): MainAppState = MainAppState()
+ @Provides
+ @SingleIn(AppScope::class)
+ fun provideCatalogAccess(): CatalogAccess = CatalogAccess { CatalogCache.getCatalog() }
+
@Provides
@SingleIn(AppScope::class)
fun provideSelectionContext(): SelectionContext = DefaultSelectionContext()
@@ -55,14 +64,28 @@ object AppCoreBindings {
@Provides
@SingleIn(AppScope::class)
- fun provideCategoryDisplaySettingsStore(): CategoryDisplaySettingsStore {
- val dbPath = getUserSettingsDatabasePath()
- val driver = JdbcSqliteDriver("jdbc:sqlite:$dbPath")
+ fun provideUserSettingsDb(): UserSettingsDb {
+ // Single shared connection to the local user database (separate from the
+ // read-only books DB). All user stores inject this instance instead of
+ // opening their own driver. New tables are added transparently for
+ // existing users via CREATE TABLE IF NOT EXISTS in Schema.create().
+ val driver = JdbcSqliteDriver("jdbc:sqlite:${getUserSettingsDatabasePath()}")
UserSettingsDb.Schema.create(driver)
- val database = UserSettingsDb(driver)
- return CategoryDisplaySettingsStore(database)
+ return UserSettingsDb(driver)
}
+ @Provides
+ @SingleIn(AppScope::class)
+ fun provideCategoryDisplaySettingsStore(database: UserSettingsDb): CategoryDisplaySettingsStore = CategoryDisplaySettingsStore(database)
+
+ @Provides
+ @SingleIn(AppScope::class)
+ fun provideHighlightStore(database: UserSettingsDb): HighlightStore = HighlightStore(database)
+
+ @Provides
+ @SingleIn(AppScope::class)
+ fun provideNoteStore(database: UserSettingsDb): NoteStore = NoteStore(database)
+
@Provides
@SingleIn(AppScope::class)
fun provideRepository(): SeforimRepository {
@@ -104,8 +127,9 @@ object AppCoreBindings {
val seforimDb = Paths.get(dbPath)
val catalogPb = Paths.get(seforimDb.parent.toString(), "catalog.pb")
val workDir = Paths.get(seforimDb.parent.toString(), "delta-cache")
- val releaseMetaUrl = System.getenv("SEFORIMAPP_RELEASE_META_URL")
- ?: "https://kdroidfilter.github.io/SefariaExport/release_meta.json"
+ val releaseMetaUrl =
+ System.getenv("SEFORIMAPP_RELEASE_META_URL")
+ ?: "https://kdroidfilter.github.io/SefariaExport/release_meta.json"
return io.github.kdroidfilter.seforimapp.framework.update.DbDeltaUpdateService(
seforimDb = seforimDb,
catalogPb = catalogPb,
@@ -125,6 +149,10 @@ object AppCoreBindings {
)
}
+ @Provides
+ @SingleIn(AppScope::class)
+ fun provideAppUpdateService(): AppUpdateService = AppUpdateService.create()
+
@Provides
@SingleIn(AppScope::class)
fun provideTabsViewModel(titleUpdateManager: TabTitleUpdateManager): TabsViewModel =
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/platform/PlatformInfo.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/platform/PlatformInfo.kt
index f364a0a9b..2e0104ded 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/platform/PlatformInfo.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/platform/PlatformInfo.kt
@@ -1,7 +1,6 @@
package io.github.kdroidfilter.seforimapp.framework.platform
-import io.github.kdroidfilter.platformtools.OperatingSystem
-import io.github.kdroidfilter.platformtools.getOperatingSystem
+import dev.nucleusframework.core.runtime.Platform
/**
* Cached platform information.
@@ -11,20 +10,20 @@ object PlatformInfo {
/**
* The current operating system, cached at startup.
*/
- val currentOS: OperatingSystem = getOperatingSystem()
+ val currentOS: Platform = Platform.Current
/**
* True if running on macOS.
*/
- val isMacOS: Boolean = currentOS == OperatingSystem.MACOS
+ val isMacOS: Boolean = currentOS == Platform.MacOS
/**
* True if running on Windows.
*/
- val isWindows: Boolean = currentOS == OperatingSystem.WINDOWS
+ val isWindows: Boolean = currentOS == Platform.Windows
/**
* True if running on Linux.
*/
- val isLinux: Boolean = currentOS == OperatingSystem.LINUX
+ val isLinux: Boolean = currentOS == Platform.Linux
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/session/SessionManager.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/session/SessionManager.kt
index 1bc58621c..c7bf48ea9 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/session/SessionManager.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/session/SessionManager.kt
@@ -82,20 +82,7 @@ object SessionManager {
val desktopsState = loadDesktopsState() ?: return
if (desktopsState.desktops.isEmpty()) return
- // Compute titles for the active desktop snapshot
- val activeSnapshot = desktopsState.snapshots[desktopsState.activeDesktopId]
- val enrichedSnapshots = desktopsState.snapshots.toMutableMap()
-
- if (activeSnapshot != null) {
- val computedTitles = computeTabTitles(activeSnapshot.destinations, activeSnapshot.tabStates, appGraph)
- val mergedTitles = activeSnapshot.titles.toMutableMap()
- computedTitles.forEach { (tabId, pair) ->
- mergedTitles[tabId] = SerializableTabTitle(title = pair.first, tabType = pair.second)
- }
- enrichedSnapshots[desktopsState.activeDesktopId] = activeSnapshot.copy(titles = mergedTitles)
- }
-
- val enrichedState = desktopsState.copy(snapshots = enrichedSnapshots)
+ val enrichedState = enrichMissingTabTitles(desktopsState, appGraph)
debugln {
buildString {
@@ -225,4 +212,34 @@ object SessionManager {
}
return titles
}
+
+ private suspend fun enrichMissingTabTitles(
+ state: DesktopsState,
+ appGraph: AppGraph,
+ ): DesktopsState {
+ val enrichedSnapshots =
+ state.snapshots.mapValues { (_, snapshot) ->
+ val destinationsMissingTitles =
+ snapshot.destinations.filter { destination ->
+ destination !is TabsDestination.Home &&
+ snapshot.titles[destination.tabId]?.title.isNullOrBlank()
+ }
+ if (destinationsMissingTitles.isEmpty()) {
+ snapshot
+ } else {
+ val computedTitles = computeTabTitles(destinationsMissingTitles, snapshot.tabStates, appGraph)
+ if (computedTitles.isEmpty()) {
+ snapshot
+ } else {
+ val mergedTitles = snapshot.titles.toMutableMap()
+ computedTitles.forEach { (tabId, pair) ->
+ mergedTitles[tabId] = SerializableTabTitle(title = pair.first, tabType = pair.second)
+ }
+ snapshot.copy(titles = mergedTitles)
+ }
+ }
+ }
+
+ return state.copy(snapshots = enrichedSnapshots)
+ }
}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/session/SessionModels.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/session/SessionModels.kt
index f398c9997..f54a02095 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/session/SessionModels.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/session/SessionModels.kt
@@ -46,6 +46,10 @@ data class BookContentPersistedState(
val selectedTocEntryId: Long = -1L,
val tocScrollIndex: Int = 0,
val tocScrollOffset: Int = 0,
+ // Notes pane
+ val isNotesVisible: Boolean = false,
+ val notesScrollIndex: Int = 0,
+ val notesScrollOffset: Int = 0,
// Content
val selectedLineIds: Set = emptySet(),
val primarySelectedLineId: Long = -1L,
@@ -79,10 +83,12 @@ data class BookContentPersistedState(
// Layout
val mainSplitPosition: Float = SplitDefaults.MAIN,
val tocSplitPosition: Float = SplitDefaults.TOC,
+ val notesSplitPosition: Float = SplitDefaults.NOTES,
val contentSplitPosition: Float = SplitDefaults.CONTENT,
val targumSplitPosition: Float = 0.8f,
val previousMainSplitPosition: Float = SplitDefaults.MAIN,
val previousTocSplitPosition: Float = SplitDefaults.TOC,
+ val previousNotesSplitPosition: Float = SplitDefaults.NOTES,
val previousContentSplitPosition: Float = SplitDefaults.CONTENT,
val previousSourcesSplitPosition: Float = SplitDefaults.SOURCES,
val previousTargumSplitPosition: Float = 0.8f,
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/AppUpdateChecker.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/AppUpdateChecker.kt
deleted file mode 100644
index 628590b16..000000000
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/AppUpdateChecker.kt
+++ /dev/null
@@ -1,62 +0,0 @@
-package io.github.kdroidfilter.seforimapp.framework.update
-
-import io.github.kdroidfilter.nucleus.updater.UpdaterConfig
-import io.github.kdroidfilter.platformtools.releasefetcher.github.GitHubReleaseFetcher
-import io.github.kdroidfilter.seforimapp.network.KtorConfig
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import kotlin.coroutines.cancellation.CancellationException
-
-object AppUpdateChecker {
- const val DOWNLOAD_URL = "https://kdroidfilter.github.io/Zayit/download"
-
- private val releaseFetcher =
- GitHubReleaseFetcher(
- owner = "kdroidFilter",
- repo = "Zayit",
- httpClient = KtorConfig.createHttpClient(),
- )
-
- /**
- * Result of an update check.
- */
- sealed class UpdateCheckResult {
- data class UpdateAvailable(
- val latestVersion: String,
- ) : UpdateCheckResult()
-
- data object UpToDate : UpdateCheckResult()
-
- data object Error : UpdateCheckResult()
- }
-
- /**
- * Checks if an update is available.
- *
- * @return [UpdateCheckResult] indicating whether an update is available,
- * the app is up-to-date, or an error occurred.
- */
- suspend fun checkForUpdate(): UpdateCheckResult =
- withContext(Dispatchers.IO) {
- try {
- val release =
- releaseFetcher.getLatestRelease()
- ?: return@withContext UpdateCheckResult.Error
-
- val latestVersion = normalizeVersion(release.tag_name)
- val currentVersion = UpdaterConfig().currentVersion.trim()
-
- if (latestVersion != currentVersion) {
- UpdateCheckResult.UpdateAvailable(latestVersion)
- } else {
- UpdateCheckResult.UpToDate
- }
- } catch (e: CancellationException) {
- throw e
- } catch (_: Exception) {
- UpdateCheckResult.Error
- }
- }
-
- private fun normalizeVersion(version: String): String = version.removePrefix("v").trim()
-}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/AppUpdateService.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/AppUpdateService.kt
new file mode 100644
index 000000000..bf9f34115
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/AppUpdateService.kt
@@ -0,0 +1,384 @@
+package io.github.kdroidfilter.seforimapp.framework.update
+
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.Stable
+import dev.nucleusframework.core.runtime.Platform
+import dev.nucleusframework.nativehttp.NativeHttpClient
+import dev.nucleusframework.updater.DownloadProgress
+import dev.nucleusframework.updater.NucleusUpdater
+import dev.nucleusframework.updater.UpdateInfo
+import dev.nucleusframework.updater.UpdateLevel
+import dev.nucleusframework.updater.UpdateResult
+import dev.nucleusframework.updater.provider.GenericProvider
+import dev.nucleusframework.updater.provider.GitHubProvider
+import io.github.kdroidfilter.seforimapp.logger.errorln
+import io.github.kdroidfilter.seforimapp.logger.infoln
+import io.github.santimattius.structured.annotations.StructuredScope
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import java.io.File
+import kotlin.coroutines.cancellation.CancellationException
+
+/** How an available update is surfaced to the user. */
+enum class UpdateMode {
+ /** Downloaded silently and installed on app close, no UI (Win/Mac PATCH only). */
+ SILENT_ON_CLOSE,
+
+ /** Surfaced via the title-bar icon + dialog; requires explicit user action. */
+ PROMPT,
+}
+
+/** UI-facing state of the auto-update flow. */
+@Immutable
+sealed interface UpdateUiState {
+ data object Idle : UpdateUiState
+
+ data object Checking : UpdateUiState
+
+ data object UpToDate : UpdateUiState
+
+ data class Available(
+ val version: String,
+ val level: UpdateLevel,
+ val mode: UpdateMode,
+ val needsDbWarning: Boolean,
+ ) : UpdateUiState
+
+ data class Downloading(
+ val version: String,
+ val level: UpdateLevel,
+ val mode: UpdateMode,
+ val needsDbWarning: Boolean,
+ val percent: Int,
+ ) : UpdateUiState
+
+ data class ReadyToInstall(
+ val version: String,
+ val level: UpdateLevel,
+ val mode: UpdateMode,
+ val needsDbWarning: Boolean,
+ val file: File,
+ ) : UpdateUiState
+
+ data class Error(
+ val message: String,
+ ) : UpdateUiState
+}
+
+/** True when the title-bar update badge should be shown (PROMPT updates only). */
+val UpdateUiState.showTitleBarIcon: Boolean
+ get() =
+ when (this) {
+ is UpdateUiState.Available -> mode == UpdateMode.PROMPT
+ is UpdateUiState.Downloading -> mode == UpdateMode.PROMPT
+ is UpdateUiState.ReadyToInstall -> mode == UpdateMode.PROMPT
+ else -> false
+ }
+
+/** The available version string, if any, regardless of mode (used by the settings banner). */
+val UpdateUiState.availableVersion: String?
+ get() =
+ when (this) {
+ is UpdateUiState.Available -> version
+ is UpdateUiState.Downloading -> version
+ is UpdateUiState.ReadyToInstall -> version
+ else -> null
+ }
+
+// --- Pure decision functions (no I/O) — see UpdateDecisionTest ---
+
+/**
+ * PATCH (0.0.x) updates install transparently on Windows/macOS; everything else
+ * (MINOR/MAJOR, any Linux, pre-release) is surfaced through the prompt UI.
+ */
+fun resolveUpdateMode(
+ level: UpdateLevel,
+ os: Platform,
+): UpdateMode =
+ if (level == UpdateLevel.PATCH && (os == Platform.Windows || os == Platform.MacOS)) {
+ UpdateMode.SILENT_ON_CLOSE
+ } else {
+ UpdateMode.PROMPT
+ }
+
+/**
+ * MINOR/MAJOR app updates may raise the minimum required database version and trigger the
+ * ~3.5 GB database update on next launch, so the user is warned beforehand on every platform.
+ */
+fun needsDbWarning(level: UpdateLevel): Boolean = level == UpdateLevel.MINOR || level == UpdateLevel.MAJOR
+
+/** PATCH updates are pre-downloaded at startup on every platform so install is instant. */
+fun shouldPreDownload(level: UpdateLevel): Boolean = level == UpdateLevel.PATCH
+
+/** Thin abstraction over [NucleusUpdater] so the service can be unit-tested with a fake. */
+interface Updater {
+ val currentVersion: String
+
+ fun isUpdateSupported(): Boolean
+
+ suspend fun checkForUpdates(): UpdateResult
+
+ fun downloadUpdate(info: UpdateInfo): Flow
+
+ fun installAndRestart(file: File)
+
+ fun installAndQuit(file: File)
+}
+
+/** Real [Updater] backed by Nucleus; honours dry-run by logging instead of launching the installer. */
+class NucleusUpdaterAdapter(
+ private val delegate: NucleusUpdater,
+ private val dryRun: Boolean,
+) : Updater {
+ override val currentVersion: String get() = delegate.currentVersion
+
+ override fun isUpdateSupported(): Boolean = delegate.isUpdateSupported()
+
+ override suspend fun checkForUpdates(): UpdateResult = delegate.checkForUpdates()
+
+ override fun downloadUpdate(info: UpdateInfo): Flow = delegate.downloadUpdate(info)
+
+ override fun installAndRestart(file: File) {
+ if (dryRun) {
+ infoln { "[update][dry-run] installAndRestart(${file.absolutePath})" }
+ return
+ }
+ delegate.installAndRestart(file)
+ }
+
+ override fun installAndQuit(file: File) {
+ if (dryRun) {
+ infoln { "[update][dry-run] installAndQuit(${file.absolutePath})" }
+ return
+ }
+ delegate.installAndQuit(file)
+ }
+}
+
+/**
+ * Dev/QA overrides resolved from environment variables (falling back to system properties).
+ * All are no-ops in normal runs.
+ */
+data class AppUpdateConfig(
+ val forceVersion: String? = null,
+ val feedUrl: String? = null,
+ val dryRun: Boolean = false,
+ val fakeState: String? = null,
+ val executableType: String? = null,
+) {
+ companion object {
+ fun fromEnv(): AppUpdateConfig =
+ AppUpdateConfig(
+ forceVersion = read("SEFORIMAPP_UPDATE_FORCE_VERSION"),
+ feedUrl = read("SEFORIMAPP_UPDATE_FEED_URL"),
+ dryRun = flag("SEFORIMAPP_UPDATE_DRY_RUN"),
+ fakeState = read("SEFORIMAPP_UPDATE_FAKE_STATE")?.lowercase(),
+ executableType = read("SEFORIMAPP_UPDATE_EXECUTABLE_TYPE"),
+ )
+
+ private fun read(key: String): String? = (System.getenv(key) ?: System.getProperty(key))?.trim()?.takeIf { it.isNotEmpty() }
+
+ private fun flag(key: String): Boolean =
+ read(key)?.let { it == "1" || it.equals("true", ignoreCase = true) || it.equals("yes", ignoreCase = true) } ?: false
+ }
+}
+
+/**
+ * Orchestrates the semi-automatic auto-update flow on top of Nucleus.
+ *
+ * Behaviour:
+ * - Win/Mac PATCH → pre-download at startup, then [installPendingOnClose] silently on close.
+ * - Linux PATCH → pre-download at startup, then prompt (icon + dialog) since `pkexec` needs interaction.
+ * - Any MINOR/MAJOR → prompt; download on user action; warns about a possible ~3.5 GB DB update.
+ *
+ * [checkOnStartup] is suspending (driven by the startup `LaunchedEffect`); [startDownload] launches
+ * on the app-lifetime [scope] so a user-triggered download survives the dialog being closed.
+ */
+@Stable
+class AppUpdateService(
+ private val updaterProvider: () -> Updater,
+ private val config: AppUpdateConfig,
+ private val os: Platform,
+ // App-lifetime scope so a user-triggered download keeps running after the dialog is closed.
+ private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default),
+) {
+ private val updater: Updater by lazy(updaterProvider)
+
+ private val _state = MutableStateFlow(initialFakeState() ?: UpdateUiState.Idle)
+ val state: StateFlow = _state.asStateFlow()
+
+ private val _dialogVisible = MutableStateFlow(false)
+ val dialogVisible: StateFlow = _dialogVisible.asStateFlow()
+
+ private var pendingInfo: UpdateInfo? = null
+ private var downloadJob: Job? = null
+
+ /** Checks for updates once at startup and pre-downloads PATCH updates. */
+ suspend fun checkOnStartup() {
+ if (config.fakeState != null) return // state pre-seeded by initialFakeState()
+ if (_state.value != UpdateUiState.Idle) return
+ _state.value = UpdateUiState.Checking
+ when (val result = updater.checkForUpdates()) {
+ is UpdateResult.NotAvailable -> _state.value = UpdateUiState.UpToDate
+ is UpdateResult.Error -> {
+ errorln { "[update] check failed: ${result.exception.message}" }
+ _state.value = UpdateUiState.Error(result.exception.message ?: "update check failed")
+ }
+ is UpdateResult.Available -> {
+ pendingInfo = result.info
+ val mode = resolveUpdateMode(result.level, os)
+ val warn = needsDbWarning(result.level)
+ infoln { "[update] available v${result.info.version} level=${result.level} mode=$mode" }
+ _state.value = UpdateUiState.Available(result.info.version, result.level, mode, warn)
+ if (shouldPreDownload(result.level)) {
+ download(result.info, result.level, mode, warn)
+ }
+ }
+ }
+ }
+
+ /**
+ * Triggers the download for a prompt update (MINOR/MAJOR) when the user confirms in the dialog.
+ * Runs on the service scope (not the dialog's), so the download continues in the background even
+ * if the user closes the dialog; progress keeps flowing into [state].
+ */
+ fun startDownload() {
+ val current = _state.value
+ if (current !is UpdateUiState.Available) return
+ if (downloadJob?.isActive == true) return
+ val info = pendingInfo ?: return
+ downloadJob = launchDownload(scope, info, current.level, current.mode, current.needsDbWarning)
+ }
+
+ private fun launchDownload(
+ @StructuredScope scope: CoroutineScope,
+ info: UpdateInfo,
+ level: UpdateLevel,
+ mode: UpdateMode,
+ warn: Boolean,
+ ): Job = scope.launch { download(info, level, mode, warn) }
+
+ private suspend fun download(
+ info: UpdateInfo,
+ level: UpdateLevel,
+ mode: UpdateMode,
+ warn: Boolean,
+ ) {
+ try {
+ infoln { "[update] download start v${info.version}" }
+ updater.downloadUpdate(info).collect { progress ->
+ val file = progress.file
+ if (file != null) {
+ infoln { "[update] download ready v${info.version} -> ${file.name}" }
+ _state.value = UpdateUiState.ReadyToInstall(info.version, level, mode, warn, file)
+ } else {
+ _state.value = UpdateUiState.Downloading(info.version, level, mode, warn, progress.percent.toInt())
+ }
+ }
+ } catch (e: CancellationException) {
+ throw e
+ } catch (
+ @Suppress("TooGenericExceptionCaught") e: Exception,
+ ) {
+ errorln { "[update] download failed: ${e.message}" }
+ _state.value = UpdateUiState.Error(e.message ?: "download failed")
+ }
+ }
+
+ /** Installs the ready update and relaunches the app (from the dialog button). */
+ fun installAndRestart() {
+ val current = _state.value
+ if (current is UpdateUiState.ReadyToInstall) {
+ if (config.fakeState != null) {
+ infoln { "[update][fake] installAndRestart(${current.file})" }
+ return
+ }
+ updater.installAndRestart(current.file)
+ }
+ }
+
+ /**
+ * Called from the window close handler. If a silent (Win/Mac PATCH) update is ready, launches
+ * the installer (which exits the process) and returns `true`; otherwise a no-op returning `false`.
+ */
+ fun installPendingOnClose(): Boolean {
+ val current = _state.value
+ return if (current is UpdateUiState.ReadyToInstall && current.mode == UpdateMode.SILENT_ON_CLOSE) {
+ if (config.fakeState != null) {
+ infoln { "[update][fake] installAndQuit(${current.file})" }
+ return false
+ }
+ infoln { "[update] applying silent update on close: v${current.version}" }
+ updater.installAndQuit(current.file)
+ true
+ } else {
+ false
+ }
+ }
+
+ fun openDialog() {
+ _dialogVisible.value = true
+ }
+
+ fun closeDialog() {
+ _dialogVisible.value = false
+ }
+
+ fun isUpdateSupported(): Boolean = config.fakeState != null || updater.isUpdateSupported()
+
+ private fun initialFakeState(): UpdateUiState? {
+ val fake = config.fakeState ?: return null
+ val version = config.forceVersion ?: "9.9.9"
+ return when (fake) {
+ "patch" ->
+ UpdateUiState.Available(version, UpdateLevel.PATCH, resolveUpdateMode(UpdateLevel.PATCH, os), false)
+ "minor" ->
+ UpdateUiState.Available(version, UpdateLevel.MINOR, UpdateMode.PROMPT, true)
+ "major" ->
+ UpdateUiState.Available(version, UpdateLevel.MAJOR, UpdateMode.PROMPT, true)
+ "downloading" ->
+ UpdateUiState.Downloading(version, UpdateLevel.MINOR, UpdateMode.PROMPT, true, 42)
+ "ready" ->
+ UpdateUiState.ReadyToInstall(version, UpdateLevel.MINOR, UpdateMode.PROMPT, true, File("fake-installer"))
+ else -> null
+ }
+ }
+
+ companion object {
+ const val DOWNLOAD_URL = "https://kdroidfilter.github.io/Zayit/download"
+
+ private const val GITHUB_OWNER = "kdroidFilter"
+ private const val GITHUB_REPO = "Zayit"
+
+ /** Builds the production service wired to GitHub releases through the native SSL client. */
+ fun create(
+ config: AppUpdateConfig = AppUpdateConfig.fromEnv(),
+ os: Platform = Platform.Current,
+ ): AppUpdateService =
+ AppUpdateService(
+ updaterProvider = {
+ val updater =
+ NucleusUpdater {
+ provider =
+ config.feedUrl
+ ?.let { GenericProvider(it) }
+ ?: GitHubProvider(owner = GITHUB_OWNER, repo = GITHUB_REPO)
+ httpClient = NativeHttpClient.create()
+ channel = "latest"
+ config.forceVersion?.let { currentVersion = it }
+ config.executableType?.let { executableType = it }
+ }
+ NucleusUpdaterAdapter(updater, dryRun = config.dryRun)
+ },
+ config = config,
+ os = os,
+ )
+ }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/DbDeltaRecoveryBootstrap.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/DbDeltaRecoveryBootstrap.kt
index e7b4bd2fd..cc5cc0d1a 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/DbDeltaRecoveryBootstrap.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/DbDeltaRecoveryBootstrap.kt
@@ -3,10 +3,10 @@ package io.github.kdroidfilter.seforimapp.framework.update
import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
import io.github.kdroidfilter.seforimapp.logger.infoln
import io.github.kdroidfilter.seforimapp.logger.warnln
+import io.github.kdroidfilter.seforimlibrary.deltaupdater.DeltaApplierClient
import io.github.vinceglb.filekit.FileKit
import io.github.vinceglb.filekit.databasesDir
import io.github.vinceglb.filekit.path
-import io.github.kdroidfilter.seforimlibrary.deltaupdater.DeltaApplierClient
import java.io.File
import java.nio.file.Path
@@ -25,7 +25,6 @@ import java.nio.file.Path
* Call this exactly once, from `main()`, before any DB consumer runs.
*/
object DbDeltaRecoveryBootstrap {
-
/** Returns `true` if a half-applied delta was rolled back. */
fun runOnce(): Boolean {
val dbPath = resolveDbPathOrNull() ?: return false
@@ -52,8 +51,10 @@ object DbDeltaRecoveryBootstrap {
private fun resolveDbPathOrNull(): String? {
val env = System.getenv("SEFORIMAPP_DATABASE_PATH")?.takeIf { it.isNotBlank() }
if (env != null) return env
- val settings = runCatching { AppSettings.getDatabasePath() }.getOrNull()
- ?.takeIf { it.isNotBlank() && !it.endsWith("lexical.db", ignoreCase = true) }
+ val settings =
+ runCatching { AppSettings.getDatabasePath() }
+ .getOrNull()
+ ?.takeIf { it.isNotBlank() && !it.endsWith("lexical.db", ignoreCase = true) }
if (settings != null) return settings
return runCatching { File(FileKit.databasesDir.path, "seforim.db").absolutePath }
.getOrNull()
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/DbDeltaUpdateService.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/DbDeltaUpdateService.kt
index 0655e1245..7d345d57e 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/DbDeltaUpdateService.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/framework/update/DbDeltaUpdateService.kt
@@ -39,7 +39,6 @@ open class DbDeltaUpdateService(
private val luceneSinksProvider: () -> LuceneUpdater.SinkSession =
defaultLuceneSinksProvider(luceneIndexDir, seforimDb),
) {
-
private val log = LoggerFactory.getLogger(DbDeltaUpdateService::class.java)
private val client by lazy {
@@ -70,10 +69,8 @@ open class DbDeltaUpdateService(
* Polls the release server and applies any available chain. Reports
* progress via [onProgress] as `current/total: status`.
*/
- open suspend fun checkAndApply(
- onProgress: (current: Int, total: Int, status: String) -> Unit = { _, _, _ -> },
- ): Outcome {
- return when (val path = client.checkForUpdate()) {
+ open suspend fun checkAndApply(onProgress: (current: Int, total: Int, status: String) -> Unit = { _, _, _ -> }): Outcome =
+ when (val path = client.checkForUpdate()) {
UpdatePath.UpToDate -> Outcome.UpToDate
is UpdatePath.FullBundle -> Outcome.NeedsFullBundle
is UpdatePath.Chain -> {
@@ -81,11 +78,14 @@ open class DbDeltaUpdateService(
Outcome.Applied(path.deltas.size)
}
}
- }
sealed interface Outcome {
data object UpToDate : Outcome
- data class Applied(val deltaCount: Int) : Outcome
+
+ data class Applied(
+ val deltaCount: Int,
+ ) : Outcome
+
data object NeedsFullBundle : Outcome
}
@@ -118,80 +118,88 @@ open class DbDeltaUpdateService(
fun defaultLuceneSinksProvider(
luceneIndexDir: Path?,
seforimDb: Path?,
- ): () -> LuceneUpdater.SinkSession = {
- if (luceneIndexDir == null) {
- LuceneUpdater.SinkSession(
- delete = LuceneUpdater.DeleteSink { },
- upsert = LuceneUpdater.UpsertSink { },
- )
- } else {
- val dir = FSDirectory.open(luceneIndexDir)
- val writer = IndexWriter(dir, IndexWriterConfig(StandardAnalyzer()))
- val bookMetaCache = HashMap()
- val dbConn = seforimDb?.let {
- java.sql.DriverManager.getConnection("jdbc:sqlite:${it.toAbsolutePath()}")
- }
+ ): () -> LuceneUpdater.SinkSession =
+ {
+ if (luceneIndexDir == null) {
+ LuceneUpdater.SinkSession(
+ delete = LuceneUpdater.DeleteSink { },
+ upsert = LuceneUpdater.UpsertSink { },
+ )
+ } else {
+ val dir = FSDirectory.open(luceneIndexDir)
+ val writer = IndexWriter(dir, IndexWriterConfig(StandardAnalyzer()))
+ val bookMetaCache = HashMap()
+ val dbConn =
+ seforimDb?.let {
+ java.sql.DriverManager.getConnection("jdbc:sqlite:${it.toAbsolutePath()}")
+ }
- fun lookupBookMeta(bookId: Long): BookMeta {
- bookMetaCache[bookId]?.let { return it }
- if (dbConn == null) return BookMeta.EMPTY.also { bookMetaCache[bookId] = it }
- return runCatching {
- dbConn.prepareStatement(
- "SELECT title, categoryId, orderIndex, isBaseBook FROM book WHERE id = ?"
- ).use { ps ->
- ps.setLong(1, bookId)
- ps.executeQuery().use { rs ->
- if (rs.next()) {
- BookMeta(
- title = rs.getString(1) ?: "",
- categoryId = rs.getLong(2),
- orderIndex = rs.getLong(3),
- isBaseBook = rs.getInt(4),
- )
- } else BookMeta.EMPTY
+ fun lookupBookMeta(bookId: Long): BookMeta {
+ bookMetaCache[bookId]?.let { return it }
+ if (dbConn == null) return BookMeta.EMPTY.also { bookMetaCache[bookId] = it }
+ return runCatching {
+ dbConn
+ .prepareStatement(
+ "SELECT title, categoryId, orderIndex, isBaseBook FROM book WHERE id = ?",
+ ).use { ps ->
+ ps.setLong(1, bookId)
+ ps.executeQuery().use { rs ->
+ if (rs.next()) {
+ BookMeta(
+ title = rs.getString(1) ?: "",
+ categoryId = rs.getLong(2),
+ orderIndex = rs.getLong(3),
+ isBaseBook = rs.getInt(4),
+ )
+ } else {
+ BookMeta.EMPTY
+ }
+ }
+ }
+ }.getOrDefault(BookMeta.EMPTY).also { bookMetaCache[bookId] = it }
+ }
+
+ LuceneUpdater.SinkSession(
+ delete =
+ LuceneUpdater.DeleteSink { id ->
+ writer.deleteDocuments(IntPoint.newExactQuery(FIELD_LINE_ID, id.toInt()))
+ },
+ upsert =
+ LuceneUpdater.UpsertSink { line ->
+ val meta = lookupBookMeta(line.bookId)
+ writer.deleteDocuments(IntPoint.newExactQuery(FIELD_LINE_ID, line.id.toInt()))
+ val doc =
+ Document().apply {
+ add(Field(FIELD_TYPE, TYPE_LINE, org.apache.lucene.document.StringField.TYPE_STORED))
+ add(IntPoint(FIELD_BOOK_ID, line.bookId.toInt()))
+ add(StoredField(FIELD_BOOK_ID, line.bookId))
+ add(IntPoint(FIELD_CATEGORY_ID, meta.categoryId.toInt()))
+ add(StoredField(FIELD_CATEGORY_ID, meta.categoryId))
+ add(IntPoint(FIELD_LINE_ID, line.id.toInt()))
+ add(StoredField(FIELD_LINE_ID, line.id))
+ add(StoredField(FIELD_LINE_INDEX, line.lineIndex.toLong()))
+ add(TextField(FIELD_TEXT, line.content, Field.Store.NO))
+ add(StoredField(FIELD_BOOK_TITLE, meta.title))
+ add(StoredField(FIELD_ORDER_INDEX, meta.orderIndex))
+ add(StoredField(FIELD_IS_BASE_BOOK, meta.isBaseBook.toLong()))
+ }
+ writer.addDocument(doc)
+ },
+ // Commit + close in lock-step: this is what guarantees
+ // the delta is actually persisted to the index. Skipping
+ // either of these silently drops every upsert.
+ onClose = {
+ try {
+ writer.commit()
+ } finally {
+ runCatching { writer.close() }
+ runCatching { dir.close() }
+ runCatching { dbConn?.close() }
}
- }
- }.getOrDefault(BookMeta.EMPTY).also { bookMetaCache[bookId] = it }
+ },
+ )
}
-
- LuceneUpdater.SinkSession(
- delete = LuceneUpdater.DeleteSink { id ->
- writer.deleteDocuments(IntPoint.newExactQuery(FIELD_LINE_ID, id.toInt()))
- },
- upsert = LuceneUpdater.UpsertSink { line ->
- val meta = lookupBookMeta(line.bookId)
- writer.deleteDocuments(IntPoint.newExactQuery(FIELD_LINE_ID, line.id.toInt()))
- val doc = Document().apply {
- add(Field(FIELD_TYPE, TYPE_LINE, org.apache.lucene.document.StringField.TYPE_STORED))
- add(IntPoint(FIELD_BOOK_ID, line.bookId.toInt()))
- add(StoredField(FIELD_BOOK_ID, line.bookId))
- add(IntPoint(FIELD_CATEGORY_ID, meta.categoryId.toInt()))
- add(StoredField(FIELD_CATEGORY_ID, meta.categoryId))
- add(IntPoint(FIELD_LINE_ID, line.id.toInt()))
- add(StoredField(FIELD_LINE_ID, line.id))
- add(StoredField(FIELD_LINE_INDEX, line.lineIndex.toLong()))
- add(TextField(FIELD_TEXT, line.content, Field.Store.NO))
- add(StoredField(FIELD_BOOK_TITLE, meta.title))
- add(StoredField(FIELD_ORDER_INDEX, meta.orderIndex))
- add(StoredField(FIELD_IS_BASE_BOOK, meta.isBaseBook.toLong()))
- }
- writer.addDocument(doc)
- },
- // Commit + close in lock-step: this is what guarantees
- // the delta is actually persisted to the index. Skipping
- // either of these silently drops every upsert.
- onClose = {
- try {
- writer.commit()
- } finally {
- runCatching { writer.close() }
- runCatching { dir.close() }
- runCatching { dbConn?.close() }
- }
- },
- )
}
- }
private data class BookMeta(
val title: String,
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/main.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/main.kt
index 42dd1b11a..68c8b658a 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/main.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/main.kt
@@ -10,29 +10,27 @@ import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.input.key.*
import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.unit.DpSize
import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.WindowPlacement
import androidx.compose.ui.window.WindowPosition
-import androidx.compose.ui.window.application
import androidx.compose.ui.window.rememberWindowState
import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
import com.kdroid.gematria.converter.toHebrewNumeral
+import dev.nucleusframework.application.aotTraining
+import dev.nucleusframework.application.nucleusApplication
+import dev.nucleusframework.core.runtime.NucleusApp
+import dev.nucleusframework.energymanager.EnergyManager
+import dev.nucleusframework.window.jewel.JewelDecoratedWindow
import dev.zacsweers.metro.createGraph
import dev.zacsweers.metrox.viewmodel.LocalMetroViewModelFactory
import dev.zacsweers.metrox.viewmodel.metroViewModel
-import io.github.kdroidfilter.nucleus.aot.runtime.AotRuntime
-import io.github.kdroidfilter.nucleus.core.runtime.ExecutableRuntime
-import io.github.kdroidfilter.nucleus.core.runtime.SingleInstanceManager
-import io.github.kdroidfilter.nucleus.energymanager.EnergyManager
-import io.github.kdroidfilter.nucleus.graalvm.GraalVmInitializer
-import io.github.kdroidfilter.nucleus.launcher.windows.WindowsJumpListManager
-import io.github.kdroidfilter.nucleus.notification.common.notification
-import io.github.kdroidfilter.nucleus.window.jewel.JewelDecoratedWindow
-import io.github.kdroidfilter.platformtools.getAppVersion
import io.github.kdroidfilter.seforim.tabs.TabType
import io.github.kdroidfilter.seforim.tabs.TabsDestination
import io.github.kdroidfilter.seforim.tabs.TabsEvents
import io.github.kdroidfilter.seforimapp.core.buildCopyWithSourcePayload
+import io.github.kdroidfilter.seforimapp.core.deeplink.ContentDeepLinkHandler
import io.github.kdroidfilter.seforimapp.core.presentation.components.AppDockMenu
import io.github.kdroidfilter.seforimapp.core.presentation.components.AppJumpList
import io.github.kdroidfilter.seforimapp.core.presentation.components.AppLinuxQuicklist
@@ -40,21 +38,24 @@ import io.github.kdroidfilter.seforimapp.core.presentation.components.AppNativeM
import io.github.kdroidfilter.seforimapp.core.presentation.components.MainTitleBar
import io.github.kdroidfilter.seforimapp.core.presentation.tabs.TabsContent
import io.github.kdroidfilter.seforimapp.core.presentation.theme.ThemeUtils
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalIsTouchMode
import io.github.kdroidfilter.seforimapp.core.presentation.utils.LocalWindowViewModelStoreOwner
+import io.github.kdroidfilter.seforimapp.core.presentation.utils.detectTouchMode
import io.github.kdroidfilter.seforimapp.core.presentation.utils.processKeyShortcuts
import io.github.kdroidfilter.seforimapp.core.presentation.utils.rememberWindowViewModelStoreOwner
import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
import io.github.kdroidfilter.seforimapp.features.database.update.DatabaseUpdateWindow
import io.github.kdroidfilter.seforimapp.features.onboarding.OnBoardingWindow
+import io.github.kdroidfilter.seforimapp.features.settings.SettingsWindow
import io.github.kdroidfilter.seforimapp.features.settings.SettingsWindowEvents
import io.github.kdroidfilter.seforimapp.features.settings.SettingsWindowViewModel
+import io.github.kdroidfilter.seforimapp.features.update.UpdateDialog
import io.github.kdroidfilter.seforimapp.framework.database.DatabaseVersionManager
import io.github.kdroidfilter.seforimapp.framework.database.getDatabasePath
import io.github.kdroidfilter.seforimapp.framework.di.AppGraph
import io.github.kdroidfilter.seforimapp.framework.di.LocalAppGraph
import io.github.kdroidfilter.seforimapp.framework.platform.PlatformInfo
import io.github.kdroidfilter.seforimapp.framework.session.SessionManager
-import io.github.kdroidfilter.seforimapp.framework.update.AppUpdateChecker
import io.github.kdroidfilter.seforimapp.logger.infoln
import io.github.kdroidfilter.seforimapp.logger.isDevEnv
import io.github.kdroidfilter.seforimlibrary.core.text.HebrewTextUtils
@@ -68,11 +69,11 @@ import seforimapp.seforimapp.generated.resources.*
import java.awt.*
import java.awt.datatransfer.StringSelection
import java.awt.event.KeyEvent
-import java.net.URI
import java.util.*
+import kotlin.time.Duration.Companion.seconds
@OptIn(ExperimentalFoundationApi::class)
-private const val AOT_TRAINING_DURATION_MS = 45_000L
+private val AOT_TRAINING_DURATION = 45.seconds
private data class StartupState(
val showOnboarding: Boolean,
@@ -118,14 +119,13 @@ private fun initializeSentry() {
Sentry.init { options ->
options.dsn = "https://09cbadaf522c567b431dd4384c8f080b@o4510855773093888.ingest.de.sentry.io/4510857007726672"
options.environment = sentryEnvironment
- options.release = getAppVersion()
+ options.release = NucleusApp.version
options.isDebug = isDevEnv
}
infoln { "Sentry initialized for environment '$sentryEnvironment'." }
}
fun main(args: Array) {
- GraalVmInitializer.initialize()
Locale.setDefault(Locale.Builder().setLanguage("he").build())
val loggingEnv = System.getenv("SEFORIMAPP_LOGGING")?.lowercase()
@@ -136,17 +136,7 @@ fun main(args: Array) {
// Roll back any half-applied seforim.db delta update from a previous
// launch BEFORE the SQLDelight repository opens the DB. Cheap stat()
// when nothing is in flight; never throws (failures are logged).
- io.github.kdroidfilter.seforimapp.framework.update.DbDeltaRecoveryBootstrap.runOnce()
-
- if (AotRuntime.isTraining()) {
- Thread({
- Thread.sleep(AOT_TRAINING_DURATION_MS)
- kotlin.system.exitProcess(0)
- }, "aot-timer").apply {
- isDaemon = false
- start()
- }
- }
+// DbDeltaRecoveryBootstrap.runOnce()
// Force OpenGL rendering backend on Windows if enabled (must be set before Skia initialization)
if (PlatformInfo.isWindows && AppSettings.isUseOpenGlEnabled()) {
@@ -155,17 +145,9 @@ fun main(args: Array) {
val appId = "io.github.kdroidfilter.seforimapp"
- // Must be set before any window creation for jump lists to work on unpackaged Windows apps
- if (PlatformInfo.isWindows) {
- WindowsJumpListManager.setProcessAppId(appId)
- }
-
- SingleInstanceManager.configuration =
- SingleInstanceManager.Configuration(
- lockIdentifier = appId,
- )
+ nucleusApplication(args) {
+ aotTraining(duration = AOT_TRAINING_DURATION)
- application {
FileKit.init(appId)
val windowState =
@@ -174,27 +156,12 @@ fun main(args: Array) {
placement = WindowPlacement.Maximized,
)
- var isWindowVisible by remember { mutableStateOf(true) }
+ val isWindowVisible by remember { mutableStateOf(true) }
val pendingDeepLink = remember { MutableStateFlow(null) }
- val isSingleInstance =
- SingleInstanceManager.isSingleInstance(
- onRestoreFileCreated =
- args.firstOrNull { it.startsWith("seforim://") }?.let { deepLink ->
- { toFile().writeText(deepLink) }
- },
- onRestoreRequest = {
- isWindowVisible = true
- windowState.isMinimized = false
- Window.getWindows().first().toFront()
- val content = toFile().readText().trim()
- if (content.isNotEmpty()) pendingDeepLink.value = content
- },
- )
- if (!isSingleInstance) {
- exitApplication()
- return@application
- }
+ // Pick up the deep link CLI arg (cold-start) and any URI relayed by a second instance
+ // through the automatic single-instance bridge.
+ onDeepLink { uri -> pendingDeepLink.value = uri.toString() }
// Create the application graph via Metro and expose via CompositionLocal
val appGraph = remember { createGraph() }
@@ -292,6 +259,7 @@ fun main(args: Array) {
CompositionLocalProvider(
LocalAppGraph provides appGraph,
LocalMetroViewModelFactory provides appGraph.metroViewModelFactory,
+ LocalLayoutDirection provides LayoutDirection.Rtl,
) {
val themeDefinition = ThemeUtils.buildThemeDefinition()
val componentStyling = ThemeUtils.buildComponentStyling()
@@ -323,6 +291,7 @@ fun main(args: Array) {
settingsWindowViewModel = settingsWindowViewModel,
onQuit = {
SessionManager.saveIfEnabled(appGraph)
+ appGraph.appUpdateService.installPendingOnClose()
exitApplication()
},
)
@@ -343,6 +312,14 @@ fun main(args: Array) {
onClearDeepLink = { pendingDeepLink.value = null },
)
+ // Resolve shareable zayit:// content deep links (cross-platform)
+ ContentDeepLinkHandler(
+ tabsViewModel = appGraph.tabsViewModel,
+ repository = appGraph.repository,
+ pendingDeepLink = pendingDeepLink,
+ onClearDeepLink = { pendingDeepLink.value = null },
+ )
+
// Linux taskbar quicklist with tabs and desktops
AppLinuxQuicklist(
desktopManager = appGraph.desktopManager,
@@ -388,14 +365,18 @@ fun main(args: Array) {
JewelDecoratedWindow(
onCloseRequest = {
- // Persist session if enabled, then exit
+ // Persist session if enabled, apply any pending silent update, then exit.
+ // installPendingOnClose() launches the installer and exits the process
+ // itself when a silent (Win/Mac PATCH) update is ready.
SessionManager.saveIfEnabled(appGraph)
+ appGraph.appUpdateService.installPendingOnClose()
exitApplication()
},
title = windowTitle,
icon = if (PlatformInfo.isMacOS) null else painterResource(Res.drawable.AppIcon),
state = windowState,
visible = isWindowVisible,
+ minimumSize = DpSize(600.dp, 300.dp),
onKeyEvent = { keyEvent ->
if (keyEvent.type == KeyEventType.KeyDown) {
// Read fresh state to avoid stale captures in cached lambda
@@ -454,12 +435,27 @@ fun main(args: Array) {
},
) {
CompositionLocalProvider(
- LocalLayoutDirection provides LayoutDirection.Rtl,
LocalWindowViewModelStoreOwner provides windowViewModelOwner,
LocalViewModelStoreOwner provides windowViewModelOwner,
) {
- LaunchedEffect(Unit) {
- window.minimumSize = Dimension(600, 300)
+ // Settings dialog rendered here so it inherits LocalLayoutDirection Rtl
+ // and the full CompositionLocalContext — including theme and user locals —
+ // is bridged into the dialog's Tao ComposeScene.
+ val settingsWindowState by settingsWindowViewModel.state.collectAsState()
+ if (settingsWindowState.isVisible) {
+ SettingsWindow(
+ onClose = { settingsWindowViewModel.onEvent(SettingsWindowEvents.OnClose) },
+ initialDestination = settingsWindowState.initialDestination,
+ )
+ }
+ // App update dialog, hoisted here so it inherits the full
+ // CompositionLocalContext (theme, Rtl) like SettingsWindow.
+ val updateDialogVisible by appGraph.appUpdateService.dialogVisible.collectAsState()
+ if (updateDialogVisible) {
+ UpdateDialog(
+ service = appGraph.appUpdateService,
+ onClose = { appGraph.appUpdateService.closeDialog() },
+ )
}
MainTitleBar()
LaunchedEffect(state.isMinimized) {
@@ -470,6 +466,21 @@ fun main(args: Array) {
}
}
+ // Keep the screen awake while a book is open in the current tab and the
+ // window is focused — opt-out via the General settings (enabled by default).
+ val keepAwakeEnabled by AppSettings.keepScreenAwakeOnBookFlow.collectAsState()
+ val shouldKeepScreenAwake =
+ keepAwakeEnabled &&
+ state.isActive &&
+ selectedTab?.destination is TabsDestination.BookContent
+ LaunchedEffect(shouldKeepScreenAwake) {
+ if (shouldKeepScreenAwake) {
+ EnergyManager.keepScreenAwake()
+ } else {
+ EnergyManager.releaseScreenAwake()
+ }
+ }
+
// Restore previously saved session once when main window becomes active
var sessionRestored by remember { mutableStateOf(false) }
LaunchedEffect(Unit) {
@@ -478,49 +489,23 @@ fun main(args: Array) {
sessionRestored = true
}
}
- // Check for updates once at startup
- val updateNotificationTitle = stringResource(Res.string.update_available_toast)
- val updateNotificationMessage = stringResource(Res.string.update_notification_message)
- val updateNotificationButton = stringResource(Res.string.update_download_action)
+ // Check for updates once at startup. PATCH updates are pre-downloaded
+ // here; MINOR/MAJOR surface the title-bar icon + UpdateDialog.
LaunchedEffect(Unit) {
- if (!mainAppState.updateCheckDone.value) {
- when (val result = AppUpdateChecker.checkForUpdate()) {
- is AppUpdateChecker.UpdateCheckResult.UpdateAvailable -> {
- if (true) return@LaunchedEffect
- mainAppState.setUpdateAvailable(result.latestVersion)
-
- if (!ExecutableRuntime.isDev()) {
- // Send system notification
- notification(
- title = updateNotificationTitle,
- message = updateNotificationMessage,
- onActivated = {
- Desktop.getDesktop().browse(URI(AppUpdateChecker.DOWNLOAD_URL))
- },
- ) {
- button(updateNotificationButton) {
- Desktop.getDesktop().browse(URI(AppUpdateChecker.DOWNLOAD_URL))
- }
- }.send()
- }
- }
-
- is AppUpdateChecker.UpdateCheckResult.UpToDate -> {
- mainAppState.markUpdateCheckDone()
- }
-
- is AppUpdateChecker.UpdateCheckResult.Error -> {
- mainAppState.markUpdateCheckDone()
- }
- }
- }
+ appGraph.appUpdateService.checkOnStartup()
}
+ // Track whether the user is interacting by touch so hover-gated
+ // controls (e.g. pane close buttons) stay reachable; published
+ // app-wide via LocalIsTouchMode.
+ var isTouchMode by remember { mutableStateOf(false) }
+
// Intercept key combos early to avoid focus traversal consuming Tab
Box(
modifier =
Modifier
.fillMaxSize()
+ .detectTouchMode { isTouchMode = it }
.onPreviewKeyEvent { keyEvent ->
if (keyEvent.type == KeyEventType.KeyDown) {
val isCtrlOrCmd = keyEvent.isCtrlPressed || keyEvent.isMetaPressed
@@ -610,7 +595,11 @@ fun main(args: Array) {
false
}
},
- ) { TabsContent() }
+ ) {
+ CompositionLocalProvider(LocalIsTouchMode provides isTouchMode) {
+ TabsContent()
+ }
+ }
}
}
}
diff --git a/SeforimApp/src/jvmMain/resources/icons/system_theme.svg b/SeforimApp/src/jvmMain/resources/icons/system_theme.svg
new file mode 100644
index 000000000..64913c172
--- /dev/null
+++ b/SeforimApp/src/jvmMain/resources/icons/system_theme.svg
@@ -0,0 +1,6 @@
+
+
diff --git a/SeforimApp/src/jvmMain/resources/icons/system_theme_dark.svg b/SeforimApp/src/jvmMain/resources/icons/system_theme_dark.svg
new file mode 100644
index 000000000..e319b4086
--- /dev/null
+++ b/SeforimApp/src/jvmMain/resources/icons/system_theme_dark.svg
@@ -0,0 +1,6 @@
+
+
diff --git a/SeforimApp/src/jvmTest/kotlin/io/github/kdroidfilter/seforimapp/catalog/CatalogPresetsTest.kt b/SeforimApp/src/jvmTest/kotlin/io/github/kdroidfilter/seforimapp/catalog/CatalogPresetsTest.kt
new file mode 100644
index 000000000..37d351ce4
--- /dev/null
+++ b/SeforimApp/src/jvmTest/kotlin/io/github/kdroidfilter/seforimapp/catalog/CatalogPresetsTest.kt
@@ -0,0 +1,155 @@
+package io.github.kdroidfilter.seforimapp.catalog
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+
+class CatalogPresetsTest {
+ // BookRef
+ @Test
+ fun `BookRef stores id and title`() {
+ val bookRef = BookRef(1L, "בראשית")
+ assertEquals(1L, bookRef.id)
+ assertEquals("בראשית", bookRef.title)
+ }
+
+ @Test
+ fun `BookRef equality and copy`() {
+ val original = BookRef(1L, "בראשית")
+ assertEquals(BookRef(1L, "בראשית"), original)
+ assertEquals(BookRef(1L, "שמות"), original.copy(title = "שמות"))
+ }
+
+ // TocQuickLink
+ @Test
+ fun `TocQuickLink stores all fields`() {
+ val link = TocQuickLink("אורח חיים", 30_149L, 252_607L)
+ assertEquals("אורח חיים", link.label)
+ assertEquals(30_149L, link.tocEntryId)
+ assertEquals(252_607L, link.firstLineId)
+ }
+
+ @Test
+ fun `TocQuickLink allows null firstLineId`() {
+ val link = TocQuickLink("Label", 100L, null)
+ assertEquals(null, link.firstLineId)
+ }
+
+ // DropdownSpec sealed hierarchy
+ @Test
+ fun `CategoryDropdownSpec implements DropdownSpec`() {
+ val spec: DropdownSpec = CategoryDropdownSpec(62L)
+ assertIs(spec)
+ assertEquals(62L, spec.categoryId)
+ }
+
+ @Test
+ fun `MultiCategoryDropdownSpec implements DropdownSpec`() {
+ val spec: DropdownSpec = MultiCategoryDropdownSpec(1L, listOf(2L, 3L, 4L))
+ assertIs(spec)
+ assertEquals(1L, spec.labelCategoryId)
+ assertEquals(listOf(2L, 3L, 4L), spec.bookCategoryIds)
+ }
+
+ @Test
+ fun `TocQuickLinksSpec embeds links inline`() {
+ val link = TocQuickLink("אורח חיים", 30_149L, 252_607L)
+ val spec: DropdownSpec = TocQuickLinksSpec(380L, listOf(link))
+ assertIs(spec)
+ assertEquals(380L, spec.bookId)
+ assertEquals(listOf(link), spec.links)
+ }
+
+ // Ids — sanity check on the codegen output. Asserts presence + non-collision,
+ // not exact values (those track upstream catalog evolution).
+ @Test
+ fun `Ids Categories core constants are set`() {
+ assertTrue(CatalogPresets.Ids.Categories.TANAKH > 0L)
+ assertTrue(CatalogPresets.Ids.Categories.TORAH > 0L)
+ assertTrue(CatalogPresets.Ids.Categories.MISHNA > 0L)
+ assertTrue(CatalogPresets.Ids.Categories.BAVLI > 0L)
+ assertTrue(CatalogPresets.Ids.Categories.YERUSHALMI > 0L)
+ assertTrue(CatalogPresets.Ids.Categories.MISHNE_TORAH > 0L)
+ assertTrue(CatalogPresets.Ids.Categories.SHULCHAN_ARUCH > 0L)
+ assertTrue(CatalogPresets.Ids.Categories.TUR > 0L)
+ // Talmud roots distinct from their parents
+ assertTrue(CatalogPresets.Ids.Categories.BAVLI != CatalogPresets.Ids.Categories.YERUSHALMI)
+ }
+
+ @Test
+ fun `Ids Books TUR is set`() {
+ assertTrue(CatalogPresets.Ids.Books.TUR > 0L)
+ }
+
+ @Test
+ fun `Ids TocTexts has all four Tur sections`() {
+ val ids =
+ setOf(
+ CatalogPresets.Ids.TocTexts.ORACH_CHAIM,
+ CatalogPresets.Ids.TocTexts.YOREH_DEAH,
+ CatalogPresets.Ids.TocTexts.EVEN_HAEZER,
+ CatalogPresets.Ids.TocTexts.CHOSHEN_MISHPAT,
+ )
+ assertEquals(4, ids.size, "TOC text IDs must be distinct")
+ assertTrue(ids.all { it > 0L })
+ }
+
+ // Dropdowns
+ @Test
+ fun `Dropdowns HOME contains all main sections`() {
+ assertEquals(6, CatalogPresets.Dropdowns.HOME.size)
+ }
+
+ @Test
+ fun `Dropdowns TANAKH is MultiCategoryDropdownSpec with three orders`() {
+ val tanakh = CatalogPresets.Dropdowns.TANAKH
+ assertIs(tanakh)
+ assertEquals(CatalogPresets.Ids.Categories.TANAKH, tanakh.labelCategoryId)
+ assertEquals(
+ listOf(
+ CatalogPresets.Ids.Categories.TORAH,
+ CatalogPresets.Ids.Categories.NEVIIM,
+ CatalogPresets.Ids.Categories.KETUVIM,
+ ),
+ tanakh.bookCategoryIds,
+ )
+ }
+
+ @Test
+ fun `Dropdowns individual category specs are CategoryDropdownSpec`() {
+ assertIs(CatalogPresets.Dropdowns.TORAH)
+ assertIs(CatalogPresets.Dropdowns.NEVIIM)
+ assertIs(CatalogPresets.Dropdowns.KETUVIM)
+ assertIs(CatalogPresets.Dropdowns.SHULCHAN_ARUCH)
+ }
+
+ @Test
+ fun `Dropdowns TUR_QUICK_LINKS embeds four links`() {
+ val turLinks = CatalogPresets.Dropdowns.TUR_QUICK_LINKS
+ assertIs