All Classes and Interfaces
Class
Description
Abstract version of the interface MenuItemVisitor, it implements all the methods by defaulting the behaviour to
the anyItem() method.
An enumeration that represents all the possible status / error return codes from the remote.
ActionMenuItem represents a menu item that is a one shot action, in that when triggered it
just runs the callback on the embedded side.
Constructs an ActionMenuItemBuilder using the standard builder pattern.
Represents an analog (numeric) menu item, it is always a zero based integer when retrieved from storage, but it can
have an offset and divisor, so therefore is able to represent decimal values.
Constructs an AnalogMenuItem using the standard builder pattern.
AnyMenuState represents any menu state of any type, it is a convenience that allows for non-generic access to
a menu state of any type, where the type is not important.
Represents the storage type for the state.
Provides a list of the support platforms as an enumeration.
the authentication states that a RemoteMenuController can be in.
Used to store the decimal state of large number menu item in the menu tree.
A menu item that can only hold boolean values (true or false).
Constructs a BooleanMenuItemBuilder using the standard builder pattern.
An implementation of menu state for booleans.
These static helper methods are the preferred way to create command message that can be sent and received from
a remote connection.
Use this interface to subscribe to connection change events, such as when the underlying connector
disconnects or reconnects with hardware.
Connection mode indicates what kind of client to server connection has been established
A base connection factory for client side remote connectors that can build connections and try to pair with a device.
A correlation ID that allows events sent from the client or server to be linked via
this ID.
Represents a scroll position as used by ScrollChoiceMenuItems, it holds the position and the current string value.
An implementation of menu state for integer values.
This is a custom menu item that can be created by the designer, but does not directly represent a different item
in the API.
Constructs a BooleanMenuItemBuilder using the standard builder pattern.
Dialog Manager provides the capability to work with dialogs, to present them, change the values of them and also
to update them from a remote command arriving.
The modes that a dialog can be in, and the transmission type for action too
Indicates how the dialog should be shown
A menu item that corresponds to the large number type on the device.
Constructs a EditableTextMenuItemBuilder using the standard builder pattern.
An implementation of menu item that can store text strings.
Constructs a EditableTextMenuItemBuilder using the standard builder pattern.
Text menu items can represent several types of value and as such the edit type must be defined.
A no-operation implementation of menu item that meets the interface but does nothing.
A menu item implementation that represents one of a known set of choices, the choices are stored as an integer
value, but each choice has a string representation as well.
Constructs a BooleanMenuItemBuilder using the standard builder pattern.
FloatMenuItem represents a menu item that uses a floating point value.
Constructs a FloatMenuItem using the standard builder pattern.
An implementation of menu state for Strings.
An implementation of menu state for integer values.
Creates a menu serializer instance that can convert menu structures to and from JSON format.
This represents an action that was performed on a list, and not really the state of the list.
The types of response that are supported, current select - single click, invoke - double click.
a local identifier holder object that holds the name and UUID
The authenticator interface that supports the checking of name and UUID pairs.
Indicates the management operations that can be performed by a particular implementation of authenticator
The button type for a dialog, dialogs generally have up to two buttons by default, each button can be one of the
following types.
Marks a method as a menu callback, when a `MenuManagerListener` is added to a menu manager `MenuManagerServer`
you can mark methods with this identifier if the method takes just two parameters, one for the ID and a boolean
that indicates if the update is local or remote.
Classes extending from MenuCommand can be sent and received on a connector.
This is a low level part of the API that most people don't need to deal, implementations will translate
commands to and from a given protocol.
Enumeration of the types of messages that can be sent to and from the server.
MenuInMenu embeds a menu within another menu by shifting the range of IDs within the remote items into another
range.
The base class for all menu items, has the most basic operations available on it that are needed by pretty much
all menu items.
This exception indicates that a particular item could not be formatted
A helper class for dealing with MenuItem objects.
An implementation of the visitor pattern for TcMenu.
MenuManager listeners get notification when any menu item has changed, this works by the `menuItemHasChanged` method
being called for each change.
The menu manager server component manages a menu tree locally, handling updates to both state and items, and also
dealing with any remote connections.
The base class of menu state, stores the value, if it's active and changed.
An instance of Menu State serializer is used between runs of a local java application to load and save the state
of any menu item that has the EEPROM field set to anything other than -1.
Menu tree holds all the menu items for a specific remote connection or local session.
Some operations support moving items up or down in the tree, when they do they use this enumeration to
describe the direction of the move.
Indicates that there has been a structural change in the list, for example addition or removal of a menu item
in the tree.
this thread factory provides better naming for threads
when you implement this interface and pass that instance to start on a ServerConnectionManager then you'll receive
an event for each new connection created.
This class provides a helper method to pair with a device.
Represents a persisted menu item, it has additional information needed to reconstitute the item at the right point
in the tree, namely the parentId, and also the type of menu item.
A portable color that represents a color in the RGBA space with single byte values for each entry (between 0..255).
An implementation of menu state for integer values.
Implements the authentication interface using a pre-defined upfront set of name and UUID pairs that must be provided
upfront.
Stores authentication to a properties file and then validates against the stored values.
An implementation of menu state serialization that stores data in a properties file at a given location.
A few general helper method to get the version and platform information to and from messages.
This is the base interface implemented by all remote connectors, it provides the means to both send and receive
menu commands.
This is the low level, communication listener interface that you implement in order to know when commands have
been received from the remote device.
This interface is implemented when you wish to receive update events from a RemoteMenuController.
Represents the remote connection details, such as name and version.
This class manages a single remote connection to an Arduino.
A menu item that represents a colour in the RGB domain with optional Alpha channel.
Constructs an Rgb32MenuItem using the builder pattern, it is a menu item that represents a PortableColor object.
Constructs a RuntimeListMenuItem using the standard builder pattern.
Represents a more configurable and more extensible version of enum that should be used when the number of choices is
larger, the choices are in eeprom, or you need more control at runtime of the choices.
Builds an extensible version of enum that should be used when the number of choices is larger, the choices are in
eeprom, or you need more control at runtime of the choices using the builder pattern.
Marks a method as being responsible for providing the value of a particular value in a scroll choice.
Each connection from a remote is represented by a class implementing this interface.
A server connection manager is responsible for connections to the menu manager, it will completely manage all the
connections, creating new ones as they come in, and removing old ones as they are closed out.
A remote connector that will communicate using a client socket.
Creates an instance of a socket based controller to a given port, and connects it with the selected menu.
Stream remote connector is the base class for all stream implementations, such as Socket and RS232.
An implementation of menu state for lists of string.
An implementation of menu state for Strings.
SubMenuItem represents a menu item that has children.
Constructs a SubMenuItemBuilder using the standard builder pattern.
A protocol implementation that uses tag value pair notation with a few special text items
in order to create messages that can be transmitted.
Field names are used to represent the possible field names that can be sent to a remote menu.
This is the parser implementation that understands tag value format and can convert the tags back into
a series of tags and values suitable for the protocol to decode messages.
An exception that indicates a problem during protocol conversion
This class represents a version number in standard form, such as 1.2.3, it can parse from text and determine which
is the newer of two versions.
A series of static helper method that make dealing with XML easier, this is because many areas of tcMenu deal with XML
documents, and these functions are generally useful.