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/StatisticsActivity.kt

@@ -12,6 +12,7 @@ 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
@@ -82,10 +83,12 @@ 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)
 
@@ -136,25 +139,57 @@ 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) {
-                ArrayList(List(state.endSpan - state.startSpan + 1) { BarEntry(it.toFloat(), 0F) })
+                // create initial array with 0
+                ArrayList(List(days) { BarEntry(it.toFloat(), 0F) })
             }
 
             array[index].y += 1F
         }
 
-        /*
-        Log.d(TAG, "values.size: ${values.size}")
+        Log.d(TAG, "values.size: ${values.size}, days: $days")
         for ((key, value) in values) {
             Log.d(TAG, "key: $key, value.size: ${value.size} ,value: ${value.joinToString { it.y.toLong().toString() }}")
         }
-         */
 
         // make sure legend names are not too long
         fun shorten(notes: String): String {
@@ -170,19 +205,18 @@ class StatisticsActivity : AppCompatActivity() {
         }
 
         val sets = arrayListOf<IBarDataSet>()
-        for ((key, value) in values.entries) {
-            if (key.startsWith("v")) {
+        for ((key, array) in values.entries) {
             val description = shorten(key)
-                val barDataSet = BarDataSet(value, description)
+            Log.d(TAG, "key: $key")
+            val barDataSet = BarDataSet(array, 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() {
@@ -195,22 +229,31 @@ class StatisticsActivity : AppCompatActivity() {
             }
         })
 
-        barChart.setScaleEnabled(true)
-        barChart.legend.isEnabled = true
+        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
+                }
 
-        //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)
+                val index = e.x.toInt()
+                if (index !in 0..values.size) {
+                    return
+                }
 
-        //barChart.axisLeft.isSLEEP_PATTERN_GRANULARITYEnabled = true
-        //barChart.axisLeft.setSLEEP_PATTERN_GRANULARITY(0.8F)
+                Log.d(TAG, "index: $index")
+            }
+            override fun onNothingSelected() {}
+        })
 
+        data.setValueTextSize(12f)
         barChart.setData(data)
+
+        barChart.legend.isEnabled = true
+        val valueCount = min(days, 24)
+        barChart.setVisibleXRangeMaximum(valueCount.toFloat())
+        barChart.xAxis.setLabelCount(valueCount)
+        barChart.xAxis.setCenterAxisLabels(false)
         barChart.invalidate()
     }
 
@@ -275,7 +318,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
                     }
@@ -313,13 +356,11 @@ class StatisticsActivity : AppCompatActivity() {
         }
 
         fun mapColor(occurrences: Int, maxOccurrences: Int): Int {
-            //Log.d(TAG, "$occurrences <= $maxOccurrences")
-            // occurrences: number of reported sleeps in a specific time slice
+            // occurrences: number of reported sleeps in a specific time slot
             // maxOccurrences: maximum number of days with data that can contribute to maxOccurrences
             assert(maxOccurrences > 0)
             assert(occurrences <= maxOccurrences)
 
-
             // map to color
             val q = occurrences.toFloat() / maxOccurrences.toFloat()
             val i = q * (SLEEP_PATTERN_COLORS.size - 1).toFloat()
@@ -335,8 +376,8 @@ class StatisticsActivity : AppCompatActivity() {
             //Log.d(TAG, "index: $index: daysWithData: $daysWithData, dayArray: ${dayArray.joinToString { it.toString() }}")
             val vals = ArrayList<Float>()
 
-            var prevIndex = -1 // time slice index
-            var prevValue = -1 // number of entries we have found for time slice
+            var prevIndex = -1 // time slot index
+            var prevValue = -1 // number of entries we have found for time slot
             for ((i, v) in dayArray.withIndex()) {
                 if (i == 0) {
                     prevIndex = i
@@ -356,6 +397,7 @@ 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()))
         }
 
@@ -436,17 +478,46 @@ class StatisticsActivity : AppCompatActivity() {
         set1.isHighlightEnabled = true
 
         set1.setDrawIcons(false)
-        barChart.legend.isEnabled = false
-        barChart.setScaleEnabled(false)
-        barChart.xAxis.setLabelCount(min(values.size, 24))
+
+        //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))
         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 singlur days.
+    // 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)) })
@@ -551,13 +622,25 @@ class StatisticsActivity : AppCompatActivity() {
             override fun onNothingSelected() {}
         })
 
+
+        Log.d(TAG, "showSleepPatternBarGraphDaily: values.size: ${values.size}, barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}")
+
         set1.setDrawIcons(false)
-        barChart.legend.isEnabled = false
-        barChart.setScaleEnabled(false)
-        barChart.xAxis.setLabelCount(min(values.size, 24))
+        //barChart.legend.isEnabled = false
+
+        //val valueCount = min(values.size, 24)
+        //barChart.setVisibleXRangeMaximum(valueCount.toFloat())
+        //barChart.xAxis.setLabelCount(valueCount)
         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()
     }
 
@@ -603,7 +686,6 @@ class StatisticsActivity : AppCompatActivity() {
             }
         }
 
-        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) {
@@ -612,7 +694,6 @@ class StatisticsActivity : AppCompatActivity() {
                 values[index].y /= daysWithData
             }
         }
