### Arduino Menu 4 Simple Example

Source: https://github.com/neu-rah/arduinomenu/blob/master/README.md

This example demonstrates a basic menu structure for controlling an LED blink pattern. It includes setup for serial communication, input, and output, and defines adjustable 'On' and 'Off' times for the blink using fields.

```c++
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/chainStream.h>
#include <menuIO/serialIn.h>

using namespace Menu;

#define LEDPIN LED_BUILTIN
#define MAX_DEPTH 1

unsigned int timeOn=10;
unsigned int timeOff=90;

MENU(mainMenu, "Blink menu", Menu::doNothing, Menu::noEvent, Menu::wrapStyle
  ,FIELD(timeOn,"On","ms",0,1000,10,1, Menu::doNothing, Menu::noEvent, Menu::noStyle)
  ,FIELD(timeOff,"Off","ms",0,10000,10,1,Menu::doNothing, Menu::noEvent, Menu::noStyle)
  ,EXIT("<Back")
);

serialIn serial(Serial);
MENU_INPUTS(in,&serial);

MENU_OUTPUTS(out,MAX_DEPTH
  ,SERIAL_OUT(Serial)
  ,NONE//must have 2 items at least
);

NAVROOT(nav,mainMenu,MAX_DEPTH,in,out);

void setup() {
  pinMode(LEDPIN, OUTPUT);
  Serial.begin(115200);
  while(!Serial);
  Serial.println("Menu 4.x");
  Serial.println("Use keys + - * /");
  Serial.println("to control the menu navigation");
}

bool blink(int timeOn,int timeOff) {return millis()%(unsigned long)(timeOn+timeOff)<(unsigned long)timeOn;}

void loop() {
  nav.poll();
  digitalWrite(LEDPIN, blink(timeOn,timeOff));
}
```

--------------------------------

### outputsList Example Initialization

Source: https://github.com/neu-rah/arduinomenu/wiki/Output

Initializes an `outputsList` with a NULL array and zero devices, suitable for headless menus where no output devices are present.

```c++
outputsList out(NULL,0);
```

--------------------------------

### Execute Navigation Commands

Source: https://github.com/neu-rah/arduinomenu/wiki/Navigation

Examples demonstrating how to use the navCmd structure with the doNav function to control menu navigation. The first example hilights the second option by index, and the second example executes the currently selected option.

```c++
nav.doNav(navCmd(idxCmd,1)); //hilite second option
nav.doNav(navCmd(enterCmd)); //execute option
```

--------------------------------

### Customizing Options in V4.x

Source: https://github.com/neu-rah/arduinomenu/wiki/Options

Demonstrates how to customize global options in V4.x by creating a config object and assigning it to the global options pointer during setup.

```c++
config myOptions('*','-',defaultNavCodes,false);

void setup() {
  options=&myOptions;//can customize options
  //...
}
```

--------------------------------

### Example: Combining Encoder, Button, and Serial Input

Source: https://github.com/neu-rah/arduinomenu/wiki/Input

This example demonstrates combining an encoder, its button, and serial input into a single input stream using chainStream. It initializes an encoder, a button mapped to the enter command, and a serial input, then combines them into a chainStream object named 'in'.

```c++
encoderIn<encA,encB> encoder;//simple quad encoder driver
encoderInStream<encA,encB> encStream(encoder,4);// simple quad encoder fake Stream

//a keyboard with only one key as the encoder button
keyMap encBtn_map[]={{-encBtn,options->getCmdChar(enterCmd)}};//negative pin numbers use internal pull-up, on = low
keyIn<1> encButton(encBtn_map);//1 is the number of keys

serialIn serial(Serial);

//input from the encoder + encoder button + serial
menuIn* inputsList[]={&encStream,&encButton,&serial};
chainStream<3> in(inputsList);//3 is the number of inputs
```

--------------------------------

### Define Compiler Flag Example

Source: https://github.com/neu-rah/arduinomenu/wiki/Compile-options

Use -D flags to activate compiler options. This example shows how to define MENU_IDLE_BKGND.

```c
-DMENU_IDLE_BKGND
```

--------------------------------

### Start Menu in Idle State

Source: https://github.com/neu-rah/arduinomenu/wiki/FAQ

Initializes the menu to start in an idle state, requiring user interaction (e.g., pressing 'select') to enter the menu. The menu resumes when select is pressed.

```c++
nav.idleOn(user_function);
```

--------------------------------

### Menu Prompt Example

Source: https://github.com/neu-rah/arduinomenu/wiki/WebMenu

Represents a common menu item, such as an action or a simple prompt. Key properties include the item's index, enabled status, and the text prompt displayed to the user.

```json
{"idx":"1","enabled":"1","selStart":" ","prompt":"Action A"}
```

--------------------------------

### Handle idle state with doInput/doOutput

Source: https://github.com/neu-rah/arduinomenu/wiki/Idling

Manage input and output manually when the menu is in an idle state. This example shows how to display a 'suspended' message and handle menu output when not idle.

```c++
//... 
  //on u8g2 or other devices that uses doInpu/doOutput instead of poll
  nav.doInput()
  if (nav.sleepTask) {
    u8g2.firstPage();
    do {
      u8g2.setCursor(0, 15);
      u8g2.print("suspended");
    } while ( u8g2.nextPage() );
  } else {
    if (nav.changed(0)) {
      u8g2.firstPage();
      do nav.doOutput(); while(u8g2.nextPage());
    }
  }
  //...
```

--------------------------------

### ESP8266 Web Menu Interface

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

This snippet demonstrates the setup for serving an ArduinoMenu interface over a web page on ESP8266/ESP32. It includes necessary includes and comments on accessing the HTML+XSLT and JSON state endpoints. Requires SPIFFS image with static web files.

