#182 provide access to navigator #172 load and save with size stored

dave · dave · commit 9ff9bee4f006 · 2023-01-11T08:08:27.000Z
diff --git a/library.json b/library.json
@@ -26,7 +26,7 @@
         "authors": "DaveTCC"
       }
     ],
-    "version": "3.0.1",
+    "version": "3.1.0",
     "license": "Apache-2.0",
     "frameworks": "arduino, mbed",
     "platforms": "*"
diff --git a/library.properties b/library.properties
@@ -4,7 +4,7 @@
 #
 
 name=tcMenu
-version=3.0.1
+version=3.1.0
 maintainer=www.thecoderscorner.com
 author=davetcc
 category=Other
diff --git a/src/EepromItemStorage.cpp b/src/EepromItemStorage.cpp
@@ -9,16 +9,22 @@
 #include "ScrollChoiceMenuItem.h"
 #include "MenuIterator.h"
 
+bool tcMenuUseSizedEeprom = false;
 
-void saveRecursively(EepromAbstraction* eeprom, MenuItem* nextMenuItem) {
+uint16_t saveRecursively(EepromAbstraction* eeprom, MenuItem* nextMenuItem) {
+    uint16_t lastItemSaved = 0;
     while (nextMenuItem) {
         if (nextMenuItem->getMenuType() == MENUTYPE_SUB_VALUE) {
-            saveRecursively(eeprom, ((SubMenuItem *) nextMenuItem)->getChild());
+            lastItemSaved = max(lastItemSaved, saveRecursively(eeprom, ((SubMenuItem *) nextMenuItem)->getChild()));
         } else {
             saveMenuItem(eeprom, nextMenuItem);
+            if(nextMenuItem->getEepromPosition() != 0xFFFF) {
+                lastItemSaved = max(lastItemSaved, nextMenuItem->getEepromPosition());
+            }
         }
         nextMenuItem = nextMenuItem->getNext();
     }
+    return lastItemSaved;
 }
 
 void saveMenuItem(EepromAbstraction* eeprom, MenuItem* nextMenuItem) {
@@ -76,7 +82,10 @@ void saveMenuItem(EepromAbstraction* eeprom, MenuItem* nextMenuItem) {
 void saveMenuStructure(EepromAbstraction* eeprom, uint16_t magicKey) {
 	serlogF2(SER_TCMENU_INFO, "Save to EEPROM with key ", magicKey);
 	eeprom->write16(0, magicKey);
-	saveRecursively(eeprom, menuMgr.getRoot());
+	uint16_t maxPos = saveRecursively(eeprom, menuMgr.getRoot());
+    if(tcMenuUseSizedEeprom) {
+        eeprom->write16(2, maxPos);
+    }
 }
 
 void loadSingleItem(EepromAbstraction* eeprom, MenuItem* nextMenuItem) {
@@ -137,23 +146,29 @@ void loadSingleItem(EepromAbstraction* eeprom, MenuItem* nextMenuItem) {
     }
 }
 
-void loadRecursively(EepromAbstraction* eeprom, MenuItem* nextMenuItem) {
+void loadRecursively(EepromAbstraction* eeprom, MenuItem* nextMenuItem, uint16_t maxLoadPosition) {
 	while (nextMenuItem) {
 		if (nextMenuItem->getMenuType() == MENUTYPE_SUB_VALUE) {
-			loadRecursively(eeprom, ((SubMenuItem*)nextMenuItem)->getChild());
+			loadRecursively(eeprom, ((SubMenuItem*)nextMenuItem)->getChild(), maxLoadPosition);
 		}
 		else {
-		    loadSingleItem(eeprom, nextMenuItem);
+            uint16_t romLoc = nextMenuItem->getEepromPosition();
+            if(romLoc <= maxLoadPosition) {
+                loadSingleItem(eeprom, nextMenuItem);
+            } else if(romLoc != 0xFFFF) {
+                serlogF4(SER_TCMENU_DEBUG, "MenuItem EEPROM load skipped ", romLoc, maxLoadPosition, nextMenuItem->getId());
+            }
 		}
 		nextMenuItem = nextMenuItem->getNext();
 	}
 }
 
 bool loadMenuStructure(EepromAbstraction* eeprom, uint16_t magicKey) {
 	if (eeprom->read16(0) == magicKey) {
+        uint16_t maxEntry = (tcMenuUseSizedEeprom) ? eeprom->read16(2) : 0xFFFE;
 		serlogFHex(SER_TCMENU_INFO, "Load from EEPROM key found ", magicKey);
 		MenuItem* nextMenuItem = menuMgr.getRoot();
-		loadRecursively(eeprom, nextMenuItem);
+		loadRecursively(eeprom, nextMenuItem, maxEntry);
 		return true;
 	}
 	else {
@@ -163,7 +178,7 @@ bool loadMenuStructure(EepromAbstraction* eeprom, uint16_t magicKey) {
 }
 
 bool loadMenuItem(EepromAbstraction* eeprom, MenuItem* theItem, uint16_t magicKey) {
-    if (eeprom->read16(0) == magicKey) {
+    if (eeprom->read16(0) == magicKey && (!tcMenuUseSizedEeprom || eeprom->read16(2) <= theItem->getEepromPosition())) {
         loadSingleItem(eeprom, theItem);
         return true;
     }
@@ -178,4 +193,8 @@ void triggerAllChangedCallbacks() {
             item->triggerCallback();
         }
     });
-}
+}
+
+void setSizeBasedEEPROMStorageEnabled(bool ena) {
+    tcMenuUseSizedEeprom = ena;
+}
diff --git a/src/EepromItemStorage.h b/src/EepromItemStorage.h
@@ -56,4 +56,10 @@ void saveMenuItem(EepromAbstraction* eeprom, MenuItem* theItem);
  */
 void triggerAllChangedCallbacks();
 
-#endif //_EEPROM_ITEM_STORAGE_H_
+/**
+ * This enables the sized EEPROM support. When this is on, new items that are beyond the last saved EEPROM position
+ * will not attempt to be loaded. This allows new items to initialise properly as long as they are at the end.
+ */
+void setSizeBasedEEPROMStorageEnabled(bool ena);
+
+#endif //_EEPROM_ITEM_STORAGE_H_
diff --git a/src/MenuHistoryNavigator.cpp b/src/MenuHistoryNavigator.cpp
@@ -51,3 +51,7 @@ MenuItem *tcnav::MenuNavigationStore::popNavigationGetActive() {
 bool tcnav::MenuNavigationStore::isShowingRoot() {
     return currentRoot == root;
 }
+
+void tcnav::MenuNavigationStore::resetStack() {
+    setRootItem(root);
+}
diff --git a/src/MenuHistoryNavigator.h b/src/MenuHistoryNavigator.h
@@ -67,6 +67,28 @@ namespace tcnav {
         MenuItem* popNavigationGetActive();
 
         bool isShowingRoot();
+
+        /**
+         * @return the depth of the navigation stack that is being managed.
+         */
+        int getNavigationDepth() const { return navIdx; }
+
+        /**
+         * The active item at a given zero based position in the stack or nullptr if out of range
+         * @param i the index
+         * @return the item or nullptr
+         */
+        MenuItem* getActiveAt(uint8_t i) { return i < navIdx ? activeItems[i] : nullptr; }
+
+        /**
+         * Get the root menu item for the given zero based position in the stack or nullptr if out of range.
+         * @param i the index
+         * @return the item or nullptr
+         */
+        MenuItem* getRootAt(uint8_t i) { return i < navIdx ? navItems[i] : nullptr; }
+
+        /** Completely reset the navigation back to the initial state where root is on display */
+        void resetStack();
     };
 }
 
diff --git a/src/tcMenu.h b/src/tcMenu.h
@@ -397,19 +397,27 @@ class MenuManager {
 	void resetMenu(bool completeReset);
 
 	/**
-	 * Get the first menu item in the linked list that is being rendered
+	 * @return the first menu item in the linked list that is being rendered
 	 */
 	MenuItem* getCurrentMenu() { return navigator.getCurrentRoot(); }
 
+    /**
+     * @return the submenu for the currently on display menu. If root is on display it will be nullptr.
+     */
 	MenuItem* getCurrentSubMenu() { return navigator.getCurrentSubMenu(); }
 
+    /**
+     * @return the underlying navigation store that manages navigation activity for this menu manager.
+     */
+    tcnav::MenuNavigationStore& getNavigationStore() { return navigator; }
+
 	/**
-	 * Get the parent of the current menu clearing all active flags too
+	 * @return the parent of the current menu clearing all active flags too
 	 */
 	MenuItem* getParentAndReset();
 
 	/**
-	 * returns the range of the encoder or other device that is providing the
+	 * @return the range of the encoder or other device that is providing the
 	 * equivalent function as the encoder.
 	 */
 	int getCurrentRangeValue() {
@@ -423,7 +431,12 @@ class MenuManager {
 	 */
 	SecuredMenuPopup* secureMenuInstance();
 
-	void stopEditingCurrentItem(bool checkMultiPart);
+    /**
+     * Stop editing the current item, if doMultiPartNext is true and we are editing a multi part field , then this will
+     * instead move editing to the next part. Otherwise, editing will end.
+     * @param checkMultiPart true to move to the next on multipart instead of ending completely
+     */
+	void stopEditingCurrentItem(bool doMultiPartNext);
 
 	/**
 	 * Adds a menu item into the tree directly after the existing item provided. Never add an item that's already in
@@ -453,11 +466,26 @@ class MenuManager {
      */
     void recalculateListIfOnDisplay(RuntimeMenuItem* runtimeItem);
 
+    /**
+     * This sets rendering hints, so that the renderer knows that something is being edited. When the rendering hints
+     * are set, they refer to the item that is currently being edited.
+     * @param hint the type of edit taking place
+     * @param start the starting point within the text
+     * @param end the ending point within the text
+     */
     void setEditorHints(CurrentEditorRenderingHints::EditorRenderingType hint, size_t start=0, size_t end=0);
     const CurrentEditorRenderingHints& getEditorHints() { return renderingHints; }
 
+    /**
+     * Lock the editor hints such that nobody can change them, useful for complex editing where more than one field is
+     * being edited at once.
+     * @param locked true to lock, otherwise false.
+     */
     void setEditorHintsLocked(bool locked);
 
+    /**
+     * Use this with caution. Resets the entire list of observers that have previously been registered.
+     */
     void resetObservers();
 
 protected:
diff --git a/src/tcMenuVersion.h b/src/tcMenuVersion.h
@@ -17,8 +17,8 @@ namespace tccore {
 
 // here we define the version as both a string and separate field
 #define TCMENU_MAJOR 3
-#define TCMENU_MINOR 0
-#define TCMENU_PATCH 1
+#define TCMENU_MINOR 1
+#define TCMENU_PATCH 0
 
 /**
  * A helper to generate the major minor version numbers used in the protocol
diff --git a/tests/tcMenuCoreTests/baseDialogTests.cpp b/tests/tcMenuCoreTests/baseDialogTests.cpp
@@ -50,6 +50,7 @@ void dialogTestCallback(ButtonType buttonPressed, void* yourData) {
 }
 
 test(testBaseDialogInfo) {
+    switches.resetAllSwitches();
 	NoRenderer noRenderer;
 	DialogTestImpl dialog(true);
 	dialog.setButtons(BTNTYPE_NONE, BTNTYPE_CLOSE);
diff --git a/tests/tcMenuCoreTests/menuManagerTests.cpp b/tests/tcMenuCoreTests/menuManagerTests.cpp
@@ -12,14 +12,53 @@ extern MockEepromAbstraction eeprom;
 
 const char szCompareData[] = "123456789";
 
-test(saveAndLoadFromMenu) {
+test(saveAndLoadFromMenuSized) {
+    switches.initialise(&mockIo, true);
+    setSizeBasedEEPROMStorageEnabled(true);
+    menuMgr.initForUpDownOk(&noRenderer, &textMenuItem1, 0, 1, 2);
+
+    eeprom.write16(0, 0xfade);
+    eeprom.write16(2, 8); // limit is location 8, shouldn't load past there.
+    eeprom.write16(4, 8);
+    eeprom.write16(6, 2);
+    eeprom.write8(8, 1);
+    eeprom.write16(20, 99);
+    eeprom.write16(34, 99);
+    menuMgr.load(eeprom);
+
+    // now check the values we've loaded back from eeprom.
+    assertEquals((int)menuAnalog2.getCurrentValue(), 8);
+    assertEquals((int)menuEnum1.getCurrentValue(), 2);
+    assertTrue(boolItem1.getBoolean());
+    // these items exceed position 8 in the rom and wont load
+    assertEquals((int)menuAnalog.getCurrentValue(), 0);
+    assertEquals((int)menuSubAnalog.getCurrentValue(), 0);
+    assertEquals((int)menuSubAnalog.getCurrentValue(), 0);
+
+    menuSubAnalog.setCurrentValue(42);
+
+    // save and then make sure the header is right
+    menuMgr.save(eeprom);
+    assertEquals(uint16_t(0xfade), eeprom.read16(0));
+    assertEquals(uint16_t(34), eeprom.read16(2));
+
+    // and now the values
+    assertEquals(eeprom.read16(20), (uint16_t)42);
+    assertEquals(eeprom.read16(4), (uint16_t)8);
+    assertEquals(eeprom.read16(6), (uint16_t)2);
+    assertEquals(eeprom.read8(8), (uint8_t)1);
+    switches.resetAllSwitches();
+}
+
+test(saveAndLoadFromMenuUnsized) {
     // initialise the menu manager and switches with basic configuration
     switches.initialise(&mockIo, true);
+    setSizeBasedEEPROMStorageEnabled(false);
     menuMgr.initForUpDownOk(&noRenderer, &textMenuItem1, 0, 1, 2);
 
     // now set up the eeprom ready to load.
     eeprom.write16(0, 0xfade);
-    eeprom.write16(2, 100);
+    eeprom.write16(34, 100);
     eeprom.write16(4, 8);
     eeprom.write16(6, 2);
     eeprom.write8(8, 1);
@@ -51,7 +90,7 @@ test(saveAndLoadFromMenu) {
 
     // now compare back from eeprom what we saved.
     assertEquals(eeprom.read16(0), (uint16_t)0xfade);
-    assertEquals(eeprom.read16(2), (uint16_t)100);
+    assertEquals(eeprom.read16(34), (uint16_t)100);
     assertEquals(eeprom.read16(20), (uint16_t)50);
     assertEquals(eeprom.read16(4), (uint16_t)8);
     assertEquals(eeprom.read16(6), (uint16_t)2);
@@ -68,6 +107,7 @@ test(saveAndLoadFromMenu) {
 
     // lastly make sure there were no errors in eeprom.
     assertFalse(eeprom.hasErrorOccurred());
+    switches.resetAllSwitches();
 }
 
 class TestMenuMgrObserver : public MenuManagerObserver {
diff --git a/tests/tcMenuCoreTests/menuNavigatorTests.cpp b/tests/tcMenuCoreTests/menuNavigatorTests.cpp
@@ -51,3 +51,39 @@ test(navigationPushAndPop) {
     assertEquals(&menuVolume, nav.getCurrentRoot());
     assertEquals(nullptr, nav.getCurrentSubMenu());
 }
+
+test(testRebuildingNavigation) {
+    MenuNavigationStore nav;
+    nav.setRootItem(&menuVolume);
+    menuMgr.initWithoutInput(&noRenderer, &menuVolume);
+
+    // now add three levels of navigation
+    nav.navigateTo(&menuChannel, menuStatus.getChild(), false);
+    nav.navigateTo(&menuLHSTemp, menuSecondLevel.getChild(), false);
+    nav.navigateTo(&menu12VStandby, menuSettings.getChild(), false);
+
+    // now attempt to iterate through the navigation stack
+    assertEquals(3, nav.getNavigationDepth());
+    assertEquals(&menuChannel, nav.getActiveAt(0));
+    assertEquals(&menuLHSTemp, nav.getActiveAt(1));
+    assertEquals(&menu12VStandby, nav.getActiveAt(2));
+    assertEquals(nav.getRoot(), nav.getRootAt(0));
+    assertEquals(menuStatus.getChild(), nav.getRootAt(1));
+    assertEquals(menuSecondLevel.getChild(), nav.getRootAt(2));
+    assertEquals(menuSettings.getChild(), nav.getCurrentRoot());
+
+    // now reset the stack and ensure it is empty
+    nav.resetStack();
+    assertEquals(0, nav.getNavigationDepth());
+
+    // put three items back into the stack
+    nav.navigateTo(&menuChannel, menuStatus.getChild(), false);
+    nav.navigateTo(&menuLHSTemp, menuSecondLevel.getChild(), false);
+    nav.navigateTo(&menu12VStandby, menuSettings.getChild(), false);
+
+    // and check they are there.
+    assertEquals(3, nav.getNavigationDepth());
+    assertEquals(&menuChannel, nav.getActiveAt(0));
+    assertEquals(&menuLHSTemp, nav.getActiveAt(1));
+    assertEquals(&menu12VStandby, nav.getActiveAt(2));
+}
diff --git a/tests/tcMenuCoreTests/tcMenuFixtures.h b/tests/tcMenuCoreTests/tcMenuFixtures.h
@@ -23,7 +23,7 @@ BackMenuItem menuBackSub(backSubFixturesFn, &menuSubAnalog);
 const PGM_TCM SubMenuInfo minfoSub = { "Settings", 7, 0xffff, 0, NO_CALLBACK };
 SubMenuItem menuSub(&minfoSub, &menuBackSub, NULL);
 
-const PGM_TCM AnalogMenuInfo minfoAnalog = { "Analog", 1, 2, 255, NO_CALLBACK, 0, 1, "AB" };
+const PGM_TCM AnalogMenuInfo minfoAnalog = { "Analog", 1, 34, 255, NO_CALLBACK, 0, 1, "AB" };
 AnalogMenuItem menuAnalog(&minfoAnalog, 0, &menuSub);
 
 const PGM_TCM AnalogMenuInfo minfoAnalog2 = { "Analog2", 2, 4, 100, NO_CALLBACK, -10, 10, "" };

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@`
`26`	`26`	`"authors": "DaveTCC"`
`27`	`27`	`}`
`28`	`28`	`],`
`29`		`- "version": "3.0.1",`
	`29`	`+ "version": "3.1.0",`
`30`	`30`	`"license": "Apache-2.0",`
`31`	`31`	`"frameworks": "arduino, mbed",`
`32`	`32`	`"platforms": "*"`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`#`
`5`	`5`
`6`	`6`	`name=tcMenu`
`7`		`-version=3.0.1`
	`7`	`+version=3.1.0`
`8`	`8`	`maintainer=www.thecoderscorner.com`
`9`	`9`	`author=davetcc`
`10`	`10`	`category=Other`
Original file line number	Diff line number	Diff line change
`@@ -51,3 +51,7 @@ MenuItem *tcnav::MenuNavigationStore::popNavigationGetActive() {`
`51`	`51`	`bool tcnav::MenuNavigationStore::isShowingRoot() {`
`52`	`52`	`return currentRoot == root;`
`53`	`53`	`}`
	`54`	`+`
	`55`	`+void tcnav::MenuNavigationStore::resetStack() {`
	`56`	`+ setRootItem(root);`
	`57`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -50,6 +50,7 @@ void dialogTestCallback(ButtonType buttonPressed, void* yourData) {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`test(testBaseDialogInfo) {`
	`53`	`+ switches.resetAllSwitches();`
`53`	`54`	`NoRenderer noRenderer;`
`54`	`55`	`DialogTestImpl dialog(true);`
`55`	`56`	`dialog.setButtons(BTNTYPE_NONE, BTNTYPE_CLOSE);`