-        }
 
         val set1 = BarDataSet(values, "")
         val data = BarData(set1)
@@ -621,44 +702,44 @@ class StatisticsActivity : AppCompatActivity() {
 
         data.setValueFormatter(object : ValueFormatter() {
             override fun getFormattedValue(value: Float): String {
-                return when (graphTypeSelection) {
-                    GraphType.SLEEP_EVENTS -> value.toInt().toString()
-                    GraphType.SLEEP_SUM -> {
                 val prefix = if (timeRangeSelection == TimeRange.DAY) { "" } else { "⌀ " }
-                        return prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.SLEEP, value.toInt())
+                return when (graphTypeSelection) {
+                    GraphType.SLEEP_EVENTS -> {
+                        prefix + value.toInt().toString()
+                    }
+                    GraphType.SLEEP_SUM -> {
+                        prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.SLEEP, value.toInt())
                     }
                     else -> {
                         Log.e(TAG, "unhandled graphTypeSelection $graphTypeSelection")
-                        value.toInt().toString()
+                        prefix + 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)
 
-            // setDaysWithData(sleepBegin, sleepEnd)
+            values[index].x += values.size.toFloat()
             if (graphTypeSelection == GraphType.BOTTLE_EVENTS) {
                 values[index].y += 1F
             } else if (graphTypeSelection == GraphType.BOTTLE_SUM) {
@@ -669,7 +750,6 @@ class StatisticsActivity : AppCompatActivity() {
             }
         }
 
-        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")
@@ -679,7 +759,6 @@ class StatisticsActivity : AppCompatActivity() {
                 values[index].y /= daysWithData
             }
         }
-        }
 
         val set1 = BarDataSet(values, "")
 
@@ -695,37 +774,34 @@ class StatisticsActivity : AppCompatActivity() {
 
         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 -> value.toInt().toString()
+                    GraphType.BOTTLE_EVENTS -> {
+                        prefix + value.toInt().toString()
+                    }
                     GraphType.BOTTLE_SUM -> {
-                        val prefix = if (timeRangeSelection == TimeRange.DAY) { "" } else { "⌀ " }
-                        return prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.BABY_BOTTLE, value.toInt())
+                        prefix + NumericUtils(applicationContext).formatEventQuantity(LunaEvent.Type.BABY_BOTTLE, value.toInt())
                     }
                     else -> {
                         Log.e(TAG, "unhandled graphTypeSelection")
-                        value.toInt().toString()
+                        prefix + value.toInt()
                     }
                 }
             }
         })
 
-// hm, does not work yet
-
         data.setValueTextSize(12f)
         barChart.setData(data)
 
-        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.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)
     }
 
     class DayCounter(val startDays: Int, val stopDays: Int) {
@@ -758,7 +834,7 @@ class StatisticsActivity : AppCompatActivity() {
 
     data class GraphState(val events: List<LunaEvent>, val dayCounter: DayCounter, val startUnix: Long, val endUnix: Long, val startSpan: Int, val endSpan: Int)
 
-    // wrapper for comon graph setup
+    // wrapper for common graph setup
     fun prepareGraph(type: LunaEvent.Type, callback: (GraphState) -> Unit) {
         val events = MainActivity.allEvents.filter { it.type == type }.sortedBy { it.time }
 
@@ -781,7 +857,7 @@ class StatisticsActivity : AppCompatActivity() {
 
         // days when the a day/week/month starts/ends
         val startDays = unixToDays(spanToUnix(startSpan))
-        val endDays = unixToDays(spanToUnix(endSpan + 1)) // until end of next week
+        val endDays = unixToDays(spanToUnix(endSpan + 1)) // until end of next span
         val dayCounter = DayCounter(startDays, endDays)
 
         // print dates
@@ -797,18 +873,21 @@ class StatisticsActivity : AppCompatActivity() {
                 val week = dateTime.get(Calendar.WEEK_OF_YEAR)
                 val day = dateTime.get(Calendar.DAY_OF_MONTH)
 
-                // Dirty hack to get monotone number of weeks
-                // The first week if the year might start in the previous year.
-                val yearFixed = if (month == 12 && week == 1) {
+                // 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 -> "$day/$month/$yearFixed"
-                    TimeRange.WEEK -> "$week/$yearFixed"
-                    TimeRange.MONTH -> "$month/$yearFixed"
+                    TimeRange.DAY -> "$days/$months/$years"
+                    TimeRange.WEEK -> "$weeks/$years"
+                    TimeRange.MONTH -> "$months/$years"
                 }
             }
         }
@@ -821,19 +900,23 @@ class StatisticsActivity : AppCompatActivity() {
     fun showGraph() {
         //Log.d(TAG, "showGraph: graphTypeSelection: $graphTypeSelection, timeRangeSelection: $timeRangeSelection")
 
+        // test
+        resetBarChart()
+
         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 ->
-                if (timeRangeSelection == TimeRange.DAY) {
-                    // specialized pattern bar for daily view
+            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.MEDICINE_EVENTS -> prepareGraph(LunaEvent.Type.MEDICINE) { state -> showMedicineBarGraph(state) }
         }
     }