#57 control over negative values in the large number support.

dave · dave · commit f8ddd806efda · 2020-08-29T16:54:21.000+01:00
diff --git a/src/EditableLargeNumberMenuItem.cpp b/src/EditableLargeNumberMenuItem.cpp
@@ -12,11 +12,11 @@ void LargeFixedNumber::clear() {
 	negative = false;
 }
 
-void LargeFixedNumber::setValue(uint32_t whole, uint32_t fraction, bool negative) {
+void LargeFixedNumber::setValue(uint32_t whole, uint32_t fraction, bool neg) {
 	clear();
 	convertToBcdPacked(fraction, 0, fractionDp);
-	convertToBcdPacked(whole, fractionDp, LARGE_NUM_MAX_DIGITS);
-	this->negative = negative;
+	convertToBcdPacked(whole, fractionDp, totalSize);
+	this->negative = neg;
 }
 
 uint32_t LargeFixedNumber::fromBcdPacked(int start, int end) {
@@ -42,23 +42,50 @@ int LargeFixedNumber::getDigit(int digit) {
 	if (digit > 11) return false;
 	uint8_t r = bcdRepresentation[digit / 2];
 	if ((digit % 2) == 0) {
-		return r & 0x0f;
+		return r & 0x0fU;
 	}
 	else {
-		return (int)(r >> 4);
+		return (int)(r >> 4U);
 	}
 }
 
-void LargeFixedNumber::setDigit(int digit, int val) {
+void LargeFixedNumber::setDigit(int digit, int v) {
+    auto val = uint8_t(v);
 	if (digit > 11) return;
 	if ((digit % 2) == 0) {
 		bcdRepresentation[digit / 2] = (bcdRepresentation[digit / 2] & 0xf0) | val;
 	}
 	else {
-		bcdRepresentation[digit / 2] = (bcdRepresentation[digit / 2] & 0x0f) | (val << 4);
+		bcdRepresentation[digit / 2] = (bcdRepresentation[digit / 2] & 0x0f) | (val << 4U);
 	}
 }
 
+float LargeFixedNumber::getAsFloat() {
+    if(fractionDp == 0) return (float)getWhole();
+
+    float fraction = ((float)getFraction() / (float)dpToDivisor(fractionDp));
+    float asFlt = (float)getWhole() + fraction;
+    serdebugF3("fract, asFlt ", fraction, asFlt);
+    if (negative) asFlt = -asFlt;
+    return asFlt;
+}
+
+void LargeFixedNumber::setFromFloat(float value) {
+    bool neg = value < 0.0f;
+    value = abs(value);
+    uint32_t val;
+    uint32_t frc;
+    if(fractionDp == 0) {
+        val = (uint32_t)value;
+        frc = 0;
+    }
+    else {
+        val = (uint32_t)value;
+        frc = (value - (float) val) * float(dpToDivisor(fractionDp));
+    }
+    setValue(val, frc, neg);
+}
+
 void EditableLargeNumberMenuItem::setLargeNumberFromString(const char* val) {
 	int offset = 0;
 	bool negative = false;
@@ -86,8 +113,10 @@ void wrapEditor(bool editRow, char val, char* buffer, int bufferSize) {
 
 int largeNumItemRenderFn(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode, char* buffer, int bufferSize) {
 	if (item->getMenuType() != MENUTYPE_LARGENUM_VALUE) return 0;
-	EditableLargeNumberMenuItem* numItem = reinterpret_cast<EditableLargeNumberMenuItem*>(item);
+	auto numItem = reinterpret_cast<EditableLargeNumberMenuItem*>(item);
+	auto negativeAllowed = numItem->isNegativeAllowed();
 	LargeFixedNumber *num = numItem->getLargeNumber();
+    int numParts = numItem->getNumberOfParts() - (negativeAllowed ? 1 : 0);
 
 	switch (mode) {
 	case RENDERFN_VALUE: {
@@ -96,21 +125,22 @@ int largeNumItemRenderFn(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode,
 		bool hadNonZero = false;
 		uint8_t editPosition = 0;
 
-		if (editingMode || num->isNegative()) {
+		if (negativeAllowed && (editingMode ||  num->isNegative())) {
 			wrapEditor(row == 1, num->isNegative() ? '-' : '+', buffer, bufferSize);
+			row = row - 1;
 		}
 
-		row = row - 2;
+		row = row - 1;
 
-		for (int i = num->decimalPointIndex(); i < (numItem->getNumberOfParts() - 1); i++) {
+		for (int i = num->decimalPointIndex(); i < numParts; i++) {
 			char txtVal = num->getDigit(i) + '0';
 			hadNonZero |= txtVal != '0';
 			if (hadNonZero || editingMode) {
 				wrapEditor(row == editPosition, txtVal, buffer, bufferSize);
 			}
 			editPosition++;
 		}
-		appendChar(buffer, '.', bufferSize);
+		if(num->decimalPointIndex() != 0) appendChar(buffer, '.', bufferSize);
 
 		for (int i = 0; i < num->decimalPointIndex(); i++) {
 			char txtVal = num->getDigit(i) + '0';
@@ -120,16 +150,23 @@ int largeNumItemRenderFn(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode,
 		return true;
 	}
 	case RENDERFN_GETRANGE: {
-		return row == 1 ? 1 : 9;
+		if(negativeAllowed) {
+		    return row == 1 ? 1 : 9;
+		}
+		else {
+		    return 9;
+		}
 	}
 	case RENDERFN_SET_VALUE: {
 		int idx = row - 1;
-		if (idx == 0) {
-			num->setNegative(buffer[0]);
-			return true;
+		if(negativeAllowed) {
+            if (idx == 0) {
+                num->setNegative(buffer[0]);
+                return true;
+            }
+            idx--;
 		}
-		idx--;
-		int dpIndex = (numItem->getNumberOfParts() - 1) - num->decimalPointIndex();
+		int dpIndex = (numParts) - num->decimalPointIndex();
 		int pos = idx >= dpIndex ? idx - dpIndex : idx + num->decimalPointIndex();
 		num->setDigit(pos, buffer[0]);
 		return true;
@@ -140,11 +177,13 @@ int largeNumItemRenderFn(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode,
 	}
 	case RENDERFN_GETPART: {
 		int idx = row - 1;
-		if (idx == 0) {			
-			return num->isNegative();
-		}
-		idx--;
-		int dpIndex = (numItem->getNumberOfParts() - 1) - num->decimalPointIndex();
+		if(negativeAllowed) {
+            if (idx == 0) {
+                return num->isNegative();
+            }
+            idx--;
+        }
+		int dpIndex = (numParts) - num->decimalPointIndex();
 		int pos =  idx >= dpIndex ? idx - dpIndex : idx + num->decimalPointIndex();
 		return num->getDigit(pos);
 	}
diff --git a/src/EditableLargeNumberMenuItem.h b/src/EditableLargeNumberMenuItem.h
@@ -19,22 +19,23 @@
 #define LARGE_NUM_ALLOC_SIZE (LARGE_NUM_MAX_DIGITS / 2)
 
 /**
- * A structure for very large integers that can be edited using the multipart editor.
- * They are represented as binary coded decimal to 12 dp with as many fraction decimal
- * places as needed. The whole can be either negative or positive, while the fraction is 
- * an unsigned number in 32 bit form. This provides numbers in the range of at least 9 digits before
- * the dp, and 9 after.
+ * A structure for very large numbers that can be edited using the multipart editor. They are represented as binary
+ * coded decimal to 12 dp with between 0 and 9 fraction decimal places if needed. The whole can be either negative or
+ * positive between 1 and 9 decimal places. Both fraction and whole can be extracted as either a floating point, a
+ * per digit value, or as integers containing whole, fraction and negative flag.
  */
 class LargeFixedNumber {
 private:
 	uint8_t bcdRepresentation[LARGE_NUM_ALLOC_SIZE];
     bool negative;
+    uint8_t totalSize;
     uint8_t fractionDp;
 public:
     /**
-     * Create a default instance with decimal places set to 4
+     * Create a default instance with decimal places set to 4 and total size 12.
      */
     LargeFixedNumber() {
+        totalSize = 12;
 		setPrecision(4);
     }
 
@@ -44,16 +45,20 @@ class LargeFixedNumber {
 	void clear();
 
 	/**
-	 * @return the number of decimal places needed.
+	 * @return the number of decimal places this represents.
 	 */
     int decimalPointIndex() const { return fractionDp; }
 
 	/**
-	 * Set the number of decimal places and zero out any currently held value.
+	 * Set the number of decimal places and optionally the total size then zero out any currently held value. When
+	 * setting this value you should ensure that: fractionDp is not larger than 9, the difference between fractionDp
+	 * and maxDigits is not greater than 9.
 	 * @param dp the new number of decimal places
+	 * @param maxDigits the total number of digits needed.
 	 */
-    void setPrecision(uint8_t dp) {
+    void setPrecision(uint8_t dp, uint8_t maxDigits = 12) {
         fractionDp = dp;
+        totalSize = maxDigits;
         clear();
     }
 
@@ -67,17 +72,10 @@ class LargeFixedNumber {
 
     /**
      * Takes a floating point value and converts it into the internal representation.
-     * This class can nearly always accurately represent a float value unless it exceeds
-     * 12 digits.
+     * This will represent the float within the bounds of the current total digits and decimal precision.
      * @param value the float value to convert
      */
-    void setFromFloat(float value) {
-        bool neg = value < 0.0f;
-        value = abs(value);
-        uint32_t val = (uint32_t)value;
-        uint32_t frc = (value - (float)val) * dpToDivisor(fractionDp);
-        setValue(val, frc, neg);
-    }
+    void setFromFloat(float value);
 
     /**
      * Converts from the BCD packed structure into an integer
@@ -88,7 +86,7 @@ class LargeFixedNumber {
 	uint32_t fromBcdPacked(int start, int end);
 
     /**
-     * Converts from the BCD packed structure into an integer
+     * Converts from an integer into BCD packed.
      * @param value the value to be encoded
      * @param start the index to start in the packed data
      * @param end will stop at one before this point
@@ -116,18 +114,12 @@ class LargeFixedNumber {
      * 
      * @return the current represented value as a floating point number.
      */
-    float getAsFloat() {
-        float fraction = ((float)getFraction() / (float)dpToDivisor(fractionDp));
-		float asFlt = (float)getWhole() + fraction;
-		serdebugF3("fract, asFlt ", fraction, asFlt);
-		if (negative) asFlt = -asFlt;
-		return asFlt;		
-    }
+    float getAsFloat();
 
     /**
      * @return true if negative otherwise false.
      */
-    bool isNegative() { return negative; }
+    bool isNegative() const { return negative; }
 
 	/**
 	 * Sets the negative flag, if true the number becomes a negative value.
@@ -141,7 +133,7 @@ class LargeFixedNumber {
      * @return the whole part of the value
      */
     uint32_t getWhole() {
-        return fromBcdPacked(fractionDp, LARGE_NUM_MAX_DIGITS);
+        return fromBcdPacked(fractionDp, totalSize);
     }
 
     /**
@@ -167,20 +159,33 @@ int largeNumItemRenderFn(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode,
 
 /**
  * A multipart editor for very large numbers, either integer or fixed point decimal that exceed the usable range 
- * of a rotary encoder or joystick to set their value. This class works by editing each digit in turn.
+ * of a rotary encoder or joystick to set their value. This class works by editing each digit in turn. This is based
+ * on LargeFixedNumber, see that for more details on the capabilities
+ * @see LargeFixedNumber
  */
 class EditableLargeNumberMenuItem : public EditableMultiPartMenuItem<LargeFixedNumber> {
+private:
+    bool negativeAllowed;
 public:
-	EditableLargeNumberMenuItem(RuntimeRenderingFn renderFn, uint16_t id, int maxDigits, int dps, MenuItem* next = NULL)
+    EditableLargeNumberMenuItem(RuntimeRenderingFn renderFn, uint16_t id, int maxDigits, int dps, bool allowNeg, MenuItem* next = nullptr)
+            : EditableMultiPartMenuItem(MENUTYPE_LARGENUM_VALUE, id, maxDigits + (allowNeg ? 1 : 0), renderFn, next) {
+        data.setPrecision(dps, maxDigits);
+        negativeAllowed = allowNeg;
+    }
+
+	EditableLargeNumberMenuItem(RuntimeRenderingFn renderFn, uint16_t id, int maxDigits, int dps, MenuItem* next = nullptr)
 		: EditableMultiPartMenuItem(MENUTYPE_LARGENUM_VALUE, id, maxDigits + 1, renderFn, next) {
-        data.setPrecision(dps);
+        data.setPrecision(dps, maxDigits);
+        negativeAllowed = true;
 	}
 
     /** gets the large integer value that this class is using */
 	LargeFixedNumber* getLargeNumber() { return &data; }  
 
     /** sets a number from a string in the form whole.fraction */
     void setLargeNumberFromString(const char* largeNum);
+
+    bool isNegativeAllowed() { return negativeAllowed; }
 };
 
 #endif //_EDITABLE_LARGE_NUMBER_MENU_ITEM_H_
diff --git a/tests/tcMenuCoreTests/LargeNumberItemTests.cpp b/tests/tcMenuCoreTests/LargeNumberItemTests.cpp
@@ -230,4 +230,56 @@ test(testSetLargeIntFromString) {
 	assertFalse(editable.getLargeNumber()->isNegative());
 }
 
+test(LargeNumWithNegativeNotAllowed) {
+    EditableLargeNumberMenuItem editable(largeNumTestCb, 101, 6, 0, false);
+
+    editable.setLargeNumberFromString("15234");
+    assertEqual(editable.getLargeNumber()->getWhole(), (uint32_t)15234);
+    assertEqual(editable.getLargeNumber()->getFraction(), (uint32_t)0);
+    assertNear(editable.getLargeNumber()->getAsFloat(), 15234.0F, 0.00001);
+    assertFalse(editable.getLargeNumber()->isNegative());
+
+    char sz[32];
+    editable.copyValue(sz, sizeof(sz));
+    assertStringCaseEqual("15234", sz);
+
+    editable.beginMultiEdit();
+    assertEqual(9, editable.nextPart());
+    assertEqual(0, editable.getPartValueAsInt());
+    editable.copyValue(sz, sizeof(sz));
+    assertStringCaseEqual("[0]15234", sz);
+
+    assertEqual(9, editable.nextPart());
+    assertEqual(1, editable.getPartValueAsInt());
+    editable.copyValue(sz, sizeof(sz));
+    assertStringCaseEqual("0[1]5234", sz);
+
+    assertEqual(9, editable.nextPart());
+    assertEqual(5, editable.getPartValueAsInt());
+    editable.copyValue(sz, sizeof(sz));
+    assertStringCaseEqual("01[5]234", sz);
+
+    assertEqual(9, editable.nextPart());
+    assertEqual(2, editable.getPartValueAsInt());
+    editable.copyValue(sz, sizeof(sz));
+    assertStringCaseEqual("015[2]34", sz);
+
+    assertEqual(9, editable.nextPart());
+    assertEqual(3, editable.getPartValueAsInt());
+    editable.valueChanged(6);
+    editable.copyValue(sz, sizeof(sz));
+    assertStringCaseEqual("0152[6]4", sz);
+
+    assertEqual(9, editable.nextPart());
+    assertEqual(4, editable.getPartValueAsInt());
+    editable.valueChanged(5);
+    editable.copyValue(sz, sizeof(sz));
+    assertStringCaseEqual("01526[5]", sz);
+    assertEqual(0, editable.nextPart());
+
+    assertFalse(editable.isEditing());
+    editable.copyValue(sz, sizeof(sz));
+    assertStringCaseEqual("15265", sz);
+}
+
 #endif // LARGE_NUMBER_ITEM_TESTS_H
