Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format the Animation library using ktfmt

Browse Source 
I missed some new files that were recently added when formatting the
animation library in ag/18799652.

Test: Manual
Bug: 235461679
Change-Id: I6c22d0079bad774058f34ebb349e105e4e4b99a2
This commit is contained in:
Jordan Demeulenaere
2022-06-13 12:31:25 +02:00
parent 76232f4e7f
commit d72c132937
3 changed files with 241 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
packages/SystemUI/animation/src/com/android/systemui/animation/FontInterpolator.kt
View File

@@ -33,9 +33,7 @@ private const val FONT_ITALIC_MIN = 0f
private const val FONT_ITALIC_ANIMATION_STEP = 0.1f
private const val FONT_ITALIC_DEFAULT_VALUE = 0f
/**
* Provide interpolation of two fonts by adjusting font variation settings.
*/
/** Provide interpolation of two fonts by adjusting font variation settings. */
class FontInterpolator {
/**
@@ -61,11 +59,14 @@ class FontInterpolator {
var index: Int,
val sortedAxes: MutableList<FontVariationAxis>
) {
constructor(font: Font, axes: List<FontVariationAxis>):
this(font.sourceIdentifier,
font.ttcIndex,
axes.toMutableList().apply { sortBy { it.tag } }
)
constructor(
font: Font,
axes: List<FontVariationAxis>
) : this(
font.sourceIdentifier,
font.ttcIndex,
axes.toMutableList().apply { sortBy { it.tag } }
)
fun set(font: Font, axes: List<FontVariationAxis>) {
sourceId = font.sourceIdentifier
@@ -86,9 +87,7 @@ class FontInterpolator {
private val tmpInterpKey = InterpKey(null, null, 0f)
private val tmpVarFontKey = VarFontKey(0, 0, mutableListOf())
/**
* Linear interpolate the font variation settings.
*/
/** Linear interpolate the font variation settings. */
fun lerp(start: Font, end: Font, progress: Float): Font {
if (progress == 0f) {
return start
@@ -115,27 +114,34 @@ class FontInterpolator {
// this doesn't take much time since the variation axes is usually up to 5. If we need to
// support more number of axes, we may want to preprocess the font and store the sorted axes
// and also pre-fill the missing axes value with default value from 'fvar' table.
val newAxes = lerp(startAxes, endAxes) { tag, startValue, endValue ->
when (tag) {
// TODO: Good to parse 'fvar' table for retrieving default value.
TAG_WGHT -> adjustWeight(
MathUtils.lerp(
val newAxes =
lerp(startAxes, endAxes) { tag, startValue, endValue ->
when (tag) {
// TODO: Good to parse 'fvar' table for retrieving default value.
TAG_WGHT ->
adjustWeight(
MathUtils.lerp(
startValue ?: FONT_WEIGHT_DEFAULT_VALUE,
endValue ?: FONT_WEIGHT_DEFAULT_VALUE,
progress))
TAG_ITAL -> adjustItalic(
MathUtils.lerp(
progress
)
)
TAG_ITAL ->
adjustItalic(
MathUtils.lerp(
startValue ?: FONT_ITALIC_DEFAULT_VALUE,
endValue ?: FONT_ITALIC_DEFAULT_VALUE,
progress))
else -> {
require(startValue != null && endValue != null) {
"Unable to interpolate due to unknown default axes value : $tag"
progress
)
)
else -> {
require(startValue != null && endValue != null) {
"Unable to interpolate due to unknown default axes value : $tag"
}
MathUtils.lerp(startValue, endValue, progress)
}
MathUtils.lerp(startValue, endValue, progress)
}
}
}
// Check if we already make font for this axes. This is typically happens if the animation
// happens backward.
@@ -149,9 +155,7 @@ class FontInterpolator {
// This is the first time to make the font for the axes. Build and store it to the cache.
// Font.Builder#build won't throw IOException since creating fonts from existing fonts will
// not do any IO work.
val newFont = Font.Builder(start)
.setFontVariationSettings(newAxes.toTypedArray())
.build()
val newFont = Font.Builder(start).setFontVariationSettings(newAxes.toTypedArray()).build()
interpCache[InterpKey(start, end, progress)] = newFont
verFontCache[VarFontKey(start, newAxes)] = newFont
return newFont
@@ -173,26 +177,28 @@ class FontInterpolator {
val tagA = if (i < start.size) start[i].tag else null
val tagB = if (j < end.size) end[j].tag else null
val comp = when {
tagA == null -> 1
tagB == null -> -1
else -> tagA.compareTo(tagB)
}
val comp =
when {
tagA == null -> 1
tagB == null -> -1
else -> tagA.compareTo(tagB)
}
val axis = when {
comp == 0 -> {
val v = filter(tagA!!, start[i++].styleValue, end[j++].styleValue)
FontVariationAxis(tagA, v)
val axis =
when {
comp == 0 -> {
val v = filter(tagA!!, start[i++].styleValue, end[j++].styleValue)
FontVariationAxis(tagA, v)
}
comp < 0 -> {
val v = filter(tagA!!, start[i++].styleValue, null)
FontVariationAxis(tagA, v)
}
else -> { // comp > 0
val v = filter(tagB!!, null, end[j++].styleValue)
FontVariationAxis(tagB, v)
}
}
comp < 0 -> {
val v = filter(tagA!!, start[i++].styleValue, null)
FontVariationAxis(tagA, v)
}
else -> { // comp > 0
val v = filter(tagB!!, null, end[j++].styleValue)
FontVariationAxis(tagB, v)
}
}
result.add(axis)
}
@@ -202,21 +208,21 @@ class FontInterpolator {
// For the performance reasons, we animate weight with FONT_WEIGHT_ANIMATION_STEP. This helps
// Cache hit ratio in the Skia glyph cache.
private fun adjustWeight(value: Float) =
coerceInWithStep(value, FONT_WEIGHT_MIN, FONT_WEIGHT_MAX, FONT_WEIGHT_ANIMATION_STEP)
coerceInWithStep(value, FONT_WEIGHT_MIN, FONT_WEIGHT_MAX, FONT_WEIGHT_ANIMATION_STEP)
// For the performance reasons, we animate italic with FONT_ITALIC_ANIMATION_STEP. This helps
// Cache hit ratio in the Skia glyph cache.
private fun adjustItalic(value: Float) =
coerceInWithStep(value, FONT_ITALIC_MIN, FONT_ITALIC_MAX, FONT_ITALIC_ANIMATION_STEP)
coerceInWithStep(value, FONT_ITALIC_MIN, FONT_ITALIC_MAX, FONT_ITALIC_ANIMATION_STEP)
private fun coerceInWithStep(v: Float, min: Float, max: Float, step: Float) =
(v.coerceIn(min, max) / step).toInt() * step
(v.coerceIn(min, max) / step).toInt() * step
companion object {
private val EMPTY_AXES = arrayOf<FontVariationAxis>()
// Returns true if given two font instance can be interpolated.
fun canInterpolate(start: Font, end: Font) =
start.ttcIndex == end.ttcIndex && start.sourceIdentifier == end.sourceIdentifier
start.ttcIndex == end.ttcIndex && start.sourceIdentifier == end.sourceIdentifier
}
}

160
packages/SystemUI/animation/src/com/android/systemui/animation/TextAnimator.kt
View File

@@ -36,8 +36,7 @@ typealias GlyphCallback = (TextAnimator.PositionedGlyph, Float) -> Unit
* Currently this class can provide text style animation for text weight and text size. For example
* the simple view that draws text with animating text size is like as follows:
*
* <pre>
* <code>
* ```
* class SimpleTextAnimation : View {
* @JvmOverloads constructor(...)
*
@@ -53,78 +52,59 @@ typealias GlyphCallback = (TextAnimator.PositionedGlyph, Float) -> Unit
* animator.setTextStyle(-1 /* unchanged weight */, sizePx, animate)
* }
* }
* </code>
* </pre>
* ```
*/
class TextAnimator(
layout: Layout,
private val invalidateCallback: () -> Unit
) {
class TextAnimator(layout: Layout, private val invalidateCallback: () -> Unit) {
// Following two members are for mutable for testing purposes.
public var textInterpolator: TextInterpolator = TextInterpolator(layout)
public var animator: ValueAnimator = ValueAnimator.ofFloat(1f).apply {
duration = DEFAULT_ANIMATION_DURATION
addUpdateListener {
textInterpolator.progress = it.animatedValue as Float
invalidateCallback()
}
addListener(object : AnimatorListenerAdapter() {
override fun onAnimationEnd(animation: Animator?) {
textInterpolator.rebase()
public var animator: ValueAnimator =
ValueAnimator.ofFloat(1f).apply {
duration = DEFAULT_ANIMATION_DURATION
addUpdateListener {
textInterpolator.progress = it.animatedValue as Float
invalidateCallback()
}
override fun onAnimationCancel(animation: Animator?) = textInterpolator.rebase()
})
}
addListener(
object : AnimatorListenerAdapter() {
override fun onAnimationEnd(animation: Animator?) {
textInterpolator.rebase()
}
override fun onAnimationCancel(animation: Animator?) = textInterpolator.rebase()
}
)
}
sealed class PositionedGlyph {
/**
* Mutable X coordinate of the glyph position relative from drawing offset.
*/
/** Mutable X coordinate of the glyph position relative from drawing offset. */
var x: Float = 0f
/**
* Mutable Y coordinate of the glyph position relative from the baseline.
*/
/** Mutable Y coordinate of the glyph position relative from the baseline. */
var y: Float = 0f
/**
* Mutable text size of the glyph in pixels.
*/
/** Mutable text size of the glyph in pixels. */
var textSize: Float = 0f
/**
* Mutable color of the glyph.
*/
/** Mutable color of the glyph. */
var color: Int = 0
/**
* Immutable character offset in the text that the current font run start.
*/
/** Immutable character offset in the text that the current font run start. */
abstract var runStart: Int
protected set
/**
* Immutable run length of the font run.
*/
/** Immutable run length of the font run. */
abstract var runLength: Int
protected set
/**
* Immutable glyph index of the font run.
*/
/** Immutable glyph index of the font run. */
abstract var glyphIndex: Int
protected set
/**
* Immutable font instance for this font run.
*/
/** Immutable font instance for this font run. */
abstract var font: Font
protected set
/**
* Immutable glyph ID for this glyph.
*/
/** Immutable glyph ID for this glyph. */
abstract var glyphId: Int
protected set
}
@@ -142,30 +122,30 @@ class TextAnimator(
/**
* GlyphFilter applied just before drawing to canvas for tweaking positions and text size.
*
* This callback is called for each glyphs just before drawing the glyphs. This function will
* be called with the intrinsic position, size, color, glyph ID and font instance. You can
* mutate the position, size and color for tweaking animations.
* Do not keep the reference of passed glyph object. The interpolator reuses that object for
* avoiding object allocations.
* This callback is called for each glyphs just before drawing the glyphs. This function will be
* called with the intrinsic position, size, color, glyph ID and font instance. You can mutate
* the position, size and color for tweaking animations. Do not keep the reference of passed
* glyph object. The interpolator reuses that object for avoiding object allocations.
*
* Details:
* The text is drawn with font run units. The font run is a text segment that draws with the
* same font. The {@code runStart} and {@code runLimit} is a range of the font run in the text
* that current glyph is in. Once the font run is determined, the system will convert characters
* into glyph IDs. The {@code glyphId} is the glyph identifier in the font and
* {@code glyphIndex} is the offset of the converted glyph array. Please note that the
* {@code glyphIndex} is not a character index, because the character will not be converted to
* glyph one-by-one. If there are ligatures including emoji sequence, etc, the glyph ID may be
* Details: The text is drawn with font run units. The font run is a text segment that draws
* with the same font. The {@code runStart} and {@code runLimit} is a range of the font run in
* the text that current glyph is in. Once the font run is determined, the system will convert
* characters into glyph IDs. The {@code glyphId} is the glyph identifier in the font and {@code
* glyphIndex} is the offset of the converted glyph array. Please note that the {@code
* glyphIndex} is not a character index, because the character will not be converted to glyph
* one-by-one. If there are ligatures including emoji sequence, etc, the glyph ID may be
* composed from multiple characters.
*
* Here is an example of font runs: "fin. 終わり"
*
* ```
* Characters : f i n . _ 終 わ り
* Code Points: \u0066 \u0069 \u006E \u002E \u0020 \u7D42 \u308F \u308A
* Font Runs : <-- Roboto-Regular.ttf --><-- NotoSans-CJK.otf -->
* runStart = 0, runLength = 5 runStart = 5, runLength = 3
* Glyph IDs : 194 48 7 8 4367 1039 1002
* Glyph Index: 0 1 2 3 0 1 2
* ```
*
* In this example, the "fi" is converted into ligature form, thus the single glyph ID is
* assigned for two characters, f and i.
@@ -188,28 +168,29 @@ class TextAnimator(
*/
var glyphFilter: GlyphCallback?
get() = textInterpolator.glyphFilter
set(value) { textInterpolator.glyphFilter = value }
set(value) {
textInterpolator.glyphFilter = value
}
fun draw(c: Canvas) = textInterpolator.draw(c)
/**
* Set text style with animation.
*
* By passing -1 to weight, the view preserve the current weight.
* By passing -1 to textSize, the view preserve the current text size.
* Bu passing -1 to duration, the default text animation, 1000ms, is used.
* By passing false to animate, the text will be updated without animation.
* By passing -1 to weight, the view preserve the current weight. By passing -1 to textSize, the
* view preserve the current text size. Bu passing -1 to duration, the default text animation,
* 1000ms, is used. By passing false to animate, the text will be updated without animation.
*
* @param weight an optional text weight.
* @param textSize an optional font size.
* @param colors an optional colors array that must be the same size as numLines passed to
* the TextInterpolator
* @param colors an optional colors array that must be the same size as numLines passed to the
* TextInterpolator
* @param animate an optional boolean indicating true for showing style transition as animation,
* false for immediate style transition. True by default.
* false for immediate style transition. True by default.
* @param duration an optional animation duration in milliseconds. This is ignored if animate is
* false.
* false.
* @param interpolator an optional time interpolator. If null is passed, last set interpolator
* will be used. This is ignored if animate is false.
* will be used. This is ignored if animate is false.
*/
fun setTextStyle(
weight: Int = -1,
@@ -232,10 +213,11 @@ class TextAnimator(
if (weight >= 0) {
// Paint#setFontVariationSettings creates Typeface instance from scratch. To reduce the
// memory impact, cache the typeface result.
textInterpolator.targetPaint.typeface = typefaceCache.getOrElse(weight) {
textInterpolator.targetPaint.fontVariationSettings = "'$TAG_WGHT' $weight"
textInterpolator.targetPaint.typeface
}
textInterpolator.targetPaint.typeface =
typefaceCache.getOrElse(weight) {
textInterpolator.targetPaint.fontVariationSettings = "'$TAG_WGHT' $weight"
textInterpolator.targetPaint.typeface
}
}
if (color != null) {
textInterpolator.targetPaint.color = color
@@ -244,22 +226,24 @@ class TextAnimator(
if (animate) {
animator.startDelay = delay
animator.duration = if (duration == -1L) {
DEFAULT_ANIMATION_DURATION
} else {
duration
}
animator.duration =
if (duration == -1L) {
DEFAULT_ANIMATION_DURATION
} else {
duration
}
interpolator?.let { animator.interpolator = it }
if (onAnimationEnd != null) {
val listener = object : AnimatorListenerAdapter() {
override fun onAnimationEnd(animation: Animator?) {
onAnimationEnd.run()
animator.removeListener(this)
val listener =
object : AnimatorListenerAdapter() {
override fun onAnimationEnd(animation: Animator?) {
onAnimationEnd.run()
animator.removeListener(this)
}
override fun onAnimationCancel(animation: Animator?) {
animator.removeListener(this)
}
}
override fun onAnimationCancel(animation: Animator?) {
animator.removeListener(this)
}
}
animator.addListener(listener)
}
animator.start()
@@ -279,4 +263,4 @@ private fun <V> SparseArray<V>.getOrElse(key: Int, defaultValue: () -> V): V {
put(key, v)
}
return v
}
}

234
packages/SystemUI/animation/src/com/android/systemui/animation/TextInterpolator.kt
View File

@@ -26,12 +26,8 @@ import android.util.MathUtils
import com.android.internal.graphics.ColorUtils
import java.lang.Math.max
/**
* Provide text style linear interpolation for plain text.
*/
class TextInterpolator(
layout: Layout
) {
/** Provide text style linear interpolation for plain text. */
class TextInterpolator(layout: Layout) {
/**
* Returns base paint used for interpolation.
@@ -64,12 +60,11 @@ class TextInterpolator(
var baseFont: Font,
var targetFont: Font
) {
val length: Int get() = end - start
val length: Int
get() = end - start
}
/**
* A class represents text layout of a single run.
*/
/** A class represents text layout of a single run. */
private class Run(
val glyphIds: IntArray,
val baseX: FloatArray, // same length as glyphIds
@@ -79,12 +74,8 @@ class TextInterpolator(
val fontRuns: List<FontRun>
)
/**
* A class represents text layout of a single line.
*/
private class Line(
val runs: List<Run>
)
/** A class represents text layout of a single line. */
private class Line(val runs: List<Run>)
private var lines = listOf<Line>()
private val fontInterpolator = FontInterpolator()
@@ -106,8 +97,8 @@ class TextInterpolator(
/**
* The layout used for drawing text.
*
* Only non-styled text is supported. Even if the given layout is created from Spanned, the
* span information is not used.
* Only non-styled text is supported. Even if the given layout is created from Spanned, the span
* information is not used.
*
* The paint objects used for interpolation are not changed by this method call.
*
@@ -130,8 +121,8 @@ class TextInterpolator(
/**
* Recalculate internal text layout for interpolation.
*
* Whenever the target paint is modified, call this method to recalculate internal
* text layout used for interpolation.
* Whenever the target paint is modified, call this method to recalculate internal text layout
* used for interpolation.
*/
fun onTargetPaintModified() {
updatePositionsAndFonts(shapeText(layout, targetPaint), updateBase = false)
@@ -140,8 +131,8 @@ class TextInterpolator(
/**
* Recalculate internal text layout for interpolation.
*
* Whenever the base paint is modified, call this method to recalculate internal
* text layout used for interpolation.
* Whenever the base paint is modified, call this method to recalculate internal text layout
* used for interpolation.
*/
fun onBasePaintModified() {
updatePositionsAndFonts(shapeText(layout, basePaint), updateBase = true)
@@ -152,11 +143,11 @@ class TextInterpolator(
*
* The text interpolator does not calculate all the text position by text shaper due to
* performance reasons. Instead, the text interpolator shape the start and end state and
* calculate text position of the middle state by linear interpolation. Due to this trick,
* the text positions of the middle state is likely different from the text shaper result.
* So, if you want to start animation from the middle state, you will see the glyph jumps due to
* this trick, i.e. the progress 0.5 of interpolation between weight 400 and 700 is different
* from text shape result of weight 550.
* calculate text position of the middle state by linear interpolation. Due to this trick, the
* text positions of the middle state is likely different from the text shaper result. So, if
* you want to start animation from the middle state, you will see the glyph jumps due to this
* trick, i.e. the progress 0.5 of interpolation between weight 400 and 700 is different from
* text shape result of weight 550.
*
* After calling this method, do not call onBasePaintModified() since it reshape the text and
* update the base state. As in above notice, the text shaping result at current progress is
@@ -168,8 +159,7 @@ class TextInterpolator(
* animate weight from 200 to 400, then if you want to move back to 200 at the half of the
* animation, it will look like
*
* <pre>
* <code>
* ```
* val interp = TextInterpolator(layout)
*
* // Interpolate between weight 200 to 400.
@@ -199,9 +189,7 @@ class TextInterpolator(
* // progress is 0.5
* animator.start()
* }
* </code>
* </pre>
*
* ```
*/
fun rebase() {
if (progress == 0f) {
@@ -243,9 +231,7 @@ class TextInterpolator(
val origin = layout.getDrawOrigin(lineNo)
canvas.translate(origin, layout.getLineBaseline(lineNo).toFloat())
run.fontRuns.forEach { fontRun ->
drawFontRun(canvas, run, fontRun, tmpPaint)
}
run.fontRuns.forEach { fontRun -> drawFontRun(canvas, run, fontRun, tmpPaint) }
} finally {
canvas.restore()
}
@@ -263,69 +249,75 @@ class TextInterpolator(
}
var maxRunLength = 0
lines = baseLayout.zip(targetLayout) { baseLine, targetLine ->
val runs = baseLine.zip(targetLine) { base, target ->
require(base.glyphCount() == target.glyphCount()) {
"Inconsistent glyph count at line ${lines.size}"
}
val glyphCount = base.glyphCount()
// Good to recycle the array if the existing array can hold the new layout result.
val glyphIds = IntArray(glyphCount) {
base.getGlyphId(it).also { baseGlyphId ->
require(baseGlyphId == target.getGlyphId(it)) {
"Inconsistent glyph ID at $it in line ${lines.size}"
lines =
baseLayout.zip(targetLayout) { baseLine, targetLine ->
val runs =
baseLine.zip(targetLine) { base, target ->
require(base.glyphCount() == target.glyphCount()) {
"Inconsistent glyph count at line ${lines.size}"
}
}
}
val baseX = FloatArray(glyphCount) { base.getGlyphX(it) }
val baseY = FloatArray(glyphCount) { base.getGlyphY(it) }
val targetX = FloatArray(glyphCount) { target.getGlyphX(it) }
val targetY = FloatArray(glyphCount) { target.getGlyphY(it) }
val glyphCount = base.glyphCount()
// Calculate font runs
val fontRun = mutableListOf<FontRun>()
if (glyphCount != 0) {
var start = 0
var baseFont = base.getFont(start)
var targetFont = target.getFont(start)
require(FontInterpolator.canInterpolate(baseFont, targetFont)) {
"Cannot interpolate font at $start ($baseFont vs $targetFont)"
}
for (i in 1 until glyphCount) {
val nextBaseFont = base.getFont(i)
val nextTargetFont = target.getFont(i)
if (baseFont !== nextBaseFont) {
require(targetFont !== nextTargetFont) {
"Base font has changed at $i but target font has not changed."
// Good to recycle the array if the existing array can hold the new layout
// result.
val glyphIds =
IntArray(glyphCount) {
base.getGlyphId(it).also { baseGlyphId ->
require(baseGlyphId == target.getGlyphId(it)) {
"Inconsistent glyph ID at $it in line ${lines.size}"
}
}
}
// Font transition point. push run and reset context.
fontRun.add(FontRun(start, i, baseFont, targetFont))
maxRunLength = max(maxRunLength, i - start)
baseFont = nextBaseFont
targetFont = nextTargetFont
start = i
val baseX = FloatArray(glyphCount) { base.getGlyphX(it) }
val baseY = FloatArray(glyphCount) { base.getGlyphY(it) }
val targetX = FloatArray(glyphCount) { target.getGlyphX(it) }
val targetY = FloatArray(glyphCount) { target.getGlyphY(it) }
// Calculate font runs
val fontRun = mutableListOf<FontRun>()
if (glyphCount != 0) {
var start = 0
var baseFont = base.getFont(start)
var targetFont = target.getFont(start)
require(FontInterpolator.canInterpolate(baseFont, targetFont)) {
"Cannot interpolate font at $start ($baseFont vs $targetFont)"
}
} else { // baseFont === nextBaseFont
require(targetFont === nextTargetFont) {
"Base font has not changed at $i but target font has changed."
for (i in 1 until glyphCount) {
val nextBaseFont = base.getFont(i)
val nextTargetFont = target.getFont(i)
if (baseFont !== nextBaseFont) {
require(targetFont !== nextTargetFont) {
"Base font has changed at $i but target font has not " +
"changed."
}
// Font transition point. push run and reset context.
fontRun.add(FontRun(start, i, baseFont, targetFont))
maxRunLength = max(maxRunLength, i - start)
baseFont = nextBaseFont
targetFont = nextTargetFont
start = i
require(FontInterpolator.canInterpolate(baseFont, targetFont)) {
"Cannot interpolate font at $start ($baseFont vs " +
"$targetFont)"
}
} else { // baseFont === nextBaseFont
require(targetFont === nextTargetFont) {
"Base font has not changed at $i but target font has " +
"changed."
}
}
}
fontRun.add(FontRun(start, glyphCount, baseFont, targetFont))
maxRunLength = max(maxRunLength, glyphCount - start)
}
Run(glyphIds, baseX, baseY, targetX, targetY, fontRun)
}
fontRun.add(FontRun(start, glyphCount, baseFont, targetFont))
maxRunLength = max(maxRunLength, glyphCount - start)
}
Run(glyphIds, baseX, baseY, targetX, targetY, fontRun)
Line(runs)
}
Line(runs)
}
// Update float array used for drawing.
if (tmpPositionArray.size < maxRunLength * 2) {
@@ -357,9 +349,9 @@ class TextInterpolator(
if (glyphFilter == null) {
for (i in run.start until run.end) {
tmpPositionArray[arrayIndex++] =
MathUtils.lerp(line.baseX[i], line.targetX[i], progress)
MathUtils.lerp(line.baseX[i], line.targetX[i], progress)
tmpPositionArray[arrayIndex++] =
MathUtils.lerp(line.baseY[i], line.targetY[i], progress)
MathUtils.lerp(line.baseY[i], line.targetY[i], progress)
}
c.drawGlyphs(line.glyphIds, run.start, tmpPositionArray, 0, run.length, font, paint)
return
@@ -386,13 +378,14 @@ class TextInterpolator(
tmpPaintForGlyph.color = tmpGlyph.color
c.drawGlyphs(
line.glyphIds,
prevStart,
tmpPositionArray,
0,
i - prevStart,
font,
tmpPaintForGlyph)
line.glyphIds,
prevStart,
tmpPositionArray,
0,
i - prevStart,
font,
tmpPaintForGlyph
)
prevStart = i
arrayIndex = 0
}
@@ -402,13 +395,14 @@ class TextInterpolator(
}
c.drawGlyphs(
line.glyphIds,
prevStart,
tmpPositionArray,
0,
run.end - prevStart,
font,
tmpPaintForGlyph)
line.glyphIds,
prevStart,
tmpPositionArray,
0,
run.end - prevStart,
font,
tmpPaintForGlyph
)
}
private fun updatePositionsAndFonts(
@@ -416,9 +410,7 @@ class TextInterpolator(
updateBase: Boolean
) {
// Update target positions with newly calculated text layout.
check(layoutResult.size == lines.size) {
"The new layout result has different line count."
}
check(layoutResult.size == lines.size) { "The new layout result has different line count." }
lines.zip(layoutResult) { line, runs ->
line.runs.zip(runs) { lineRun, newGlyphs ->
@@ -434,7 +426,7 @@ class TextInterpolator(
}
require(newFont === newGlyphs.getFont(i)) {
"The new layout has different font run." +
" $newFont vs ${newGlyphs.getFont(i)} at $i"
" $newFont vs ${newGlyphs.getFont(i)} at $i"
}
}
@@ -442,7 +434,7 @@ class TextInterpolator(
// check new font can be interpolatable with base font.
require(FontInterpolator.canInterpolate(newFont, run.baseFont)) {
"New font cannot be interpolated with existing font. $newFont," +
" ${run.baseFont}"
" ${run.baseFont}"
}
if (updateBase) {
@@ -478,19 +470,19 @@ class TextInterpolator(
}
// Shape the text and stores the result to out argument.
private fun shapeText(
layout: Layout,
paint: TextPaint
): List<List<PositionedGlyphs>> {
private fun shapeText(layout: Layout, paint: TextPaint): List<List<PositionedGlyphs>> {
val out = mutableListOf<List<PositionedGlyphs>>()
for (lineNo in 0 until layout.lineCount) { // Shape all lines.
val lineStart = layout.getLineStart(lineNo)
val count = layout.getLineEnd(lineNo) - lineStart
val runs = mutableListOf<PositionedGlyphs>()
TextShaper.shapeText(layout.text, lineStart, count, layout.textDirectionHeuristic,
paint) { _, _, glyphs, _ ->
runs.add(glyphs)
}
TextShaper.shapeText(
layout.text,
lineStart,
count,
layout.textDirectionHeuristic,
paint
) { _, _, glyphs, _ -> runs.add(glyphs) }
out.add(runs)
}
return out
@@ -498,8 +490,8 @@ class TextInterpolator(
}
private fun Layout.getDrawOrigin(lineNo: Int) =
if (getParagraphDirection(lineNo) == Layout.DIR_LEFT_TO_RIGHT) {
getLineLeft(lineNo)
} else {
getLineRight(lineNo)
}
if (getParagraphDirection(lineNo) == Layout.DIR_LEFT_TO_RIGHT) {
getLineLeft(lineNo)
} else {
getLineRight(lineNo)
}