Settle on "Story" for the named when presenting a storyboard

bnorm · bnorm · commit a38af96b5ef8 · 2025-03-29T07:58:18.000-05:00
diff --git a/examples/basic/src/jvmMain/kotlin/main.desktop.kt b/examples/basic/src/jvmMain/kotlin/main.desktop.kt
@@ -1,12 +1,12 @@
  import androidx.compose.material.MaterialTheme
 import androidx.compose.material.darkColors
 import androidx.compose.ui.window.application
-import dev.bnorm.storyboard.easel.DesktopStoryboard
+import dev.bnorm.storyboard.easel.DesktopStory
 
 fun main() {
     application {
         MaterialTheme(colors = darkColors()) {
-            DesktopStoryboard(BASIC_STORYBOARD)
+            DesktopStory(BASIC_STORYBOARD)
         }
     }
 }
diff --git a/examples/basic/src/wasmJsMain/kotlin/main.web.kt b/examples/basic/src/wasmJsMain/kotlin/main.web.kt
@@ -2,13 +2,13 @@ import androidx.compose.material.MaterialTheme
 import androidx.compose.material.darkColors
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.window.CanvasBasedWindow
-import dev.bnorm.storyboard.easel.WebStoryboard
+import dev.bnorm.storyboard.easel.WebStory
 
 @OptIn(ExperimentalComposeUiApi::class)
 fun main() {
     CanvasBasedWindow(canvasElementId = "ComposeTarget", title = BASIC_STORYBOARD.title) {
         MaterialTheme(colors = darkColors()) {
-            WebStoryboard(BASIC_STORYBOARD)
+            WebStory(BASIC_STORYBOARD)
         }
     }
 }
diff --git a/examples/interactive/src/commonMain/kotlin/AppScene.kt b/examples/interactive/src/commonMain/kotlin/AppScene.kt
@@ -12,8 +12,8 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
 import dev.bnorm.storyboard.core.StoryboardBuilder
-import dev.bnorm.storyboard.core.StoryboardState
-import dev.bnorm.storyboard.easel.EmbeddedStoryboard
+import dev.bnorm.storyboard.core.StoryState
+import dev.bnorm.storyboard.easel.EmbeddedStory
 import dev.bnorm.storyboard.easel.template.Body
 import dev.bnorm.storyboard.easel.template.Header
 import dev.bnorm.storyboard.easel.template.RevealEach