```cpp
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
#include <menuIO/esp8266Out.h>   // ESP8266 web output driver
using namespace Menu;

// JSON response structure for root menu:
// {
//   "output": "",
//   "menu": {
//     "title": {"prompt": "Main menu"},
//     "path": "", "sel": "0",
//     "items": [
//       {"idx":"0","enabled":"1","selStart":">","prompt":"Led: ",
//        "value":"Off","options":["On","Off"]},
//       {"idx":"1","enabled":"1","selStart":" ","prompt":"Brightness",
//        "field":"50","range":{"low":"0","high":"100","step":"10","tune":"1"},"unit":"%"}
//     ]
//   }
// }

// WebSocket path commands:
// "/"        -> root menu
// "/0"       -> activate item 0 (enter submenu or execute action)
// "/0/1"     -> set toggle/select item 0 to value index 1
// "/1/value" -> set numeric field to value

// #define MAX_DEPTH 2
// int ledCtrl = LOW;
// int brightness = 50;
// TOGGLE(ledCtrl, ledMenu, "Led: ", doNothing, noEvent, noStyle
//   ,VALUE("On",  HIGH, doNothing, noEvent)
//   ,VALUE("Off", LOW,  doNothing, noEvent)
// );
// MENU(mainMenu, "Main menu", doNothing, noEvent, wrapStyle
//   ,SUBMENU(ledMenu)
//   ,FIELD(brightness, "Brightness", "%", 0, 100, 10, 1, doNothing, noEvent, wrapStyle)
// );
// ... ESP8266 server setup omitted for brevity; see examples/lolin32 for full sketch

```

--------------------------------

### NAVROOT Macro for Menu Navigation

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

The NAVROOT macro instantiates the navRoot object, connecting the menu tree, input, and output streams. It requires 'menu.h' and 'menuIO/serialOut.h'. The example shows runtime configuration options like enabling/disabling menu items and controlling input/output polling.

```cpp
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
using namespace Menu;

#define MAX_DEPTH 3

MENU(mainMenu, "Root", doNothing, noEvent, wrapStyle
  ,OP("Item A", doNothing, noEvent)
  ,OP("Item B", doNothing, noEvent)
  ,EXIT("<Exit")
);

serialIn serial(Serial);
MENU_OUTPUTS(out, MAX_DEPTH ,SERIAL_OUT(Serial) ,NONE);

// Expands to: navNode nav_cursors[MAX_DEPTH]; navRoot nav(mainMenu, nav_cursors, MAX_DEPTH-1, serial, out);
NAVROOT(nav, mainMenu, MAX_DEPTH, serial, out);

void setup() {
  Serial.begin(115200);
  while(!Serial);

  // Runtime configuration
  nav.showTitle    = true;     // show menu title on first line
  nav.canExit      = true;     // allow exiting from root to idle
  nav.inputBurst   = 1;        // process one input per poll (slow displays)
  nav.useUpdateEvent = false;  // use enterEvent (not updateEvent) on field change

  // Disable a menu item at startup
  mainMenu[1].enabled = disabledStatus;  // disables "Item B"
}

void loop() {
  nav.poll();   // full automation: reads input, redraws if changed
  // or manually:
  // nav.doInput();   // process input only
  // nav.doOutput();  // redraw only if changed
}

```

--------------------------------

### Get Option by Index

Source: https://github.com/neu-rah/arduinomenu/wiki/FAQ

Retrieves a prompt object representing the option at a specific index within the current navigation level.

```c++
nav.node()[idx]
```

--------------------------------

### JSON Response Example for Menu Root

Source: https://github.com/neu-rah/arduinomenu/wiki/WebMenu

This JSON structure represents the state of the main menu page. It includes the menu title, current path, selection, and a list of available items, each with its properties like index, enabled status, prompt, and value.

```json
{
  "output":"",
  "menu":{
    "title":{"prompt":"Main menu"},
    "path":"",
    "sel":"0",
    "items":[
      {"idx":"0","enabled":"1","selStart":">","prompt":"Led: ","value":"Off","options":["On","Off"]},
      {"idx":"1","enabled":"1","selStart":" ","prompt":"Action A"},
      {"idx":"2","enabled":"1","selStart":" ","prompt":"Action B"},
      {"idx":"3","enabled":"1","selStart":" ","prompt":"On" ,"field":"50","range":            
      {"low":"0","high":"100","step":"10","tune":"1"},"unit":"ms"},
      {"idx":"4","enabled":"1","selStart":" ","prompt":"Select" ,"select":"Zero","options":["Zero","One","Two"]},
      {"idx":"5","enabled":"1","selStart":" ","prompt":"Choose" ,"choose":"Last","options":            
      ["First","Second","Third","Last"]
    ]
  }
}
```

--------------------------------

### Get Selected Option Prompt

Source: https://github.com/neu-rah/arduinomenu/wiki/FAQ

Returns the prompt object for the currently selected option. This object represents the selected menu item.

```c++
nav.selected()
```

--------------------------------

### Text Field Example

Source: https://github.com/neu-rah/arduinomenu/wiki/WebMenu

Represents a menu item that is a text field. It includes common prompt information and specific properties for text input, such as the current text value.

```json
{"idx":"1","enabled":"1","selStart":" ","prompt":"Key","editCursor":" ","text":"XXXXXX"}
```

--------------------------------

### Field Item Example

Source: https://github.com/neu-rah/arduinomenu/wiki/WebMenu

Represents a menu item that is a field, allowing users to view and potentially edit values. It includes common prompt information along with field-specific details like current value, range, and unit.

```json
{
  "idx":"1",
  "enabled":"1",
  "cursor":" ",
  "prompt":"",
  "field":"0.00",
  "range":{
    "low":"0.00",
    "high":"100.00",
    "step":"10.00",
    "tune":"1.00"
  },
  "unit":"%"
}
```

--------------------------------

