Planned improvements (without any promises or timeline), from higher priority to lower.
readline) can ignore line-length,
soft line-breaks, and window resize. This will also allow
variable width-fonts.
Some values can be defined as formats, where a ‘%’ percent character indicates a places where values and expressions are substituted. (Somewhat like tmux but using ‘%’ instead of ‘#’.)
Special characters are percent, double quotes, curly barces, and semicolon.
Conditional: {A1?A2?A3?X1|B1?Y|Z}
is like C’s A1||A2||A3 ? X1 : B1 ? Y : Z.
Usually an unescaped semi-colon is equivalent to a line-break. Both are usually used to separate items in a list.
Text inside double quotes is literal, except that string escapes
are processed. For example to include a literal semi-colon
instead of having it be processed as a separator write ";";
to write double quotes write "\"".
A simple substiution looks like %{variable}.
That text is replaced by the value of the variable.
Some single-letter forms such as %M (???)
are context-dependent shortcurs for variables or expressions.
aa
Better support for one session with multiple windows with differing widths. Support “logical line” (infitinely wide) terminal model. Lazy line-breaking (on a per-line basis) for better performance (at least faster re-size).
The controlling window (or primary window?) has the controlling window size (width and height). The window width (or height) is the width (or height) (in characters unless specified) of a given window. The terminal width (or height) is the width (or height) of the controlling window.
A line is logical line (represented as a block element), ignoring soft line-breaks. Line-breaking splits a line into one or more rows. A given line may be split in two different ways (at the same time): A terminal row is the result of splitting a line based on terminal width; standard xterm commands work in therms of terminal rows. A window row is the result of splitting a line based on window width; this is how the line is displayed in a given window.
These are properties of line object. We use the DOM block element.
If this line contains N terminal rows, then endTRows
is an array of length N, pointng to line elements that
mark the end of the N’th terminal row.
(The last element of the array may be null if the line is
terminated by an implicted end-of-block.)
Similar to endTRows, but an array of ends of window rows.
If this is the controlling windows, same as endTRows,
unless noTBreak.
True if endTRows is valid. Cleared if controlling window is re-sized.
True if endTRows is valid. Cleared if current window is re-sized.
True breakLine1 has been run on the line (since it was last modified).
No terminal breaks, only visual breaks:
Treat this line as if the terminal width is infinite,
thus it always has a single terminal row.
In this case, endTRows has size 1.
Cursor motion ignores soft line breaks (in this line).
New property outputAtEnd: If output cursor at end of logical line
(possibly nested in style-span or pprint-group).
In insertSimpleOutput if outputAtEnd just append the current line.
(Note a deferred line-break may overwrite following lines.)
Window resize:
Set rebreakNeeded on all lines.
On all likes that might becomes visible,
if measureNeeded call unbreakLines, then breakLine1 (to measure).
While implementing all of the features of xterm is probably not feasible, we should at least have a list of anything we don’t implement, or implement differently from xterm.
See also the ECMA-48 standard.
Error recovery and state transitions should follow this.
If the src attribute of <img> is a relative URL
(or optionally a file: URL), then
the domterm html command should read the file
and embed it as a data: URL.
(As long as no --base option is specified.)
We may want to support syntax coloring (including in REPL input lines)
and other highlighting.
If the DomTerm element is not the only element in the <document>’s
<body> then the selection may be lost to another “widget”
unless we simulate the selection as a highlighted range.
Think about how to do multi-line paste.
Copying to HTML should convert <div class='domterm-pre'> to
<pre> so pasting without stylesheets works better.
Handle saving and truncating scrolled-out output. Most terminal emulators have “max number of lines in scroll buffer” setting. What makes this a little tricky is because there may multiple windows attached to the same session. So this would require changes to the protocol for saving/restoring and syncorinizing sessions.
Some toolkits to explore for integrated browser/application:
nw executable is better supported.
DomTerm includes a “window manager” (implemented using GoldenLayout) that supports panes and tabs. If DomTerm is integrated in an application with its own window manager, such as Atom or Visual Studio Code, it would make sense to instead integrate with the latter manager.
The neo.mjs project has cross-window drag-and-drop.
For qtdomterm there is experimental support
for more advanced Qt docking librariers:
Qt Advanced Docking System and
KDDockWidgets.
Theia and Jupyter use PhosphorJS, now archived. A newer version is part of JupyterLab.
Similarly, when running under a tiling window manager using the latter to manage panes and tabs is likely preferable.
TermySequence has lots of features. Source code.
Atom packages are in ~/.atom/packages.
Seemingly helpful tutorial:
“How to Write Atom Packages Using Vanilla JavaScript”.
Web browsers for Atom include atom-web-view (aka web-view), or atom-browser-webview. Neither of them work well, probably because of Atom API changes.
Terminal emulators for Electron: Extraterm (interesting, uses CodeMirror). Black Screen (extra shell features).
Terminal emulators for Atom: Term 3. terminal-plus. atom-terminal-panel. Termrk.
Tabs for Electron (compatible with dragula).
Various Electron Awesome links Community links.
The idea is the line-editing mode would provide the functionality of readline or similar programs.
The idea is readline would delegate basic line editing (and re-display) to DomTerm, while DomTerm would call back to readline for command completion, history, etc.
This has a couple of advantages over plain readline: One is to have mousing actually work (i.e. no more readline not being able to move the cursor on mouse-clicks). Another advantage is local editing, which is a benefit over slow links (such as satellites) or when you don’t want to interrupt the server needlessly.
Readline should at least behave as if the screen width were infinite, delegating line-wrapping to DomTerm.
A process may "print"/paint graphics with event handlers. For example a button. On clicking the button, the click should be bundled as an event objects sent back to the inferior.
Zsh editor (zle) supports Emacs-like mark and region. Emacs has a “shift-selection” state, which we would like to emulate.
On mouse selection, or a shift-motion command (such as Shift+Right), should set the region in shift-selection mode: We send Ctrl+Space to the client (setting the mark) at the “anchor” and move the cursor as needed. We also (locally to DomTerm) set the “shift-selection” mode. If when in shift-selection mode any (special) key is pressed without the shift modfier, then shift-selection mode is turned off, the selection is collapsed, and Escape - Ctrl+Space is sent to decativate the region.
Can do this lazily, so we only get the selection highlighting: On mouse selection or shift-motion command
It may be useful to load new JavaScript libraries into DomTerm.
We can do this when loading a DomTerm web-page, by
having the server add <script> elements to the
generated web page.
More flexible is do it dynamically:
domterm load-javascript "foo.js"
This works by essentialy doing createElement("script").
For this to be useful we need to better define the DomTerm JavaScipt API with extension hooks.
A useful extension library would be a plotting library. The Plotly looks powerful (and big), and controlled by a JSON-able data structure.
A "notebook" is a saved (and potentially executable) representation of a session.
IPython/Jupyter has a JSON encoding for "notebooks". This is flexible and extensible, but requires special tools. See also Polynote.
The DomTerm notebook format should just be a simple html page. Essentially a serialization of the DOM. The page may include some generated header information and metadata. It may include references to JavaScript that would allow former execution, as well as viewing actions (like hide/unhide, wrap-to-fit, etc). This references should be simple and relative, so the actual JavaScript loaded can depend on context.
The format must be XML-compatible (XHTML) so it can be parsed by XML tools such as XSLT.
Specific format TBD.
The html page must be viewable and look reasonable in a browser even if JavaScript library or style files are missing or JavaScript is disabled.
A notebook may be include additional resources in other files, such as images. If notebook consists of multiple files, they should be bundled in a zip archive (like LibreOffice does).
Tools to convert to and from Jupyter format would be nice, so we should avoid gratuitous conceptual incompatibility.
Detachable sessions (similar to GNU Screen and tmux) means that a front-end can disconnect from a session, while the session (child process) persists. The same or a different front-end can later re-attach to the session.
DomTerm implements detachable sessions using a combination of check-pointing the display state, plus having the backend recording output commands since last check-point.
This can can handle unexpected detaches, as when a connection dies. However, it’s a bit heavy-handed: check-pointing should only save parts of the state that have changed. (This gets a bit tricky when there may be multiple windows displaying the same session, combined with not-yet-implemented auto-trunctating of old output.)
See also Mosh (also LWN article), and EternalTerminal.
A DomTerm front-end can used used to display sessions running on remote backends. The challenge is having the remote sessions persist if connection is lost. Managing state for a detached session is handled by the domterm backend, which therefore needs to run remotely. However, the part that manages windows and commands needs to run locally.
The solution is to run the backend in proxy mode. Supposed the user types:
domterm [user]@host command
This can be implemented bying having the (local) backend do:
ssh [user@]host domterm --browser-pipe command
(A password may have to be requested.)
The --browser-pipe option is a special kind of browser-specifier:
Instead of output being sent to the browser, it is written to stdout;
input from stdin is (mostly) sent to the command.
(“Mostly” because the remote domterm processes certain
escape sequences. For example the "WS" sequences
is used to change the pty window size.)
The local domterm backend acts as a proxy for the remote backend.
It is also useful to be able to connect to a remote backend, directly from
a browser, without having to install a local domterm command.
That requires a remote https server, and has some more
permission and security complications.
Create screencasts, maybe using Peek, or Byzanz. Consider using key-mon (available on Fedora) to display clicks etc.