@@ -29,15 +29,15 @@ fun StoryboardBuilder.AppScene() {
                     Modifier.padding(vertical = 16.dp, horizontal = 16.dp),
                     verticalArrangement = Arrangement.spacedBy(16.dp),
                 ) {
-                    val storyboard = rememberSaveable { StoryboardState(createStoryboard()) }
+                    val storyboard = rememberSaveable { StoryState(createStoryboard()) }
 
                     RevealEach(frame.createChildTransition { it.toState() }) {
                         item { Text("• Storyboard is ultimately just a Compose application.") }
                         item { Text("• Anything achieve with Compose, is possible in Storyboard!") }
                         item { Text("• You could even embed a Storyboard, in a Storyboard!") }
                         item {
                             MaterialTheme(colors = darkColors()) {
-                                EmbeddedStoryboard(
+                                EmbeddedStory(
                                     storyboard,
                                     modifier = Modifier.requiredSize(storyboard.storyboard.size / 3),
                                 )
diff --git a/examples/interactive/src/jvmMain/kotlin/main.desktop.kt b/examples/interactive/src/jvmMain/kotlin/main.desktop.kt
@@ -2,13 +2,13 @@ import androidx.compose.material.MaterialTheme
 import androidx.compose.material.lightColors
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.window.application
-import dev.bnorm.storyboard.easel.DesktopStoryboard
+import dev.bnorm.storyboard.easel.DesktopStory
 
 fun main() {
     application {
         val storyboard = createStoryboard()
         MaterialTheme(colors = lightColors(background = Color.Gray)) {
-            DesktopStoryboard(storyboard)
+            DesktopStory(storyboard)
         }
     }
 }
diff --git a/examples/interactive/src/wasmJsMain/kotlin/main.web.kt b/examples/interactive/src/wasmJsMain/kotlin/main.web.kt
@@ -3,14 +3,14 @@ import androidx.compose.material.lightColors
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.window.CanvasBasedWindow
-import dev.bnorm.storyboard.easel.WebStoryboard
+import dev.bnorm.storyboard.easel.WebStory
 
 @OptIn(ExperimentalComposeUiApi::class)
 fun main() {
     val storyboard = createStoryboard()
     CanvasBasedWindow(canvasElementId = "ComposeTarget", title = storyboard.title) {
         MaterialTheme(colors = lightColors(background = Color.Gray)) {
-            WebStoryboard(storyboard)
+            WebStory(storyboard)
         }
     }
 }
diff --git a/storyboard-core/src/commonMain/kotlin/dev/bnorm/storyboard/core/SceneScope.kt b/storyboard-core/src/commonMain/kotlin/dev/bnorm/storyboard/core/SceneScope.kt
@@ -41,13 +41,13 @@ internal class PreviewSceneScope<T>(
 }
 
 internal class StoryboardSceneScope<T>(
-    private val storyboard: StoryboardState,
+    private val storyState: StoryState,
     override val states: ImmutableList<T>,
     override val frame: Transition<out Frame<T>>,
     animatedVisibilityScope: AnimatedVisibilityScope,
     sharedTransitionScope: SharedTransitionScope,
 ) : SceneScope<T>,
     AnimatedVisibilityScope by animatedVisibilityScope,
     SharedTransitionScope by sharedTransitionScope {
-    override val direction: AdvanceDirection get() = storyboard.currentDirection
+    override val direction: AdvanceDirection get() = storyState.currentDirection
 }
diff --git a/storyboard-core/src/commonMain/kotlin/dev/bnorm/storyboard/core/StoryState.kt b/storyboard-core/src/commonMain/kotlin/dev/bnorm/storyboard/core/StoryState.kt
@@ -10,7 +10,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import kotlin.math.abs
 
-class StoryboardState(
+class StoryState(
     val storyboard: Storyboard,
     initialIndex: Storyboard.Index = Storyboard.Index(0, 0),
 ) {
@@ -100,7 +100,7 @@ class StoryboardState(
 
             // Find the next target frame index.
             val targetIndex = findTargetIndex(direction) ?: return false
-            this@StoryboardState.targetIndex = frames[targetIndex].storyboardIndex
+            this@StoryState.targetIndex = frames[targetIndex].storyboardIndex
         } else {
             // Reverse directions.
             val tmp = currentIndex
@@ -153,7 +153,7 @@ class StoryboardState(
         return true
     }
 
-    class StateScene<T>(
+    internal class StateScene<T>(
         val sceneIndex: Int,
         val scene: Scene<T>,
     ) : Comparable<StateScene<*>> {
@@ -162,7 +162,7 @@ class StoryboardState(
         }
     }
 
-    class StateFrame<T>(
+    internal class StateFrame<T>(
         val frameIndex: Int,
         val scene: StateScene<T>,
         val state: Frame<T>,
diff --git a/storyboard-core/src/commonMain/kotlin/dev/bnorm/storyboard/ui/Preview.kt b/storyboard-core/src/commonMain/kotlin/dev/bnorm/storyboard/ui/Preview.kt
@@ -88,7 +88,7 @@ fun ScenePreview(
 }
 
 @Composable
-fun StoryboardPreview(
+fun StoryPreview(
     storyboard: Storyboard,
     displayType: DisplayType = DisplayType.Preview,
 ) {
@@ -117,13 +117,13 @@ fun StoryboardPreview(
 }
 
 @Composable
-fun StoryboardPreview(
+fun StoryPreview(
     name: String = "Preview",
     description: String? = null,
     size: DpSize = Storyboard.DEFAULT_SIZE,
     decorator: SceneDecorator = SceneDecorator.None,
     displayType: DisplayType = DisplayType.Preview,
     block: StoryboardBuilder.() -> Unit,
 ) {
-    StoryboardPreview(Storyboard.build(name, description, size, decorator, block), displayType)
+    StoryPreview(Storyboard.build(name, description, size, decorator, block), displayType)
 }
diff --git a/storyboard-core/src/commonMain/kotlin/dev/bnorm/storyboard/ui/StoryScene.kt b/storyboard-core/src/commonMain/kotlin/dev/bnorm/storyboard/ui/StoryScene.kt
@@ -15,11 +15,11 @@ import androidx.compose.ui.unit.DpSize
 import dev.bnorm.storyboard.core.*
 
 @Composable
-fun StoryboardScene(storyboard: StoryboardState, modifier: Modifier = Modifier) {
+fun StoryScene(storyState: StoryState, modifier: Modifier = Modifier) {
     val holder = rememberSaveableStateHolder()
-    ProvideStoryboard(storyboard.storyboard) {
-        SceneWrapper(storyboard.storyboard.size, storyboard.storyboard.decorator, DisplayType.Story, modifier) {
-            val frame = storyboard.rememberTransition()
+    ProvideStoryboard(storyState.storyboard) {
+        SceneWrapper(storyState.storyboard.size, storyState.storyboard.decorator, DisplayType.Story, modifier) {
+            val frame = storyState.rememberTransition()
             frame.createChildTransition { it.scene }.AnimatedContent(
                 transitionSpec = {
                     val direction = when {
@@ -32,7 +32,7 @@ fun StoryboardScene(storyboard: StoryboardState, modifier: Modifier = Modifier)
             ) { scene ->
                 holder.SaveableStateProvider(scene) {
                     Box(Modifier.fillMaxSize()) {
-                        SceneContent(storyboard, scene, frame, this@AnimatedContent, this@SceneWrapper)
+                        SceneContent(storyState, scene, frame, this@AnimatedContent, this@SceneWrapper)
                     }
                 }
             }
@@ -42,9 +42,9 @@ fun StoryboardScene(storyboard: StoryboardState, modifier: Modifier = Modifier)
 
 @Composable
 private fun <T> SceneContent(
-    storyboard: StoryboardState,
-    stateScene: StoryboardState.StateScene<T>,
-    frame: Transition<StoryboardState.StateFrame<*>>,
+    storyState: StoryState,
+    stateScene: StoryState.StateScene<T>,
+    frame: Transition<StoryState.StateFrame<*>>,
     animatedContentScope: AnimatedContentScope,
     sharedTransitionScope: SharedTransitionScope,
 ) {
@@ -57,9 +57,9 @@ private fun <T> SceneContent(
         }
     }
 
-    val scope = remember(storyboard, stateScene, state, animatedContentScope, sharedTransitionScope) {
+    val scope = remember(storyState, stateScene, state, animatedContentScope, sharedTransitionScope) {
         StoryboardSceneScope(
-            storyboard = storyboard,
+            storyState = storyState,
             states = stateScene.scene.states,
             frame = state,
             animatedVisibilityScope = animatedContentScope,
diff --git a/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/EmbeddedStory.kt b/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/EmbeddedStory.kt
@@ -5,15 +5,15 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
-import dev.bnorm.storyboard.core.StoryboardState
-import dev.bnorm.storyboard.ui.StoryboardScene
+import dev.bnorm.storyboard.core.StoryState
+import dev.bnorm.storyboard.ui.StoryScene
 
 @Composable
-fun EmbeddedStoryboard(storyboard: StoryboardState, modifier: Modifier = Modifier) {
+fun EmbeddedStory(storyState: StoryState, modifier: Modifier = Modifier) {
     val coroutineScope = rememberCoroutineScope()
     val overlayState = remember(coroutineScope) { OverlayState(coroutineScope) }
     Box(modifier = modifier.onPointerMovePress(overlayState)) {
-        StoryboardScene(storyboard)
-        StoryboardOverlay(storyboard, overlayState)
+        StoryScene(storyState)
+        StoryOverlay(storyState, overlayState)
     }
 }
diff --git a/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/Story.kt b/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/Story.kt
@@ -9,16 +9,16 @@ import androidx.compose.runtime.saveable.rememberSaveableStateHolder
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.input.key.*
 import dev.bnorm.storyboard.core.AdvanceDirection
-import dev.bnorm.storyboard.core.StoryboardState
+import dev.bnorm.storyboard.core.StoryState
 import dev.bnorm.storyboard.easel.internal.requestFocus
-import dev.bnorm.storyboard.ui.StoryboardScene
+import dev.bnorm.storyboard.ui.StoryScene
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 
 @Composable
-fun Storyboard(
-    storyboard: StoryboardState,
-    overview: StoryboardOverview = remember(storyboard) { StoryboardOverview.of(storyboard) },
+fun Story(
+    storyState: StoryState,
+    overview: StoryOverview = remember(storyState) { StoryOverview.of(storyState) },
     overlayState: OverlayState = rememberOverlayState(),
     modifier: Modifier = Modifier,
 ) {
@@ -42,13 +42,13 @@ fun Storyboard(
                 transitionSpec = { fadeIn(tween(300)) togetherWith fadeOut(tween(300)) }
             ) { isOverview ->
                 if (isOverview) {
-                    StoryboardOverview(
+                    StoryOverview(
                         overview = overview,
                         onExitOverview = {
                             job?.cancel()
                             job = coroutineScope.launch {
                                 // TODO this doesn't work because the transition is not attached!
-                                storyboard.jumpTo(it)
+                                storyState.jumpTo(it)
                                 job = null
                                 overview.isVisible = false
                             }
@@ -58,20 +58,20 @@ fun Storyboard(
                         modifier = Modifier.fillMaxSize(),
                     )
                 } else {
-                    holder.SaveableStateProvider(storyboard) {
+                    holder.SaveableStateProvider(storyState) {
                         Box(modifier = Modifier.onPointerMovePress(state = overlayState)) {
-                            StoryboardScene(
-                                storyboard = storyboard,
+                            StoryScene(
+                                storyState = storyState,
                                 modifier = Modifier
                                     .fillMaxSize()
                                     .sharedElement(
                                         rememberSharedContentState(OverviewCurrentIndex),
                                         animatedVisibilityScope = this@AnimatedContent
                                     )
                                     .requestFocus()
-                                    .onStoryboardNavigation(storyboard = storyboard)
+                                    .onStoryboardNavigation(storyboard = storyState)
                                     .onKeyEvent { handleKeyEvent(it) })
-                            StoryboardOverlay(storyboard = storyboard, state = overlayState)
+                            StoryOverlay(storyState = storyState, state = overlayState)
                         }
                     }
                 }
@@ -81,7 +81,7 @@ fun Storyboard(
 }
 
 @Composable
-internal fun Modifier.onStoryboardNavigation(storyboard: StoryboardState): Modifier {
+internal fun Modifier.onStoryboardNavigation(storyboard: StoryState): Modifier {
     val coroutineScope = rememberCoroutineScope()
     var job by remember { mutableStateOf<Job?>(null) }
 
diff --git a/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/StoryOverlay.kt b/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/StoryOverlay.kt
@@ -22,7 +22,7 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.input.pointer.*
 import androidx.compose.ui.unit.dp
 import dev.bnorm.storyboard.core.AdvanceDirection
-import dev.bnorm.storyboard.core.StoryboardState
+import dev.bnorm.storyboard.core.StoryState
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
@@ -31,15 +31,15 @@ import kotlinx.coroutines.launch
 import kotlin.time.TimeMark
 import kotlin.time.TimeSource
 
-interface StoryboardOverlayScope : BoxScope {
+interface StoryOverlayScope : BoxScope {
     fun Modifier.overlayElement(): Modifier
 }
 
 @Composable
-fun StoryboardOverlay(
-    storyboard: StoryboardState,
+fun StoryOverlay(
+    storyState: StoryState,
     state: OverlayState,
-    content: @Composable StoryboardOverlayScope.() -> Unit = {
+    content: @Composable StoryOverlayScope.() -> Unit = {
         val coroutineScope = rememberCoroutineScope()
         var job by remember { mutableStateOf<Job?>(null) }
 
@@ -57,7 +57,7 @@ fun StoryboardOverlay(
                     onClick = {
                         job?.cancel()
                         job = coroutineScope.launch {
-                            storyboard.advance(AdvanceDirection.Backward)
+                            storyState.advance(AdvanceDirection.Backward)
                             job = null
                         }
                     }
@@ -68,7 +68,7 @@ fun StoryboardOverlay(
                     onClick = {
                         job?.cancel()
                         job = coroutineScope.launch {
-                            storyboard.advance(AdvanceDirection.Forward)
+                            storyState.advance(AdvanceDirection.Forward)
                             job = null
                         }
                     }
@@ -89,7 +89,7 @@ fun StoryboardOverlay(
                 .alpha(alpha)
         ) {
             val scope = remember(state) {
-                object : StoryboardOverlayScope, BoxScope by this {
+                object : StoryOverlayScope, BoxScope by this {
                     override fun Modifier.overlayElement(): Modifier {
                         return onPointerEnterExit(state)
                     }
diff --git a/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/StoryOverview.kt b/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/StoryOverview.kt
diff --git a/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/notes/ShowAssist.kt b/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/notes/ShowAssist.kt
diff --git a/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/notes/StoryNotes.kt b/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/notes/StoryNotes.kt
diff --git a/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/notes/StoryTimer.kt b/storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/notes/StoryTimer.kt
diff --git a/storyboard-easel/src/jvmMain/kotlin/dev/bnorm/storyboard/easel/DesktopStory.kt b/storyboard-easel/src/jvmMain/kotlin/dev/bnorm/storyboard/easel/DesktopStory.kt
diff --git a/storyboard-easel/src/wasmJsMain/kotlin/dev/bnorm/storyboard/easel/WebStory.kt b/storyboard-easel/src/wasmJsMain/kotlin/dev/bnorm/storyboard/easel/WebStory.kt

Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,12 @@`
`1`	`1`	`import androidx.compose.material.MaterialTheme`
`2`	`2`	`import androidx.compose.material.darkColors`
`3`	`3`	`import androidx.compose.ui.window.application`
`4`		`-import dev.bnorm.storyboard.easel.DesktopStoryboard`
	`4`	`+import dev.bnorm.storyboard.easel.DesktopStory`
`5`	`5`
`6`	`6`	`fun main() {`
`7`	`7`	`application {`
`8`	`8`	`MaterialTheme(colors = darkColors()) {`
`9`		`- DesktopStoryboard(BASIC_STORYBOARD)`
	`9`	`+ DesktopStory(BASIC_STORYBOARD)`
`10`	`10`	`}`
`11`	`11`	`}`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,13 +2,13 @@ import androidx.compose.material.MaterialTheme`
`2`	`2`	`import androidx.compose.material.darkColors`
`3`	`3`	`import androidx.compose.ui.ExperimentalComposeUiApi`
`4`	`4`	`import androidx.compose.ui.window.CanvasBasedWindow`
`5`		`-import dev.bnorm.storyboard.easel.WebStoryboard`
	`5`	`+import dev.bnorm.storyboard.easel.WebStory`
`6`	`6`
`7`	`7`	`@OptIn(ExperimentalComposeUiApi::class)`
`8`	`8`	`fun main() {`
`9`	`9`	`CanvasBasedWindow(canvasElementId = "ComposeTarget", title = BASIC_STORYBOARD.title) {`
`10`	`10`	`MaterialTheme(colors = darkColors()) {`
`11`		`- WebStoryboard(BASIC_STORYBOARD)`
	`11`	`+ WebStory(BASIC_STORYBOARD)`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,13 +2,13 @@ import androidx.compose.material.MaterialTheme`
`2`	`2`	`import androidx.compose.material.lightColors`
`3`	`3`	`import androidx.compose.ui.graphics.Color`
`4`	`4`	`import androidx.compose.ui.window.application`
`5`		`-import dev.bnorm.storyboard.easel.DesktopStoryboard`
	`5`	`+import dev.bnorm.storyboard.easel.DesktopStory`
`6`	`6`
`7`	`7`	`fun main() {`
`8`	`8`	`application {`
`9`	`9`	`val storyboard = createStoryboard()`
`10`	`10`	`MaterialTheme(colors = lightColors(background = Color.Gray)) {`
`11`		`- DesktopStoryboard(storyboard)`
	`11`	`+ DesktopStory(storyboard)`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,14 +3,14 @@ import androidx.compose.material.lightColors`
`3`	`3`	`import androidx.compose.ui.ExperimentalComposeUiApi`
`4`	`4`	`import androidx.compose.ui.graphics.Color`
`5`	`5`	`import androidx.compose.ui.window.CanvasBasedWindow`
`6`		`-import dev.bnorm.storyboard.easel.WebStoryboard`
	`6`	`+import dev.bnorm.storyboard.easel.WebStory`
`7`	`7`
`8`	`8`	`@OptIn(ExperimentalComposeUiApi::class)`
`9`	`9`	`fun main() {`
`10`	`10`	`val storyboard = createStoryboard()`
`11`	`11`	`CanvasBasedWindow(canvasElementId = "ComposeTarget", title = storyboard.title) {`
`12`	`12`	`MaterialTheme(colors = lightColors(background = Color.Gray)) {`
`13`		`- WebStoryboard(storyboard)`
	`13`	`+ WebStory(storyboard)`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`	`}`