### Implement Idle/Suspend Mode with Screensaver

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

Use `idleOn()` and `idleOff()` to suspend menu I/O and execute a custom function, such as a screensaver. The `idleFunc` receives idle events and can be used to display dynamic content or perform background tasks. Set `nav.idleTask` in `setup()` for automatic invocation when the menu exits the root.

```cpp
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
using namespace Menu;

#define MAX_DEPTH 1

// idleFunc signature: result fn(menuOut& o, idleEvent e)
result screenSaver(menuOut& o, idleEvent e) {
  switch (e) {
    case idleStart:
      o.clear();
      Serial.println("=== SCREENSAVER ON ===");
      break;
    case idling:
      // called every poll while idle — draw dynamic content here
      o.setCursor(0, 0);
      o.print("Uptime: ");
      o.print(millis() / 1000);
      o.print("s   ");
      nav.idleChanged = true;  // signal: keep calling idling every poll
      break;
    case idleEnd:
      Serial.println("=== MENU RESUMED ===");
      break;
  }
  return proceed;
}

MENU(mainMenu, "Demo", doNothing, noEvent, wrapStyle
  ,OP("Sleep now", [](){ nav.idleOn(screenSaver); return proceed; }, enterEvent)
  ,OP("Item B",    doNothing, noEvent)
  ,EXIT("<Exit")  // exiting root also triggers idle
);

serialIn serial(Serial);
MENU_OUTPUTS(out, MAX_DEPTH ,SERIAL_OUT(Serial) ,NONE);
NAVROOT(nav, mainMenu, MAX_DEPTH, serial, out);

void setup() {
  Serial.begin(115200);
  while(!Serial);
  nav.idleTask = screenSaver;   // auto-invoked when menu exits root
  // nav.timeOut = 30;           // optional: auto-idle after 30s inactivity
}

void loop() {
  nav.poll();
  // Check idle state for non-menu work:
  if (nav.sleepTask) {
    // menu is suspended — safe to do sensor reads, etc.
  }
  // nav.idleOff();  // call to resume menu from code
}

```

--------------------------------

### V3.x Config Structure

Source: https://github.com/neu-rah/arduinomenu/wiki/Options

Defines the configuration structure for Arduino Menu in V3.x, including cursors, inversion flags, 2D navigation, navigation codes, update event usage, and exit behavior. It also includes a method to get command characters.

```c++
struct config {
  char selectedCursor;//='>';
  char disabledCursor;//='-';
  bool invertFieldKeys;//=false;
  bool nav2D;//=false;// N/A should be false
  const navCodesDef &navCodes;//=defaultNavCodes;
  bool useUpdateEvent;//=false, if false, when field value is changed use enterEvent instead.
  bool canExit;//=true, if false do not exit from main menu
  inline char getCmdChar(navCmds cmd) const {return navCodes[cmd].ch;}
};
```

--------------------------------

### Create List of Menu Output Devices

Source: https://github.com/neu-rah/arduinomenu/wiki/Initialization

Define a static array of menuOut pointers and initialize an outputsList controller with this array and its size.

```c++
Menu::menuOut* const outputs[] MEMMODE={&outSerial,&outLCD};//list of output devices
Menu::outputsList out(outputs,2);//outputs list controller
```

--------------------------------

### Initialize Prompt (Non-AVR)

Source: https://github.com/neu-rah/arduinomenu/wiki/Menu-structure-objects

Initializes a prompt option without using PROGMEM, suitable for non-AVR devices. Requires a callback function and an event handler.

```c++
//define "Op 1"
void op1Func();
promptShadow op1Info("Op 1",(callback)op1Func,enterEvent);
prompt op1(op1Info);
```

--------------------------------

### Get Selected Option Index

Source: https://github.com/neu-rah/arduinomenu/wiki/FAQ

Returns the index of the currently selected option within the current navigation level.

```c++
nav.node().sel
```

--------------------------------

### Customizing Options in V3.x

Source: https://github.com/neu-rah/arduinomenu/wiki/Options

Shows how to instantiate and assign a custom configuration object to the global options pointer in V3.x, allowing for detailed customization of menu behavior.

```c++
config myOptions(
  '>',//character used as cursor on enabled options
  '-',//character used as cursor on disabled options
  false,//invert up/down keys between nav and field edit
  false,//2D Nav - not implemented yet
  defaultNavCodes,//use default navigation characters '[+] [-] [\*] [/]'
  true,//use updateEvent
  true//can exit from main menu
);

... 

options=&myOptions;
```

--------------------------------

### Initialize Empty Outputs List

Source: https://github.com/neu-rah/arduinomenu/wiki/Initialization

Create an outputsList named 'out' with a length of zero when no outputs are required.

```c++
Menu::outputsList out(NULL,0);
```

--------------------------------

### Initialize Prompt (AVR with PROGMEM)

Source: https://github.com/neu-rah/arduinomenu/wiki/Menu-structure-objects

Initializes a prompt option using PROGMEM for AVR microcontrollers. This method stores strings and structures in flash memory to save RAM.

```c++
//define "Op 1"
void op1Func();
const char op1Text[] PROGMEM="Op 1";
const promptShadowRaw op1InfoRaw PROGMEM={(callback)op1Func,\_noStyle,op1Text,enterEvent,noStyle};
const promptShadow& op1Info=*(promptShadow*)&op1InfoRaw;
prompt op1(op1Info);
```

--------------------------------

### Prevent Menu Exit

Source: https://github.com/neu-rah/arduinomenu/wiki/FAQ

Configures the menu system to prevent users from exiting the current menu. This is typically set during the setup phase.

```c++
options->canExit=false;
```

--------------------------------

### Get Current Navigation Level Controller

Source: https://github.com/neu-rah/arduinomenu/wiki/FAQ

Retrieves the navigation level controller object for the current menu. This object provides access to navigation-specific functions.

