#324, #308 remove active and edit flags on item, move work around in the renderer.

Author: davetcc

examples/avr/keyboardEthernetShield/keyboardEthernetShield.ino

@@ -93,6 +93,9 @@ void setup() {
     // of the widget is fixed, and the height field instead indicates the first custom character for the first icon.
     renderer.setFirstWidget(&connectedWidget);
 
+    // we can choose which way RGB items should present, either has HEX_HTML or DECIMAL
+    Rgb32MenuItem::setRgbPrintMode(HEX_HTML);
+
 	setupMenu();
 
 	auto* authenticator = reinterpret_cast<EepromAuthenticatorManager*>(menuMgr.getAuthenticator());

examples/avr/keyboardEthernetShield/tcMenuLiquidCrystal.cpp

@@ -79,25 +79,25 @@ int calculateOffset(GridPosition::GridJustification just, int totalLen, const ch
 void copyIntoBuffer(char* buffer, const char* source, int offset, int bufferLen) {
     auto len = strlen(source);
     for(size_t i=0; i<len; i++) {
-        auto pos = offset+i;
-        if(pos >= bufferLen) return;
+        size_t pos = offset+i;
+        if(pos >= (size_t)bufferLen) return;
         buffer[pos] = source[i];
     }
 }
 
-void LiquidCrystalRenderer::drawMenuItem(GridPositionRowCacheEntry* entry, Coord where, Coord areaSize, bool /*ignored*/) {
+void LiquidCrystalRenderer::drawMenuItem(GridPositionRowCacheEntry* entry, Coord where, Coord areaSize, const DrawingFlags& drawingFlags) {
     auto* theItem = entry->getMenuItem();
     theItem->setChanged(false);
     char sz[21];
 
     if(entry->getPosition().getJustification() == GridPosition::JUSTIFY_TITLE_LEFT_VALUE_RIGHT) {
-        buffer[0] = theItem->isEditing() ? editChar : (theItem->isActive() ? forwardChar : ' ');
+        buffer[0] = drawingFlags.isEditing() ? editChar : (drawingFlags.isActive() ? forwardChar : ' ');
         lcd->setCursor(where.x, where.y);
         int offs = 1;
         uint8_t finalPos = theItem->copyNameToBuffer(buffer, offs, bufferSize);
         for(uint8_t i = finalPos; i < uint8_t(areaSize.x); ++i)  buffer[i] = 32;
         buffer[bufferSize] = 0;
-        copyMenuItemValue(theItem, sz, sizeof sz);
+        copyMenuItemValue(theItem, sz, sizeof sz, drawingFlags.isActive());
         uint8_t count = strlen(sz);
         int cpy = bufferSize - count;
         strcpy(buffer + cpy, sz);
@@ -116,12 +116,12 @@ void LiquidCrystalRenderer::drawMenuItem(GridPositionRowCacheEntry* entry, Coord
         if(itemNeedsValue(entry->getPosition().getJustification())) {
             sz[valueStart] = 32;
             valueStart++;
-            copyMenuItemValue(entry->getMenuItem(), sz + valueStart, sizeof(sz) - valueStart);
+            copyMenuItemValue(entry->getMenuItem(), sz + valueStart, sizeof(sz) - valueStart, drawingFlags.isActive());
             serlogF2(SER_TCMENU_DEBUG, "Value ", sz);
         }
         int position = calculateOffset(entry->getPosition().getJustification(), int(areaSize.x) + 1, sz);
         copyIntoBuffer(&buffer[1], sz, position, bufferSize);
-        buffer[0] = theItem->isEditing() ? editChar : (theItem->isActive() ? forwardChar : ' ');
+        buffer[0] = drawingFlags.isEditing() ? editChar : (drawingFlags.isActive() ? forwardChar : ' ');
         buffer[min(uint8_t(areaSize.x + 1), bufferSize)] = 0;
         lcd->setCursor(where.x, where.y);
         if(theItem == menuMgr.getCurrentEditor() && menuMgr.getEditorHints().getEditorRenderingType() != CurrentEditorRenderingHints::EDITOR_REGULAR) {

examples/avr/keyboardEthernetShield/tcMenuLiquidCrystal.h

@@ -50,7 +50,7 @@ class LiquidCrystalRenderer : public BaseGraphicalRenderer {
 
     void drawingCommand(RenderDrawingCommand command) override;
     void drawWidget(Coord where, TitleWidget* widget, color_t colorFg, color_t colorBg) override;
-    void drawMenuItem(GridPositionRowCacheEntry* entry, Coord where, Coord areaSize, bool drawAll) override;
+    void drawMenuItem(GridPositionRowCacheEntry* entry, Coord where, Coord areaSize, const DrawingFlags& drawAll) override;
     void fillWithBackgroundTo(int endPoint) override;
 
     ItemDisplayPropertiesFactory &getDisplayPropertiesFactory() override { return propertiesFactory; }

src/BaseDialog.cpp

@@ -289,7 +289,7 @@ void MenuBasedDialog::internalSetVisible(bool visible) {
         factory.addGridPosition(&btn2Item, GridPosition(GridPosition::DRAW_TEXTUAL_ITEM, GridPosition::JUSTIFY_RIGHT_NO_VALUE, 2, 2, row, 0));
         factory.addGridPosition(&bufferItem, GridPosition(GridPosition::DRAW_TEXTUAL_ITEM, GridPosition::JUSTIFY_LEFT_VALUE_ONLY, 1, 0));
 
-        auto toMakeActive = (lastBtnVal == 0 && btn1Item.isActive()) ? &btn1Item : &btn2Item;
+        auto toMakeActive = (lastBtnVal == 0 && renderer->getActiveItem() == &btn1Item) ? &btn1Item : &btn2Item;
         menuMgr.navigateToMenu(&backItem, toMakeActive, true);
     }
     else {
@@ -317,11 +317,6 @@ void MenuBasedDialog::resetDialogFields() {
     bufferItem.setReadOnly(true);
     btn1Item.setNext(&btn2Item);
     addedMenuItems = 0;
-
-    backItem.setActive(false);
-    bufferItem.setActive(false);
-    btn1Item.setActive(false);
-    btn2Item.setActive(false);
 }
 
 void withMenuDialogIfAvailable(DialogInitialiser dlgFn) {

src/BaseRenderers.cpp

@@ -35,19 +35,23 @@ class RenderingMenuMgrObserver : public MenuManagerObserver {
 } menuMgrListener;
 
 
-BaseMenuRenderer::BaseMenuRenderer(int bufferSize, RendererType rType) : MenuRenderer(rType, bufferSize) {
+BaseMenuRenderer::BaseMenuRenderer(int bufferSize, RendererType rType, uint8_t displayNum) : MenuRenderer(rType, bufferSize) {
 	ticksToReset = 0;
     lastOffset = 0;
+    displayNumber = displayNum;
     resetValInTicks = 30 * TC_DISPLAY_UPDATES_PER_SECOND;
-	renderCallback = nullptr;
+    renderCallback = nullptr;
     renderFnPressType = RPRESS_NONE;
 	redrawMode = MENUDRAW_COMPLETE_REDRAW;
 	this->lastOffset = 0;
     this->firstWidget = nullptr;
     this->dialog = nullptr;
     displayTakenMode = NOT_TAKEN_OVER;
     updatesPerSecond = TC_DISPLAY_UPDATES_PER_SECOND;
-    MenuRenderer::theInstance = this;
+    // if this is the default display, it becomes the static (IE global) instance for dialogs etc.
+    if(displayNum == 0) {
+        MenuRenderer::theInstance = this;
+    }
 }
 
 void BaseMenuRenderer::initialise() {
@@ -151,6 +155,14 @@ void BaseMenuRenderer::setFirstWidget(TitleWidget* widget) {
 	this->redrawMode = MENUDRAW_COMPLETE_REDRAW;
 }
 
+uint8_t BaseMenuRenderer::setActiveItem(MenuItem* item) {
+    if(!item) return 0;
+    if(activeItem) activeItem->setChanged(true);
+    item->setChanged(true);
+    activeItem = item;
+    return findItemIndex(menuMgr.getCurrentMenu(), item);
+}
+
 int BaseMenuRenderer::findItemIndex(MenuItem *root, MenuItem *toFind) {
     uint8_t i = 0;
     MenuItem *itm = root;
@@ -165,18 +177,7 @@ int BaseMenuRenderer::findItemIndex(MenuItem *root, MenuItem *toFind) {
 }
 
 int BaseMenuRenderer::findActiveItem(MenuItem *root) {
-    uint8_t i = 0;
-    MenuItem *itm = root;
-    while (itm != nullptr) {
-        if (itm->isVisible()) {
-            if (itm->isActive() || itm->isEditing()) {
-                return i;
-            }
-            i++;
-        }
-        itm = itm->getNext();
-    }
-    return 0;
+    return findItemIndex(menuMgr.getCurrentMenu(), activeItem);
 }
 
 uint8_t BaseMenuRenderer::itemCount(MenuItem* item, bool includeNonVisible) {

src/BaseRenderers.h

@@ -285,22 +285,23 @@ class BaseMenuRenderer : public MenuRenderer, Executable {
 protected:
 	uint8_t lastOffset;
 	uint8_t updatesPerSecond;
+    uint8_t displayNumber = 0;
+    MenuRedrawState redrawMode;
 	uint16_t ticksToReset;
     uint16_t resetValInTicks;
-	MenuRedrawState redrawMode;
 	TitleWidget* firstWidget;
     CustomDrawing *customDrawing;
-	DisplayTakeoverMode displayTakenMode;
     BaseDialog* dialog;
-
+    DisplayTakeoverMode displayTakenMode;
 	RenderPressMode renderFnPressType;
 	RendererCallbackFn renderCallback;
+    MenuItem* activeItem = nullptr;
 public:
 	/**
 	 * constructs the renderer with a given buffer size 
 	 * @param bufferSize size of text buffer to create
 	 */
-	BaseMenuRenderer(int bufferSize, RendererType rType = RENDER_TYPE_BASE);
+	BaseMenuRenderer(int bufferSize, RendererType rType = RENDER_TYPE_BASE, uint8_t displayNum = 0);
 
 	/** 
 	 * Destructs the class removing the allocated buffer
@@ -400,13 +401,6 @@ class BaseMenuRenderer : public MenuRenderer, Executable {
 	 */
     virtual MenuItem *getMenuItemAtIndex(MenuItem *pItem, uint8_t idx);
 
-    /**
-     * Find the active item offset in the list
-     * @param root the root item
-     * @return the position 0 based.
-     */
-    virtual int findActiveItem(MenuItem* root);
-
     /**
      * Find an item's offset in a given root, safely returns 0.
      * @param root the root item
@@ -423,6 +417,24 @@ class BaseMenuRenderer : public MenuRenderer, Executable {
      */
     virtual uint8_t itemCount(MenuItem* item, bool includeNonVisible);
 
+    /**
+     * Set the active index to a new menu item, the active item is the one that is selected for editing and
+     * other display purposes. You must never pass null to this method, and you are returned the index in the array
+     * that is now selected.
+     * @return the active item index.
+     */
+     virtual uint8_t setActiveItem(MenuItem* item);
+
+     MenuItem* getActiveItem() { return activeItem; }
+
+    /**
+     * Find the active item offset in the list
+     * @param root the root item
+     * @return the position 0 based.
+     */
+    int findActiveItem(MenuItem* root);
+
+
     /**
 	 * For menu systems that support title widgets, this will allow the first widget.
 	 * @param the first widget in a chain of widgets linked by next pointer.
@@ -469,6 +481,8 @@ class BaseMenuRenderer : public MenuRenderer, Executable {
      */
     void invalidateAll() { redrawMode = MENUDRAW_COMPLETE_REDRAW; }
 
+    static BaseMenuRenderer* getInstance() { return reinterpret_cast<BaseMenuRenderer *>(theInstance); }
+
 protected:
 	/**
 	 * set up a countdown to default back to the submenu

src/EepromItemStorage.cpp

@@ -189,7 +189,7 @@ bool loadMenuItem(EepromAbstraction* eeprom, MenuItem* theItem, uint16_t magicKe
 
 void triggerAllChangedCallbacks() {
     getParentRootAndVisit(menuMgr.getRoot(), [](MenuItem* item) {
-        if(item->isChanged() && item->getEepromPosition() != 0xffff) {
+        if(item->isChanged(0) && item->getEepromPosition() != 0xffff) {
             item->triggerCallback();
         }
     });

src/MenuItems.cpp

@@ -27,16 +27,6 @@ void MenuItem::setSendRemoteNeeded(uint8_t remoteNo, bool needed) {
 	bitWrite(flags, (remoteNo + (int)MENUITEM_REMOTE_SEND0), (needed && !isLocalOnly()));
 }
 
-void MenuItem::setEditing(bool active) {
-	bool isEditOnEntry = isEditing();
-	bitWrite(flags, MENUITEM_EDITING, active);
-	setChanged(true);
-	if (isMenuRuntimeMultiEdit(this) && !active && isEditOnEntry) {
-		auto* item = reinterpret_cast<EditableMultiPartMenuItem*>(this);
-		item->stopMultiEdit();
-	}
-}
-
 void MenuItem::setSendRemoteNeededAll() {
     // make sure local only fields are never marked for sending.
     if(isLocalOnly()) clearSendRemoteNeededAll();
@@ -119,9 +109,10 @@ uint16_t MenuItem::getEepromPosition() const
 	return  isInfoProgMem() ? get_info_uint(&info->eepromAddr) : info->eepromAddr;
 }
 
-void MenuItem::setActive(bool active)  {
-    bitWrite(flags, MENUITEM_ACTIVE, active);
-    setChanged(true);
+void MenuItem::setChanged(bool changed) {
+    flags = flags | MENUITEM_ALL_CHANGE;
+    if(isLocalOnly()) return;
+    flags = flags | MENUITEM_ALL_REMOTES;
 }
 
 // on avr boards we store all info structures in progmem, so we need this code to
@@ -320,19 +311,19 @@ const char NO_STR[] PGM_TCM   = TXT_BOOL_NO_TEXT;
 const char TRUE_STR[] PGM_TCM = TXT_BOOL_TRUE_TEXT;
 const char FALSE_STR[] PGM_TCM= TXT_BOOL_FALSE_TEXT;
 
-void copyMenuItemNameAndValue(const MenuItem* item, char* buffer, size_t bufferSize, char additionalSep) {
+void copyMenuItemNameAndValue(const MenuItem* item, char* buffer, size_t bufferSize, char additionalSep, bool active) {
     item->copyNameToBuffer(buffer, bufferSize);
     if(additionalSep != 0) appendChar(buffer, additionalSep, bufferSize);
     appendChar(buffer, ' ', bufferSize);
 
     int pos = strlen(buffer);
-    copyMenuItemValue(item, buffer + pos, bufferSize - pos);
+    copyMenuItemValue(item, buffer + pos, bufferSize - pos, active);
 }
 
 const char CHECKED_STR[] PROGMEM = "[X]";
 const char UNCHECKED_STR[] PROGMEM = "[ ]";
 
-void copyMenuItemValue(const MenuItem* item, char* buffer, size_t bufferSize) {
+void copyMenuItemValue(const MenuItem* item, char* buffer, size_t bufferSize, bool active) {
     buffer[0] = 0;
     if(item->getMenuType() == MENUTYPE_ENUM_VALUE) {
         auto* enItem = reinterpret_cast<const EnumMenuItem*>(item);
@@ -372,12 +363,12 @@ void copyMenuItemValue(const MenuItem* item, char* buffer, size_t bufferSize) {
     }
     else if(item->getMenuType() == MENUTYPE_BACK_VALUE) {
         buffer[0]=0;
-        if(item->isActive()) {
+        if(active) {
             strncpy(buffer, "[..]", bufferSize);
         }
     }
     else if(item->getMenuType() == MENUTYPE_TITLE_ITEM) {
-        if(reinterpret_cast<const tcgfx::RuntimeTitleMenuItem*>(item)->getCallback() && item->isActive()) {
+        if(reinterpret_cast<const tcgfx::RuntimeTitleMenuItem*>(item)->getCallback() && active) {
             strncpy(buffer, "...", bufferSize);
         } else buffer[0] = 0;
     }
@@ -387,9 +378,9 @@ void copyMenuItemValue(const MenuItem* item, char* buffer, size_t bufferSize) {
     }
 }
 
-void copyMenuItemValueDefault(const MenuItem* item, char* buffer, size_t bufferSize, const char* defValue) {
+void copyMenuItemValueDefault(const MenuItem* item, char* buffer, size_t bufferSize, const char* defValue, bool active) {
     buffer[0]=0;
-    copyMenuItemValue(item, buffer, bufferSize);
+    copyMenuItemValue(item, buffer, bufferSize, active);
     if(strlen(buffer)==0) {
         strncpy(buffer, defValue, bufferSize);
         buffer[bufferSize - 1] = 0;