All Classes Interface Summary Class Summary Enum Summary
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 |
|
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 |
|
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 LinearLayout s and vertical alignment on horizontal LinearLayout s.
|
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 |
|
SwingTerminalFrame |
This class is similar to what SwingTerminal used to be before Lanterna 3.0; a JFrame that contains a terminal
emulator.
|
SwingTerminalImplementation |
|
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 |
|
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 |
|
VirtualTerminal.BufferWalker |
|
VirtualTerminalListener |
Listener class for VirtualTerminal that allows you to receive callbacks on certain events.
|
VirtualTerminalTextGraphics |
|
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 |
|
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.
|