- VT52/ANSI/1xxx/2xx and -partially- 4xx/5xx emulation and Xterm extension.
- Both 7-Bit and 8-Bit modes.
- UTF8
- OCS and DCS
- ANSI colors
- Alternate screen buffer. 
- Resize

- Copy-paste support
- Scrollback buffer
- Mouse support
- And various optimizations.

for(;;) {
	if(quit)
		return false;
	Sleep(10);	// Let's eat less CPU cycle while waiting for connections.
//...

- Scrollback buffer is implemented.
- Chameleon (theme) support is implemented.
- VT52/1xx/2xx keyboard (with function keys) support is implemented.
- Conformance levels support is added (i.e. it is now possible to restrict the operation level to e.g. VT52, VT102, or VT220 etc.)

-- Mouse tracking support added. Terminal can now handle mouse events if they are supported by the applications (See above video for example)
-- Bracketed paste mode added.
-- "G-sets" upport added. It now supports legacy applications that rely on font shifting (g0, g1, g2, g3, gl, gr).
-- DEC Technical charset is added.

- 256 colors support added.
- ANSI colors support added.
- XTerm dynamic colors suppport added.
- VT 4xx rectangular area operations are added (copy, invert, move, fill, in both selective and normal modes)
- UDK (DEC's user-defined function keys support) added.
- Lazy resize option is added (to reduce flickers on network terminals uch as SSH-based ones)
- Size hint added.
- A .usc file is added to the Terminal package. (The most common options (font, ink, paper, cursor, sizehint etc.) can be set using TheIDE's layout editor. Also it shows a size hint (in calculated cell size) to simplfy positiong the widget in the layout ediyor.
- It is also tested on Windows, and it works well. :)  (currently as SSH terminal, in the near future as a frontend for Windows power shell too) 

#include <Core/Core.h>
#include <Terminal/Terminal.h>

using namespace Upp;

const char *nixshell = "/bin/bash";

struct TerminalExample : TopWindow {
	Terminal	term;
	PtyProcess	pty;

	TerminalExample()
	{
		term.WhenBell	=   [=]()		{ BeepExclamation(); };
		term.WhenTitle	=   [=](String s)	{ Title(s); };
		term.WhenResize	=   [=]()		{ pty.SetSize(term.GetPageSize()); };
		term.WhenOutput	=   [=](String s)	{ PutGet(s); };
		SetRect(term.GetStdSize());	// 80 x 24 cells (scaled).
		Sizeable().Zoomable().CenterScreen().Add(term.SizePos());
		SetTimeCallback(-1, [=]()		{ PutGet(); });
		pty.Start(nixshell, Environment(), GetHomeDirectory());
	}
	
	void PutGet(String out = Null)
	{
		term.Write(pty.Get());
		pty.Write(out);
		if(!pty.IsRunning())
			Break();
	}
};

GUI_APP_MAIN
{
	TerminalExample().Run();
}

Terminal package is a flexible, easy-to-use yet powerful cross-platform virtual terminal emulation library written in C/C++ for Ultimate++.

It is designed from the ground up with modularity and maintainability in mind. 
In this respect the package consists of several re-usable classes, only one being the Terminal widget.
	
## Requirements

- Ultimate++ (ver. >= 2019.1)
- POSIX, Windows (and probably MacOS, though not tested.)
- A decent enough C/C++ compiler that supports at least C++11. (GCC/CLANG/MinGW/Msc)
- Snacks & beer.

## Features

*Note that below list is only a summary of the currently supported features. Technical specifications and documentation will be available soon. 

- Supports whatever platform Ultimate++ supports. (Linux, Windows, MacOS).
- Supports VT52/VT1xx/VT2xx, partial VT4XX/5XX, and xterm emulation modes.
- Supports user configurable device conformance levels (1, 2, 3, 4, and 0 as VT52 emulation).
- Supports both 7-bits and 8-bits I/O.
- Supports Unicode/UTF8.
- Supports user configurable, legacy "g-set" (G0/G1/G2/G3), and related shifting functions (LS0/LS1/LS1R/LS2/LS2R/LS3/LS3R).
- Supports ANSI conformance levels.
- Supports various terminal state, device, and mode reports.
- Supports DEC VT52 graphics charset, VT1xx line-drawing charset, VT2xx multinational charset, and VT3xx technical charset.
- Supports VT52/VT1xx/VT2xx keyboard emulation with function keys.
- Supports UDK (DEC's user-defined function keys feature).
- Supports user configurable blinking text and blink interval.
- Supports ANSI colors (16 colors palette).
- Supports ISO colors (256 colors palette).
- Supports xterm dynamic colors (dynamic ink/paper/selection colors).
- Supports bright colors.
- Supports background color erase (BCE).
- Supports transparency (i.e. allows background images).
- Supports VT4xx rectangular area operations: copy, invert, fill. erase.
- Supports VT4xx rectangular area checksum calculation and reporting.
- Supports both DEC and ANSI style selective erases.
- Supports alternate screen buffer.
- Supports history/scrollback buffer.
- Has a user switchable scrollbar.
- Supports xterm style alternate scroll.
- Supports resize (and optional lazy resize to reduce flicker on network terminals such as SSH-based ones).
- Supports both immediate display refresh and delayed (buffered) display refresh.
- Supports xterm style mouse tracking: button, wheel, motion, focus in/out events.
- Supports user configurable cursor styles (block, beam, underscore, blinking/steady).
- Supports cursor locking.
- Supports clipboard operations (copy/paste/select all - including history buffer) and basic drag-and-drop ops.
- Supports bracketed paste mode.
- Has a predefined yet programmable context menu (left mouse button menu).
- Supports window titles.
- Supports bell notifications.
- Supports VT1xx LEDs.
- Supports size hint.
- Supports Ultimate++ style data serialization.
- Supports per-widget customization (i.e no global variables or properties are used).
- Includes a Terminal.usc file for TheIDE's layout editor.

This example demonstrates how a terminal multiplexing can be achieved simply by using a splitter widget. Splitter is a container ctrl that can be used to split any parent ctrl into resizeable horizontal and/or vertical panes. It also demonstrates the usage of NTL containers with Terminal widget:

True/direct (24-bit) color support has landed.

Terminal: Clipboard and DND operations improved.
Terminal: Drag animation for drag-copy operation implemented.
Terminal: WhenClip event added. (Allows client code to inspect/accept/reject pasted/dropped clips.
Terminal: Api doc updated accordingly.

- Sixel graphics support is added to the Terminal package. It is now possible to view sixel images, using the Terminal package.  However, the initial support is only for external viewing. Embedded images are a TODO.

- A basic terminal example with sixel viewer is also added to the package.

- SixelRenderer class and a convenience function: RenderSixelImage is also added to the package. This class and the function can also be used as a stand-alone sixel renderer.

- Alt-key handling is improved.

Terminal: Embedded images support  is added (currently, sixel).
Terminal: Renderer is improved and further optimized.
Terminal: Upp::Display support for image objects are added.
Terminal: LeftAlignedImageDisplay() and RightAlingnedImageDisplay() functions added.

- Terminal: SixelRenderer class is rewritten;
- Terminal: SixelRaster class, a StreamRaster interface for sixel images, is added to the package.
- Terminal: A subset of xterm's window-op reports are implemented.
- Terminal: An I/O synchronization issue with the PtyProcess class that led to artifacts on screen on some setups is fixed.
- Terminal: Inline image support is improved.
- Terminal: Room is made for other inline image protocols.
- Terminal: WhenSixel event is removed in favor of a generic WhenImage event.
- Terminal: Image rendering strategy is changed to cell-level rendering for further flexibility.
- Terminal: An LRU-type shared image data cache is implemented.
- Terminal: Support for Jexer, a modern text user interface (TUI) and windowing system for terminal emulators, is added.
- Terminal: A general purpose data variable is added to the cell structure.
- Terminal: SGR image flag is added to the cell structure.
- Examples: Examples are further simplified.
- Various optimizations and fixes.
- Image gallery is updated.

This example demonstrates the interaction between the Terminal widget and Ultimate++'s Core/SSH package, in a multithreaded environment.
Therefore it also demonstrates the usage and power of U++s own Core/SSH package in a multithreaded GUI environment.

Terminal ctrl is now able to display 24-bit jpeg, gif, bmp, etc. raster formats, using the Jexer Image Protocol and Upp's own StreamRaster interface.

1) It is "8-bit clean". It can be safely deliver images over the network, and with Utf-8.
2) Popular image formats can be decoded much faster than sixels. (Up to 8 to 10 times faster on bigger image files), and usually have a lower bandwidth requirements.
3) Allows 24 bit (true color) images.
4) The wire protocol is very simple.