```c++
nav.node()
```

--------------------------------

### Automating Input Chain Construction with MENU_INPUTS

Source: https://github.com/neu-rah/arduinomenu/wiki/Input

The MENU_INPUTS macro simplifies the creation of input chains. Provide the desired stream name followed by a list of input streams to be concatenated.

```c++
MENU_INPUTS(name[,&menuIn]);
```

```c++
MENU_INPUTS(in,&encStream,&encButton,&serial);
```

--------------------------------

### Panel Structure Definition

Source: https://github.com/neu-rah/arduinomenu/wiki/Output

Defines a rectangular area on an output device with position (x, y) and dimensions (w, h). Use `maxX()` and `maxY()` to get the maximum coordinates.

```c++
struct panel {
    idx_t x,y,w,h;
    inline idx_t maxX() const {return x+w;}
    inline idx_t maxY() const {return y+h;}
  };
```

--------------------------------

### Custom Menu Item Rendering with Class Extension

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

Extend `prompt` or use `altFIELD` to customize how menu items are displayed. `fancyPrompt` overrides `printTo` for custom rendering, while `altFIELD` with `decPlaces` formats floating-point values to a specified decimal precision.

```cpp
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
using namespace Menu;

#define MAX_DEPTH 2

// Custom prompt that renders with a border
class fancyPrompt : public prompt {
public:
  fancyPrompt(constMEM promptShadow& p) : prompt(p) {}
  Used printTo(navRoot& root, bool sel, menuOut& out,
               idx_t idx, idx_t len, idx_t panelNr) override {
    out.print(sel ? F("[*] ") : F("[ ] "));
    return out.printRaw(F("Custom Item"), len);
  }
};

double temperature = 23.456;

// altFIELD with 2 decimal places using built-in decPlaces template
// altFIELD(FieldClass, var, label, unit, min, max, step, tune, action, eventMask, style)
MENU(mainMenu, "Custom Items", doNothing, noEvent, wrapStyle
  ,altOP(fancyPrompt, "Special", doNothing, noEvent)
  ,altFIELD(decPlaces<2>::menuField, temperature, "Temp", "C",
            -40.0, 85.0, 1.0, 0.01, doNothing, noEvent, noStyle)
  ,EXIT("<Back")
);

serialIn serial(Serial);
MENU_OUTPUTS(out, MAX_DEPTH ,SERIAL_OUT(Serial) ,NONE);
NAVROOT(nav, mainMenu, MAX_DEPTH, serial, out);

void setup() { Serial.begin(115200); while(!Serial); }
void loop()  { nav.poll(); }
// Output renders temperature as "23.46 C" (2 decimal places)

```

--------------------------------

### Get Active Menu Node

Source: https://github.com/neu-rah/arduinomenu/wiki/FAQ

Returns the currently active menu node object. This node represents the menu prompt that can receive commands and may have an associated action.

```c++
nav.active()
```

--------------------------------

### Define Menu Outputs using Macro

Source: https://github.com/neu-rah/arduinomenu/wiki/Initialization

Use the MENU_OUTPUTS macro to define an outputs list and its associated menu output drivers. Requires at least two outputs, such as SERIAL_OUT and NONE.

```c++
MENU_OUTPUTS(simpleOut,MAX_DEPTH
  ,SERIAL_OUT(Serial)
  ,NONE//must have 2 items at least, if using this macro
);
```

--------------------------------

### Initialize Serial and LCD Output Devices

Source: https://github.com/neu-rah/arduinomenu/wiki/Initialization

Initialize dedicated idx_t arrays for each output device to store navigation depth information. Then, create the respective output driver objects, passing the Arduino device and the idx_t array.

```c++
Menu::idx_t serialTops[MAX_DEPTH];
Menu::serialOut outSerial(Serial,serialTops);
Menu::idx_t lcdTops[MAX_DEPTH];
Menu::liquidCrystalOut outLCD(lcd,lcdTops,pList);
```

--------------------------------

### Define Output Panels for Menu System

Source: https://github.com/neu-rah/arduinomenu/wiki/Initialization

Declare a static array of panels to describe output areas and a dynamic array of navNode pointers for navigation status. Initialize a panelsList manager with these.

```c++
const Menu::panel panels[] MEMMODE={{0,0,40,2}};
Menu::navNode* nodes[sizeof(panels)/sizeof(Menu::panel)];//navNodes to store navigation status
Menu::panelsList pList(panels,nodes,1);//a list of panels and nodes
```

--------------------------------

### Custom Navigation Codes Definition

Source: https://github.com/neu-rah/arduinomenu/wiki/Options

Example of defining a custom navigation codes table, mapping various navigation commands (like up, down, enter) to specific character codes. This table is used by the menu system to interpret user input.

```c++
const navCodesDef myCodes={
  {noCmd,(char)0xff},
  {escCmd,'/'},
  {enterCmd,'*'},
  {upCmd,'+'},
  {downCmd,'-'},
  {leftCmd,'-'},
  {rightCmd,'+'},
  {idxCmd,'?'},
  {scrlUpCmd,0x35},
  {scrlUpCmd,0x36}
};
```

--------------------------------

### Prompt (OP)

Source: https://github.com/neu-rah/arduinomenu/wiki/Menu-structure-objects

Prompts are the most basic menu structure, deriving from Action and associating text. They can be constructed using the OP macro.

