Consolidate all view state information in new ViewState data class (alamkanak#161)

Author: thellmund

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

@@ -6,33 +6,32 @@ import android.text.StaticLayout
 import kotlin.math.roundToInt
 
 internal class AllDayEventsUpdater<T : Any>(
-    private val view: WeekView<T>,
-    private val config: WeekViewConfigWrapper,
+    private val viewState: ViewState,
     private val cache: WeekViewCache<T>,
     private val chipsCache: EventChipsCache<T>
 ) : Updater {
 
-    private val boundsCalculator = EventChipBoundsCalculator<T>(config)
+    private val boundsCalculator = EventChipBoundsCalculator<T>(viewState)
     private val spannableStringBuilder = SpannableStringBuilder()
 
     private var previousHorizontalOrigin: Float? = null
     private var dummyTextLayout: StaticLayout? = null
 
-    override fun isRequired(drawingContext: DrawingContext): Boolean {
-        val didScrollHorizontally = previousHorizontalOrigin != config.currentOrigin.x
-        val dateRange = drawingContext.dateRange
+    override fun isRequired(): Boolean {
+        val didScrollHorizontally = previousHorizontalOrigin != viewState.currentOrigin.x
+        val dateRange = viewState.dateRange
         val containsNewChips = chipsCache.allDayEventChipsInDateRange(dateRange).any { it.bounds == null }
         return didScrollHorizontally || containsNewChips
     }
 
-    override fun update(drawingContext: DrawingContext) {
+    override fun update() {
         cache.clearAllDayEventLayouts()
 
-        val datesWithStartPixels = drawingContext.dateRangeWithStartPixels
+        val datesWithStartPixels = viewState.dateRangeWithStartPixels
         for ((date, startPixel) in datesWithStartPixels) {
             // If we use a horizontal margin in the day view, we need to offset the start pixel.
             val modifiedStartPixel = when {
-                config.isSingleDay -> startPixel + config.eventMarginHorizontal.toFloat()
+                viewState.isSingleDay -> startPixel + viewState.eventMarginHorizontal.toFloat()
                 else -> startPixel
             }
 
@@ -47,7 +46,7 @@ internal class AllDayEventsUpdater<T : Any>(
             .map { it.height().roundToInt() }
             .max() ?: 0
 
-        config.updateAllDayEventHeight(maximumChipHeight)
+        viewState.updateAllDayEventHeight(maximumChipHeight)
     }
 
     private fun calculateTextLayout(
@@ -71,8 +70,8 @@ internal class AllDayEventsUpdater<T : Any>(
         val event = eventChip.event
         val bounds = checkNotNull(eventChip.bounds)
 
-        val fullHorizontalPadding = config.eventPaddingHorizontal * 2
-        val fullVerticalPadding = config.eventPaddingVertical * 2
+        val fullHorizontalPadding = viewState.eventPaddingHorizontal * 2
+        val fullVerticalPadding = viewState.eventPaddingVertical * 2
 
         val width = bounds.width() - fullHorizontalPadding
         val height = bounds.height() - fullVerticalPadding
@@ -106,7 +105,7 @@ internal class AllDayEventsUpdater<T : Any>(
         val text = spannableStringBuilder.build()
         val availableWidth = width.toInt()
 
-        val textPaint = config.getTextPaint(event)
+        val textPaint = viewState.getTextPaint(event)
         val textLayout = text.toTextLayout(textPaint, availableWidth)
         val lineHeight = textLayout.height / textLayout.lineCount
 
@@ -124,7 +123,7 @@ internal class AllDayEventsUpdater<T : Any>(
         event: ResolvedWeekViewEvent<T>
     ): StaticLayout {
         if (dummyTextLayout == null) {
-            val textPaint = config.getTextPaint(event)
+            val textPaint = viewState.getTextPaint(event)
             dummyTextLayout = "".toTextLayout(textPaint, width = 0)
         }
         return checkNotNull(dummyTextLayout)
@@ -135,9 +134,9 @@ internal class AllDayEventsUpdater<T : Any>(
         availableWidth: Int,
         existingTextLayout: StaticLayout
     ): StaticLayout {
-        val textPaint = config.getTextPaint(event)
+        val textPaint = viewState.getTextPaint(event)
         val bounds = checkNotNull(bounds)
-        val width = bounds.width().roundToInt() - (config.eventPaddingHorizontal * 2)
+        val width = bounds.width().roundToInt() - (viewState.eventPaddingHorizontal * 2)
 
         val ellipsized = text.ellipsized(textPaint, availableWidth)
         val isTooSmallForText = width < 0
@@ -152,8 +151,8 @@ internal class AllDayEventsUpdater<T : Any>(
 
     private val RectF.isValidEventBounds: Boolean
         get() = (left < right &&
-            left < view.width &&
-            top < view.height &&
-            right > config.timeColumnWidth &&
+            left < viewState.viewWidth &&
+            top < viewState.viewHeight &&
+            right > viewState.timeColumnWidth &&
             bottom > 0)
 }

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

@@ -5,65 +5,61 @@ import kotlin.math.max
 import kotlin.math.roundToInt
 
 internal class BackgroundGridDrawer(
-    private val view: WeekView<*>,
-    private val config: WeekViewConfigWrapper
+    private val viewState: ViewState
 ) : Drawer {
 
     private lateinit var hourLines: FloatArray
 
-    override fun draw(
-        drawingContext: DrawingContext,
-        canvas: Canvas
-    ) {
-        drawingContext.startPixels.forEach { startPixel ->
-            val startX = max(startPixel, config.timeColumnWidth)
+    override fun draw(canvas: Canvas) {
+        viewState.startPixels.forEach { startPixel ->
+            val startX = max(startPixel, viewState.timeColumnWidth)
             drawGrid(startX, startPixel, canvas)
         }
     }
 
     private fun createHourLines(): FloatArray {
-        val headerHeight = config.getTotalHeaderHeight()
-        val gridHeight = view.height - headerHeight.toInt()
-        val linesPerDay = (gridHeight / config.hourHeight) + 1
-        val overallLines = linesPerDay.roundToInt() * (config.numberOfVisibleDays + 1)
+        val headerHeight = viewState.getTotalHeaderHeight()
+        val gridHeight = viewState.viewHeight - headerHeight.toInt()
+        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
     }
 
     private fun drawGrid(startX: Float, startPixel: Float, canvas: Canvas) {
-        if (config.showHourSeparators) {
+        if (viewState.showHourSeparators) {
             hourLines = createHourLines()
             drawHourLines(startX, startPixel, canvas)
         }
 
-        if (config.showDaySeparators) {
+        if (viewState.showDaySeparators) {
             drawDaySeparators(startPixel, canvas)
         }
     }
 
     private fun drawDaySeparators(startPixel: Float, canvas: Canvas) {
-        val days = config.numberOfVisibleDays
-        val widthPerDay = config.totalDayWidth
-        val top = config.headerHeight
+        val days = viewState.numberOfVisibleDays
+        val widthPerDay = viewState.totalDayWidth
+        val top = viewState.headerHeight
 
         for (i in 0 until days) {
             val start = startPixel + widthPerDay * (i + 1)
-            canvas.drawLine(start, top, start, top + view.height, config.daySeparatorPaint)
+            canvas.drawLine(start, top, start, top + viewState.viewHeight, viewState.daySeparatorPaint)
         }
     }
 
     private fun drawHourLines(startX: Float, startPixel: Float, canvas: Canvas) {
-        val hourStep = config.timeColumnHoursInterval
+        val hourStep = viewState.timeColumnHoursInterval
         var lineIndex = 0
 
-        for (hour in hourStep until config.hoursPerDay step hourStep) {
-            val heightOfHour = (config.hourHeight * hour)
-            val top = config.headerHeight + config.currentOrigin.y + heightOfHour
+        for (hour in hourStep until viewState.hoursPerDay step hourStep) {
+            val heightOfHour = (viewState.hourHeight * hour)
+            val top = viewState.headerHeight + viewState.currentOrigin.y + heightOfHour
 
-            val widthPerDay = config.totalDayWidth
-            val separatorWidth = config.hourSeparatorPaint.strokeWidth
+            val widthPerDay = viewState.totalDayWidth
+            val separatorWidth = viewState.hourSeparatorPaint.strokeWidth
 
-            val isNotHiddenByHeader = top > config.headerHeight - separatorWidth
-            val isWithinVisibleRange = top < view.height
+            val isNotHiddenByHeader = top > viewState.headerHeight - separatorWidth
+            val isWithinVisibleRange = top < viewState.viewHeight
             val isVisibleHorizontally = startPixel + widthPerDay - startX > 0
 
             if (isNotHiddenByHeader && isWithinVisibleRange && isVisibleHorizontally) {
@@ -75,6 +71,6 @@ internal class BackgroundGridDrawer(
             }
         }
 
-        canvas.drawLines(hourLines, config.hourSeparatorPaint)
+        canvas.drawLines(hourLines, viewState.hourSeparatorPaint)
     }
 }

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

@@ -194,7 +194,7 @@ internal fun firstDayOfYear(): Calendar {
     }
 }
 
-internal fun WeekViewConfigWrapper.createDateRange(start: Int, end: Int): List<Calendar> {
+internal fun ViewState.createDateRange(start: Int, end: Int): List<Calendar> {
     val firstDate = today()
     firstDate.firstDayOfWeek = firstDayOfWeek
     return (start..end).map { firstDate + Days(it - 1) }

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

@@ -7,15 +7,11 @@ import java.util.Calendar
 import kotlin.math.max
 
 internal class DayBackgroundDrawer(
-    private val view: WeekView<*>,
-    private val config: WeekViewConfigWrapper
+    private val viewState: ViewState
 ) : Drawer {
 
-    override fun draw(
-        drawingContext: DrawingContext,
-        canvas: Canvas
-    ) {
-        drawingContext.dateRangeWithStartPixels.forEach { (date, startPixel) ->
+    override fun draw(canvas: Canvas) {
+        viewState.dateRangeWithStartPixels.forEach { (date, startPixel) ->
             drawDayBackground(date, startPixel, canvas)
         }
     }
@@ -32,32 +28,32 @@ internal class DayBackgroundDrawer(
         startPixel: Float,
         canvas: Canvas
     ) {
-        val endPixel = startPixel + config.widthPerDay
-        val isCompletelyHiddenByTimeColumn = endPixel <= config.timeColumnWidth
+        val endPixel = startPixel + viewState.widthPerDay
+        val isCompletelyHiddenByTimeColumn = endPixel <= viewState.timeColumnWidth
         if (isCompletelyHiddenByTimeColumn) {
             return
         }
 
-        val actualStartPixel = max(startPixel, config.timeColumnWidth)
-        val height = view.height.toFloat()
+        val actualStartPixel = max(startPixel, viewState.timeColumnWidth)
+        val height = viewState.viewHeight.toFloat()
 
-        if (config.showDistinctPastFutureColor) {
-            val useWeekendColor = day.isWeekend && config.showDistinctWeekendColor
-            val pastPaint = config.getPastBackgroundPaint(useWeekendColor)
-            val futurePaint = config.getFutureBackgroundPaint(useWeekendColor)
+        if (viewState.showDistinctPastFutureColor) {
+            val useWeekendColor = day.isWeekend && viewState.showDistinctWeekendColor
+            val pastPaint = viewState.getPastBackgroundPaint(useWeekendColor)
+            val futurePaint = viewState.getFutureBackgroundPaint(useWeekendColor)
 
-            val startY = config.headerHeight + config.currentOrigin.y
-            val endX = startPixel + config.widthPerDay
+            val startY = viewState.headerHeight + viewState.currentOrigin.y
+            val endX = startPixel + viewState.widthPerDay
 
             when {
                 day.isToday -> drawPastAndFutureRect(actualStartPixel, startY, endX, pastPaint, futurePaint, height, canvas)
                 day.isBeforeToday -> canvas.drawRect(actualStartPixel, startY, endX, height, pastPaint)
                 else -> canvas.drawRect(actualStartPixel, startY, endX, height, futurePaint)
             }
         } else {
-            val todayPaint = config.getDayBackgroundPaint(day.isToday)
-            val right = startPixel + config.widthPerDay
-            canvas.drawRect(actualStartPixel, config.headerHeight, right, height, todayPaint)
+            val todayPaint = viewState.getDayBackgroundPaint(day.isToday)
+            val right = startPixel + viewState.widthPerDay
+            canvas.drawRect(actualStartPixel, viewState.headerHeight, right, height, todayPaint)
         }
     }
 
@@ -71,10 +67,10 @@ internal class DayBackgroundDrawer(
         canvas: Canvas
     ) {
         val now = now()
-        val hour = now.hour - config.minHour
+        val hour = now.hour - viewState.minHour
         val hourFraction = now.minute / MINUTES_PER_HOUR
 
-        val beforeNow = (hour + hourFraction) * config.hourHeight
+        val beforeNow = (hour + hourFraction) * viewState.hourHeight
         canvas.drawRect(startX, startY, endX, startY + beforeNow, pastPaint)
         canvas.drawRect(startX, startY + beforeNow, endX, height, futurePaint)
     }

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

@@ -4,21 +4,18 @@ import android.graphics.Canvas
 import java.util.Calendar
 
 internal class DayLabelsDrawer<T>(
-    private val config: WeekViewConfigWrapper,
+    private val viewState: ViewState,
     private val cache: WeekViewCache<T>
 ) : Drawer {
 
-    override fun draw(
-        drawingContext: DrawingContext,
-        canvas: Canvas
-    ) {
-        val left = config.timeColumnWidth
+    override fun draw(canvas: Canvas) {
+        val left = viewState.timeColumnWidth
         val top = 0f
         val right = canvas.width.toFloat()
-        val bottom = config.getTotalHeaderHeight()
+        val bottom = viewState.getTotalHeaderHeight()
 
         canvas.drawInRect(left, top, right, bottom) {
-            drawingContext.dateRangeWithStartPixels.forEach { (date, startPixel) ->
+            viewState.dateRangeWithStartPixels.forEach { (date, startPixel) ->
                 drawLabel(date, startPixel, this)
             }
         }
@@ -29,8 +26,8 @@ internal class DayLabelsDrawer<T>(
         val textLayout = cache.dateLabelLayouts[key]
 
         canvas.withTranslation(
-            x = startPixel + config.widthPerDay / 2,
-            y = config.headerRowPadding.toFloat()
+            x = startPixel + viewState.widthPerDay / 2,
+            y = viewState.headerRowPadding.toFloat()
         ) {
             textLayout.draw(this)
         }