layout: replace menu icon with utf8 character

The three dot menu icosn looks odd when stretched
due to the dynamic menu feature. Thus replace it
with the hamburger menu character that looks better
when scaled.

app/src/main/java/it/danieleverducci/lunatracker/MainActivity.kt

@@ -421,10 +421,10 @@ class MainActivity : AppCompatActivity() {
     }
 
     fun addSleepEvent(event: LunaEvent) {
-        askSleepValue(event, true) { saveEvent(event) }
+        askSleepValue(event) { saveEvent(event) }
     }
 
-    fun askSleepValue(event: LunaEvent, hideDurationButtons: Boolean, onPositive: () -> Unit) {
+    fun askSleepValue(event: LunaEvent, onPositive: () -> Unit) {
         val d = AlertDialog.Builder(this)
         val dialogView = layoutInflater.inflate(R.layout.dialog_edit_duration, null)
         d.setTitle(event.getDialogTitle(this))
@@ -432,9 +432,8 @@ class MainActivity : AppCompatActivity() {
         d.setView(dialogView)
 
         val durationTextView = dialogView.findViewById<TextView>(R.id.dialog_date_duration)
-        val datePicker = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
-        val durationButtons = dialogView.findViewById<LinearLayout>(R.id.duration_buttons)
         val durationNowButton = dialogView.findViewById<Button>(R.id.dialog_date_duration_now)
+        val datePicker = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
         val durationMinus5Button = dialogView.findViewById<Button>(R.id.dialog_date_duration_minus5)
         val durationPlus5Button = dialogView.findViewById<Button>(R.id.dialog_date_duration_plus5)
 
@@ -466,13 +465,6 @@ class MainActivity : AppCompatActivity() {
 
         onDateChange(pickedDateTime.time.time / 1000)
 
-        if (hideDurationButtons) {
-            durationButtons.visibility = View.GONE
-            d.setMessage(getString(R.string.log_sleep_dialog_description_start))
-        } else {
-            durationButtons.visibility = View.VISIBLE
-            d.setMessage(event.getDialogMessage(this))
-
         fun adjust(minutes: Int) {
             duration += minutes * 60
             if (duration < 0) {
@@ -493,7 +485,6 @@ class MainActivity : AppCompatActivity() {
                 onDateChange(pickedDateTime.time.time / 1000)
             }
         }
-        }
 
         d.setPositiveButton(android.R.string.ok) { dialogInterface, i ->
             val time = pickedDateTime.time.time / 1000
@@ -516,7 +507,6 @@ class MainActivity : AppCompatActivity() {
     }
 
     fun addAmountEvent(event: LunaEvent) {
-        setToPreviousQuantity(event)
         askAmountValue(event, true) { saveEvent(event) }
     }
 
@@ -533,7 +523,7 @@ class MainActivity : AppCompatActivity() {
             R.array.AmountLabels,
             android.R.layout.simple_spinner_dropdown_item
         )
-
+        // set pre-selected item and ensure the quantity to index is in bounds
         spinner.setSelection(event.quantity.coerceIn(0, spinner.count - 1))
 
         val dateTV = dialogView.findViewById<TextView>(R.id.dialog_date_picker)
@@ -845,7 +835,7 @@ class MainActivity : AppCompatActivity() {
                 LunaEvent.Type.PUKE -> askAmountValue(event, false, updateValues)
                 LunaEvent.Type.TEMPERATURE -> askTemperatureValue(event, false, updateValues)
                 LunaEvent.Type.NOTE -> askNotes(event, false, updateValues)
-                LunaEvent.Type.SLEEP -> askSleepValue(event, false, updateValues)
+                LunaEvent.Type.SLEEP -> askSleepValue(event, updateValues)
                 else -> {
                     Log.w(TAG, "Unexpected type: ${event.type}")
                 }

app/src/main/java/it/danieleverducci/lunatracker/StatisticsActivity.kt

@@ -12,7 +12,6 @@ import android.widget.Toast
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.graphics.toColorInt
 import com.github.mikephil.charting.charts.BarChart
-import com.github.mikephil.charting.components.YAxis
 import com.github.mikephil.charting.data.BarData
 import com.github.mikephil.charting.data.BarDataSet
 import com.github.mikephil.charting.data.BarEntry
@@ -83,12 +82,10 @@ class StatisticsActivity : AppCompatActivity() {
         barChart.axisRight.setDrawGridLines(false)
         barChart.axisRight.setDrawLabels(false)
 
+        //barChart.xAxis.setDrawGridLines(true)
         barChart.xAxis.setDrawLabels(true)
         barChart.xAxis.setDrawAxisLine(false)
 
-        barChart.isScaleXEnabled = false
-        barChart.isScaleYEnabled = true
-
         graphTypeSpinner = findViewById(R.id.graph_type_selection)
         timeRangeSpinner = findViewById(R.id.time_range_selection)
 
@@ -139,54 +136,20 @@ class StatisticsActivity : AppCompatActivity() {
         }
     }
 
-    fun resetBarChart() {
-        barChart.fitScreen()
-        barChart.data?.clearValues()
-        barChart.xAxis.valueFormatter = null
-        barChart.notifyDataSetChanged()
-        barChart.clear()
-        barChart.invalidate()
-/*
-        barChart.setBackgroundColor(Color.WHITE)
-        //barChart.description.text = logbookName
-        barChart.setDrawValueAboveBar(false)
-
-        barChart.axisLeft.setAxisMinimum(0F)
-        barChart.axisLeft.setDrawGridLines(false)
-        barChart.axisLeft.setDrawLabels(false)
-
-        barChart.axisRight.setDrawGridLines(false)
-        barChart.axisRight.setDrawLabels(false)
-
-        //barChart.xAxis.setDrawGridLines(true)
-        barChart.xAxis.setDrawLabels(true)
-        barChart.xAxis.setDrawAxisLine(false)
-
-        barChart.xAxis.setCenterAxisLabels(true)
-        barChart.setScaleEnabled(false)
-        //barChart.isScaleXEnabled = false
-        //barChart.isScaleYEnabled = true
-*/
-        // for debugging
-        Log.d(TAG, "resetBarChart; barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}, barChart.visibleXRange: ${barChart.visibleXRange}, barChart.xAxis.isCenterAxisLabelsEnabled: ${barChart.xAxis.isCenterAxisLabelsEnabled}, barChart.isAutoScaleMinMaxEnabled: ${barChart.isAutoScaleMinMaxEnabled}, barChart.isScaleXEnabled: ${barChart.isScaleXEnabled}, barChart.isScaleYEnabled: ${barChart.isScaleYEnabled}")
-    }
-
     fun showMedicineBarGraph(state: GraphState) {
         val values = HashMap<String, ArrayList<BarEntry>>()
-        val days = state.endSpan - state.startSpan + 1
 
         for (event in state.events) {
             val index = unixToSpan(event.time) - state.startSpan
             val key = event.notes.trim().lowercase()
             val array = values.getOrPut(key) {
-                // create initial array with 0
-                ArrayList(List(days) { BarEntry(it.toFloat(), 0F) })
+                ArrayList(List(state.endSpan - state.startSpan + 1) { BarEntry(it.toFloat(), 0F) })
             }
 
             array[index].y += 1F
         }
 
-        Log.d(TAG, "values.size: ${values.size}, days: $days")
+        Log.d(TAG, "values.size: ${values.size}")
         for ((key, value) in values) {
             Log.d(TAG, "key: $key, value.size: ${value.size} ,value: ${value.joinToString { it.y.toLong().toString() }}")
         }
@@ -205,18 +168,19 @@ class StatisticsActivity : AppCompatActivity() {
         }
 
         val sets = arrayListOf<IBarDataSet>()
-        for ((key, array) in values.entries) {
+        for ((key, value) in values.entries) {
+            if (key.startsWith("v")) {
                 val description = shorten(key)
-            Log.d(TAG, "key: $key")
-            val barDataSet = BarDataSet(array, description)
+                val barDataSet = BarDataSet(value, description)
                 barDataSet.color = chooseColor(key)
                 sets.add(barDataSet)
             }
+        }
 
         val data = BarData(sets)
         //data.groupBars(0F, 0.2F, 0.1F);
-        //data.setValueTextSize(12f)
-        //data.barWidth = 1F
+        data.setValueTextSize(12f)
+        data.barWidth = 1F
         //data.groupBars(0F, 1F, 1F)
 
         data.setValueFormatter(object : ValueFormatter() {
@@ -229,31 +193,22 @@ class StatisticsActivity : AppCompatActivity() {
             }
         })
 
-        barChart.setOnChartValueSelectedListener(object : OnChartValueSelectedListener {
-            override fun onValueSelected(e: Entry?, h: Highlight?) {
-                Log.d(TAG, "onValueSelected ${e == null} ${h == null}")
-                if (e == null || h == null) {
-                    return
-                }
-
-                val index = e.x.toInt()
-                if (index !in 0..values.size) {
-                    return
-                }
-
-                Log.d(TAG, "index: $index")
-            }
-            override fun onNothingSelected() {}
-        })
-
-        data.setValueTextSize(12f)
-        barChart.setData(data)
-
+        barChart.setScaleEnabled(true)
         barChart.legend.isEnabled = true
-        val valueCount = min(days, 24)
-        barChart.setVisibleXRangeMaximum(valueCount.toFloat())
-        barChart.xAxis.setLabelCount(valueCount)
-        barChart.xAxis.setCenterAxisLabels(false)
+
+        //barChart.xAxis.setLabelCount(min(values.size, 24), false);
+        //val maxCount = min(maxIndex, 30) // values.size
+        //Log.d(TAG, "maxCount: $maxCount")
+        barChart.setVisibleXRangeMaximum(20F) //maxCount.toFloat()) // show max 24 entries
+        barChart.xAxis.setLabelCount(30, true)
+        //barChart.xAxis.isEnabled = false
+        barChart.xAxis.setCenterAxisLabels(true)
+        barChart.setScaleEnabled(false)
+
+        //barChart.axisLeft.isSLEEP_PATTERN_GRANULARITYEnabled = true
+        //barChart.axisLeft.setSLEEP_PATTERN_GRANULARITY(0.8F)
+
+        barChart.setData(data)
         barChart.invalidate()
     }
 
@@ -292,7 +247,7 @@ class StatisticsActivity : AppCompatActivity() {
         return ranges
     }
 
-    fun showSleepPatternBarGraphSlotted(state: GraphState) {
+    fun showSleepPatternBarGraph(state: GraphState) {
         val ranges = toSleepRanges(state.events)
         val values = ArrayList<BarEntry>()
         val stack = ArrayList(List(state.endSpan - state.startSpan + 1) { IntArray(24 * 60 * 60 / SLEEP_PATTERN_GRANULARITY) })
@@ -318,7 +273,7 @@ class StatisticsActivity : AppCompatActivity() {
                     assert(sleepBegin <= sleepEnd)
                     val iBegin = (sleepBegin - dayBegin) / SLEEP_PATTERN_GRANULARITY
                     val iEnd = iBegin + (sleepEnd - sleepBegin) / SLEEP_PATTERN_GRANULARITY
-                    //Log.d(TAG, "index: $index, iBegin: $iBegin, iEnd: $iEnd, dayBegin: ${Date(dayBegin * 1000)}, dayEnd: ${Date(dayEnd * 1000)}, sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}")
+                    Log.d(TAG, "index: $index, iBegin: $iBegin, iEnd: $iEnd, dayBegin: ${Date(dayBegin * 1000)}, dayEnd: ${Date(dayEnd * 1000)}, sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}")
                     for (j in iBegin..iEnd) {
                         stack[index][j.toInt()] += 1
                     }
@@ -356,7 +311,7 @@ class StatisticsActivity : AppCompatActivity() {
         }
 
         fun mapColor(occurrences: Int, maxOccurrences: Int): Int {
-            // occurrences: number of reported sleeps in a specific time slot
+            // occurences: number of reported sleeps in a specific time slice
             // maxOccurrences: maximum number of days with data that can contribute to maxOccurrences
             assert(maxOccurrences > 0)
             assert(occurrences <= maxOccurrences)
@@ -373,18 +328,18 @@ class StatisticsActivity : AppCompatActivity() {
         for ((index, dayArray) in stack.withIndex()) {
             val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
 
-            //Log.d(TAG, "index: $index: daysWithData: $daysWithData, dayArray: ${dayArray.joinToString { it.toString() }}")
+            //Log.d(TAG, "index: $index: dayArray: ${dayArray.joinToString { it.toString() }}")
             val vals = ArrayList<Float>()
 
-            var prevIndex = -1 // time slot index
-            var prevValue = -1 // number of entries we have found for time slot
+            var prevIndex = -1 // time slice index
+            var prevValue = -1 // number of entries we have found for time slice
             for ((i, v) in dayArray.withIndex()) {
                 if (i == 0) {
                     prevIndex = i
                     prevValue = v
                 } else if (prevValue != v) {
                     vals.add((i - prevIndex).toFloat())
-                    allColors.add(mapColor(prevValue.coerceAtMost(daysWithData), daysWithData))
+                    allColors.add(mapColor(prevValue, daysWithData))
                     prevIndex = i
                     prevValue = v
                 }
@@ -397,11 +352,10 @@ class StatisticsActivity : AppCompatActivity() {
 
             //Log.d(TAG, "Range $index, vals: ${vals.joinToString { it.toInt().toString() }}") //, allColors: ${allColors.joinToString { it.toString() }}")
 
-            Log.d(TAG, "index: ${index.toFloat()}")
             values.add(BarEntry(index.toFloat(), vals.toFloatArray()))
         }
 
-        //Log.d(TAG, "daysWithData: ${state.dayCounter.daysWithData.joinToString()}")
+        Log.d(TAG, "daysWithData: ${state.dayCounter.daysWithData.joinToString()}")
 
         barChart.setOnChartValueSelectedListener(object : OnChartValueSelectedListener {
             override fun onValueSelected(e: Entry?, h: Highlight?) {
@@ -419,7 +373,7 @@ class StatisticsActivity : AppCompatActivity() {
                     return
                 }
 
-                if ((lastToastShown + TOAST_FREQUENCY_MS) > System.currentTimeMillis()) {
+                if ((lastToastShown + 3500) > System.currentTimeMillis()) {
                     // only show one Toast message after another
                     return
                 }
@@ -478,46 +432,15 @@ class StatisticsActivity : AppCompatActivity() {
         set1.isHighlightEnabled = true
 
         set1.setDrawIcons(false)
-
-        //barChart.legend.isEnabled = false
-/*
-        val valueCount = min(values.size, 24)
-        barChart.setVisibleXRangeMaximum(valueCount.toFloat())
-
-        barChart.xAxis.setLabelCount(valueCount)
-*/
-Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}, barChart.visibleXRange: ${barChart.visibleXRange}, barChart.xAxis.isCenterAxisLabelsEnabled: ${barChart.xAxis.isCenterAxisLabelsEnabled}, barChart.isAutoScaleMinMaxEnabled: ${barChart.isAutoScaleMinMaxEnabled}, barChart.isScaleXEnabled: ${barChart.isScaleXEnabled}, barChart.isScaleYEnabled: ${barChart.isScaleYEnabled}")
-
-//barChart.minimumWidth
-
-        //barChart.isAutoScaleMinMaxEnabled = true
-
-        //barChart.setScaleEnabled(true)
-        //barChart.fitScreen()
-
-//debugBarValues(values)
-
-        //barChart.xAxis.setLabelCount(min(values.size, 24))
+        barChart.legend.isEnabled = false
+        barChart.setScaleEnabled(false)
+        barChart.xAxis.setLabelCount(min(values.size, 24))
         data.setValueTextSize(12f)
         barChart.setData(data)
-        Log.d(TAG, "xChartMax: ${barChart.xChartMax}")
-        barChart.centerViewTo(barChart.xChartMax, 0F, YAxis.AxisDependency.RIGHT)
 
-        // does not work quite right yet
-
-        barChart.legend.isEnabled = false
-        val valueCount = min(values.size, 24)
-        barChart.setVisibleXRangeMaximum(valueCount.toFloat())
-        barChart.xAxis.setLabelCount(valueCount)
-        barChart.xAxis.setCenterAxisLabels(false)
         barChart.invalidate()
-
-
-        //barChart.moveViewToX(77F) //values.lastOrNull()!!.x)
     }
 
-    // Sleep pattern bars that do not use time slots.
-    // This is useful/nicer for bars that only represent data of a singular days.
     fun showSleepPatternBarGraphDaily(state: GraphState) {
         val ranges = toSleepRanges(state.events)
         val values = ArrayList(List(state.endSpan - state.startSpan + 1) { BarEntry(it.toFloat(), FloatArray(0)) })
@@ -600,7 +523,7 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
                     return
                 }
 
-                if ((lastToastShown + TOAST_FREQUENCY_MS) > System.currentTimeMillis()) {
+                if ((lastToastShown + 3500) > System.currentTimeMillis()) {
                     // only show one Toast message after another
                     return
                 }
@@ -622,32 +545,20 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
             override fun onNothingSelected() {}
         })
 
-
-        Log.d(TAG, "showSleepPatternBarGraphDaily: values.size: ${values.size}, barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}")
-
         set1.setDrawIcons(false)
-        //barChart.legend.isEnabled = false
-
-        //val valueCount = min(values.size, 24)
-        //barChart.setVisibleXRangeMaximum(valueCount.toFloat())
-        //barChart.xAxis.setLabelCount(valueCount)
+        barChart.legend.isEnabled = false
+        barChart.setScaleEnabled(false)
+        barChart.xAxis.setLabelCount(min(values.size, 24))
         data.setValueTextSize(12f)
         barChart.setData(data)
 
-        Log.d(TAG, "showSleepPatternBarGraphDaily: new barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}")
-
-        barChart.legend.isEnabled = false
-        val valueCount = min(values.size, 24)
-        barChart.setVisibleXRangeMaximum(valueCount.toFloat())
-        barChart.xAxis.setLabelCount(valueCount)
-        barChart.xAxis.setCenterAxisLabels(false)
         barChart.invalidate()
     }
 
     fun showSleepBarGraph(state: GraphState) {
         val ranges = toSleepRanges(state.events)
         val values = ArrayList(List(state.endSpan - state.startSpan + 1) { BarEntry(it.toFloat(), 0F) })
-        //Log.d(TAG, "startUnix: ${Date(state.startUnix * 1000)}, endUnix: ${Date(state.endUnix * 1000)}")
+        Log.d(TAG, "startUnix: ${Date(state.startUnix * 1000)}, endUnix: ${Date(state.endUnix * 1000)}")
 
         for (range in ranges) {
             // a sleep event can span to another day
@@ -658,13 +569,12 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
             val endIndex = unixToSpan(endUnix)
             var mid = startUnix
 
-            //Log.d(TAG, "beginIndex: $begIndex, endIndex: $endIndex, startUnix: ${Date(startUnix * 1000)} ($startUnix), endUnix: ${Date(endUnix * 1000)} ($endUnix)")
             //Log.d(TAG, "startUnix: ${Date(startUnix * 1000)}, endUnix: ${Date(endUnix * 1000)}, begIndex: $begIndex, endIndex: $endIndex (index diff: ${endIndex - begIndex})")
             for (i in begIndex..endIndex) {
                 // i is the days/weeks/months since unix epoch
                 val spanBegin = spanToUnix(i)
                 val spanEnd =  spanToUnix(i + 1)
-                //Log.d(TAG, "i: $i, mid: ${Date(mid * 1000)}, spanBegin: ${Date(spanBegin * 1000)}, spanEnd: ${Date(spanEnd * 1000)}, beginUnix: ${Date(startUnix * 1000)} endUnix: ${Date(endUnix * 1000)}")
+                //Log.d(TAG, "mid: ${Date(mid * 1000)}, spanBegin: ${Date(spanBegin * 1000)}, spanEnd: ${Date(spanEnd * 1000)}, beginUnix: ${Date(startUnix * 1000)} endUnix: ${Date(endUnix * 1000)}")
                 val sleepBegin = max(mid, spanBegin)
                 val sleepEnd = min(endUnix, spanEnd)
                 val index = i - state.startSpan
@@ -686,6 +596,7 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
             }
         }
 
+        if (graphTypeSelection == GraphType.SLEEP_SUM) {
             for (index in values.indices) {
                 val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
                 if (daysWithData == 0) {
@@ -694,6 +605,7 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
                     values[index].y /= daysWithData
                 }
             }
+        }
 
         val set1 = BarDataSet(values, "")
         val data = BarData(set1)
@@ -702,44 +614,44 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
 
         data.setValueFormatter(object : ValueFormatter() {
             override fun getFormattedValue(value: Float): String {
-                val prefix = if (timeRangeSelection == TimeRange.DAY) { "" } else { "⌀ " }
                 return when (graphTypeSelection) {
-                    GraphType.SLEEP_EVENTS -> {
-                        prefix + value.toInt().toString()
-                    }
+                    GraphType.SLEEP_EVENTS -> value.toInt().toString()
                     GraphType.SLEEP_SUM -> {
-                        prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.SLEEP, value.toInt())
+                        val prefix = if (timeRangeSelection == TimeRange.DAY) { "" } else { "⌀ " }
+                        return prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.SLEEP, value.toInt())
                     }
                     else -> {
                         Log.e(TAG, "unhandled graphTypeSelection $graphTypeSelection")
-                        prefix + value.toInt().toString()
+                        value.toInt().toString()
                     }
                 }
             }
         })
 
         set1.setDrawIcons(false)
-
+        barChart.legend.isEnabled = false
+        barChart.setScaleEnabled(false)
+        barChart.xAxis.setLabelCount(min(values.size, 24))
         data.setValueTextSize(12f)
         barChart.setData(data)
 
-        barChart.legend.isEnabled = false
-        val valueCount = min(values.size, 24)
-        barChart.setVisibleXRangeMaximum(valueCount.toFloat())
-        barChart.xAxis.setLabelCount(valueCount)
-        barChart.xAxis.setCenterAxisLabels(false)
         barChart.invalidate()
     }
 
     fun showBottleBarGraph(state: GraphState) {
         val values = ArrayList(List(state.endSpan - state.startSpan + 1) { BarEntry(it.toFloat(), 0F) })
 
+        // needed?
+        for (i in values.indices) {
+            values[i].x = i.toFloat()
+        }
+
         for (event in state.events) {
             val index = unixToSpan(event.time) - state.startSpan
 
             state.dayCounter.setDaysWithData(event.time, event.time)
 
-            values[index].x += values.size.toFloat()
+            // setDaysWithData(sleepBegin, sleepEnd)
             if (graphTypeSelection == GraphType.BOTTLE_EVENTS) {
                 values[index].y += 1F
             } else if (graphTypeSelection == GraphType.BOTTLE_SUM) {
@@ -750,6 +662,7 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
             }
         }
 
+        if (graphTypeSelection == GraphType.BOTTLE_SUM) {
             for (index in values.indices) {
                 val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
                 //Log.d(TAG, "index: $index, daysWithData: $daysWithData")
@@ -759,6 +672,7 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
                     values[index].y /= daysWithData
                 }
             }
+        }
 
         val set1 = BarDataSet(values, "")
 
@@ -774,34 +688,37 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
 
         data.setValueFormatter(object : ValueFormatter() {
             override fun getFormattedValue(value: Float): String {
-                val prefix = if (timeRangeSelection == TimeRange.DAY) { "" } else { "⌀ " }
                 //Log.d(TAG, "getFormattedValue ${dataTypeSelectionValue} ${eventTypeSelectionValue}")
                 return when (graphTypeSelection) {
-                    GraphType.BOTTLE_EVENTS -> {
-                        prefix + value.toInt().toString()
-                    }
+                    GraphType.BOTTLE_EVENTS -> value.toInt().toString()
                     GraphType.BOTTLE_SUM -> {
-                        prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.BABY_BOTTLE, value.toInt())
+                        val prefix = if (timeRangeSelection == TimeRange.DAY) { "" } else { "⌀ " }
+                        return prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.BABY_BOTTLE, value.toInt())
                     }
                     else -> {
                         Log.e(TAG, "unhandled graphTypeSelection")
-                        prefix + value.toInt()
+                        value.toInt().toString()
                     }
                 }
             }
         })
 
+// hm, does not work yet
+
         data.setValueTextSize(12f)
         barChart.setData(data)
 
-        //barChart.legend.isEnabled = false
-        val valueCount = min(values.size, 24)
-        barChart.setVisibleXRangeMaximum(valueCount.toFloat())
-        barChart.xAxis.setLabelCount(valueCount)
-        barChart.xAxis.setCenterAxisLabels(false)
-        barChart.invalidate()
+        barChart.moveViewToX(values.lastOrNull()!!.x)
 
-        //barChart.moveViewToX(values.lastOrNull()!!.x)
+        val maximumRange = 16F
+        //val count = values.size.coerceIn(5, 20)
+        barChart.setVisibleXRangeMaximum(maximumRange) // show max 24 entries
+        barChart.xAxis.setLabelCount(maximumRange.toInt(), true)
+        //barChart.xAxis.isEnabled = false
+        barChart.xAxis.setCenterAxisLabels(true)
+        barChart.setScaleEnabled(false)
+
+        barChart.invalidate()
     }
 
     class DayCounter(val startDays: Int, val stopDays: Int) {
@@ -812,10 +729,8 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
         fun countDaysWithData(beginUnix: Long, endUnix: Long): Int {
             val beginDays = unixToDays(beginUnix)
             val endDays = unixToDays(endUnix)
-            //Log.d(TAG, "countDaysWithData: beginDays: $beginDays, endDays: $endDays, ${Date(beginUnix * 1000)} - ${Date(endUnix * 1000)}")
             var count = 0
             for (i in (beginDays - startDays)..<(endDays - startDays)) {
-                //Log.d(TAG, "countDaysWithData: i: $i, size: ${daysWithData.size}")
                 count += if (daysWithData[i]) { 1 } else { 0 }
             }
             return count
@@ -834,8 +749,8 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
 
     data class GraphState(val events: List<LunaEvent>, val dayCounter: DayCounter, val startUnix: Long, val endUnix: Long, val startSpan: Int, val endSpan: Int)
 
-    // wrapper for common graph setup
-    fun prepareGraph(type: LunaEvent.Type, callback: (GraphState) -> Unit) {
+    // wrapper for comon graph setup
+    fun prepareGraph(type: LunaEvent.Type, cb: (GraphState) -> Unit) {
         val events = MainActivity.allEvents.filter { it.type == type }.sortedBy { it.time }
 
         if (events.isEmpty()) {
@@ -857,7 +772,7 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
 
         // days when the a day/week/month starts/ends
         val startDays = unixToDays(spanToUnix(startSpan))
-        val endDays = unixToDays(spanToUnix(endSpan + 1)) // until end of next span
+        val endDays = unixToDays(spanToUnix(endSpan + 1)) // until end of next week
         val dayCounter = DayCounter(startDays, endDays)
 
         // print dates
@@ -872,51 +787,28 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
                 val month = dateTime.get(Calendar.MONTH) + 1 // month starts at 0
                 val week = dateTime.get(Calendar.WEEK_OF_YEAR)
                 val day = dateTime.get(Calendar.DAY_OF_MONTH)
-
-                // Adjust years if the first week of a year starts in the previous year.
-                val years = if (month == 12 && week == 1) {
-                    year + 1
-                } else {
-                    year
-                }
-
-                val days = "%02d".format(day)
-                val weeks = "%02d".format(week)
-                val months = "%02d".format(month)
-
                 return when (timeRangeSelection) {
-                    TimeRange.DAY -> "$days/$months/$years"
-                    TimeRange.WEEK -> "$weeks/$years"
-                    TimeRange.MONTH -> "$months/$years"
+                    TimeRange.DAY -> "$day/$month/$year"
+                    TimeRange.WEEK -> "$week/$year"
+                    TimeRange.MONTH -> "$month/$year"
                 }
             }
         }
 
-        //Log.d(TAG, "startDaysUnix: ${Date(daysToUnix(startDays) * 1000)}. endDaysUnix: ${Date(daysToUnix(endDays) * 1000)}")
+        Log.d(TAG, "startDaysUnix: ${Date(daysToUnix(startDays) * 1000)}. endDaysUnix: ${Date(daysToUnix(endDays) * 1000)}")
 
-        callback(GraphState(events, dayCounter, startUnix, endUnix, startSpan, endSpan))
+        cb(GraphState(events, dayCounter, startUnix, endUnix, startSpan, endSpan))
     }
 
     fun showGraph() {
-        //Log.d(TAG, "showGraph: graphTypeSelection: $graphTypeSelection, timeRangeSelection: $timeRangeSelection")
-
-        // test
-        resetBarChart()
+        Log.d(TAG, "showGraph: graphTypeSelection: $graphTypeSelection, timeRangeSelection: $timeRangeSelection")
 
         when (graphTypeSelection) {
             GraphType.BOTTLE_EVENTS,
             GraphType.BOTTLE_SUM -> prepareGraph(LunaEvent.Type.BABY_BOTTLE) { state -> showBottleBarGraph(state) }
             GraphType.SLEEP_EVENTS,
             GraphType.SLEEP_SUM -> prepareGraph(LunaEvent.Type.SLEEP) { state -> showSleepBarGraph(state) }
-            GraphType.SLEEP_PATTERN -> prepareGraph(LunaEvent.Type.SLEEP) { state -> showSleepPatternBarGraphSlotted(state) }
-/*                if (timeRangeSelection == TimeRange.DAY) {
-                    // specialized pattern bar for daily view (optional)
-                    showSleepPatternBarGraphDaily(state)
-                } else {
-                    showSleepPatternBarGraphSlotted(state)
-                }
-            }
-*/
+            GraphType.SLEEP_PATTERN -> prepareGraph(LunaEvent.Type.SLEEP) { state -> showSleepPatternBarGraph(state) }
             GraphType.MEDICINE_EVENTS -> prepareGraph(LunaEvent.Type.MEDICINE) { state -> showMedicineBarGraph(state) }
         }
     }
@@ -966,10 +858,7 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
         const val TAG = "StatisticsActivity"
 
         // 15 min steps
-        const val SLEEP_PATTERN_GRANULARITY = 15 * 60
-
-        // Time between toast messages (to prevent jams)
-        const val TOAST_FREQUENCY_MS = 3500
+        val SLEEP_PATTERN_GRANULARITY = 15 * 60
 
         // color gradient
         val SLEEP_PATTERN_COLORS = arrayOf(
@@ -978,22 +867,20 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
             "#77B1BF".toColorInt(), "#66A7B7".toColorInt(), "#559DAF".toColorInt(), "#4493A7".toColorInt(),
             "#33899F".toColorInt(), "#228097".toColorInt(), "#11768F".toColorInt(), "#006C87".toColorInt()
         )
-
+        private val dateTime = Calendar.getInstance() // scratch pad
         var graphTypeSelection = GraphType.SLEEP_SUM
         var timeRangeSelection = TimeRange.DAY
 
-        private val dateTime = Calendar.getInstance() // scratch pad
-
-        // convert month to seconds since epoch
         fun unixToMonths(seconds: Long): Int {
+            //val dateTime = Calendar.getInstance()
             dateTime.time = Date(seconds * 1000)
             val years = dateTime.get(Calendar.YEAR)
             val months = dateTime.get(Calendar.MONTH)
             return 12 * years + months
         }
 
-        // convert month to seconds since epoch
         fun monthsToUnix(months: Int): Long {
+            //val dateTime = Calendar.getInstance()
             dateTime.time = Date(0)
             dateTime.set(Calendar.YEAR, months / 12)
             dateTime.set(Calendar.MONTH, months % 12)
@@ -1003,25 +890,18 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
             return dateTime.time.time / 1000
         }
 
-        // convert seconds to weeks since epoch
         fun unixToWeeks(seconds: Long): Int {
+            //val dateTime = Calendar.getInstance()
             dateTime.time = Date(seconds * 1000)
-            val years = dateTime.get(Calendar.YEAR) - 1970
+            val years = dateTime.get(Calendar.YEAR)
             val weeks = dateTime.get(Calendar.WEEK_OF_YEAR)
-            val month = dateTime.get(Calendar.MONTH) + 1 // month starts at 0
-
-            if (month == 12 && weeks == 1) {
-                // The first week if the year might start in the previous year.
-                return 52 * (years + 1) + weeks
-            }
-
             return 52 * years + weeks
         }
 
-        // convert weeks to seconds since epoch
         fun weeksToUnix(weeks: Int): Long {
+            //val dateTime = Calendar.getInstance()
             dateTime.time = Date(0)
-            dateTime.set(Calendar.YEAR, 1970 + weeks / 52)
+            dateTime.set(Calendar.YEAR, weeks / 52)
             dateTime.set(Calendar.WEEK_OF_YEAR, weeks % 52)
             dateTime.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY)
             dateTime.set(Calendar.HOUR, 0)
@@ -1030,16 +910,17 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
             return dateTime.time.time / 1000
         }
 
-        // convert seconds to days since epoch
         fun unixToDays(seconds: Long): Int {
+            //val dateTime = Calendar.getInstance()
             dateTime.time = Date(seconds * 1000)
             val years = dateTime.get(Calendar.YEAR)
             val days = dateTime.get(Calendar.DAY_OF_YEAR)
             return 365 * years + days
         }
 
-        // convert days to seconds since epoch
+        // convert from days to Date
         fun daysToUnix(days: Int): Long {
+            //val dateTime = Calendar.getInstance()
             dateTime.time = Date(0)
             dateTime.set(Calendar.YEAR, days / 365)
             dateTime.set(Calendar.DAY_OF_YEAR, days % 365)
@@ -1063,6 +944,42 @@ Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barCha
             return newArray
         }
 
+/*
+        fun colorGradient(fromColor: Int, toColor: Int, percent: Int): Int {
+            assert(percent in 0..100)
+
+            val a1 = fromColor.shr(24).and(0xff)
+            val r1 = fromColor.shr(16).and(0xff)
+            val g1 = fromColor.shr(8).and(0xff)
+            val b1 = fromColor.shr(0).and(0xff)
+
+            //Log.d(TAG, "${a1.toHexString()} ${r1.toHexString()} ${g1.toHexString()}  ${b1.toHexString()}")
+
+            val a2 = toColor.shr(24).and(0xff)
+            val r2 = toColor.shr(16).and(0xff)
+            val g2 = toColor.shr(8).and(0xff)
+            val b2 = toColor.shr(0).and(0xff)
+
+            //Log.d(TAG, "${a2.toHexString()} ${r2.toHexString()} ${g2.toHexString()}  ${b2.toHexString()}")
+
+            val pc = (percent.toFloat() / 100F).coerceIn(0F, 1F)
+            val a = a1 + (pc * abs(a2 - a1)).toInt()
+            val r = r1 + (pc * abs(r2 - r1)).toInt()
+            val g = g1 + (pc * abs(g2 - g1)).toInt()
+            val b = a1 + (pc * abs(b2 - b1)).toInt()
+
+            //Log.d(TAG, "${a.toHexString()} ${r.toHexString()} ${g.toHexString()}  ${b.toHexString()}")
+            val Red = r.shl(16).and(0x00FF0000)
+            val Green = g.shl(8).and(0x0000FF00)
+            val Blue = b.and(0x000000FF)
+            val aa = a.shl(24).and(0xFF000000.toInt())
+            val color = aa.or(Red).or(Green).or(Blue)
+            return color
+            //Log.d(TAG, "c: ${c.toHexString()} ${color.toInt().toHexString()}")
+            //return Color.argb(a, r, g, b)
+        }
+    */
+
         // for debugging
         fun debugBarValues(values: ArrayList<BarEntry>) {
             for (value in values) {

app/src/main/res/layout/dialog_edit_duration.xml

@@ -15,7 +15,6 @@
         android:text="💤"/>
 
     <LinearLayout
-        android:id="@+id/duration_buttons"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:gravity="center"

app/src/main/res/values/strings.xml

@@ -131,7 +131,6 @@
     <string name="log_unknown_dialog_description"></string>
     <string name="log_weight_dialog_description">Insert the weight:</string>
     <string name="log_sleep_dialog_description">Set sleep duration:</string>
-    <string name="log_sleep_dialog_description_start">Start sleep cycle:</string>
 
     <string name="measurement_unit_liquid_base_metric" translatable="false">ml</string>
     <string name="measurement_unit_weight_base_metric" translatable="false">g</string>