```APIDOC
## Prompt (OP)

Prompts are the most basic menu structure it derives from an Action and associate it with a text.

They can be constructed by macro OP. (see menu definition)

Here is an example of initializing an option without macros for an non-AVR (PROGMEM) device.

```c++
//define "Op 1"
void op1Func();
promptShadow op1Info("Op 1",(callback)op1Func,enterEvent);
prompt op1(op1Info);
```

And here the same for an AVR (PROGMEM) device.

```c++
//define "Op 1"
void op1Func();
const char op1Text[] PROGMEM="Op 1";
const promptShadowRaw op1InfoRaw PROGMEM={(callback)op1Func,\_noStyle,op1Text,enterEvent,noStyle};
const promptShadow& op1Info=*(promptShadow*)&op1InfoRaw;
prompt op1(op1Info);
```

**OP** macro automates all of that, but it must be used inside a MENU macro.
```

--------------------------------

### Arduinomenu Callback Function Signatures

Source: https://github.com/neu-rah/arduinomenu/wiki/Actions

Demonstrates the four accepted callback function formats for menu actions. These functions can have no parameters, accept an event mask, or accept both an event mask and a prompt item.

```c++
void myFunc1();
```

```c++
result myFunc2();
```

```c++
void myFunc3(eventMask e);
```

```c++
result myFunc4(eventMask e,prompt& p);
```

--------------------------------

### Combine Multiple Input Devices with MENU_INPUTS

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

Use `MENU_INPUTS` to chain multiple input streams (e.g., encoder, button, serial) into a single navigation input. Ensure all input devices are initialized before use.

```cpp
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
#include <menuIO/encoderIn.h>
#include <menuIO/keyIn.h>
#include <menuIO/chainStream.h>
using namespace Menu;

#define MAX_DEPTH 2
#define ENC_A  2
#define ENC_B  3
#define BTN_OK 4

// Quadrature encoder (uses PCINT or polling)
encoderIn<ENC_A, ENC_B> encoder;
encoderInStream<ENC_A, ENC_B> encStream(encoder, 4);

// Single button mapped to 'enter' command character
keyMap btnMap[] = {{-BTN_OK, options->getCmdChar(enterCmd)}};  // negative = INPUT_PULLUP
keyIn<1> btnInput(btnMap);

// Serial fallback input
serialIn serial(Serial);

// Combine all three into one stream
// MENU_INPUTS(name, &stream1, &stream2, ...)
MENU_INPUTS(in, &encStream, &btnInput, &serial);
// equivalent to:
// menuIn* inputList[] = {&encStream, &btnInput, &serial};
// chainStream<3> in(inputList);

MENU(mainMenu, "Encoder Demo", doNothing, noEvent, wrapStyle
  ,OP("Start", doNothing, enterEvent)
  ,OP("Stop",  doNothing, enterEvent)
  ,EXIT("<Back")
);

MENU_OUTPUTS(out, MAX_DEPTH ,SERIAL_OUT(Serial) ,NONE);
NAVROOT(nav, mainMenu, MAX_DEPTH, in, out);

void setup() {
  Serial.begin(115200);
  while(!Serial);
  encoder.begin();  // required since v2.x
}
void loop() { nav.poll(); }

```

--------------------------------

### Include Header File in C

Source: https://github.com/neu-rah/arduinomenu/blob/master/examples/serialio/include/readme.txt

Demonstrates how to include a custom header file named 'header.h' in a C source file using the `#include` directive. Ensure the header file is accessible in the project's include path.

```c
#include "header.h"

int main (void)
{
 ...
}
```

--------------------------------

### menuOut Constructor

Source: https://github.com/neu-rah/arduinomenu/wiki/Output

Constructor for the menuOut class. Requires a RAM workspace for navigation data, a list of panels, and optional output device styles.

```cpp
menuOut(idx_t *topsList,panelsList &pan,styles os=minimalRedraw)
```

--------------------------------

### Initialize Serial Input for Menu

Source: https://github.com/neu-rah/arduinomenu/wiki/Initialization

Wrap the Serial object with a serialIn object to use it as a menu input. This is required from version 4 onwards.

```c++
serialIn in(Serial);//changed on version 4
NAVROOT(nav,main_menu,MAX_DEPTH,in,out);
```

--------------------------------

### outputsList Constructor

Source: https://github.com/neu-rah/arduinomenu/wiki/Output

Constructs an `outputsList` object to manage multiple output devices. `n` specifies the number of output devices in the `outA` array.

```c++
outputsList(menuOut* const outA[],int n);
```

--------------------------------

### menuOut Constructor

Source: https://github.com/neu-rah/arduinomenu/wiki/Output

Constructor for the `menuOut` class, used to initialize the menu output system.

```APIDOC
## menuOut Constructor

### Description
Initializes the `menuOut` class with provided RAM workspace for navigation data and a list of panels. It also accepts output device styles.

### Method
```c++
menuOut(idx_t *topsList, panelsList &pan, styles os=minimalRedraw)
```

### Parameters
#### Path Parameters
- **topsList** (idx_t*) - Required - RAM area for dynamic navigation data with size equal to the number of panels.
- **pan** (panelsList&) - Required - A list of panels.
- **os** (styles) - Optional - Output device styles (enum styles). Defaults to `minimalRedraw`.
```

--------------------------------

### Constructing navRoot Object

Source: https://github.com/neu-rah/arduinomenu/wiki/Navigation

Use this constructor to create a new `navRoot` object. It requires a menu root, a path array for navigation levels, the maximum depth, an input stream, and an outputs list.

```cpp
navRoot(menuNode& root,navNode* path,idx_t maxDepth,Stream& in,outputsList &o)
```

--------------------------------

### outputsList Class

Source: https://github.com/neu-rah/arduinomenu/wiki/Output

Manages a list of output devices, allowing simultaneous output to multiple destinations.

