EditableLargeNumberMenuItem.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 https://www.thecoderscorner.com (Dave Cherry).
 * This product is licensed under an Apache license, see the LICENSE file in the top-level directory.
 */
 
#ifndef _EDITABLE_LARGE_NUMBER_MENU_ITEM_H_
#define _EDITABLE_LARGE_NUMBER_MENU_ITEM_H_
 
#include "RuntimeMenuItem.h"
#include <IoLogging.h>
 
#define LARGE_NUM_MAX_DIGITS 12
#define LARGE_NUM_ALLOC_SIZE (LARGE_NUM_MAX_DIGITS / 2)
 
class LargeFixedNumber {
private:
    uint8_t bcdRepresentation[LARGE_NUM_ALLOC_SIZE] = {};
    bool negative = false;
    uint8_t totalSize = 12;
    uint8_t fractionDp = 0;
public:
    LargeFixedNumber() = default;
 
    LargeFixedNumber(int totalDigits, int decimalPointIndex, uint32_t whole, uint32_t fraction, bool negative);
 
    LargeFixedNumber(const LargeFixedNumber& other) = default;
    LargeFixedNumber& operator=(const LargeFixedNumber& other) = default;
 
    void clear();
 
    int decimalPointIndex() const { return fractionDp; }
 
    int getTotalDigits() const { return totalSize; }
 
    void setPrecision(uint8_t dp, uint8_t maxDigits = 12) {
        fractionDp = dp;
        totalSize = maxDigits;
        clear();
    }
 
    void setValue(uint32_t whole, uint32_t fraction, bool negative);
 
    void setFromFloat(float value);
 
    uint32_t fromBcdPacked(int start, int end);
 
    void convertToBcdPacked(uint32_t value, int start, int end);
 
    int getDigit(int digit);
 
    void setDigit(int digit, int val);
 
    float getAsFloat();
 
    bool isNegative() const { return negative; }
 
    void setNegative(bool neg) {
        negative = neg;
    }
 
    uint32_t getWhole() {
        return fromBcdPacked(fractionDp, totalSize);
    }
 
    uint32_t getFraction() {
        return fromBcdPacked(0, fractionDp);
    }
 
    uint8_t* getNumberBuffer() {
        return bcdRepresentation;
    }
};
 
int largeNumItemRenderFn(RuntimeMenuItem* item, uint8_t row, RenderFnMode mode, char* buffer, int bufferSize);
 
class EditableLargeNumberMenuItem : public EditableMultiPartMenuItem {
private:
    LargeFixedNumber data;
    bool negativeAllowed;
public:
    EditableLargeNumberMenuItem(RuntimeRenderingFn renderFn, const LargeFixedNumber& initial, uint16_t id, bool allowNeg, MenuItem* next = nullptr)
            : EditableMultiPartMenuItem(MENUTYPE_LARGENUM_VALUE, id, initial.getTotalDigits() + (allowNeg ? 1 : 0), renderFn, next) {
        data = initial;
        negativeAllowed = allowNeg;
    }
 
    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, maxDigits);
        negativeAllowed = true;
    }
 
    EditableLargeNumberMenuItem(const AnyMenuInfo* info, const LargeFixedNumber& initial, bool allowNeg, MenuItem* next = nullptr, bool isPgm = INFO_LOCATION_PGM)
        : EditableMultiPartMenuItem(info, isPgm, MENUTYPE_LARGENUM_VALUE, initial.getTotalDigits() + (allowNeg ? 1 : 0), largeNumItemRenderFn, next) {
        data = initial;
        negativeAllowed = allowNeg;
    }
 
    LargeFixedNumber* getLargeNumber() { return &data; }  
 
    void setLargeNumberFromString(const char* largeNum);
 
    bool isNegativeAllowed() const { return negativeAllowed; }
};
 
#endif //_EDITABLE_LARGE_NUMBER_MENU_ITEM_H_