All Classes

Class	Description
AbsoluteLayout	Layout manager that places components where they are manually specified to be and sizes them to the size they are manually assigned to.
AbstractBasePane<T extends BasePane>	This abstract implementation of BasePane has the common code shared by all different concrete implementations.
AbstractBasePane.EmptyMenuBar
AbstractBorder	Abstract implementation of Border interface that has some of the methods filled out.
AbstractComponent<T extends Component>	AbstractComponent provides some good default behaviour for a Component, all components in Lanterna extends from this class in some way.
AbstractComposite<T extends Container>	This abstract implementation contains common code for the different Composite implementations.
AbstractDialogBuilder<B,T extends DialogWindow>	Abstract class for dialog building, containing much shared code between different kinds of dialogs
AbstractInteractableComponent<T extends AbstractInteractableComponent<T>>	Default implementation of Interactable that extends from AbstractComponent.
AbstractListBox<V,T extends AbstractListBox<V,T>>	Base class for several list box implementations, this will handle things like list of items and the scrollbar.
AbstractListBox.DefaultListBoxRenderer<V,T extends AbstractListBox<V,T>>	The default renderer for AbstractListBox and all its subclasses.
AbstractListBox.ListItemRenderer<V,T extends AbstractListBox<V,T>>	The default list item renderer class, this can be extended and customized it needed.
AbstractScreen	This class implements some of the Screen logic that is not directly tied to the actual implementation of how the Screen translate to the terminal.
AbstractTerminal	Containing a some very fundamental functionality that should be common (and usable) to all terminal implementations.
AbstractTextGraphics	This class hold the default logic for drawing the basic text graphic as exposed by TextGraphic.
AbstractTextGUI	This abstract implementation of TextGUI contains some basic management of the underlying Screen and other common code that can be shared between different implementations.
AbstractTextGUIThread	Abstract implementation of TextGUIThread with common logic for both available concrete implementations.
AbstractTheme	Abstract Theme implementation that manages a hierarchical tree of theme nodes ties to Class objects.
AbstractTheme.ThemeTreeNode
AbstractWindow	Abstract Window has most of the code requiring for a window to function, all concrete window implementations extends from this in one way or another.
ActionListBox	This class is a list box implementation that displays a number of items that has actions associated with them.
ActionListDialog	Dialog containing a multiple item action list box
ActionListDialogBuilder	Dialog builder for the ActionListDialog class, use this to create instances of that class and to customize them
AltAndCharacterPattern	Character pattern that matches characters pressed while ALT key is held down
AnimatedLabel	This is a special label that contains not just a single text to display but a number of frames that are cycled through.
AnimatedLabel.AnimationTimerTask
ANSITerminal	Class containing graphics code for ANSI compliant text terminals and terminal emulators.
AsynchronousTextGUIThread	Extended interface of TextGUIThread for implementations that uses a separate thread for all GUI event processing and updating.
AsynchronousTextGUIThread.State	Enum representing the states of the GUI thread life-cycle
AWTTerminal	This class provides an AWT implementation of the Terminal interface that is an embeddable component you can put into an AWT container.
AWTTerminalFontConfiguration	This class encapsulates the font information used by an AWTTerminal.
AWTTerminalFontConfiguration.BoldMode	Controls how the SGR bold will take effect when enabled on a character.
AWTTerminalFrame	This class is similar to what SwingTerminal used to be before Lanterna 3.0; a Frame that contains a terminal emulator.
AWTTerminalImplementation	AWT implementation of GraphicalTerminalImplementation that contains all the overrides for AWT Created by martin on 08/02/16.
BasePane	BasePane is the base container in a Text GUI.
BasePaneListener<T extends BasePane>	Base listener interface having callback methods for events relating to BasePane (and Window, which extends BasePane) so that you can be notified by a callback when certain events happen.
BasicCharacterPattern	Very simple pattern that matches the input stream against a pre-defined list of characters.
BasicTextImage	Simple implementation of TextImage that keeps the content as a two-dimensional TextCharacter array.
BasicWindow	Simple AbstractWindow implementation that you can use as a building block when creating new windows without having to create new classes.
Border	Main interface for different border classes, with additional methods to help lanterna figure out the size and offset of components wrapped by borders.
Border.BorderRenderer
BorderLayout	BorderLayout imitates the BorderLayout class from AWT, allowing you to add a center component with optional components around it in top, bottom, left and right locations.
BorderLayout.Location	This type is what you use as the layout data for components added to a panel using BorderLayout for its layout manager.
Borders	This class containers a couple of border implementation and utility methods for instantiating them.
Borders.AbstractBorderRenderer
Borders.BorderStyle
Borders.DoubleLine
Borders.DoubleLineRenderer
Borders.SingleLine
Borders.SingleLineRenderer
Borders.StandardBorder
BundleLocator	This class permits to deal easily with bundles.
BundleLocator.UTF8Control
Button	Simple labeled button that the user can trigger by pressing the Enter or the Spacebar key on the keyboard when the component is in focus.
Button.BorderedButtonRenderer
Button.ButtonRenderer	Helper interface that doesn't add any new methods but makes coding new button renderers a little bit more clear
Button.DefaultButtonRenderer	This is the default button renderer that is used if you don't override anything.
Button.FlatButtonRenderer	Alternative button renderer that displays buttons with just the label and minimal decoration
Button.Listener	Listener interface that can be used to catch user events on the button
CharacterPattern	Used to compare a list of character if they match a particular pattern, and in that case, return the kind of keystroke this pattern represents
CharacterPattern.Matching	This immutable class describes a matching result.
CheckBox	The checkbox component looks like a regular checkbox that you can find in modern graphics user interfaces, a label and a space that the user can toggle on and off by using enter or space keys.
CheckBox.CheckBoxRenderer	Helper interface that doesn't add any new methods but makes coding new check box renderers a little bit more clear
CheckBox.DefaultCheckBoxRenderer	The default renderer that is used unless overridden.
CheckBox.Listener	Listener interface that can be used to catch user events on the check box
CheckBoxList<V>	This is a list box implementation where each item has its own checked state that can be toggled on and off
CheckBoxList.CheckBoxListItemRenderer<V>	Default renderer for this component which is used unless overridden.
CheckBoxList.Listener	Listener interface that can be attached to the CheckBoxList in order to be notified on user actions
ComboBox<V>	This is a simple combo box implementation that allows the user to select one out of multiple items through a drop-down menu.
ComboBox.ComboBoxRenderer<V>	Helper interface that doesn't add any new methods but makes coding new combo box renderers a little bit more clear
ComboBox.DefaultComboBoxRenderer<V>	This class is the default renderer implementation which will be used unless overridden.
ComboBox.Listener	Listener interface that can be used to catch user events on the combo box
Component	This is the main interface defining a component in Lanterna, although you will probably not implement this directly but rather extend the AbstractComponent or another one of the sub-classes instead to avoid implementing most of the methods in this interface.
ComponentRenderer<T extends Component>	This interface defines a renderer for a component, an external class that does the sizing and rendering.
Composite	A Composite is a Container that contains only one (or zero) component.
Container	Container is a component that contains a collection of child components.
CtrlAltAndCharacterPattern	Character pattern that matches characters pressed while ALT and CTRL keys are held down
CtrlAndCharacterPattern	Character pattern that matches characters pressed while CTRL key is held down
CygwinTerminal	This class extends UnixLikeTerminal and implements the Cygwin-specific implementations.
DefaultKeyDecodingProfile	This profile attempts to collect as many code combinations as possible without causing any collisions between patterns.
DefaultMutableThemeStyle	This basic implementation of ThemeStyle keeps the styles in its internal state and allows you to mutate them.
DefaultShapeRenderer	Default implementation of ShapeRenderer.
DefaultShapeRenderer.Callback
DefaultTableCellRenderer<V>	Default implementation of TableCellRenderer
DefaultTableHeaderRenderer<V>	Default implementation of TableHeaderRenderer
DefaultTableRenderer<V>	Default implementation of TableRenderer
DefaultTerminalFactory	This TerminalFactory implementation uses a simple auto-detection mechanism for figuring out which terminal implementation to create based on characteristics of the system the program is running on.
DefaultTextGUIGraphics	Created by Martin on 2017-08-11.
DefaultTheme
DefaultVirtualTerminal
DefaultWindowDecorationRenderer	Default window decoration renderer that is used unless overridden with another decoration renderer.
DefaultWindowManager	The default window manager implementation used by Lanterna.
DelegatingTheme	Allows you to more easily wrap an existing theme and alter the behaviour in some special cases.
DelegatingThemeDefinition	Allows you to more easily wrap an existing theme definion and alter the behaviour in some special cases.
DialogWindow	Thin layer on top of the AbstractWindow class that automatically sets properties and hints to the window to make it act more like a modal dialog window
Direction	Enum for distinguishing between horizontal and vertical directions.
DirectoryDialog	Dialog that allows the user to iterate the file system and pick directory.
DirectoryDialog.DoNothing
DirectoryDialogBuilder	Dialog builder for the DirectoryDialog class, use this to create instances of that class and to customize them.
DoublePrintingTextGraphics	This TextGraphics implementation wraps another TextGraphics and forwards all operations to it, but with a few differences.
EmptySpace	Simple component which draws a solid color over its area.
EmptyWindowDecorationRenderer	Implementation of WindowDecorationRenderer that is doesn't render any window decorations
EscapeSequenceCharacterPattern	This implementation of CharacterPattern matches two similar patterns of Escape sequences, that many terminals produce for special keys.
EscapeSequenceCharacterPattern.State
ExtendedTerminal	This class extends the normal Terminal interface and adds a few more methods that are considered rare and shouldn't be encouraged to be used.
FatWindowDecorationRenderer
FileDialog	Dialog that allows the user to iterate the file system and pick file to open/save
FileDialog.DoNothing
FileDialogBuilder	Dialog builder for the FileDialog class, use this to create instances of that class and to customize them
FixedTerminalSizeProvider	Using this terminal size provider, your terminal will be set to a fixed size and will never receive any resize events.
GraphicalTerminalImplementation	This is the class that does the heavy lifting for both AWTTerminal and SwingTerminal.
GraphicalTerminalImplementation.DirtyCellsLookupTable
GridLayout	This emulates the behaviour of the GridLayout in SWT (as opposed to the one in AWT/Swing).
GridLayout.Alignment	The enum is used to specify where in a grid cell a component should be placed, in the case that the preferred size of the component is smaller than the space in the cell.
GridLayout.GridLayoutData
GUIBackdrop	Special component that is by default displayed as the background of a text gui unless you override it with something else.
ImageComponent
InputDecoder	Used to read the input stream character by character and generate Key objects to be put in the input queue.
InputFilter	This interface can be used to programmatically intercept input from the user and decide if the input should be passed on to the interactable.
InputProvider	Objects implementing this interface can read character streams and transform them into Key objects which can be read in a FIFO manner.
Interactable	This interface marks a component as able to receive keyboard input from the user.
Interactable.FocusChangeDirection	When focus has changed, which direction.
Interactable.Result	Enum to represent the various results coming out of the handleKeyStroke method
InteractableLookupMap	This class is used to keep a 'map' of the usable area and note where all the interact:ables are.
InteractableRenderer<T extends Component & Interactable>	Extended interface for component renderers used with interactable components.
IOSafeExtendedTerminal	Interface extending ExtendedTerminal that removes the IOException throw clause.
IOSafeTerminal	Interface extending Terminal that removes the IOException throw clause.
IOSafeTerminalAdapter	This class exposes methods for converting a terminal into an IOSafeTerminal.
IOSafeTerminalAdapter.ConvertToRuntimeException
IOSafeTerminalAdapter.DoNothingAndOrReturnNull
IOSafeTerminalAdapter.ExceptionHandler
IOSafeTerminalAdapter.Extended	This class exposes methods for converting an extended terminal into an IOSafeExtendedTerminal.
KeyDecodingProfile	In order to convert a stream of characters into objects representing keystrokes, we need to apply logic on this stream to detect special characters.
KeyStroke	Represents the user pressing a key on the keyboard.
KeyStroke.RealF3	an F3-KeyStroke that is distinguishable from a CursorLocation report.
KeyType	This enum is a categorization of the various keys available on a normal computer keyboard that are usable (detectable) by a terminal environment.
Label	Label is a simple read-only text display component.
LanternaThemes	Catalog of available themes, this class will initially contain the themes bundled with Lanterna but it is possible to add additional themes as well.
LayoutData	Empty interface to use for values that can be used as a layout meta-data on components.
LayoutManager	A layout manager is a class that takes an area of usable space and a list of components to fit on that space.
LinearLayout	Simple layout manager the puts all components on a single line, either horizontally or vertically.
LinearLayout.Alignment	This enum type will decide the alignment of a component on the counter-axis, meaning the horizontal alignment on vertical LinearLayouts and vertical alignment on horizontal LinearLayouts.
LinearLayout.GrowPolicy	This enum type will what to do with a component if the container has extra space to offer.
LinearLayout.LinearLayoutData
ListSelectDialog<T>	Dialog that allows the user to select an item from a list
ListSelectDialogBuilder<T>	Dialog builder for the ListSelectDialog class, use this to create instances of that class and to customize them
LocalizedString	Set of predefined localized string. All this strings are localized by using LocalizedUIBundle. Changing the locale by calling Locale.setDefault(Locale).
LocalizedUIBundle	This class permits to get easily localized strings about the UI.
Menu	Implementation of a drop-down menu contained in a MenuBar and also a sub-menu inside another Menu.
MenuBar	A menu bar offering drop-down menus.
MenuItem	This class is a single item that appears in a Menu with an optional action attached to it
MenuItem.DefaultMenuItemRenderer	Default renderer for menu items (both sub-menus and regular items)
MenuItem.MenuItemRenderer	Helper interface that doesn't add any new methods but makes coding new menu renderers a little bit more clear
MenuPopupWindow	This class is a Window implementation that automatically sets some common settings that you'd want on specifically popup windows with menu items.
MessageDialog	Simple message dialog that displays a message and has optional selection/confirmation buttons
MessageDialogBuilder	Dialog builder for the MessageDialog class, use this to create instances of that class and to customize them
MessageDialogButton	This enum has the available selection of buttons that you can add to a MessageDialog.
MouseAction	MouseAction, a KeyStroke in disguise, this class contains the information of a single mouse action event.
MouseActionType	Enum type for the different kinds of mouse actions supported
MouseCaptureMode	Constant describing different modes for capturing mouse input.
MouseCharacterPattern	Pattern used to detect Xterm-protocol mouse events coming in on the standard input channel Created by martin on 19/07/15.
MultiWindowTextGUI	This is the main Text GUI implementation built into Lanterna, supporting multiple tiled windows and a dynamic background area that can be fully customized.
NormalCharacterPattern	Character pattern that matches one character as one KeyStroke with the character that was read
NullTextGraphics	TextGraphics implementation that does nothing, but has a pre-defined size
Panel	This class is the basic building block for creating user interfaces, being the standard implementation of Container that supports multiple children.
Panels	Utility class for quickly bunching up components in a panel, arranged in a particular pattern
ProgressBar	This GUI element gives a visual indication of how far a process of some sort has progressed at any given time.
ProgressBar.DefaultProgressBarRenderer	Default implementation of the progress bar GUI component renderer.
ProgressBar.LargeProgressBarRenderer	This progress bar renderer implementation takes slightly more space (three rows) and draws a slightly more complicates progress bar with fixed measurers to mark 25%, 50% and 75%.
PropertyTheme	Theme implementation that stores the theme definition in a regular java Properties object.
RadioBoxList<V>	The list box will display a number of items, of which one and only one can be marked as selected.
RadioBoxList.Listener	Listener interface that can be attached to the RadioBoxList in order to be notified on user actions
RadioBoxList.RadioBoxListItemRenderer<V>	Default renderer for this component which is used unless overridden.
SameTextGUIThread	This TextGUIThread implementation is assuming the GUI event thread will be the same as the thread that creates the TextGUI objects.
SameTextGUIThread.Factory	Default factory class for SameTextGUIThread, you need to pass this to the TextGUI constructor if you want it to use this class
Screen	Screen is a fundamental layer in Lanterna, presenting the terminal as a bitmap-like surface where you can perform smaller in-memory operations to a back-buffer, effectively painting out the terminal as you'd like it, and then call refresh to have the screen automatically apply the changes in the back-buffer to the real terminal.
Screen.RefreshType	This enum represents the different ways a Screen can refresh the screen, moving the back-buffer data into the front-buffer that is being displayed.
ScreenBuffer	Defines a buffer used by AbstractScreen and its subclasses to keep its state of what's currently displayed and what the edit buffer looks like.
ScreenInfoAction	ScreenInfoAction, a KeyStroke in disguise, this class contains the reported position of the screen cursor.
ScreenInfoCharacterPattern	This class recognizes character combinations which are actually a cursor position report.
ScreenTextGraphics	This is an implementation of TextGraphics that targets the output to a Screen.
Scrollable	Describes an area that can be 'scrolled', by moving a range of lines up or down.
ScrollBar	Classic scrollbar that can be used to display where inside a larger component a view is showing.
ScrollBar.DefaultScrollBarRenderer	Default renderer for ScrollBar which will be used unless overridden.
ScrollBar.ScrollBarRenderer	Helper class for making new ScrollBar renderers a little bit cleaner
ScrollingAWTTerminal	This is a AWT Container that carries an AWTTerminal with a scrollbar, effectively implementing a pseudo-terminal with scrollback history.
ScrollingSwingTerminal	This is a Swing JComponent that carries a SwingTerminal with a scrollbar, effectively implementing a pseudo-terminal with scrollback history.
SeparateTextGUIThread	Default implementation of TextGUIThread, this class runs the GUI event processing on a dedicated thread.
SeparateTextGUIThread.Factory	Factory class for creating SeparateTextGUIThread objects
Separator	Static non-interactive component that is typically rendered as a single line.
Separator.DefaultSeparatorRenderer	This is the default separator renderer that is used if you don't override anything.
Separator.SeparatorRenderer	Helper interface that doesn't add any new methods but makes coding new button renderers a little bit more clear
SGR	SGR - Select Graphic Rendition, changes the state of the terminal as to what kind of text to print after this command.
ShapeRenderer	This package private interface exposes methods for translating abstract lines, triangles and rectangles to discreet points on a grid.
SimpleTerminalResizeListener	This class is a simple implementation of Terminal.ResizeListener which will keep track of the size of the terminal and let you know if the terminal has been resized since you last checked.
SimpleTheme	Very basic implementation of Theme that allows you to quickly define a theme in code.
SimpleTheme.Definition	Internal class inside SimpleTheme used to allow basic editing of the default style and the optional overrides.
SimpleTheme.RendererProvider<T extends Component>
SplitPanel
StreamBasedTerminal	An abstract terminal implementing functionality for terminals using OutputStream/InputStream.
StyleSet<T extends StyleSet<T>>
StyleSet.Set
SubTextGraphics	This implementation of TextGraphics will take a 'proper' object and composite a view on top of it, by using a top-left position and a size.
SwingTerminal	This class provides an Swing implementation of the Terminal interface that is an embeddable component you can put into a Swing container.
SwingTerminalFontConfiguration	Font configuration class for SwingTerminal that is extending from AWTTerminalFontConfiguration
SwingTerminalFrame	This class is similar to what SwingTerminal used to be before Lanterna 3.0; a JFrame that contains a terminal emulator.
SwingTerminalImplementation	Concrete implementation of GraphicalTerminalImplementation that adapts it to Swing
Symbols	Some text graphics, taken from http://en.wikipedia.org/wiki/Codepage_437 but converted to its UTF-8 counterpart.
TabBehaviour	What to do about the tab character when putting on a Screen.
Table<V>	The table class is an interactable component that displays a grid of cells containing data along with a header of labels.
TableCellBorderStyle	Describing how table cells are separated when drawn
TableCellRenderer<V>	The main interface to implement when you need to customize the way table cells are drawn
TableHeaderRenderer<V>	This interface can be implemented if you want to customize how table headers are drawn.
TableModel<V>	A TableModel contains the data model behind a table, here is where all the action cell values and header labels are stored.
TableModel.Listener<V>	Listener interface for the TableModel class which can be attached to a TableModel to be notified of changes to the table model.
TableRenderer<V>	Formalized interactable renderer for tables
TelnetProtocol	Contains the telnet protocol commands, although not a complete set.
TelnetTerminal	This class is used by the TelnetTerminalServer class when a client has connected in; this class will be the interaction point for that client.
TelnetTerminal.NegotiationState	This class contains some of the various states that the Telnet negotiation protocol defines.
TelnetTerminal.TelnetClientEventListener
TelnetTerminal.TelnetClientIACFilterer
TelnetTerminalServer	This class implements a Telnet server, capable of accepting multiple clients and presenting each one as their own Terminal.
Terminal	This is the main terminal interface, at the lowest level supported by Lanterna.
TerminalEmulatorAutoCloseTrigger	This enum stored various ways the AWTTerminalFrame and SwingTerminalFrame can automatically close (hide and dispose) themselves when a certain condition happens.
TerminalEmulatorColorConfiguration	Color configuration settings to be using with SwingTerminal.
TerminalEmulatorDeviceConfiguration	Object that encapsulates the configuration parameters for the terminal 'device' that a SwingTerminal is emulating.
TerminalEmulatorDeviceConfiguration.CursorStyle	Different cursor styles supported by SwingTerminal
TerminalEmulatorPalette	This class specifies the palette of colors the terminal will use for the normally available 8 + 1 ANSI colors but also their 'bright' versions with are normally enabled through bold mode.
TerminalFactory	This interface is for abstracting the creation of your Terminal object.
TerminalInputMethodRequests
TerminalPosition	A 2-d position in 'terminal space'.
TerminalRectangle	This class is immutable and cannot change its internal state after creation.
TerminalResizeListener	Listener interface that can be used to be alerted on terminal resizing
TerminalScreen	This is the default concrete implementation of the Screen interface, a buffered layer sitting on top of a Terminal.
TerminalScreen.ScreenPointComparator
TerminalScreen.ScrollHint
TerminalScrollController	This interface can be used to control the backlog scrolling of a SwingTerminal.
TerminalScrollController.Null	Implementation of TerminalScrollController that does nothing
TerminalSize	Terminal dimensions in 2-d space, measured in number of rows and columns.
TerminalTextGraphics	This is the terminal's implementation of TextGraphics.
TerminalTextUtils	This class contains a number of utility methods for analyzing characters and strings in a terminal context.
TextBox	This component keeps a text content that is editable by the user.
TextBox.DefaultTextBoxRenderer	This is the default text box renderer that is used if you don't override anything.
TextBox.Style	Enum value to force a TextBox to be either single line or multi line.
TextBox.TextBoxRenderer	Helper interface that doesn't add any new methods but makes coding new text box renderers a little bit more clear
TextBox.TextChangeListener	Listener interface for when the TextBox content has changed.
TextBuffer	This class is used to store lines of text inside of a terminal emulator.
TextCharacter	Represents a single character with additional metadata such as colors and modifiers.
TextColor	This is an abstract base class for terminal color definitions.
TextColor.ANSI	This class represent classic ANSI colors that are likely to be very compatible with most terminal implementations.
TextColor.Factory	Utility class to instantiate colors from other types and definitions
TextColor.Indexed	This class represents a color expressed in the indexed XTerm 256 color extension, where each color is defined in a lookup-table.
TextColor.RGB	This class can be used to specify a color in 24-bit color space (RGB with 8-bit resolution per color).
TextGraphics	This interface exposes functionality to 'draw' text graphics on a section of the terminal.
TextGraphicsWriter
TextGraphicsWriter.WordPart
TextGUI	This is the base interface for advanced text GUIs supported in Lanterna.
TextGUI.Listener	Listener interface for TextGUI, firing on events related to the overall GUI
TextGUIElement	This interface is the base part in the Lanterna Text GUI component hierarchy
TextGUIGraphics	TextGraphics implementation used by TextGUI when doing any drawing operation.
TextGUIThread	Class that represents the thread this is expected to run the event/input/update loop for the TextGUI.
TextGUIThread.ExceptionHandler	This interface defines an exception handler, that is used for looking at exceptions that occurs during the main event loop of the TextGUIThread.
TextGUIThreadFactory	Factory class for creating TextGUIThread objects.
TextImage	An 'image' build up of text characters with color and style information.
TextInputDialog	TextInputDialog is a modal text input dialog that prompts the user to enter a text string.
TextInputDialogBuilder	Dialog builder for the TextInputDialog class, use this to create instances of that class and to customize them
TextInputDialogResultValidator	Interface to implement for custom validation of text input in a TextInputDialog
Theme	The main theme interface, from which you can retrieve theme definitions
ThemeDefinition	A ThemeDefinition contains a collection of ThemeStyle:s, which defines on a lower level which colors and SGRs to apply if you want to draw according to the theme.
ThemedTextGraphics	Expanded TextGraphics that adds methods to interact with themes
ThemeStyle	ThemeStyle is the lowest entry in the theme hierarchy, containing the actual colors and SGRs to use.
UnixLikeTerminal	Base class for all terminals that generally behave like Unix terminals.
UnixLikeTerminal.CtrlCBehaviour	This enum lets you control how Lanterna will handle a ctrl+c keystroke from the user.
UnixLikeTTYTerminal	UnixLikeTerminal extends from ANSITerminal and defines functionality that is common to UnixTerminal and CygwinTerminal, like setting tty modes; echo, cbreak and minimum characters for reading as well as a shutdown hook to set the tty back to original state at the end.
UnixTerminal	This class extends UnixLikeTerminal and implements the Unix-specific parts.
UnixTerminalSizeQuerier	This class allows you to override by what means Lanterna detects the size of the terminal.
VirtualScreen	VirtualScreen wraps a normal screen and presents it as a screen that has a configurable minimum size; if the real screen is smaller than this size, the presented screen will add scrolling to get around it.
VirtualScreen.DefaultFrameRenderer
VirtualScreen.FrameRenderer	Interface for rendering the virtual screen's frame when the real terminal is too small for the virtual screen
VirtualTerminal	A virtual terminal is a kind of terminal emulator implemented inside of Lanterna that exposes the Terminal interface and maintains its state completely internally.
VirtualTerminal.BufferLine	Interface used by VirtualTerminal.BufferWalker to repressent a line in the text buffer when iterating over a range of lines
VirtualTerminal.BufferWalker	Callback interface that is used by VirtualTerminal.forEachLine(int, int, BufferWalker) as a way to iterate over a range of lines in the text buffer
VirtualTerminalListener	Listener class for VirtualTerminal that allows you to receive callbacks on certain events.
VirtualTerminalTextGraphics	Implementation of TextGraphics for VirtualTerminal
WaitingDialog	Dialog that displays a text message, an optional spinning indicator and an optional progress bar.
Window	Window is a base unit in the TextGUI system, it represents a collection of components grouped together, usually surrounded by a border and a title.
Window.Hint	Window hints are meta-data stored along with the window that can be used to give the GUI system some ideas of how this window wants to be treated.
WindowBasedTextGUI	Extension of the TextGUI interface, this is intended as the base interface for any TextGUI that intends to make use of the Window class.
WindowDecorationRenderer	Interface that defines a class that draws window decorations, i.e.
WindowList
WindowListener	Extended BasePaneListener for Window that exposes additional events that are specific to windows
WindowListenerAdapter	Adapter class for WindowListener to make it easier to create listeners without having to implement every interface method.
WindowManager	Window manager is a class that is plugged in to a WindowBasedTextGUI to manage the position and placement of windows.
WindowPostRenderer	Classes implementing this interface can be used along with DefaultWindowManagerTextGUI to put some extra processing after a window has been rendered.
WindowShadowRenderer	This WindowPostRenderer implementation draws a shadow under the window
WrapBehaviour	What to do when line length is exceeded.