```APIDOC
## class outputsList

### Description
Manages a collection of output devices (`menuOut` objects) to which menu content can be displayed simultaneously. Useful for debugging or alternative displays. Can be initialized with a NULL array and zero size for headless operation.

### Public Data Members
- **cnt** (int): The number of output devices in the list, defaults to 1.
- **outs** (menuOut* const*): An array of pointers to `menuOut` device drivers.

### Construction
```c++
outputsList(menuOut* const outA[], int n)
```

_Parameters:_
  - **outA**: An array of pointers to `menuOut` output devices.
  - **n**: The number of output devices in the array.

### Public Function Members
- **operator[](idx_t i)**: Returns the `menuOut` device at the specified index `i`.
- **printMenu(navNode& nav) const**: Prints the specified `navNode` to all output devices.
- **clearLine(idx_t ln, idx_t panelNr = 0, colorDefs color = bgColor, bool selected = false, status stat = enabledStatus) const**: Clears a specific line on a given panel, with options for color, selection state, and status.
- **clearChanged(navNode& nav) const**: Signals that the `navNode` has been drawn and changes can be cleared.
- **clear()**: Clears all output devices.
- **setCursor(idx_t x, idx_t y)**: Sets the cursor position on the current output device.
- **setColor(colorDefs c, bool selected = false, status s = enabledStatus)**: Sets the current color for text, with options for selection state and status.
- **drawCursor(idx_t ln, bool selected, status stat, idx_t panelNr = 0)**: Draws the cursor on a specific line and panel, considering selection state and status.
- **doNav(navCmd cmd, class navNode &nav)**: Applies a navigation command to all devices (experimental).
- **idle(idleFunc f, idleEvent e)**: Applies an idle function and event to all devices.
```

--------------------------------

### menuOut Class

Source: https://github.com/neu-rah/arduinomenu/wiki/Output

Base class for menu output devices, providing a foundation for custom display implementations.

```APIDOC
## class menuOut : public Print

### Description
Serves as the base class for all menu output devices. It inherits from the system's `Print` class, enabling easy output of information. Custom output devices should inherit from this class.

### Enums
#### enum styles
Describes attributes and capabilities of an output device. These are binary masks and can be combined.

* **none**: Use default device attributes.
* **redraw**: Indicates the device requires a full redraw (e.g., U8Glib).
* **minimalRedraw**: Indicates the device supports partial screen updates (e.g., LCD, TFT).
* **drawNumIndex**: If true, numeric index accelerators (1-9) are displayed with their respective [index] at the left.
* **usePreview**: Enables the use of menu or options preview on the next available panel.
* **expandEnums**: Used for size control of the enum.
```

--------------------------------

### navRoot Constructor

Source: https://github.com/neu-rah/arduinomenu/wiki/Navigation

Constructs a new navRoot object, initializing the navigation control with a root menu, path, maximum depth, input stream, and output list.

```APIDOC
## navRoot Constructor

### Description
Constructs a new navRoot object, initializing the navigation control with a root menu, path, maximum depth, input stream, and output list.

### Signature
```cpp
navRoot(menuNode& root, navNode* path, idx_t maxDepth, Stream& in, outputsList &o)
```

### Parameters
- **root** (menuNode&) - The menu object for the entry level.
- **path** (navNode*) - An array of navigation level controllers, with a size equal to `maxDepth`.
- **maxDepth** (idx_t) - The maximum navigation path depth.
- **in** (Stream&) - The inputs control object (can be `NO_INPUTS_NAV`).
- **o** (outputsList&) - The outputs control object (can be `NO_OUTPUTS_NAV`).
```

--------------------------------

### Configure Multiple Parallel Outputs with MENU_OUTPUTS

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

Use `MENU_OUTPUTS` to direct menu output to multiple devices simultaneously, such as an LCD and serial monitor. The `NONE` macro is used as a terminator for the driver list.

```cpp
#include <menu.h>
#include <LiquidCrystal.h>
#include <menuIO/liquidCrystalOut.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
using namespace Menu;

#define MAX_DEPTH 2

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  // standard wiring

MENU(mainMenu, "Dual Output", doNothing, noEvent, wrapStyle
  ,OP("Option 1", doNothing, noEvent)
  ,OP("Option 2", doNothing, noEvent)
  ,EXIT("<Back")
);

// MENU_OUTPUTS(name, MAX_DEPTH, driver1, driver2, ..., NONE)
// LCD_OUT(lcd_obj, {col, row, width, height})
// SERIAL_OUT(Serial)
MENU_OUTPUTS(out, MAX_DEPTH
  ,LCD_OUT(lcd, {0, 0, 16, 2})   // 16x2 LCD, full screen
  ,SERIAL_OUT(Serial)            // serial debug mirror
);
// Note: macro requires at least 2 entries; use NONE as second if only one device needed.

serialIn serial(Serial);
NAVROOT(nav, mainMenu, MAX_DEPTH, serial, out);

void setup() {
  Serial.begin(115200);
  while(!Serial);
  lcd.begin(16, 2);
}
void loop() { nav.poll(); }

```

--------------------------------

### Menu Execution - doInput() (Overloads)

Source: https://github.com/neu-rah/arduinomenu/wiki/Home

These functions are used to manually control the input processing for the menu system. `doInput()` checks for available input, while `doInput(const char* in)` allows you to feed a specific character as input.

```APIDOC
## doInput()

### Description
Checks the inputs list for available data.

### Method
`inline void doInput();`

### Parameters
None
```

```APIDOC
## doInput(const char* in)

### Description
Calls the menu system to consider a given character as input.

### Method
`void doInput(const char* in);`

### Parameters
#### Path Parameters
- **in** (const char*) - Description: The character to be processed as input.
```

--------------------------------

### Printing Menu to Arbitrary Device

Source: https://github.com/neu-rah/arduinomenu/wiki/Navigation

Prints the current menu to a specified `menuOut` device. Useful for directing output to specific streams.

```cpp
Used printMenu(menuOut& o) const
```

--------------------------------

### Menu Navigation Options (v4.0)

Source: https://github.com/neu-rah/arduinomenu/blob/master/README.md

Configuration options for menu navigation, including 2D navigation, exit behavior, and input burst limits. These options are part of the global settings in version 4.0.

