This repository contains a menu library in C++ that is originally intended for use in 8-bit microcontrollers. It is basically a design exercise in OOP, C++ callbacks and C++ templates. I initially developed a similar version without using templates for a project at my workplace. Then I felt it could be improved to reduce code boilerplate when defining new sections, and refine the inheritance structure and other details.
It is not really finished, much improvable for sure, and may have some bugs, but I uploaded it anyway for reference mainly, and maybe to discuss improvements or just talk about the current design.
It should be usable as of now too.
The structure of the menu system is the following:
On the one hand, there are a number of menu item types defined on menu_item.h.
These follow a pretty simple inheritance pattern where there is a pure virtual
base item AbstractMenuItem and two other classes are derived from it:
SectionMenuItem and EndpointMenuItem. The latter is another pure virtual
class for editable items. They only point to the variables containing those
values, they don't copy them to avoid data redundancy and the need to keep those
values updated if they are changed externally for some reason. However, since an
editing cancellation functionality is desired, there is a temporal item
TempMenuItem used during an edition operation, the value of which is copied
back to the original item if the value change is finally committed.
There are 4 types of editable menu items which are used in the definition of menu sections:
-
IntegerMenuItem: for items holding editable integer values:uint8_t,int32_t, etc. -
DecimalMenuItem: same as the previous but for floating point types. -
BoolMenuItem: for boolean types. -
SelectionMenuItem: for items displaying a text string for the limited amount of values they can hold, much like a drop-down list in computer graphical interfaces.
A menu is defined with a series of interleaved sections, which are classes
derived from SectionTemplate. This can be seen in test_menu.h. Then, the
sections are created by a subclass of the MenuFactory class, defined in
menu_factory.h. This is done with a creation function taking a section ID and
returning a new instance of the section requested.
Everything is controlled by the MenuController, defined in
menu_controller.h, which exposes a straightforward interface for navigating
through the menu, editing item values, committing or discarding changes, getting
information used by GUI manager to do its task, etc.
In order to decouple as much as possible the menu controller from the display
controller, there is a specific class StateInfo used for returning information
of the last menu action, which is useful to display error messages when the user
tries to perform an action that is forbidden, when the user navigates past the
end of the section back to the top item, or when a screen refresh is needed
after a change of section, for example.
For similar reasons, there is a class for controlling the way the items arrange
as the selection moves along the list of items. This functionality is very
coupled to that of the GUI so separating them completely is difficult. Currently
there is the class MenuNavByPages, which is intended to be used with a GUI
controller that displays a number of items in the screen until the cursor moves
past the top or bottom. A different type of menu movement could be a scrolling
mechanism, for instance. In order to accommodate for some flexibility that is
clearly needed, the idea of the current implementation is to provide a mechanism
to override some functions of the menu controller class with those of the chosen
navigation implementation, probably by means of C++ templates, and guaranteeing
that different navigation methods are easily interchangeable without unwanted
side effects. As of now however, this is unfinished and therefore still tightly
coupled, so the only navigation method available is by pages.
The current test design, as defined in main.cpp, displays the name of the
node/item on the left column and the value it holds on the right, if any. If no
value is shown on the right, then that is a navigation item, i.e. an item
containing a subsection.
Navigation can be done with wasd, but once in edit mode, only accepting or
cancelling the change is allowed for exiting this mode.
The build process is done with a simple make file Makefile, so typing make
at the terminal should be enough. There are no external dependencies apart from
the standard C++ library. The code has been successfully compiled using g++
(GCC) 4.8.1.