Planned improvements (without any promises or timeline), from higher priority to lower.
Polish paging/pausing and update documentation.
Polish and finish remote-ssh facility. Get auto-backup implemented.
Continue converting lws-term to make better use of C++.
Do line-breaking lazily.
Implement “infinite lines”: Escape sequences or mode so application
(or library like
readline) can ignore line-length,
soft line-breaks, and window resize. This will also allow
Bundle documentation and add command to browse it. Use a zip file, with compressed images (with link to full images on website).
Port backend to native MS-Windows (without WSL).
Improve integration for selected applications: fish and other shells. Nushell. Mutt email client (handle html). Info reader replacement supporting html.
Open a text editor in a pane. Probably either Monaco or CodeMirror 6.
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
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
True if endTRows is valid. Cleared if controlling window is re-sized.
True if endTRows is valid. Cleared if current window is re-sized.
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).
outputAtEnd: If output cursor at end of logical line
(possibly nested in style-span or pprint-group).
outputAtEnd just append the current line.
(Note a deferred line-break may overwrite following lines.)
rebreakNeeded on all lines.
On all likes that might becomes visible,
measureNeeded call unbreakLines, then breakLine1 (to measure).
Custom window decoration (including possible “hamburger menu”) could reduce some wasted vertical space. Consider how it works with panes and tabbars. Here is how it can be done with Qt.
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.
src attribute of
<img> is a relative URL
(or optionally a
file: URL), then
domterm html command should read the file
and embed it as a
(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
<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.js (formerly node-webkit).
Seems to have slightly lower resouce usage than Electron,
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.
Similarly, when running under a tiling window manager using the latter to manage panes and tabs is likely preferable.
Atom packages are in
Seemingly helpful tutorial:
Enhance the Paging mode so it is a more general View/Copy mode. An important feature is being able to set and modify the selection without using a mouse. See Windows Terminal issue; tmux copy mode; iTerm2 copy mode.
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
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:
This works by essentialy doing
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.
The format must be XML-compatible (XHTML) so it can be parsed by XML tools such as XSLT.
Specific format TBD.
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.)
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:
This can be implemented bying having the (local) backend do:
(A password may have to be requested.)
--browser-pipe option is a special kind of window-specifier:
Instead of output being sent to the browser, it is written to stdout;
input from stdin is (mostly) sent to the
(“Mostly” because the remote domterm processes certain
escape sequences. For example the
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
That requires a remote
https server, and has some more
permission and security complications.