```c++
bool nav2D=false;//not used
bool canExit=true;//v4.0 moved from global options
bool useUpdateEvent=false;//if false, use enterEvent when field value is changed.
idx_t inputBurst=1;//limit of inputs that can be processed before output
```

--------------------------------

### Programmatic Navigation with navRoot::doNav

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

Control menu navigation from code using `nav.doNav()` with predefined navigation commands. This is useful for automated testing or custom control logic. Available commands include `idxCmd` for index-based jumps and `enterCmd` for selection.

```cpp
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
using namespace Menu;

#define MAX_DEPTH 2

MENU(mainMenu, "Prog Nav", doNothing, noEvent, wrapStyle
  ,OP("Item 0", doNothing, enterEvent)
  ,OP("Item 1", doNothing, enterEvent)
  ,OP("Item 2", doNothing, enterEvent)
  ,EXIT("<Back")
);

serialIn serial(Serial);
MENU_OUTPUTS(out, MAX_DEPTH ,SERIAL_OUT(Serial) ,NONE);
NAVROOT(nav, mainMenu, MAX_DEPTH, serial, out);

void setup() {
  Serial.begin(115200);
  while(!Serial);
}

void loop() {
  nav.poll();

  // Example: after 3 s, programmatically select Item 2 and enter it
  if (millis() == 3000) {
    nav.doNav(navCmd(idxCmd, 2));   // jump cursor to index 2
    nav.doNav(navCmd(enterCmd));    // "click" enter on it
  }

  // Available navCmds:
  // noCmd, escCmd, enterCmd, upCmd, downCmd, leftCmd, rightCmd, idxCmd
  // nav.doInput("/");   // string-based: '/' = escape, '*' = enter, '+' = up, '-' = down
}

```

--------------------------------

### Output Current Menu

Source: https://github.com/neu-rah/arduinomenu/wiki/Navigation

Requests the output controller to draw the current menu on the registered output devices. This is a shorthand for `printMenu()`.

```cpp
void doOutput()
```

--------------------------------

### choose

Source: https://github.com/neu-rah/arduinomenu/wiki/Menu-structure-objects

An enumerated field that allows selecting a value as a sub-menu by clicking.

```APIDOC
## choose

`public menuVariant<T>`

enumerated field, click to select value as a sub-menu
```

--------------------------------

### Default Menu Handlers

Source: https://github.com/neu-rah/arduinomenu/wiki/Utils

Provides default implementations for menu actions and idle events. `inaction` is the default idle handler, `doNothing` is a callback that does nothing, and `doExit` provides the default action for exiting a menu.

```cpp
result Menu::inaction(menuOut& o,idleEvent) {return proceed;}
```

```cpp
result Menu::doNothing() {return proceed;}
```

```cpp
result Menu::doExit() {return quit;}
```

--------------------------------

### SELECT Macro for Submenu Choices

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

Use the SELECT macro to present choices as a submenu. It reflects external changes to the variable and requires the 'menu.h' and 'menuIO/serialOut.h' headers. The 'onColorChange' function demonstrates how to react to value changes.

```cpp
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
using namespace Menu;

#define MAX_DEPTH 2

int colorMode = 0;   // 0=Off, 1=Red, 2=Green, 3=Blue

result onColorChange(eventMask e, prompt& p) {
  // colorMode is already updated when this fires
  Serial.print("Color: "); Serial.println(colorMode);
  return proceed;
}

// SELECT(var, id, label, action, eventMask, style, VALUE(...), ...)
SELECT(colorMode, colorSel, "Color", onColorChange, enterEvent, noStyle
  ,VALUE("Off",   0, doNothing, noEvent)
  ,VALUE("Red",   1, doNothing, noEvent)
  ,VALUE("Green", 2, doNothing, noEvent)
  ,VALUE("Blue",  3, doNothing, noEvent)
);

MENU(mainMenu, "LED Control", doNothing, noEvent, wrapStyle
  ,SUBMENU(colorSel)
  ,EXIT("<Back")
);

serialIn serial(Serial);
MENU_OUTPUTS(out, MAX_DEPTH ,SERIAL_OUT(Serial) ,NONE);
NAVROOT(nav, mainMenu, MAX_DEPTH, serial, out);

void setup() { Serial.begin(115200); while(!Serial); }
void loop()  { nav.poll(); }

```

--------------------------------

### Printing Menu to Output Device

Source: https://github.com/neu-rah/arduinomenu/wiki/Navigation

Requests the output controller to draw the current menu. This version uses the registered output devices.

```cpp
Used printMenu() const
```

--------------------------------

### menu

Source: https://github.com/neu-rah/arduinomenu/wiki/Menu-structure-objects

A basic menu implementation that inherits directly from menuNode without adding extra functions.

```APIDOC
## menu

`public menuNode`

Just a raw menu implementation straight from its base class menuNode. no extra functions added.
```

--------------------------------

### Menu Execution - doOutput()

Source: https://github.com/neu-rah/arduinomenu/wiki/Home

The `doOutput()` function is responsible for checking and satisfying any output needs of the menu system. It also detects user value changes and updates the display accordingly.

```APIDOC
## doOutput()

### Description
Verifies the need for output and satisfies it. This function also checks user values for changes and redraws them if necessary.

### Method
`inline void doOutput();`

### Parameters
None
```

--------------------------------

### Dynamically Disabling/Enabling Menu Items

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

This C++ snippet shows how to disable or enable menu items at runtime using index access on the menu object. It demonstrates the `enabledStatus` and `disabledStatus` flags for controlling item navigability. The 'Factory Reset' option is initially locked.