- Explicit hyperlinks support is added.
- Standard menu  improved and modularized.
- Cell tracking methods are implemented.
- Various fixes and cosmetics.
- Docs are updated accordingly.

ls -l --hyperlink

- Terminal: Rectangle selection is now supported.
- Terminal: Iniline images can now be copied to clipboard or sent to client. (It uses the same mechanism as hyperlinks: CTRL + double click or context menu)
- Terminal: Options menu is implemented. Options menu contains the most relevant options for terminal. 

DnD operations and animations are added for both hyperlinks and inline images. (Activated with CTRL-key modifier)

- Initial steps for scripting support (using the Esc language).
- A proper double-width (Eastern-Asian/CJK) characters support.
- A proper tmux/screen support.
- A proper support for ISO 8613-6 true/indexed color formats.
- A much faster renderer. (In some torture tests (such as ncurses/dots on fulscreen mode) the performance gain can be up to %80.

- Source code is restructured.
- Console class is ditched for the sake of simplicity. There is now only Terminal, deriving from Upp:CTrl.
- Eastern-Asian/CJK double width characters support is added.
- Text overline attribute is now supported.
- APCs (application programming commands) are now supported. This is the first step towards terminal scripting feature. APCs can be also be used by client code for private purposes.
- TRUECOLOR flag is removed. Terminal ctrl is now fully and officially a true color terminal emulator.
- Accordingly, CMY and CMYK color spaces are now supported too!
- Support for color text specifications (rgb, hash3, hash6, hash9, hash12) are added.
- xterm window actions are reports are implemented. It is now possible for host apps to move, resize, minimize, maximize, fullscreen the terminal.
- Renderer has seen a significat performance boost (up to 80% on some torture tests).
- tmux/screen is fully supported.
- Hyperlinks now show nice dots under their texts when they are "inactive" (i.e. no mouse hovering over them)
- API docs and specifications docs are significantly improved.

expected-terminal=xterm
max-vt-level=4

Terminal ctrl: v0.3, passed 407 tests, failed on 101 tests, 

Terminal ctrl: v0.2 passed only 160 of the same tests.

expected-terminal=xterm
max-vt-level=4

Gnome Terminal (v.3.36.1.1): passed 163 tests and failed on 345 tests.

Kitty: passed 122 tests, and failed on 386 tests.

xterm: Fassed all tests. (not suprisingly) 

Autowrap mode is fixed.

- Jsonization support is added.
- Xmlization support is added.

Results of command: time find /usr/share

Terminal Emulator                  real         user        sys
-----------------                 ----------   ----------   ----------
Terminal Ctrl (Current):          0m23,104s    0m1,297s     0m2,879s
Terminal Ctrl (with fix):       **0m4,002s     0m0,774s     0m1,622s**
xterm                             0m15,059s    0m0,991s     0m2,527s
Gnome Terminal                    0m4,217s     0m0,778s     0m1,773s
Kitty                             0m4,907s     0m0,887s     0m2,325s