Add Desktop template update action

Author: rosuH

desktopApp/src/main/kotlin/me/rosuh/easywatermark/desktop/DesktopWindow.kt

@@ -37,6 +37,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import kotlin.time.Clock
 import me.rosuh.easywatermark.data.db.buildTemplateDatabase
 import me.rosuh.easywatermark.data.db.unpackDefaultTemplateSeed
 import me.rosuh.easywatermark.data.model.ImageFormat
@@ -179,7 +180,8 @@ private fun resolveDesktopOutputDir(): File {
  * onto the window loads it through the same Open-image save spine (`Modifier.dragAndDropTarget` + the AWT
  * file-list flavor; updates `lastImage` + `lastSavedFile`; unsupported/empty/while-busy drops fail softly).
  * S4d-160: a minimal "Templates" section over the shared Desktop Room path saves the current watermark
- * text, lists saved templates, and applies (Use → `WatermarkConfigEditor.updateText`) or deletes them.
+ * text, lists saved templates, and applies (Use → `WatermarkConfigEditor.updateText`), updates in place
+ * (Update → `TemplateEditor.update`), or deletes them.
  * S4d-198: REACTIVE preview — every successful explicit editor action (Apply text/degree/color/opacity/
  * gaps/text-size, the tile/typeface/style buttons, "Use text watermark", and template "Use") now
  * auto-refreshes the on-screen preview through the SAME `refreshPreview()` → `runSaveFlow` temp-file spine
@@ -1059,10 +1061,12 @@ fun launchDesktopWindow() = application {
                         },
                     ) { Text("Copy output path") }
                 }
-                // S4d-160: minimal Templates section over the shared Desktop Room template path. "Save current
-                // text" stores the edited watermark text (templateEditor.add); each saved row applies it (Use →
-                // WatermarkConfigEditor.updateText + sync the text field) or deletes it. S4d-198: Use auto-refreshes
-                // the preview after a successful apply. `content` is the watermark TEXT (S4d-159).
+                // S4d-160/S4d-226: minimal Templates section over the shared Desktop Room template path. "Save
+                // current text" stores the edited watermark text (templateEditor.add); each saved row applies it
+                // (Use → WatermarkConfigEditor.updateText + sync the text field), updates in place from the
+                // current watermark text (Update → TemplateEditor.update, preserving id/creationDate), or deletes
+                // it. S4d-198: Use auto-refreshes the preview after a successful apply. `content` is the watermark
+                // TEXT (S4d-159).
                 Text("Templates", style = MaterialTheme.typography.subtitle1)
                 Button(
                     // S4d-162: require nonblank text so an empty template can't be saved.
@@ -1121,6 +1125,31 @@ fun launchDesktopWindow() = application {
                                     }
                                 },
                             ) { Text("Use") }
+                            Button(
+                                // S4d-226: update the existing row from the current watermark text.
+                                enabled = !busy && watermarkText.isNotBlank(),
+                                onClick = {
+                                    val text = watermarkText
+                                    scope.launch {
+                                        busy = true
+                                        val next = withContext(Dispatchers.IO) {
+                                            try {
+                                                templateEditor.update(
+                                                    template.copy(
+                                                        content = text,
+                                                        lastModifiedDate = Clock.System.now(),
+                                                    )
+                                                )
+                                                "Updated template to: \"$text\""
+                                            } catch (t: Throwable) {
+                                                "Failed: ${t.message}"
+                                            }
+                                        }
+                                        status = next
+                                        busy = false
+                                    }
+                                },
+                            ) { Text("Update") }
                             Button(
                                 enabled = !busy,
                                 onClick = {

shared/src/desktopTest/kotlin/me/rosuh/easywatermark/data/db/TemplateRoundtripTest.kt

@@ -12,6 +12,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
+import kotlin.time.Clock
 
 /**
  * S4d-142: Desktop (JVM) templates roundtrip over the commonMain Room path, built by the new desktopMain
@@ -51,4 +52,23 @@ class TemplateRoundtripTest {
         editor.delete(afterAdd[0])
         assertTrue(repo.getAllTemplate().first().isEmpty(), "store is empty again after delete")
     }
+
+    @Test
+    fun update_preserves_id_and_creation_date() = runBlocking {
+        editor.add("original content")
+        val afterAdd = repo.getAllTemplate().first()
+        assertEquals(1, afterAdd.size, "exactly one template after add")
+
+        val original = afterAdd[0]
+        val originalId = original.id
+        val originalCreationDate = original.creationDate
+        assertTrue(originalId != 0, "autoGenerate assigned a row id")
+
+        editor.update(original.copy(content = "updated content", lastModifiedDate = Clock.System.now()))
+        val afterUpdate = repo.getAllTemplate().first()
+        assertEquals(1, afterUpdate.size, "still exactly one template after update")
+        assertEquals(originalId, afterUpdate[0].id, "update preserves the row id")
+        assertEquals("updated content", afterUpdate[0].content, "update changes the content")
+        assertEquals(originalCreationDate, afterUpdate[0].creationDate, "update preserves the creation date")
+    }
 }