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

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

using namespace Upp;

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

struct TerminalExample : TopWindow {
	Terminal term;
	PtyProcess pty;
	
	TerminalExample()
	{
		SetRect(term.GetStdSize());
		Sizeable().Zoomable().CenterScreen().Add(term.SizePos());
		term.WhenBell   = [=]()                { BeepExclamation(); };
		term.WhenTitle  = [=](String s)        { Title(s);          };
		term.WhenOutput = [=](String s)        { pty.Write(s);      };
		term.WhenResize = [=]()                { pty.SetSize(term.GetPageSize()); };
		term.WhenLink   = [=](const String& s) { PromptOK(s);       };
		term.InlineImages().Hyperlinks().WindowOps().DynamicColors();
		term.SetHistorySize(65536);
	}
	
	void Run()
	{
		pty.Start(nixshell, Environment(), GetHomeDirectory());
		OpenMain();
		while(IsOpen() && pty.IsRunning()) {
			int ms = 16;
			String in = pty.Get();
			if(!IsNull(in)) {
				term.WriteUtf8(in);
				int len = in.GetLength();
				if(len >= 1024)
					ms = 1024 * 16 / len; // Scale to workload...
			}
			ProcessEvents();
			Sleep(ms);
		}
	}

};

GUI_APP_MAIN
{
	TerminalExample().Run();
}

- Auto-hide option for mouse cursor is added. Terminal ctrl can be configured to automatically hide the mouse pointer when the user types a text.

- Initial support for copy-on-select style (X11-style) text selection is added.
- Terminal ctrl recognizes CMY/CMYK and urxvt-style RGBA color text specifications via dynamic colors extension.

1) Check the API docs first. Terminal ctrl contains regular topic++ files for TheIDE. It should be available through TheIDE's help system.

2) Create a CtrlLib application (basic or with layout, it's up to you. Terminal ctrl contains a layout file, so you can use it in TheIDE's layout editor.)

3) Add Terminal ctrl to you app. As it is a regular ctrl, it can be added to your window or any other "parent" ctrl via Ctrl::Add() method.

4) If you are going to use it as a local terminal, using a pty (currently on POSIX only), then Terminal package contains a PtyProcess class.
   Add #include <Terminal/PtyProcess.h> to your app. Then all you need to do is set up the events and loop.
   Provided examples use a rudimentary loop which is sufficient for most cases but you can write much efficient loops that'll suit your personal need and use-case. 

5) If you are going to use it as a GUI front end for, say, SSH shells, add uppsrc/Core/SSH package to you app, and connect the loop. See the rudimentary upp-components/Examples/SshTerminalExample

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

using namespace Upp;

struct MinimalTerminalExample : TopWindow {
    Terminal term;          // A terminal ctrl instance.
    PtyProcess pty;         // A pseudoconsole process instance.
    MinimalTerminalExample()
    {
        SetRect(0, 0, 800, 600);
        Sizeable().Zoomable().CenterScreen().Add(term.SizePos());
        term.WhenOutput = [=](String out)   { pty.Write(out);  };                       // Terminal output
        term.WhenResize = [=]               { pty.SetSize(term.GetPageSize()); };       // Notifies the pty about page size changes.
        pty.Start("/bin/bash", Environment(), GetHomeDirectory());                      // Start a shell process on pty.
        // For a reasonable throughput, a callback-based loop is sufficient.
        SetTimeCallback(-1, [=] { term.WriteUtf8(pty.Get()); if(!pty.IsRunning()) Break(); });
    }
    
//  For very high throughput, below loop (or something better) can be used.
//
//  void Run()
//  {
//      pty.Start("/bin/bash", Environment(), GetHomeDirectory());
//      OpenMain();
//      while(IsOpen() && pty.IsRunning()) {
//          ProcessEvents();
//          String s = pty.Get();   // PtyProcess reads are non-blocking.
//          if(!IsNull(s))
//              term.WriteUtf8(s);
//          int l = s.GetLength();
//          Sleep(l >= 1024 ? 1024 * 10 / l : 10); // Scale...
//      }
//  }

};

GUI_APP_MAIN
{
    MinimalTerminalExample().Run();
}

CPU:        AMD FX 6100 - Black Edition (Six-core processor)
Memory:     8 GiB, DDR-3 1800 Mhz
Storage:    128 Gib SSD, 1Tib HDD
Graphics:   AMD Radeon R7 240, 2GiB
Monitor:    LCD, HD (1080p)
OS/Kernel:  Arch/Linux 5.6 (x86_64)
Desktop:    GNOME 3.36 (X11)
Framework:  Ultimate++ 2020.1 (alpha)
Flags:      GUI
Compilers:  GCC 10.0.1 CLANG 10.0.0
Application: TerminalExample (with a high throughput loop).
Font:       The same IBM Plex Mono, monospace font used in all tests.

