Introduce "Graph2" meter style (two-channel graph)

Introduce a new meter mode (meter style) called "Graph2". The "Graph2"
name stands for "two-channel graph" or "two-quadrant graph".

This meter mode is not in the list of default supported modes. This
"Graph2" mode is intended for meters with two item values. It plots
the first item above the x-axis and the second item below the x-axis.
Items other than the first two are always hidden.

This code is written with the intention to share as much code with the
Graph meter mode as possible.

Signed-off-by: Kang-Che Sung <[email protected]>

Author: Explorer09

Meter.c

@@ -873,7 +873,7 @@ static void GraphMeterMode_recordNewValue(Meter* this, const GraphDrawContext* c
 
    // Sum the values of all items
    double sum = 0.0;
-   if (this->curItems > 0) {
+   if (this->mode != GRAPH2_METERMODE && this->curItems > 0) {
       sum = Meter_computeSum(this);
       assert(sum >= 0.0);
       assert(sum <= DBL_MAX);
@@ -887,6 +887,17 @@ static void GraphMeterMode_recordNewValue(Meter* this, const GraphDrawContext* c
       // Dynamic scale. "this->total" is ignored.
       // Determine the scale and "total" that we need afterward. The "total" is
       // rounded up to a power of 2.
+
+      if (this->mode == GRAPH2_METERMODE) {
+         // Find the greatest value in this->values array
+         for (uint8_t i = 0; i < maxItems && i < this->curItems; i++) {
+            if (isgreater(this->values[i], total)) {
+               total = this->values[i];
+            }
+         }
+         total = MINIMUM(DBL_MAX, total);
+      }
+
       int scaleExp = 0;
       (void)frexp(total, &scaleExp);
       scaleExp = MAXIMUM(0, scaleExp);
@@ -906,6 +917,23 @@ static void GraphMeterMode_recordNewValue(Meter* this, const GraphDrawContext* c
    assert(h <= UINT16_MAX / 8);
    double maxDots = (double)(int32_t)(h * 8);
 
+   if (maxItems == 1 || this->mode == GRAPH2_METERMODE) {
+      // We just need to record the number of dots in the graph data buffer.
+      for (uint8_t i = 0; i < maxItems; i++) {
+         unsigned int numDots = 0;
+         if (total > 0.0 && i < this->curItems && isPositive(this->values[i])) {
+            double value = MINIMUM(total, this->values[i]);
+
+            numDots = (unsigned int)(int32_t)ceil((value / total) * maxDots);
+            // Division of (value / total) can underflow
+            numDots = MAXIMUM(1, numDots);
+         }
+         assert(numDots <= UINT16_MAX - (8 - 1));
+         valueStart[(isPercentChart ? 0 : 1) + i].numDots = (uint16_t)numDots;
+      }
+      return;
+   }
+
    // The total number of dots that we would draw for this record
    unsigned int numDots = 0;
    if (total > 0.0 && sum > 0.0) {
@@ -914,12 +942,6 @@ static void GraphMeterMode_recordNewValue(Meter* this, const GraphDrawContext* c
    }
    assert(numDots <= UINT16_MAX - (8 - 1));
 
-   if (maxItems == 1) {
-      // We just need to record the number of dots in the graph data buffer.
-      valueStart[isPercentChart ? 0 : 1].numDots = (uint16_t)numDots;
-      return;
-   }
-
    // This is a meter of multiple items.
    // First clear the cells, which might contain data of the previous record.
    unsigned int y = (numDots + (8 - 1)) / 8; // Round up
@@ -1021,25 +1043,71 @@ static int GraphMeterMode_lookupCell(const Meter* this, const GraphDrawContext*
       deltaExp = scaleExp - valueStart[0].scaleExp;
    }
 
-   if (maxItems == 1) {
-      unsigned int numDots = valueStart[isPercentChart ? 0 : 1].numDots;
+   if (this->mode == GRAPH2_METERMODE || maxItems == 1) {
+      assert(maxItems <= 2);
 
-      if (numDots < 1)
-         goto cellIsEmpty;
+      unsigned int numBlanks[2];
+      numBlanks[1] = 0;
+
+      const GraphDataCell* itemStart = &valueStart[isPercentChart ? 0 : 1];
 
-      // Scale according to exponent difference. Round up.
-      numDots = deltaExp < UINT16_WIDTH ? ((numDots - 1) >> deltaExp) : 0;
-      numDots++;
+      uint8_t i = 0;
+      do {
+         unsigned int numDots = itemStart[i].numDots;
+         if (numDots >= 1) {
+            // Scale according to exponent difference. Round up.
+            numDots = deltaExp < UINT16_WIDTH ? ((numDots - 1) >> deltaExp) : 0;
+            numDots++;
+         }
+
+         numBlanks[i] = h * 8 - numDots;
+         if (this->mode == GRAPH2_METERMODE) {
+            numBlanks[i] /= 2;
+         }
+      } while (++i < maxItems);
 
-      if (y > (numDots - 1) / 8)
+      const uint8_t dotAlignment = 2;
+      bool canShowHalfCell = true;
+
+      unsigned int blanksAtEnd = numBlanks[0];
+      if (h - 1 - y < blanksAtEnd / 8)
+         goto cellIsEmpty;
+      if (h - 1 - y == blanksAtEnd / 8) {
+         blanksAtEnd = (blanksAtEnd % 8) / dotAlignment * dotAlignment;
+         canShowHalfCell = false;
+      } else {
+         blanksAtEnd = 0;
+      }
+
+      unsigned int blanksAtStart = numBlanks[1];
+      if (y < blanksAtStart / 8)
          goto cellIsEmpty;
+      if (y == blanksAtStart / 8) {
+         blanksAtStart = (blanksAtStart % 8) / dotAlignment * dotAlignment;
+         if (blanksAtEnd + blanksAtStart >= 8) {
+            // Happens only if numDots of both items are 0
+            goto cellIsEmpty;
+         }
+         canShowHalfCell = false;
+      } else {
+         blanksAtStart = 0;
+      }
 
       itemIndex = 0;
-      *details = 0xFF;
-      if (y == (numDots - 1) / 8) {
-         const uint8_t dotAlignment = 2;
-         unsigned int blanksAtTopCell = (8 - 1 - (numDots - 1) % 8) / dotAlignment * dotAlignment;
-         *details <<= blanksAtTopCell;
+      if (this->mode == GRAPH2_METERMODE) {
+         if (y * 2 < h - 1) {
+            itemIndex = 1;
+         } else if (y * 2 == h - 1 && itemStart[1].numDots > itemStart[0].numDots) {
+            itemIndex = 1;
+         }
+      }
+
+      if (this->mode == GRAPH2_METERMODE && y * 2 == h - 1 && canShowHalfCell) {
+         *details = itemStart[1].numDots > itemStart[0].numDots ? 0xF0 : 0x0F;
+      } else {
+         *details = 0xFF;
+         *details >>= blanksAtStart;
+         *details = (uint8_t)((*details >> blanksAtEnd) << blanksAtEnd);
       }
    } else {
       int deltaExpArg = MINIMUM(UINT16_WIDTH - 1, deltaExp);
@@ -1062,13 +1130,14 @@ static int GraphMeterMode_lookupCell(const Meter* this, const GraphDrawContext*
    /* fallthrough */
 
 cellIsEmpty:
-   if (y == 0)
+   if (this->mode != GRAPH2_METERMODE && y == 0)
       *details |= 0xC0;
 
    if (itemIndex == (uint8_t)-1)
       return BAR_SHADOW;
 
    assert(itemIndex < maxItems);
+   assert(itemIndex < Meter_maxItems(this));
    return Meter_attributes(this)[itemIndex];
 }
 
@@ -1171,12 +1240,20 @@ static void GraphMeterMode_draw(Meter* this, int x, int y, int w) {
 
    uint8_t maxItems = Meter_maxItems(this);
    assert(this->curItems <= maxItems);
+   if (this->mode == GRAPH2_METERMODE) {
+      // Items other than the first two are always hidden in "Graph2" mode.
+      maxItems = 2;
+   }
 
    bool isPercentChart = Meter_isPercentChart(this);
 
-   size_t nCellsPerValue = maxItems == 1 ? maxItems : h;
-   if (!isPercentChart)
+   size_t nCellsPerValue = this->mode == GRAPH2_METERMODE || maxItems == 1 ? maxItems : h;
+   if (!isPercentChart) {
       nCellsPerValue *= 2;
+      if (this->mode == GRAPH2_METERMODE) {
+         nCellsPerValue--;
+      }
+   }
 
    GraphDrawContext context = {
       .maxItems = maxItems,
@@ -1368,6 +1445,11 @@ static const MeterMode Meter_modes[] = {
       .h = 3,
       .draw = LEDMeterMode_draw,
    },
+   [GRAPH2_METERMODE] = {
+      .uiName = "Graph2",
+      .h = DEFAULT_GRAPH_HEIGHT,
+      .draw = GraphMeterMode_draw,
+   },
 };
 
 /* Meter class and methods */

MeterMode.h

@@ -14,6 +14,7 @@ enum MeterModeId_ {
    TEXT_METERMODE,
    GRAPH_METERMODE,
    LED_METERMODE,
+   GRAPH2_METERMODE /* Not default supported */,
    LAST_METERMODE
 };