@apexnative/navigation 1.0.0-alpha.6 → 1.0.0-alpha.8

package/android/src/main/java/dev/apexnative/navigation/views/element/animators/ImageMorph.kt

@@ -0,0 +1,199 @@
+package dev.apexnative.navigation.views.element.animators
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import android.view.View
+import android.widget.ImageView
+import com.facebook.react.uimanager.BackgroundStyleApplicator
+import com.facebook.react.uimanager.style.LogicalEdge
+import com.facebook.react.views.image.ReactImageView
+import com.facebook.react.views.view.ReactViewGroup
+import dev.apexnative.navigation.utils.borderRadius
+import kotlin.math.abs
+import kotlin.math.roundToInt
+
+/**
+ * A shared image flies as its image, fitted all the way: the copy goes from where `from` is drawn to where `to` is
+ * drawn in its screen ([FlightGeometry]), clipped to its corners, and the image of `to` in it goes from the part and
+ * place `from` shows its image at (its fit, `resizeMode`) to those of `to`, keeping its proportions where both fits
+ * do. The image is `to`'s own drawable, drawn on the layer's canvas and only read: an animated image plays on. The
+ * corners are the image's own radius, else that of a parent that clips it (`overflow: hidden`) and that it fills.
+ * Where a parent cuts the view, only the part that shows flies, as with a view ([ViewMorph]). A pair whose views draw
+ * more than their images (a background, a border) or whose images differ in proportions flies as pictures of the views
+ * ([ViewMorph]).
+ */
+internal class ImageMorph private constructor(
+    private val start: ImageEnd,
+    private val end: ImageEnd,
+    private val image: Drawable,
+    // Where the image's drawable draws the image, in the coordinates it draws in.
+    private val drawn: RectF,
+) : FlightPicture() {
+    private val flight = FlightGeometry(start.end, end.end)
+    private val cut = FlightMask.of(start.visible, end.visible)?.let(::MaskCut)
+    private var at = start.end
+    private var progress = 0f
+    private val rect = RectF()
+    private val imageRect = FloatArray(RECT)
+    private val maskPaint = Paint(Paint.ANTI_ALIAS_FLAG)
+    // What is drawn over the mask keeps only the mask's pixels: the corners stay smooth.
+    private val contentPaint = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.SRC_IN) }
+
+    override val live: Boolean get() = true
+
+    override fun update(time: Float, progress: Float) {
+        this.progress = progress
+        at = flight.at(progress, time)
+        for (i in 0 until RECT) imageRect[i] = lerp(start.image[i], end.image[i])
+        cut?.update(time, progress)
+    }
+
+    override fun draw(canvas: Canvas) {
+        rect.set(-at.width / 2, -at.height / 2, at.width / 2, at.height / 2)
+        val imageWidth = imageRect[2] - imageRect[0]
+        val imageHeight = imageRect[3] - imageRect[1]
+        if (rect.isEmpty || imageWidth <= 0 || imageHeight <= 0 || drawn.isEmpty) return
+        val alpha = (lerp(start.alpha, end.alpha) * 255).roundToInt().coerceIn(0, 255)
+        if (alpha == 0) return
+        val radius = lerp(start.radius, end.radius)
+        // The copy turns about its center, mirrored where a view is.
+        canvas.translate(at.centerX, at.centerY)
+        canvas.rotate(at.rotation)
+        canvas.scale(at.mirrorX, at.mirrorY)
+        canvas.saveLayer(rect, null)
+        canvas.drawRoundRect(rect, radius, radius, maskPaint)
+        cut?.draw(canvas, rect)
+        contentPaint.alpha = alpha
+        canvas.saveLayer(rect, contentPaint)
+        canvas.translate(imageRect[0], imageRect[1])
+        canvas.scale(imageWidth / drawn.width(), imageHeight / drawn.height())
+        canvas.translate(-drawn.left, -drawn.top)
+        image.draw(canvas)
+    }
+
+    private fun lerp(from: Float, to: Float) = from + (to - from) * progress
+
+    // One end of the flight: where the view is drawn, where its image shows in it (left, top, right, bottom from the
+    // view's center, at the size it is drawn at), its corner radius there, its opacity and the part of it that shows.
+    private class ImageEnd(
+        val end: FlightEnd,
+        val image: FloatArray,
+        val radius: Float,
+        val alpha: Float,
+        val visible: VisiblePart,
+    )
+
+    companion object {
+        private const val RECT = 4
+
+        // How far from its parent's size an image still fills it, in pixels.
+        private const val FILLS = 1
+        private const val HIDDEN = "hidden"
+
+        // How far the proportions of two images may differ for one to stand for the other, in parts of one.
+        private const val SAME_ASPECT = 0.02f
+
+        /**
+         * The morph of [from] into [to] in [layer], each cut by its parents up to the view of its screen ([fromRoot],
+         * [toRoot]); none when an image isn't there to fit, the images differ in proportions, or a view draws more
+         * than its image.
+         */
+        fun of(from: ImageView, to: ImageView, fromRoot: View?, toRoot: View?, layer: View): ImageMorph? {
+            if (!onlyImage(from) || !onlyImage(to)) return null
+            val image = to.drawable ?: return null
+            val drawn = drawnRect(to) ?: return null
+            val fromDrawn = drawnRect(from) ?: return null
+            if (!sameAspect(fromDrawn.width(), fromDrawn.height(), drawn.width(), drawn.height())) return null
+            val start = endOf(from, layer, fromRoot) ?: return null
+            val end = endOf(to, layer, toRoot) ?: return null
+            return ImageMorph(start, end, image, drawn)
+        }
+
+        /** Whether an image of [width] × [height] has the proportions of one of [otherWidth] × [otherHeight]. */
+        internal fun sameAspect(width: Float, height: Float, otherWidth: Float, otherHeight: Float): Boolean {
+            if (width <= 0f || height <= 0f || otherWidth <= 0f || otherHeight <= 0f) return false
+            val aspect = width / height
+            val other = otherWidth / otherHeight
+            return abs(aspect - other) <= SAME_ASPECT * other
+        }
+
+        // The view draws nothing but its image: no background color, no border (React Native draws them as the
+        // view's background, around the image).
+        private fun onlyImage(view: View): Boolean = try {
+            val background = BackgroundStyleApplicator.getBackgroundColor(view)
+            (background == null || Color.alpha(background) == 0) && LogicalEdge.entries.none {
+                (BackgroundStyleApplicator.getBorderWidth(view, it) ?: 0f) > 0f
+            }
+        } catch (e: RuntimeException) {
+            false
+        }
+
+        private fun endOf(view: ImageView, layer: View, root: View?): ImageEnd? {
+            if (view.width <= 0 || view.height <= 0) return null
+            val shown = shownRect(view) ?: return null
+            val place = LayerPlace.of(view, layer, root)
+            val end = place.end(view.width, view.height)
+            val image = imageFromCenter(
+                floatArrayOf(shown.left, shown.top, shown.right, shown.bottom),
+                view.width, view.height, end.width, end.height,
+            )
+            val radius = cornerRadius(view)
+            return ImageEnd(
+                end, image, radius * end.scale, view.alpha, place.visible(view.width, view.height, radius),
+            )
+        }
+
+        // Where the drawable draws the image when the view draws it: Fresco's image where its fit puts it in the
+        // drawable, another image at its drawable's bounds (the view's matrix comes on top).
+        private fun drawnRect(view: ImageView): RectF? {
+            val rect = if (view is ReactImageView) {
+                if (!view.hasHierarchy()) return null
+                RectF().also { view.hierarchy.getActualImageBounds(it) }
+            } else {
+                RectF(view.drawable?.bounds ?: return null)
+            }
+            return rect.takeUnless { it.isEmpty }
+        }
+
+        // Where the image shows in the view, in its pixels.
+        private fun shownRect(view: ImageView): RectF? {
+            val rect = drawnRect(view) ?: return null
+            if (view !is ReactImageView) view.imageMatrix.mapRect(rect)
+            rect.offset(view.paddingLeft.toFloat(), view.paddingTop.toFloat())
+            return rect
+        }
+
+        private fun cornerRadius(view: ImageView): Float {
+            view.borderRadius.takeIf { it > 0f }?.let { return it }
+            val parent = view.parent as? ReactViewGroup ?: return 0f
+            val fills = abs(parent.width - view.width) <= FILLS && abs(parent.height - view.height) <= FILLS
+            return if (fills && parent.overflow == HIDDEN) parent.borderRadius else 0f
+        }
+
+        /**
+         * The rect [shown] (left, top, right, bottom) of a view of [width] × [height], from the view's center, at the
+         * size [shownWidth] × [shownHeight] the view is drawn at.
+         */
+        internal fun imageFromCenter(
+            shown: FloatArray,
+            width: Int,
+            height: Int,
+            shownWidth: Float,
+            shownHeight: Float,
+        ): FloatArray {
+            val scaleX = shownWidth / width
+            val scaleY = shownHeight / height
+            return floatArrayOf(
+                (shown[0] - width / 2f) * scaleX,
+                (shown[1] - height / 2f) * scaleY,
+                (shown[2] - width / 2f) * scaleX,
+                (shown[3] - height / 2f) * scaleY,
+            )
+        }
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/views/element/animators/SharedAnimatorFactory.kt

@@ -1,75 +1,85 @@
 package dev.apexnative.navigation.views.element.animators
 
-import android.animation.Animator
 import android.view.View
 import android.widget.ImageView
-import com.facebook.react.views.image.ReactImageView
 import com.facebook.react.views.text.ReactTextView
-import com.facebook.react.views.view.ReactViewGroup
 import dev.apexnative.navigation.options.SharedElementTransitionOptions
 import dev.apexnative.navigation.views.animations.AnimationRules
 import dev.apexnative.navigation.views.animations.Curves
-import dev.apexnative.navigation.views.element.TransitionLayer
+import dev.apexnative.navigation.views.element.elementSkipped
 import dev.apexnative.navigation.views.element.pairName
 
 /**
- * The animator of a shared element by the kinds of its two views, chosen by explicit classes, never by reflection:
- * texts (`TextChangeAnimator`, the module), React views with children (`ViewChangeAnimator`, the module; a failed
- * picture flies as a view without children), React images ([ReactImageAnimator]), other images ([ImageMatrixAnimator]),
- * any other view ([PlainViewAnimator]). The animator gets the pair's duration (else the fallback, the screen's fade),
- * its delay and its curve here, each of its own (a spring in real time); an `AnimatorSet` around it never sets them.
- * Main thread only.
+ * The flight of a shared pair, as on iOS: a copy drawn in the transition's layer, chosen by the kinds of the two views,
+ * by explicit classes, never by reflection — texts ([TextMorph]), images ([ImageMorph]; one without an image to fit
+ * flies as a view), any other views ([ViewMorph]). The views themselves are neither moved nor changed. The animator
+ * gets the pair's duration (else the fallback, the screen's fade), its delay and its curve here, each of its own (a
+ * spring in real time); an `AnimatorSet` around it never sets them. Main thread only.
  */
 internal object SharedAnimatorFactory {
-    /**
-     * A pair's animator, and how it shows the pair: by pictures in the layer's overlay while `to` is hidden (the
-     * modules), or by moving `to` itself, which shows from the start of the flight.
-     */
-    class Flight(val animator: Animator, val drawsPictures: Boolean)
+    /** A pair's animator and the copy it moves. */
+    class Flight(val animator: MoveAnimator, val picture: FlightPicture)
 
     /**
-     * The flight of the pair [from] → [to]; [to] is in [layer] at its margins, at its real alpha (the pictures are
-     * taken now). [toParent] is the parent [to] had in its screen, [toStandIn] the view in its place there. None: the
-     * pair doesn't fly (a text that didn't change, a picture that can't be taken, no place).
+     * The flight of the pair [from] → [to] in [layer], its pictures taken now; a view or an image shows only the part
+     * its parents up to the view of its screen ([fromRoot], [toRoot]) leave visible, a text shows whole, as on iOS.
+     * None: the pair doesn't fly — a text that doesn't change, or, with a line in [log], a view without a size or a
+     * picture that can't be taken.
      */
     fun create(
         from: View,
         to: View,
-        toParent: View?,
-        toStandIn: View?,
-        layer: TransitionLayer,
+        fromRoot: View?,
+        toRoot: View?,
+        layer: View,
         options: SharedElementTransitionOptions,
         fallbackDuration: Long,
         log: (String) -> Unit,
     ): Flight? {
-        val flight = when {
-            from is ReactTextView && to is ReactTextView -> pictures(
-                TextChangeAnimator(from, to, toStandIn).takeIf { it.shouldAnimate() }?.create(options),
-            )
-            hasChildren(from) || hasChildren(to) -> pictures(
-                ViewChangeAnimator(from, to, toStandIn).takeIf { it.shouldAnimate() }?.create(options),
-            ) ?: moves(PlainViewAnimator(from, to, toStandIn, layer).create())
-            from is ReactImageView && to is ReactImageView ->
-                moves(ReactImageAnimator(from, to, toStandIn, layer).create())
-            from is ImageView && to is ImageView -> moves(
-                ImageMatrixAnimator(
-                    from, to, toStandIn, layer, from.parent as? View, toParent, options.toId.get(""), log,
-                ).create(),
-            )
-            else -> moves(PlainViewAnimator(from, to, toStandIn, layer).create())
-        } ?: return null
-        val animator = flight.animator
-        (animator as? MoveAnimator)?.element = pairName(options.fromId.get(""), options.toId.get(""))
+        val name = pairName(options.fromId.get(""), options.toId.get(""))
+        if (from.width <= 0 || from.height <= 0 || to.width <= 0 || to.height <= 0) {
+            elementSkipped(name, "a view of the pair has no size, it isn't laid out", log)
+            return null
+        }
+        val picture = if (from is ReactTextView && to is ReactTextView) {
+            val text = TextMorph.of(from, to, layer) ?: return noPicture(name, log)
+            if (!text.changes) return null
+            text
+        } else {
+            val image = if (from is ImageView && to is ImageView) {
+                ImageMorph.of(from, to, fromRoot, toRoot, layer)
+            } else {
+                null
+            }
+            image ?: ViewMorph.of(from, to, fromRoot, toRoot, layer) ?: return noPicture(name, log)
+        }
+        val animator = MoveAnimator().apply {
+            element = name
+            onStart {
+                picture.shown = true
+                picture.update(0f, curve.getInterpolation(0f))
+                layer.invalidate()
+            }
+            onFrame {
+                picture.update(it, curve.getInterpolation(it))
+                layer.invalidate()
+            }
+            // A flight that landed keeps its last frame until the transition takes the layer away: the screens may
+            // still move. A stopped one draws nothing more.
+            onEnd {
+                if (!landed) picture.shown = false
+                layer.invalidate()
+            }
+        }
         val duration = AnimationRules.durationOf(options.duration.get(null), fallbackDuration)
         animator.duration = duration
         animator.startDelay = AnimationRules.delayOf(options.startDelay.get(null))
         animator.interpolator = Curves.of(options.interpolation, duration)
-        return flight
+        return Flight(animator, picture)
     }
 
-    private fun pictures(animator: Animator?): Flight? = animator?.let { Flight(it, drawsPictures = true) }
-
-    private fun moves(animator: Animator?): Flight? = animator?.let { Flight(it, drawsPictures = false) }
-
-    private fun hasChildren(view: View): Boolean = view is ReactViewGroup && view.childCount > 0
+    private fun noPicture(name: String, log: (String) -> Unit): Flight? {
+        elementSkipped(name, "no picture of a view of the pair can be taken", log)
+        return null
+    }
 }

package/android/src/main/java/dev/apexnative/navigation/views/element/animators/{TextChangeAnimator.kt → TextMorph.kt}

@@ -1,91 +1,105 @@
 package dev.apexnative.navigation.views.element.animators
 
-import android.animation.Animator
 import android.graphics.Canvas
-import android.graphics.ColorFilter
 import android.graphics.Picture
-import android.graphics.PixelFormat
 import android.graphics.PointF
-import android.graphics.drawable.Drawable
 import android.text.Layout
 import android.view.View
-import android.view.ViewGroup
 import android.widget.TextView
 import com.facebook.react.views.text.ReactTextView
-import dev.apexnative.navigation.options.SharedElementTransitionOptions
 import dev.apexnative.navigation.utils.TextViewUtils
 import dev.apexnative.navigation.views.animations.ValueInterpolation
 import kotlin.math.abs
 import kotlin.math.min
 import kotlin.math.roundToInt
 
-// The text moves as two pictures of itself, of the text that goes away and of the text that comes, the same text or
-// another. Both keep their proportions, scaled by the font size from a point of the first line, and one turns into the
-// other in a quarter of the move: at its start when the text grows, at its end when it shrinks, so the larger picture
-// shows most of the way (as on iOS). Each text is where it is drawn, at the scale and angle its parents and its own
-// properties give it; the angle goes along the shorter arc (FlightGeometry). The pictures are drawing commands, not
-// pixels: they stay sharp at any scale and keep the colors, emoji and background of the text. They are drawn in the
-// overlay of the transition layer while `to` is hidden.
-class TextChangeAnimator internal constructor(
-    from: View,
-    to: View,
-    // Where `to` was in its screen: what the text flies to.
-    private val toStandIn: View?,
-) : PropertyAnimatorCreator<ReactTextView>(from, to, ReactTextView::class.java) {
-    private val pictures by lazy { pictures() }
+/**
+ * The text moves as two pictures of itself, of the text that goes away and of the text that comes, the same text or
+ * another. Both keep their proportions, scaled by the font size from a point of the first line, and one turns into the
+ * other in a quarter of the move: at its start when the text grows, at its end when it shrinks, so the larger picture
+ * shows most of the way (as on iOS). Each text is where it is drawn, at the scale and angle its parents and its own
+ * properties give it; the angle goes along the shorter arc ([FlightGeometry]). The pictures are drawing commands, not
+ * pixels: they stay sharp at any scale and keep the colors, emoji and background of the text.
+ */
+internal class TextMorph private constructor(private val start: TextPicture, private val end: TextPicture) :
+    FlightPicture() {
+    /** Whether the text changes on the way: another text, another size, or drawn elsewhere. */
+    val changes: Boolean
+        get() = start.text != end.text || start.fontSize != end.fontSize || start.drawnElsewhere(end)
 
-    override fun shouldAnimateProperty(fromChild: ReactTextView, toChild: ReactTextView): Boolean {
-        val (start, end) = pictures ?: return false
-        return fromChild.text.toString() != toChild.text.toString() ||
-            TextViewUtils.getTextSize(fromChild) != TextViewUtils.getTextSize(toChild) || start.drawnElsewhere(end)
+    private val grows = end.shownSize >= start.shownSize
+    private var progress = 0f
+    private var time = 0f
+    private var changeOver = 0f
+    private var mirrorX = 1f
+    private var mirrorY = 1f
+
+    override fun update(time: Float, progress: Float) {
+        this.progress = progress
+        this.time = time
+        val changeOverStart = if (grows) 0f else 1f - CHANGE_OVER
+        changeOver = ((time - changeOverStart) / CHANGE_OVER).coerceIn(0f, 1f)
     }
 
-    override fun create(options: SharedElementTransitionOptions): Animator {
-        val (start, end) = checkNotNull(pictures)
-        val layer = to.parent as ViewGroup
-        val drawable = TextMorphDrawable(start, end)
-        // Everything changes between the start and the end of the animation: a cancelled one ends too.
-        return MoveAnimator().apply {
-            onStart {
-                drawable.setBounds(0, 0, layer.width, layer.height)
-                layer.overlay.add(drawable)
-                to.alpha = 0f
-            }
-            onFrame {
-                drawable.update(it, curve.getInterpolation(it))
-                layer.invalidate()
-            }
-            // A flight that landed where `to` shows only in its screen keeps its last picture: the transition takes the
-            // layer away with it and shows `to` in its place.
-            val holds = FlightEnd.holdsAtEnd(to, toStandIn, layer)
-            onEnd {
-                if (!holds || !landed) {
-                    layer.overlay.remove(drawable)
-                    layer.invalidate()
-                    to.alpha = end.alpha
-                }
-            }
+    override fun draw(canvas: Canvas) {
+        val x = start.position.x + (end.position.x - start.position.x) * progress
+        val y = start.position.y + (end.position.y - start.position.y) * progress
+        val fontSize = start.shownSize + (end.shownSize - start.shownSize) * progress
+        val rotation = ValueInterpolation.angle(start.rotation, end.rotation, progress, time)
+        mirrorX = ValueInterpolation.number(start.mirrorX, end.mirrorX, progress, time)
+        mirrorY = ValueInterpolation.number(start.mirrorY, end.mirrorY, progress, time)
+        draw(canvas, start, x, y, fontSize, rotation, 1f - changeOver)
+        draw(canvas, end, x, y, fontSize, rotation, changeOver)
+    }
+
+    private fun draw(
+        canvas: Canvas,
+        text: TextPicture,
+        x: Float,
+        y: Float,
+        fontSize: Float,
+        rotation: Float,
+        shown: Float,
+    ) {
+        val alpha = (shown * text.alpha * 255).roundToInt().coerceIn(0, 255)
+        if (alpha == 0) return
+        val scale = fontSize / text.fontSize
+        val count = canvas.save()
+        canvas.translate(x, y)
+        canvas.rotate(rotation)
+        canvas.scale(scale * mirrorX, scale * mirrorY)
+        canvas.translate(-text.anchor.x, -text.anchor.y)
+        // The picture fades as a whole: its letters and background don't show through each other.
+        if (alpha < 255) {
+            canvas.saveLayerAlpha(0f, 0f, text.picture.width.toFloat(), text.picture.height.toFloat(), alpha)
         }
+        canvas.drawPicture(text.picture)
+        canvas.restoreToCount(count)
     }
 
-    // `to` is in the transition layer already: the pictures are drawn in its coordinates. `from` is where it is drawn
-    // on the screen, `to` where it is drawn once back in its screen. Texts that line up the same way go from that point
-    // of their first lines (the same text lies over itself); others from the start of the line, as on iOS: a centered
-    // text no longer sticks out of a text at the start.
-    private fun pictures(): Pair<TextPicture, TextPicture>? {
-        val layer = to.parent as? ViewGroup ?: return null
-        val fromLayout = (from as TextView).layout ?: return null
-        val toLayout = (to as TextView).layout ?: return null
-        val edge = lineEdge(fromLayout).takeIf { it == lineEdge(toLayout) } ?: LineEdge.START
-        val start = TextPicture.of(from, LayerPlace.of(from, layer), edge) ?: return null
-        val end = TextPicture.of(to, LayerPlace.of(to, layer, toStandIn), edge) ?: return null
-        return start to end
+    companion object {
+        private const val CHANGE_OVER = 0.25f
+
+        /**
+         * The morph of [from] into [to] in [layer]; none when a text isn't laid out or its picture can't be taken.
+         * Texts that line up the same way go from that point of their first lines (the same text lies over itself);
+         * others from the start of the line, as on iOS: a centered text no longer sticks out of a text at the start.
+         */
+        fun of(from: ReactTextView, to: ReactTextView, layer: View): TextMorph? {
+            val fromLayout = from.layout ?: return null
+            val toLayout = to.layout ?: return null
+            val edge = lineEdge(fromLayout).takeIf { it == lineEdge(toLayout) } ?: LineEdge.START
+            val start = TextPicture.of(from, LayerPlace.of(from, layer), edge) ?: return null
+            val end = TextPicture.of(to, LayerPlace.of(to, layer), edge) ?: return null
+            return TextMorph(start, end)
+        }
     }
 }
 
-// A text's picture, the point of its first line it is scaled from (in the view) and where that point is drawn in the
-// transition layer, its font size, the scale and angle it is drawn at, and its opacity.
+// A text's picture and its text, the point of its first line it is scaled from (in the view) and where that point is
+// drawn in the transition layer, its font size, the scale and angle it is drawn at, and its opacity.
 private class TextPicture(
+    val text: String,
     val picture: Picture,
     val anchor: PointF,
     val position: PointF,
@@ -124,7 +138,8 @@ private class TextPicture(
             val position = place.point(anchor.x, anchor.y)
             val scale = min(abs(place.scaleX), abs(place.scaleY))
             return TextPicture(
-                picture, anchor, PointF(position[0], position[1]), fontSize, scale, place.rotation,
+                view.text.toString(), picture, anchor, PointF(position[0], position[1]), fontSize, scale,
+                place.rotation,
                 mirrorX = if (place.scaleX < 0) -1f else 1f,
                 mirrorY = if (place.scaleY < 0) -1f else 1f,
                 alpha = view.alpha,
@@ -159,68 +174,3 @@ private fun lineEdge(layout: Layout): LineEdge {
         else -> LineEdge.START
     }
 }
-
-// Both pictures where the move has brought the text: the font size it shows at, its angle and the point of the first
-// line go from the start to the end along the transition's curve, the pictures change over by the clock.
-private class TextMorphDrawable(private val start: TextPicture, private val end: TextPicture) : Drawable() {
-    private val grows = end.shownSize >= start.shownSize
-    private var progress = 0f
-    private var time = 0f
-    private var changeOver = 0f
-    private var mirrorX = 1f
-    private var mirrorY = 1f
-
-    fun update(time: Float, progress: Float) {
-        this.progress = progress
-        this.time = time
-        val changeOverStart = if (grows) 0f else 1f - CHANGE_OVER
-        changeOver = ((time - changeOverStart) / CHANGE_OVER).coerceIn(0f, 1f)
-    }
-
-    override fun draw(canvas: Canvas) {
-        val x = start.position.x + (end.position.x - start.position.x) * progress
-        val y = start.position.y + (end.position.y - start.position.y) * progress
-        val fontSize = start.shownSize + (end.shownSize - start.shownSize) * progress
-        val rotation = ValueInterpolation.angle(start.rotation, end.rotation, progress, time)
-        mirrorX = ValueInterpolation.number(start.mirrorX, end.mirrorX, progress, time)
-        mirrorY = ValueInterpolation.number(start.mirrorY, end.mirrorY, progress, time)
-        draw(canvas, start, x, y, fontSize, rotation, 1f - changeOver)
-        draw(canvas, end, x, y, fontSize, rotation, changeOver)
-    }
-
-    private fun draw(
-        canvas: Canvas,
-        text: TextPicture,
-        x: Float,
-        y: Float,
-        fontSize: Float,
-        rotation: Float,
-        shown: Float,
-    ) {
-        val alpha = (shown * text.alpha * 255).roundToInt().coerceIn(0, 255)
-        if (alpha == 0) return
-        val scale = fontSize / text.fontSize
-        val count = canvas.save()
-        canvas.translate(x, y)
-        canvas.rotate(rotation)
-        canvas.scale(scale * mirrorX, scale * mirrorY)
-        canvas.translate(-text.anchor.x, -text.anchor.y)
-        // The picture fades as a whole: its letters and background don't show through each other.
-        if (alpha < 255) {
-            canvas.saveLayerAlpha(0f, 0f, text.picture.width.toFloat(), text.picture.height.toFloat(), alpha)
-        }
-        canvas.drawPicture(text.picture)
-        canvas.restoreToCount(count)
-    }
-
-    override fun setAlpha(alpha: Int) = Unit
-
-    override fun setColorFilter(colorFilter: ColorFilter?) = Unit
-
-    @Deprecated("Deprecated in Java")
-    override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
-
-    private companion object {
-        const val CHANGE_OVER = 0.25f
-    }
-}