Make minor code improvements

Author: thellmund

core/src/main/java/com/alamkanak/weekview/CalendarRenderer.kt

@@ -169,8 +169,7 @@ private class BackgroundGridDrawer(
     }
 
     private fun createHourLines(): FloatArray {
-        val headerHeight = viewState.getTotalHeaderHeight()
-        val gridHeight = viewState.viewHeight - headerHeight.toInt()
+        val gridHeight = viewState.viewHeight - viewState.headerHeight
         val linesPerDay = (gridHeight / viewState.hourHeight) + 1
         val overallLines = linesPerDay.roundToInt() * (viewState.numberOfVisibleDays + 1)
         return FloatArray(overallLines * 4) // 4 lines make a cube in the grid

core/src/main/java/com/alamkanak/weekview/EventChipBoundsCalculator.kt

@@ -50,7 +50,9 @@ internal class EventChipBoundsCalculator(
         eventChip: EventChip,
         startPixel: Float
     ): RectF {
-        val top = viewState.headerTextHeight + viewState.headerRowPadding * 1.5f
+        val padding = viewState.headerRowPadding
+
+        val top = padding + viewState.dateLabelHeight + padding / 2
         val height = viewState.allDayEventTextPaint.textSize + viewState.eventPaddingVertical * 2
         val bottom = top + height
 

core/src/main/java/com/alamkanak/weekview/HeaderRenderer.kt

@@ -7,6 +7,7 @@ import android.text.StaticLayout
 import android.util.SparseArray
 import androidx.collection.ArrayMap
 import java.util.Calendar
+import kotlin.math.max
 import kotlin.math.roundToInt
 
 internal class HeaderRenderer(
@@ -19,8 +20,7 @@ internal class HeaderRenderer(
 
     private val headerRowUpdater = HeaderRowUpdater(
         viewState = viewState,
-        labelLayouts = dateLabelLayouts,
-        eventChipsCache = eventChipsCache
+        labelLayouts = dateLabelLayouts
     )
 
     private val dateLabelDrawer = DayLabelsDrawer(
@@ -50,69 +50,39 @@ internal class HeaderRenderer(
     }
 
     override fun render(canvas: Canvas) {
-        if (headerRowUpdater.isRequired()) {
-            headerRowUpdater.update()
-        }
-        dateLabelDrawer.draw(canvas)
-
         if (eventsUpdater.isRequired()) {
             eventsUpdater.update()
         }
         eventsDrawer.draw(canvas)
+
+        headerRowUpdater.update()
+        dateLabelDrawer.draw(canvas)
     }
 }
 
 private class HeaderRowUpdater(
     private val viewState: ViewState,
-    private val labelLayouts: SparseArray<StaticLayout>,
-    private val eventChipsCache: EventChipsCache
+    private val labelLayouts: SparseArray<StaticLayout>
 ) : Updater {
 
-    private var previousHorizontalOrigin: Float? = null
-    private val previousAllDayEventIds = mutableSetOf<Long>()
-
-    override fun isRequired(): Boolean {
-        val didScrollHorizontally = previousHorizontalOrigin != viewState.currentOrigin.x
-        val currentTimeColumnWidth = viewState.timeTextWidth + viewState.timeColumnPadding * 2
-        val didTimeColumnChange = currentTimeColumnWidth != viewState.timeColumnWidth
-        val allDayEvents = eventChipsCache.allDayEventChipsInDateRange(viewState.dateRange)
-            .map { it.eventId }
-            .toSet()
-        val didEventsChange = allDayEvents.hashCode() != previousAllDayEventIds.hashCode()
-        return (didScrollHorizontally || didTimeColumnChange || didEventsChange).also {
-            previousAllDayEventIds.clear()
-            previousAllDayEventIds += allDayEvents
+    override fun update() {
+        val missingDates = viewState.dateRange.filterNot { labelLayouts.contains(it.toEpochDays()) }
+        for (date in missingDates) {
+            val key = date.toEpochDays()
+            labelLayouts.put(key, calculateStaticLayoutForDate(date))
         }
-    }
 
-    override fun update() {
-        val dateLabels = updateDateLabels(viewState)
-        updateHeaderHeight(viewState, dateLabels)
+        val dateLabels = viewState.dateRange.map { labelLayouts[it.toEpochDays()] }
+        updateHeaderHeight(dateLabels)
     }
 
-    private fun updateDateLabels(state: ViewState): List<StaticLayout> {
-        val textLayouts = state.dateRange.map { date ->
-            date.toEpochDays() to calculateStaticLayoutForDate(date)
-        }.toMap()
-
-        labelLayouts.clear()
-        labelLayouts += textLayouts
-
-        return textLayouts.values.toList()
-    }
+    private fun <E> SparseArray<E>.contains(key: Int): Boolean = indexOfKey(key) >= 0
 
     private fun updateHeaderHeight(
-        state: ViewState,
         dateLabels: List<StaticLayout>
     ) {
         val maximumLayoutHeight = dateLabels.map { it.height.toFloat() }.max() ?: 0f
-        state.headerTextHeight = maximumLayoutHeight
-        refreshHeaderHeight()
-    }
-
-    private fun refreshHeaderHeight() {
-        val visibleEvents = eventChipsCache.allDayEventChipsInDateRange(viewState.dateRange)
-        viewState.hasEventInHeader = visibleEvents.isNotEmpty()
+        viewState.dateLabelHeight = maximumLayoutHeight
         viewState.refreshHeaderHeight()
     }
 
@@ -135,23 +105,23 @@ private class DayLabelsDrawer(
 ) : Drawer {
 
     override fun draw(canvas: Canvas) {
-        val left = viewState.timeColumnWidth
-        val top = 0f
-        val right = canvas.width.toFloat()
-        val bottom = viewState.getTotalHeaderHeight()
-
-        canvas.drawInBounds(left, top, right, bottom) {
+        canvas.drawInBounds(
+            left = viewState.timeColumnWidth,
+            top = 0f,
+            right = canvas.width.toFloat(),
+            bottom = viewState.headerHeight
+        ) {
             viewState.dateRangeWithStartPixels.forEach { (date, startPixel) ->
-                drawLabel(date, startPixel, this)
+                drawLabel(date, startPixel)
             }
         }
     }
 
-    private fun drawLabel(day: Calendar, startPixel: Float, canvas: Canvas) {
+    private fun Canvas.drawLabel(day: Calendar, startPixel: Float) {
         val key = day.toEpochDays()
         val textLayout = dateLabelLayouts[key]
 
-        canvas.withTranslation(
+        withTranslation(
             x = startPixel + viewState.widthPerDay / 2,
             y = viewState.headerRowPadding.toFloat()
         ) {
@@ -192,7 +162,10 @@ private class AllDayEventsUpdater(
 
             val eventChips = eventChipsCache.allDayEventChipsByDate(date)
             for (eventChip in eventChips) {
-                calculateTextLayout(eventChip, modifiedStartPixel)
+                val bounds = eventChip.calculateBounds(modifiedStartPixel)
+                if (bounds != null) {
+                    eventsLabelLayouts[eventChip] = eventChip.calculateTextLayout()
+                }
             }
         }
 
@@ -201,27 +174,18 @@ private class AllDayEventsUpdater(
             .map { it.height().roundToInt() }
             .max() ?: 0
 
-        viewState.updateAllDayEventHeight(maximumChipHeight)
+        viewState.currentAllDayEventHeight = maximumChipHeight
     }
 
-    private fun calculateTextLayout(
-        eventChip: EventChip,
-        startPixel: Float
-    ) {
-        val chipRect = boundsCalculator.calculateAllDayEvent(eventChip, startPixel)
-        eventChip.bounds = if (chipRect.isValidEventBounds) chipRect else null
-
-        if (chipRect.isValidEventBounds) {
-            val textLayout = calculateChipTextLayout(eventChip)
-            if (textLayout != null) {
-                eventsLabelLayouts[eventChip] = textLayout
-            }
-        }
+    private fun EventChip.calculateBounds(startPixel: Float): RectF? {
+        val chipRect = boundsCalculator.calculateAllDayEvent(this, startPixel)
+        bounds = chipRect
+        return chipRect.takeIf { it.isValidEventBounds }
     }
 
-    private fun calculateChipTextLayout(eventChip: EventChip): StaticLayout? {
-        val event = eventChip.event
-        val bounds = checkNotNull(eventChip.bounds)
+    private fun EventChip.calculateTextLayout(): StaticLayout? {
+        val event = event
+        val bounds = checkNotNull(bounds)
 
         val fullHorizontalPadding = viewState.eventPaddingHorizontal * 2
         val fullVerticalPadding = viewState.eventPaddingVertical * 2
@@ -262,7 +226,7 @@ private class AllDayEventsUpdater(
         val chipHeight = lineHeight + fullVerticalPadding
         bounds.bottom = bounds.top + chipHeight
 
-        return eventChip.ellipsizeText(text, availableWidth, existingTextLayout = textLayout)
+        return ellipsizeText(text, availableWidth, existingTextLayout = textLayout)
     }
 
     /**
@@ -314,12 +278,12 @@ internal class AllDayEventsDrawer(
     private val eventChipDrawer = EventChipDrawer(viewState)
 
     override fun draw(canvas: Canvas) {
-        val left = viewState.timeColumnWidth
-        val top = 0f
-        val right = canvas.width.toFloat()
-        val bottom = viewState.getTotalHeaderHeight()
-
-        canvas.drawInBounds(left, top, right, bottom) {
+        canvas.drawInBounds(
+            left = viewState.timeColumnWidth,
+            top = 0f,
+            right = canvas.width.toFloat(),
+            bottom = viewState.headerHeight
+        ) {
             for ((eventChip, textLayout) in allDayEventLayouts) {
                 eventChipDrawer.draw(eventChip, canvas, textLayout)
             }

core/src/main/java/com/alamkanak/weekview/Renderers.kt

@@ -3,7 +3,7 @@ package com.alamkanak.weekview
 import android.graphics.Canvas
 
 internal interface Updater {
-    fun isRequired(): Boolean
+    fun isRequired(): Boolean = true
     fun update()
 }
 

core/src/main/java/com/alamkanak/weekview/TimeColumnRenderer.kt

@@ -11,17 +11,15 @@ internal class TimeColumnRenderer(
     private val timeLabelLayouts = SparseArray<StaticLayout>()
 
     init {
-        cacheTimeLabels()
+        updateTimeLabels()
     }
 
     override fun onSizeChanged(width: Int, height: Int) {
-        timeLabelLayouts.clear()
-        cacheTimeLabels()
+        updateTimeLabels()
     }
 
     override fun onTimeFormatterChanged(formatter: TimeFormatter) {
-        timeLabelLayouts.clear()
-        cacheTimeLabels()
+        updateTimeLabels()
     }
 
     override fun render(canvas: Canvas) = with(viewState) {
@@ -41,16 +39,18 @@ internal class TimeColumnRenderer(
                 continue
             }
 
-            val x = timeTextWidth + timeColumnPadding
             var y = topMargin - timeTextHeight / 2
 
             // If the hour separator is shown in the time column, move the time label below it
             if (showTimeColumnHourSeparator) {
                 y += timeTextHeight / 2 + hourSeparatorPaint.strokeWidth + timeColumnPadding
             }
 
+            val label = timeLabelLayouts[hour]
+            val x = timeColumnWidth - timeColumnPadding
+
             canvas.withTranslation(x, y) {
-                timeLabelLayouts[hour].draw(this)
+                label.draw(this)
             }
 
             if (showTimeColumnHourSeparator && hour > 0) {
@@ -74,10 +74,21 @@ internal class TimeColumnRenderer(
         }
     }
 
-    private fun cacheTimeLabels() = with(viewState) {
+    private fun updateTimeLabels() = with(viewState) {
+        var maxLineLength = 0f
+        var maxLineHeight = 0
+
+        timeLabelLayouts.clear()
         for (hour in displayedHours) {
             val textLayout = timeFormatter(hour).toTextLayout(timeTextPaint, width = Int.MAX_VALUE)
+            maxLineLength = textLayout.maxLineLength
+            maxLineHeight = textLayout.height
             timeLabelLayouts.put(hour, textLayout)
         }
+
+        updateTimeColumnBounds(
+            lineLength = maxLineLength,
+            lineHeight = maxLineHeight.toFloat()
+        )
     }
 }