```cpp
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
using namespace Menu;

#define MAX_DEPTH 1

bool adminMode = false;

result toggleAdmin() {
  adminMode = !adminMode;
  // enable/disable items at runtime
  mainMenu[2].enabled = adminMode ? enabledStatus : disabledStatus;
  return proceed;
}

MENU(mainMenu, "System", doNothing, noEvent, wrapStyle
  ,OP("Status",       doNothing,   noEvent)
  ,OP("Toggle Admin", toggleAdmin, enterEvent)
  ,OP("Factory Reset",doNothing,   enterEvent)  // starts disabled
  ,EXIT("<Back")
);

serialIn serial(Serial);
MENU_OUTPUTS(out, MAX_DEPTH ,SERIAL_OUT(Serial) ,NONE);
NAVROOT(nav, mainMenu, MAX_DEPTH, serial, out);

void setup() {
  Serial.begin(115200);
  while(!Serial);
  mainMenu[2].enabled = disabledStatus;  // lock Factory Reset initially
}
void loop() { nav.poll(); }
// After "Toggle Admin", "Factory Reset" becomes navigable

```

--------------------------------

### V4.x Global Config Options

Source: https://github.com/neu-rah/arduinomenu/wiki/Options

Defines global configuration options for Arduino Menu in V4.x, such as selected and disabled option cursors, navigation codes, and input inversion flags. Some options like numValueInput have moved to the menuIn object.

```c++
      char selectedCursor;//='>'; selected option text cursor
      char disabledCursor;//='-'; disabled option text cursor
      const navCodesDef &navCodes;//=defaultNavCodes; reference to existing navigation chars/commands table
      bool invertFieldKeys;//global fields keys inversion flag (for code driven single input)
```

```c++
bool nav2D=false;//not used
bool canExit=true;//v4.0 moved from global options
bool useUpdateEvent=false;//if false, use enterEvent when field value is changed.
idx_t inputBurst=1;//limit of inputs that can be processed before output
```

--------------------------------

### Handle Menu Output

Source: https://github.com/neu-rah/arduinomenu/wiki/Home

This function verifies the need for output and satisfies it. It also checks for user value changes and redraws them accordingly. It is an inline function.

```c++
inline void doOutput();
```

--------------------------------

### Define Central Navigation Object using Macro

Source: https://github.com/neu-rah/arduinomenu/wiki/Initialization

Use the NAVROOT macro as a shorthand to initialize the central navigation object, specifying the navigation object name, menu definition, max depth, input stream, and output list.

```c++
NAVROOT(nav,main_menu,MAX_DEPTH,in,out);
```

--------------------------------

### navNode Constructor

Source: https://github.com/neu-rah/arduinomenu/wiki/Navigation

Initializes a navNode object, which controls a single navigation depth layer targeting a menu or multi-choice option.

```APIDOC
## class navNode

### Description
This object controls a single navigation depth layer, targeting a menu or multi-choice option. The `navRoot` object uses an array of these objects with a size equal to `maxDepth`.

### Public Data Members
- **idx_t sel=0**: The current selection index.
- **menuNode* target**: The focused menu node.
- **static navRoot* root**: The navigation root object (experimental). This might change to non-static to allow multiple navigation root objects.
```

--------------------------------

### Padded Options Group Configuration

Source: https://github.com/neu-rah/arduinomenu/wiki/WebMenu

Groups multiple options or fields together as a single selectable item. Each item in the 'pad' array defines a sub-menu or field with its own configuration, including range and units.

```json
{
  "idx":"0",
  "enabled":"1",
  "selStart": ">",
  "prompt":"",
  "pad":[
    {"idx":"0","enabled":"1","cursor":" ","prompt":"" ,"field":"1","range":
    {"low":"1","high":"31","step":"1","tune":"0"},"unit":"/"},
    {"idx":"1","enabled":"1","cursor":" ","prompt":"" ,"field":"1","range":            
    {"low":"1","high":"12","step":"1","tune":"0"},"unit":"/"},
    {"idx":"2","enabled":"1","cursor":" ","prompt":"" ,"field":"2000","range":
    {"low":"2000","high":"2100","step":"10","tune":"1"},"unit":""}
  ]
}
```

--------------------------------

### Customize Navigation Key Mappings

Source: https://context7.com/neu-rah/arduinomenu/llms.txt

Remap physical key inputs to navigation commands by defining a custom `navCodesDef` table and applying it via the global `options` pointer. This allows using custom key layouts, such as WASD for navigation.

```cpp
#include <menu.h>
#include <menuIO/serialOut.h>
#include <menuIO/serialIn.h>
using namespace Menu;

#define MAX_DEPTH 1

// Custom navigation key table — remap to WASD + Space/Esc
const navCodesDef myNavCodes = {
  {noCmd,    0},
  {escCmd,   'q'},   // 'q' = escape/back
  {enterCmd, ' '},   // space = enter/select
  {upCmd,    'w'},   // 'w' = up
  {downCmd,  's'},   // 's' = down
  {leftCmd,  'a'},
  {rightCmd, 'd'},
  {idxCmd,   '?'},
  {scrlUpCmd, 0x35},
  {scrlDownCmd, 0x36}
};

// Custom config: cursor char, disabled char, nav codes, invertFieldKeys
config myOptions('*', '-', myNavCodes, false);

MENU(mainMenu, "Custom Keys", doNothing, noEvent, wrapStyle
  ,OP("Option A", doNothing, noEvent)
  ,OP("Option B", doNothing, noEvent)
  ,EXIT("<Back")
);

serialIn serial(Serial);
MENU_OUTPUTS(out, MAX_DEPTH ,SERIAL_OUT(Serial) ,NONE);
NAVROOT(nav, mainMenu, MAX_DEPTH, serial, out);

void setup() {
  options = &myOptions;   // apply before NAVROOT use
  Serial.begin(115200);
  while(!Serial);
}
void loop() { nav.poll(); }
// Navigate with W/S, select with Space, go back with Q

```