Disclaimer: The benchmarks below do not represent any competition.
            They don't represent any weak spots of the mentioned terminals. They are all high quality stuff.
            The sole purpose of these benchmarks is to give an idea as to where the Terminal ctrl's "engine" performance stands ATM.

Note: All benchmarks are repeated 50 times, automatically.
      The performance difference between GCC/CLANG builds is negligable.
      The latest stable versions of the mentioned terminals are used in these tests (as of May-June 2020).

Results of command: "time find /usr", file count: 415897, page size: 237 x 55, Monospace Font)

Terminal Emulator                  real         user        sys        Notes
-----------------                 ----------   ----------   ---------- ----------
Alacritty                         0m3,776s     0m1,134s     0m2,637s   Scrollback buffer size: 64k
Terminal ctrl                     0m4,126s     0m1,202s     0m2,466s   Scrollback buffer size: 64k
Kitty                             0m5,608s     0m1,224s     0m2,763s   Scrollback buffer size: 64k
Gnome Terminal                    0m6,785s     0m1,243s     0m3,015s   Scrollback buffer size: 64k
xterm                             0m24,368s    0m1,661s     0m3,766s   Scrollback buffer size: 64k

Terminal Emulator                  real         user        sys         Notes
-----------------                 ----------   ----------   ----------  ----------
Simple terminal (0.8)             0m3,791s     0m1,162s     0m2,533s    Has no scrollback buffer.
Terminal ctrl   (0.3)             0m3,971s     0m1,120s     0m2,472s    Scrollback disabled.

Terminal Emulator                  real         user        sys         Notes
-----------------                 ----------   ----------   ----------  ----------
Terminal ctrl   (0.3)             0m4,380s     0m1,479s     0m2,536s    localhost, Scrollback buffer size: 2000 lines, no compression, (SshTerminalExample is used)
PuTTY (0.73)                      0m40,828s    0m1,354s     0m3,071s    localhost, Scrollback buffer size: 2000 lines, no compression

// Vte-bench, benchmark 1: scrolling. page size: 237 x 55, Monospace Font.

Terminal Emulator                  real         user        sys        Notes
-----------------                 ----------   ----------   ---------- ----------
Alacritty                         0m1,936s     0m0,001s     0m0,946s
Kitty                             0m2,985s     0m0,000s     0m0,567s
Gnome Terminal                    0m3,758s     0m0,001s     0m0,940s
Terminal ctrl                     0m4,064s     0m0,000s     0m0,859s
Simple terminal (0.8)             0m4,623s     0m0,000s     0m1,105s 
xterm                             0m47,249s    0m0,000s     0m0,567s

// Vte-bench, benchmark 2: alt-screen-random-write, page size: 237 x 55, Monospace Font.

Terminal Emulator                  real         user        sys        Notes
-----------------                 ----------   ----------   ---------- ----------
Alacritty                         0m1,520s     0m0,000s     0m0,554s
Kitty                             0m2,750s     0m0,000s     0m0,408s
Gnome Terminal                    0m3,153s     0m0,004s     0m0,726s
Terminal ctrl                     0m3,790s     0m0,000s     0m0,474s
Simple terminal (0.8)             0m7,097s     0m0,001s     0m0,825s 
xterm                             0m19,797s    0m0,001s     0m0,993s

// Vte-bench, benchmark 3: scrolling-in-region, page size: 237 x 55, Monospace Font.

Terminal Emulator                  real         user        sys        Notes
-----------------                 ----------   ----------   ---------- ----------
Alacritty                         0m3,337s     0m0,001s     0m3,297s
Gnome Terminal                    0m5,280s     0m0,001s     0m3,254s
Kitty                             0m6,326s     0m0,001s     0m6,034s
Terminal ctrl                     0m6,739s     0m0,001s     0m4,033s
Simple terminal (0.8)             0m7,844s     0m0,001s     0m7,348s
xterm                             3m36,599s    0m0,001s     0m11,011s

IBM Plex  Mono: 0x0020-0x07FF (Base glyphs)
Fira Code Mono: 0x2500-0x259f (Box drawing glyphs)
GNU Free  Mono: 0x2800-0x28FF (Braille glyphs)
Awesome   Mono: ------------- (Other glyphs) 

- Automatic VT allocation mechanism is implemented. 
  Since U++ suppports function keys from F1 to F12, I have limited the valid VT numbers within tty1-tty12 range (This can be easily changed if required).

- Accordingly, VT switching is implemented.
  Since we mute the vt keyboard input, this required manual handling of the linux signals, and as a result the vt handle had to be made a global static integeer (atomic).

- To prevent any screen buffer damage, U++ linuxframebuffer backend now does not copy the drawn image onto framebuffer when the
  vt is switched away (i,e., whem it loses focus).

- Accordingly, CTRL + ALT + [F1-f12] key combinations are reserved for VT switching.

- SHIFT keys are not working properly. (Can't get any capital letters.)

- No double click.

- No key repeat.