TGM Minima

TGM Minima is combination of text editor with extensive support for tagging and linking, and a minimalistic interface to the Maxima Computer Algebra System software, with a direct support for Gnuplot along with that.

TGM Minima is a script in Tcl/Tk, thus in principle multi-platform. It is developed and used under Linux, with a partial testing under Wine and ReactOS. This tool is available as is, under the GNU GPL 2+ licenses, without any warranty whatsoever. If having any suggestions, do not hesitate to contact me. Notice that Mixima is a python-wise counterpart of TGM Minima.

TGM Minima can run in two modes: inter mode, with Maxima backend run at interactive session, and batch mode, with Maxima backend run at batches. The inter mode is intended for Maxima-heavy use, while the batch mode is directed to editing-mainly work. When the TGM Minima script contains "inter", "batch" string in its name, the default mode is the inter, batch one, accordingly; otherwise the batch (at Wine/ReactOS), inter (elsewhere) mode is the default one. The inter/batch mode can be set by its startup option too.

Documents opened by TGM Minima have (by default) the ".twt" extension, meaning "text-with-tags" for the support of tags (and links) at TGM Minima documents. See the tagging part regarding the use of tags and links. Control-p, Control-n can be used for going between sections and computation blocks.
Text lines starting with %% are visually displayed as comments.

TGM Minima interface in the inter mode is based on two parts: upper part is taken as a free-form text (with maxima-code snippets included), the lower part is taken as a command window from where commands are sent to Maxima. When a part of UI (e.g. a widget) contains more subparts, like here the text and command parts, Control-, and Control-. can be used (besides just clicking) to jump between the subparts. Any (auxiliary) widget can be closed by pressing Escape; minimizing is commonly by Shift-Escape.

Sending commands to Maxima (and thus executing them if Maxima considers them as having correct syntax) is done via Control/Shift-Enter key combinations: Shift-Enter is for (sending command and) keeping the sent command at the command part, Control-(Shift-)Enter removes the sent command (the whole content) from the command part. Before the commands are sent to Maxima a basic check is done whether text strings, comments and brackets are correctly written/matched in the commands to be sent. And if the commands end by neither semicolon ";" nor dollar "$" sign, semicolon is added (unless Lisp mode is detected).

Along with that, the sent commands are put into history list. If it would happen (in the inter mode) that TGM Minima would fail to detect that Maxima has finished its current job, the command field can be unlocked (use mouse menu in such a case there).

The batch mode provides a separate batch widget instead of the (lower) command field. Command checking and (not) clearing of the command part is alike at the inter mode. Control-m/Control-M invokes the batch widget, the main part, respectively, in the batch mode. In the inter mode Control-m/Control-M can be used for focusing the command/text parts, respectively.

Notice that Control-m in the batch widget (when at batch mode and) when a batch is running, presents a tool for putting a text line into the running batch. This is aimed for cases when Maxima (running at a batch) asks a question. A menu that offers the line-insertion tool, or stopping the batch, can be shown by mouse menu-button click in the (upper) output batch part (while a batch is running) too.

In the following we mainly deal with the inter mode. Once (some) results from Maxima come back, both the command (by default) and results are put into the upper part (when at the inter mode). The exact placing depends on respective TGM Minima setting, see below the [s|v|e] setting. Unless set otherwise, the output is put by the line of cursor at the upper part if the cursor (at the upper part) is on an effectively empty line; otherwise it is put at the first available place, or to the end of the current section. It can be set for always in-place and always to-document-end placing too.

Unless set otherwise (see below), the insertion place is checked for being flanked by ~-lines that serve as tags for inner-computation blocks in the (upper) text part. Notice that when a Maxima command is taken as a selected part at the main (upper) text, its result can be set to get inserted by the cursor regardless of the above outlined setting (that is mainly for executing commands from the lower/command field).

In the batch mode, the commands are put to the end of the batch-output field; and (start of) the output from batches (that includes the input too, since Maxima works that way) can be put to the main text window too (if the command is executed from that main window instead of being started from within the batch widget). Notice that use of the prepend command (middle entry at the batch window) can be switched by Control-Tab when the middle entry is focused.

Notice that multi-command executing can lead to some result parts (of the latter commands) being delayed, and TGM Minima by itself starting to accept other commands. If in such cases user executes another command before the rest of Maxima outputs comes (just see whether your computer crunches something or not), the next-coming outputs are put into the upper part along with the new (not the previous) command.

If the system is with /proc part of filesystem (alike Linux), or if the system is alike ReactOS (and with TWAPI installed, that is suggested for Wine-like systems anyway), TGM Minima presents the current CPU usage by the used Maxima instance. That may be used as a label for seeing whether Maxima has finished its current job or not yet.

File-related operations are according to the top-left buttons: opening a file (Control-o), re-opening recently opened files (Control-O), read-only viewer with simple import of tabular data from TeX and PDF files (Control-r), linking widget for remote links (Control-l), simple versioning and export to html (Control-e/E), saving the text (Control-s; by default saving text from the main/upper part only), saving into a new file (Control-S).

The read-only viewer can be used e.g. for previewing results of remote-link searches, to choose a file to load. Plus it can read some tables (e.g. from PDF files, internally rendered by "pdftotext" tool when available) and form Maxima arrays from them.
The export widget has (besides exporting to html files) a limited support for versioning via copying to local ".prev" subdirectories. Changes between versions are taken by "diff" command (when available).

When in the inter mode, commands from the lower (command) part can be set for saving along the text from the upper (main) text part. The switch is done by Alt-m, and setting on is by Alt-M. When it is set on, the size grip (by the command part) gets greenish color. When in batch mode, Alt-m/M are used for setting to warn on quiting TGM Minima with non-empty fields in the batch widget.

Notice that many actions within TGM Minima are limited to such states of TGM Minima when no command is being currently executed by Maxima; and setting changes are commonly limited to situations when Maxima is not in (detected) Lisp mode either. Generally combinations of keys that are set for some actions can be found by seeking "bind" commands within the TGM Minima script. Closing of TGM Minima is done (along common closing of the application window) by Control-q.

Right off the file-wise buttons is setting (the circle) for remote links within the loaded document, and the search entry that can be used for local links (and for setting line length) too. Menu-button clicks on the circle (search entry) provide options for scanning (search) modes.

Detected state of Maxima is displayed at the middle of the top bar; and the window title contains name of opened file (if any) along with the (un)saved state. Clicking the status label (Alt-T) switches between file path, file name, directory path display in the window title; and clicks with control (and shift) puts the respective path string (with newline added) into clipboard.

Besides common cut/copy/paste (that is done by Control-x/c/v in within both main-text and command parts), Control-w, is bound for pasting (selected text) into the other part. When at the main text part, Control-w offers menu for copying. When at the command part (regardless wheter in inter or batch mode), Control-w copies into region by cursor and Control-W puts the selected part by the end of the main text, both follow ~-line enforcing according to setting for the command outputs. Control-Alt-w, Control-Alt-W variants do those upwards copying without ~-lines enforcing regardless of the setting.
Regarding the plotting widget, Control-w presents a menu for copying (here the whole content) into a file or into the main text part.

Undo/redo is by Control-z/Control-y for the part where cursor is active (Control-Alt-z/Control-Alt-y for the other part, when at inter mode).

Lines with (at least three) tilde letters, that is ~~~ strings, are taken as delimiters of blocks within the main/upper (text) part that contain code and outputs from Maxima. Double-click on an empty line (or Control-~ at any line) in the main/upper (text) part puts in such a ~-line. Notice that these lines can be continued by Tab on one or more characters; that is writing a single ~ character and pressing Tab key grows the line.

These blocks (started by ~-lines) are ended by ~-lines too or by (visually splitting) section lines that we introduce below. While it is not necessary to have such blocks in the (main/upper) text part at all, TGM Minima by default tries to keep both commands sent to Maxima and results received from Maxima within such blocks (in the main/upper text part).

The inner computation blocks (in the main/upper text part) can be highlighted in three ways: (i) filled whole blocks, (ii) ~-lines only, (iii) with sidewise stripes along the blocks. The third case requires a recent version of Tcl/Tk installed. Switching between these forms is by Control-\. The ~-lines themselves can be set hidden by Alt-h and by clicking the ~ label left off the top-right buttons. Notice that the hiding is blocked in cases where such a hiding of ~-lines could lead to confusion. That is namely in cases of: pairs of adjacent ~-lines, empty computation blocks, ~-line without a newline at the end of the text.

Visual splitting of the text in the main/upper part can be done by three types of lines: *-line, =-lines, #-lines, each consisting of at least ten (*, =, #, respectively) characters. These lines can be put in by mouse menu-button click while holding the shift key. These lines can be continued by Tab on starting parts of such lines alike it is for the ~-lines. Notice that these (that is *, =, #) lines end inner computation blocks, that is without any block-ending ~-line there (as advised above). Besides acting as visually splitting markers, these lines work as sort-of section lines when dealing with tagging: links to tags can be specified onto pairs of tags where the tag pairs can be required to be located within sections delimited by the lines introduced here (and/or by ~-lines).

The line with cursor is denoted by a (by default) grey highlighting, that turns blue within the computation blocks, and yellowish over the section lines. Minor alterations can be done as follows: The shade of the highlighting can be altered by Alt-\ for the main/upper (text) part, and by Alt-/ for the lower (command) part. These shades go through three saturations. Along with that, Control-/ switches on/off line numbering in the command part (at inter mode).

The lower part (that is considered to be a Maxima code) has highlighted comments and text strings. Pairing of corresponding brackets (outside comments and text strings) is visualized in the (lower) command part and jumping between them is by Control-b. Notice that TGM Minima tries to adjust its recognition of comments (in the command part) according to (detected) Maxima vs. Lisp mode.

Detection of being inside/outside comments and text strings in the main/upper part is by guessing only, since it is considered to contain a mix of free-form text and maxima code. By that, pairing of brackets in the main/upper part (and jumping between them, by Control-b too) employs just a simple guessing on presence of comments and text strings there. The Control-B action adds text selecting to the jumps.

Besides growing the ~-lines and section lines (see above), Tab without any key modifier have additional two actions: when the previous (meant just before the insert cursor) letters in a line end with a character that is ascii alphanumerical or underscore, TGM Minima considers it as a beginning of a name and tries to find a unique continuation of it within the names it has loaded previously (e.g. during TGM Minima startup, see below).

Names are considered to be based solely on ascii alphanumerical characters and the undersocre letter. If previous character is not ascii alphanumerical nor underscore (or just being at line start), by default 4 spaces are added (unless it is a case of a line continuation of ~-line or a section line, see above). Notice that regarding the name search, Shift-Tab confines to names of functions. Use of Tab key with control (plus possibly shift) is described below.

By default at inter mode, the known names are user functions and values defined already within first Maxima starting, that is at Maxima packages loaded at ini-scripts when TGM Minima itself is started. Notice that these names are not reloaded when Maxima is restarted during a TGM Minima session, though the names can be loaded again: by Control-u for functions, Control-U for values as seen by the respective lists in Maxima when the update is issued (here again without removal of the names already known within TGM Minima).
When at batch mode, the Control-u/U actions (for loading names of functions/values) have to be issued within the batch widget.

When at inter mode, then besides Control-u/U, the current-names loading is called by double-click in the command field with held control (for functions), or with held control and shift (for values) too.
Since these updates are done via commands to Maxima, they only work when no (other) command is being currently executed by Maxima, and when not being in Lisp mode either (that is alike for the other Maxima-based settings).

Names can be loaded from name-files (if set to be loaded by TGM Minima, see command-line parameters below) too. An example name file is prepared with names of functions and options of the common Maxima file input and output, along with a shell script that starts TGM Minima automatically with loading that file.

The known names can be used for offering lists with name completions. Control-Tab, Control-Shift-Tab are used for search (and display if found) of names that continue the beginning of word there. If many possible continuations are found, they are displayed: for Control-Tab in larger sets (at up to four columns) if the operating system allows such displays (otherwise in single-column way), for Control-Shift-Tab just in single-column subsets. Passing within the subsets (if amounts of continuing names were found) is e.g. by Control-Left, Control-Right. Then Left, Right are either for horizontal moving within multi-column subsets, or, in the case of single-column displays, for the subset passing alike Control-Left, Control-Right there.

Notice that these Tab-based searches, for both unique continuations and (non-unique) displays, are bound for words in both the upper and lower parts (in the inter mode), and for both the main text field and command input in the batch widget (in the batch mode).

Common text search (via the topwise entry) is done only for the main/upper text part. Text string to be searched has to be put into the top-bar entry; its focusing (leaving) can be done by Control-f (Escape). If a text is selected at a part, Control-F (while being at that part) sets the selected text as the search entry text (in the top bar).
Notice that Alt-c (when the search entry is focused) or clicking the search entry while holding the control key switches the search entry between search and setting mode.

Search can be done in next ways: case-insensitive (Enter), case-sensitive (Shift-Enter), regular-expression search (Alt-Enter); all when the (topwise) entry is focused.
Additionally, when the search entry contains a local link, Control-Enter/Control-Shift-Enter execute its search.

Found strings are marked by (greenish) background color, the first (if any found) following after cursor is selected. Going between the already found strings (without doing new actual search) is by Control-g/G: Control-g forwards, Control-G backwards. A simple replace/seek box (again only if some strings are already found) can be invoked by Control-h/H.

Tagging:

Organizing the "twt" TGM Minima documents, i.e. "text-with-tags" documents,
can be carried out in two ways:

1) by section lines (for text parts) and tilde lines (for computation blocks),
   where the sections/blocks are partitioned in a schematic way;
2) semantics is added by regular tags and links to them, where the tagging
   is for marking particular parts of text according to its meaning;

Tag forms: declared tags, links to local tags (i.e. within a document),
           links to remote tags (generally at other documents);

* declared tags: [#tag_type:tag value]
tag types: simple word-like, allowed chars: a-zA-Z0-9_
tag values: a more-free form, with next restrictions:
            without any nesting of (links to) tags, without \ { } letters,
            and [] () "" only allowed when simply (without nesting) pair-matched.
* local links: [@tag_type:(part of) tag value]
* remote links: [@...dir_part.../...glob_part...\tag_type:(part of) tag value]

Use of tags:

Section lines (*/=/#-lines) are mainly for schematic delimiting of parts of documents,
and tilde-lines alike schematically delimit parts with code and computation outputs.
Tags add contextual labeling into the "twt" TGM Minima documents.

The 'doc(ument)' and 'top(ic)' types are used as helpers for document saving and exporting.
Then the 'sec' type is supposed to serve for (sub)sections, like:
[#sec:/part/subpart/subsubpart] etc.

Links to tags can be both within documents, i.e. local tags:
using @ instead of # (and without the directory/glob part put in),
and between documents, i.e. remote tags:
with 'dir/glob\' part added in between link start (again by @) and the linked tag;
here dir can be both relative and absolute ('~/subdir' can be used for starting the dir
from home directory), and glob can contain the '*' wildcard character.
If using drive spec in the dir part, it has to be preceded by slash, like: /Z:/dir

When ':' char is put at the dir part start, it tries several upward (three by default)
directories when looking for the files (with tags); the testing count can be specified.
E.g. [@:2/name_start\sec:some] looks for files with names starting by "name_start"
in the current and two upwards directories (checking [#sec:some*] tag presence there).

The ':' or ':number' specifier can be used by the end of the glob part (before \) too.
There it is for testing files in subdirectories (':' is for three subdirs by default).
In such a case and when the glob itself is specified, the glob filters:
* either (by default) the onset subdirectories (along the files on the same level),
* or (if search got started with Shift held) the final nodes, that is the searched files.

The search is restricted to *.twt files, and possibly (if set so) to *.txt files too.

Matching is done case-insensitive for tag names (filesystem part in remote links
depends on the ways of operating systems). And comparisons among links and tags
is (by default) limited to the extents put into the links: [@sec:some] links to
[#sec:some], [#sec:some section], etc. This can be changed by adding '=' to link
ends (where the added '=' is only used for declaring the non-limited comparisons),
and similarly a trailing '*' is considered to explicitly state the limited
(that is default) way of comparisons.

The '*' wildcard can be put at the tag type end too (that is just before the ":" char).
Thus e.g. both [@*:*] and [@*:] links look for all tags within the loaded document.

The '*' wildcard is put automatically to the end of glob part, thus e.g. [@./\sec:some]
looks for [#sec:some...] at all TGM Minima documents in the directory where the current
document is located. If '=' is put to the glob end, the '*' is not added there.

Up to two tag parts can be put in links, separated by \ or \\: requiring tags of both
specs to be present in the searched document, and tags of the second tag spec are shown.
The \\ inter-tag connective allows tags of the two specs being wherever in documents,
while the \ inter-tag connective requires occurrences within the same (sub)sections;
(sub)section nesting goes as "# > = > * > ~" and by section-line lengths then;

Thus e.g. the [@tag:some=\*:*] link looks for all tags at all document sections
(delimited by section lines) where the [#tag:some] tag is located.
Recall that sections for tag pairs are defined by the section/tilde lines,
that is not by possibly present tags with "sec" type.

Following a link to its target can be done by:
* Control-Enter and Control-Shift-Enter if it is not bound for command executing,
* Control-j (Control-Alt-j/Control-J), these are set solely for links-to-tags following,
* Control-Double-click and Control-Shift-Double-click (when at text) can be used too.

Use of Shift (and upper-case J, or j with Alt) in link following is for:
* starting the search upwards at local links,
* use of glob at end of the downwards sub-directory scans (if it is set).

Local links can be followed from the search entry too, by Control-(Shift)-Enter.
Remote links are followed via the Linking widget (opened by Control-l).

Notice that Control-[ Control-] are for lists of tags, links to tags, respectively,
Control-@ provides list of possible (local) links to tags present in the document.

Highlighting is by Control-{ Control-} for tags, links to tags, respectively,
Control-# is for highlighting all the links/tags in the document.

When a tag has type "img" or "gpl", tag values are considered to be paths to the respective files. Then Control-t/T action on it opens the image (for "img" tag type), runs gnuplot script (for "gpl" tag type).
Regarding the "img" tag type, i.e. tags like [#img:path/to/image.png], the image (if found, and if it is a PNG or GIF figure) is put into the text along the tag.
Regarding the "gpl" tag type, i.e. tags like [#gpl:path/to/gnuplot/script], the script is run with its print output redirected via netcat (if available) back to TGM Minima.

Additionally to the "img" and "gpl" tags, a partial support for direct opening of http links, images and gnuplot scripts is via double-click to URLs (for http links), or paths to (image/plotting) files in the (main/upper) text part. This search is executed when control (and shift) keyes are held during the double click.
Regarding opening local files, double-click with held both control and shift does path search in both directions from the clicked place (going over directory delimiters in both ways); double-click with only control held considers the clicked place as a top region of the searched path (going upwards to a first directory delimiter only). These two above ways do not support spaces (nor special characters) in the paths by default. If dealing with paths (to images and gnuplot scripts) that have spaces inside, such paths have to be enclosed in quotation marks (",') to be recognized.

If the found path is relative, it is considered to be relative to the directory of the currently open file (or of the last open file, if no file is currently open). Notice that a single tilde ~ letter can be used for denoting the home directory.
Recall that regarding the (lower) command part in the inter mode, instead of dealing with paths, there the double-clicks with control (and shift) held are for updates of names (of functions, values) into the dictionaries for keyword finding.

If no path is recognized in double-clicks with control (and shift), the clicked text is considered to be tag link, that is an attempt to follow a link is done then. Regarding tagging and linking generally, see the tagging part above.

When at the batch mode, "tag bar" is provided below the main text part. Actions on the tag bar (at the bottom of the main window) when it is focused, for declared tags (links to tags) when at left-hand (right-hand) part of the bottom bar:
Forwards and leftwards arrows are used for sliding over tags just within the bar, that is without any actions within the document.
Tab (Shift-Tab) slides over tags forwards (backwards) along with highlighting the tags at document.
Control-(Shift-)Tab are for lists of tags, alike Control-[ Control-] at document.
'Enter' locates and highlights the current (link to) tag at the document,
'Shift-Enter' locates tags in a complementary way: from document location to the bar.
'Control-Enter' (and similarly 'Control-Shift-Enter') locates tags at document, with focusing the text (and putting the cursor at the located link/tag).
'Alt-Enter' highlights all (links to) tags in the document; Control-g/G can slide over the highlighted (links to) tags then.

The rightmost buttons at the top bar (in the inter mode) are, from right: '?' for showing simple help info (Control-?), '!' for restarting the Maxima backend (Control-I), 'X' for interrupting Maxima execution (Control-i, via sending console-based Control-C key stroke to Maxima; this requires Tcl with TWAPI installed if run under ReactOS-like systems). Notice that Control-K is for quiting Maxima. The 'ยง' button is for showing history of executed commands (Control-').

The ';' button (Control-;) is for prepared commands that can be put into any writable part. Enter, Control-Enter is for inserting shorter, longer version, respectively. When used along with Shift, it adds trailing newline to (multi-line) text fields, and erases the current content at (single-line) text entries.
Reading of user-specified commands can be done at startup via use of the --cmd-path=<file> parameter. See the commands_example.txt file for an example how to specify the commands.

The left-most button (in the top-right corner) is for Gnuplot-based plotting widget (Control-d); Shift-Enter, Control-Enter in there sends commands to Gnuplot without restarting it, with restarting it, respectively.
Click the mouse menu button within the 'Data' tab at the plotting widget to get help on the auxiliary dealing with data for plotting. The plotting widget is available (and its button is present) both in the inter-mode and batch-mode forms of TGM Minima.

When in batch mode, a 'Σ' button (Control-m) is for the batch widget. The 'X' button provides both Maxima interrupting and stopping (when Maxima is connected) under the batch mode.

The circle left off the right-wise buttons is for setting the use of additional key bindings at Gnuplot (when run via Maxima). In the plotting widget, those bindings can be set for Gnuplot run directly too. Help in the plotting widget contains description of these additional bindings. Notice that menu-button click provides a menu with description of the setting modes; it is alike for the other settings around there too.

Then several labels with settings for display within TGM Minima and for Maxima lines and labels are to the left from the rightmost circle label. They are in inter mode, from right:
'~' for showing/hiding ~-lines (alt-h) that is already introduced within the text above,
's' / 'v' / 'e' for specifying where to put the Maxima outputs within the (upper) text part (Alt-`, Alt-~);
's' is for in-situ placing, that is always by the cursor in the (upper) text part,
'e' is for placing at the end, regardless of position of insert cursor,
'v' for volatile placing: by the cursor if it is at effectively empty line (empty line or line with spaces, or ~-line), at an available place otherwise.

'a' is for switching on/off automatic enforcing of computation blocks for commands and outputs that are put into the (upper) text part (Alt-a). With this set on, TGM Minima assures that the outputs (and commands) that are pushed into the (upper) text part, are put into the blocks based on ~-lines (within the upper text part). Notice that TGM Minima tries to avoid adjacent ~-lines. Thus when this option is switched on (default unless respective command-line parameter is used), and when the setting for placing (see below) directs to a region around a computation block, TGM Minima puts the respective Maxima outputs into those adjacent blocks in the (upper) text.

';;' for attempts to ensure lines ending with semicolon even within blocks of several lines (Alt-;, this is for simple sets of lines only)
'i' for putting the input (that iss Maxima commands) into the main text along with outputs from Maxima (Alt-i)
't' for showing elapsed times after commands (Alt-t, 'showtime' Maxima variable, this is actually set still for true, and just filtered out if unselected here),

Notice that settings due to the next labels (still at the inter mode) are done via sending respective commands to Maxima. And it is only done when Maxima is connected, and when not being in Lisp mode.

'^'/'**' for display of exponents (in outputs in 1D display) as ^ or ** (Alt-^)
'b' for labels binding (Alt-b, negation of 'nolabels'),
'%' for showing input/output labels (Alt-%, set by Maxima internal '*display-labels-p*' variable),
Notice that when input/output labels are shown, and if multiple commands are sent to Maxima for executing at once, TGM Minima filters out the input labels that Maxima returns in between the respective multiple results.

'<-1' / '<:1' / '<|1' / '<|2' / 'c|2' / '(λ)' for setting the Maxima display line form (via Maxima 'display2d', 'leftjust', 'linel' properties). The used cases correspond respectively to:
(i) one-dimensional, left-adjusted, long lines,
(ii) one-dimensional, left-adjusted, long-but-split lines,
(iii) one-dimensional, left-adjusted, short lines,
(iv) two-dimensional, left-adjusted, short lines,
(v) two-dimensional, centered, short lines,
(vi) inner Lisp forms get displayed (this may help if at debugging).

When at batch mode, the '~' and 'a' options are availabel alike at the inter mode.
Then if selections are used for maxima commands, the next option: '^' / '**' / 'r^' / 'r' is for mangling the outputs of the batches;
it can set exponents with ** (Alt-^, instead of ^) and/or to apply ratsimp (Alt-r).

't' and ';;' are again alike at the inter mode,
and 'x' / '+' / '!' is for stopping Maxima, letting Maxima, letting Maxima with some cleaning applied, respectively, after the ends of batches.
If outputs from batches are targeted to the main field too, the left-most option there '(count)' sets the maximal count of lines per batch allowed to be inserted there.

The options present at the batch widget are already described above, with the display setting allows TeX output too, and the maximal count of lines (per batch) is for the all lines, that is not only those put into the main text field (that only works when a batch is triggered from the main text field).
Notice that when the count of lines outputted from a batch (incl. the command lines themselves) goes over the maximal allowed line count, the batch is stopped (to limit issues with gone-wild batches).

TGM Minima supports spell-checking (via aspell, hunspell, ispell) of selected text in the main/upper part. Spell-checking can be started via Control-(Alt)-! (the alt key changes permissiveness on use of concatenated words), or from menu that is shown on mouse menu-button click with shift held when some text is selected.

TGM Minima admits next command-line options:

    --1dim-long
        Maxima run with leftjust:true, display2d:false, with non-split
        (quite) long lines (the default way gets the lines split)
    --1dim-short
        Maxima run with leftjust:true, display2d:false,
        short lines (default has long/split lines)
    --1dim-split
        Maxima run with leftjust:true, display2d:false,
        (quite) long lines where the output gets split (with backslash)
        by the line size of the (set) short lines though, this is default
    --2dim-center
        Maxima run with leftjust:false, display2d:true, short lines
        (default is leftjust:true, display2d:false, long/split lines)
    --2dim-left
        Maxima run with leftjust:true, display2d:true, short lines
        (default is with display2d:false, long/split lines)
    --allow-maxima-setting [batch-mode only]
        allows to use Maxima-setting commands that change the Maxima
        setting that is done by TGM Minima (default is to disallow it)
    --backup-on-save=[tilde|none]
        if "tilde", a save action to an already existing file moves
        the current (that is before the saving) file content to a file
        that gets ~ at the end of its name
    --batch-end=[clean|quit|wait] [batch-mode only]
        when a batch finishes, the Maxima process is ended for the "quit"
        case; otherwise left running for faster onset of next batches;
        the "clean" case does (some) cleaning before starting a new batch
    --batch-mode
        the Maxima backend used via batches only
    --batch-prepend-command=<string> [batch-mode only]
        sets default command that is put into starts of Maxima batches
        (when TGM Minima run in batch mode)
    --batch-prepend-disabled [batch-mode only]
        the prepended command (if set, in batch mode) set to not be
        used by default
    --batch-prepend-enabled [batch-mode only]
        the prepended command (if set, in batch mode) set to be used
        by default
    --batch-prepend-ini [batch-mode only]
        the prepended command (if set and enabled, in batch mode)
        set to be used within initializations, that is without being
        shown in batch output
    --batch-prepend-regular [batch-mode only]
        the prepended command (if set and enabled, in batch mode)
        set to be used along other commands, that is being shown
        in batch output
    --bind-labels
        Maxima run with nolabels:false (default is nolabels:true)
    --block-mode=[fill|line|side]
        fill: inner-computation blocks in the text part shown with
              background color; this got the default mode
        line: only the delimiting tilde-lines of the inner-computation
              blocks in the text part shown with background color
              (unless being hidden)
        side: the inner-computation blocks in the text part shown with
              sidewise stripes (requires Tcl/Tk version 8.6.6 or newer)
    --buttons-figs
        buttons display figures (when figures are set for them, mostly
        buttons at the main window only, default)
    --buttons-text
        buttons display text/letters only, that is not displaying figures
        (default is to display figures when such are set)
    --clipboard-forcing=<path>
        <path> provides a program that (externally) enforces storing
        of clipboard content so that it survives end of TGM Minima session
        (x11 flavor of Tk does not enforce such a clipboard duration)
    --clipboard-selection [X11 version only]
        Tk-internal option for X11 version, allows clipboard retention
        via direct communication with GNOME clipboard manager, this has
        issues for pre-8.6.8 Tcl/Tk (used by default on newer Tcl/Tk)
    --clipboard-selectionless [X11 version only]
        Tk-internal option for X11 version, disallows direct communication
        with GNOME clipboard manager since it has issues for pre-8.6.8 Tcl/Tk
        (this option is default for pre-8.6.8 Tcl/Tk)
    --cmd-path=<file>
        file with prepared commands; this option can be used several times
    --cmd-view=[common|user]
        the default part at the prepared-commands window
    --command-lines [inter-mode only]
        shows line numbers in the command part by default
    --command-size=<integer> [inter-mode only]
        height of the (lower) command part: valid values from 6 to 30
    --command-select-only
        to only use selected ranges in command field to send them (under
        Control/Shift-Enter actions) to Maxima as actual commands
        (default is selections-if-any, otherwise the whole command field)
    --command-select-whole
        to use selected ranges in command field if any present, otherwise
        the whole command field for sending to Maxima as actual commands
        (this way is the default one)
    --command-whole-only
        to only use the whole command field (regardless of possibly selected
        ranges in there) to send them (under Control/Shift-Enter actions) to
        Maxima as actual commands (default is selections-if-any, otherwise
        the whole command field)
    --default-ft-txt
        using ".txt" (instead of ".twt") as the default suffix for TGM
        Minima files; notice that this makes tag searches (that is linking)
        more computationally intensive
    --default-ft-twt
        using ".twt" (this is default) as the default suffix for
        TGM Minima files
    --diff-unified
        to show diffs (at the export widget) in the unified format by default
    --disallow-maxima-setting [batch-mode only]
        does not allow to use the Maxima-setting commands that change
        those Maxima settings that are done by TGM Minima (this is default);
        notice that allowing is possible for the batch mode only
    --display-adjust-[none|exp|ratsimp]
        applies modifications for display: "exp" for a**b instead of a^b,
        "ratsimp" applies the ratsimp() function [this for batch-mode only]
    --exclude-input [inter-mode only]
        to not put the sent commands alongside the results return by Maxima
        (default is to include input)
    --file-open=<file> [batch-mode only]
        text file that gets opened at the end of TGM Minima startup
    --gnuplot-bind-print
        to print out commands for additional bindings for Gnuplot
        that are prepared for use at the TGM Minima software
    --gnuplot-bind=[no|yes]
        to set the added bindings (Gnuplot's bind command) for gnuplot
        by default (this is for cases when Gnuplot is used directly)
    --gnuplot-bind-mxm=[no|var|pre|post]
        to set the added bindings (Gnuplot's bind command) for gnuplot
        when Gnuplot is used via Maxima
        no:   to not set it at all
        var:  set as "gnuplot_bindings" variable at Maxima
        pre:  set as the variable and added to gnuplot_preamble option
        post: set as the variable and added to gnuplot_postamble option
    --gnuplot-path=<path>
        path for Gnuplot when used directly, that is not via Maxima
        (default is to use Gnuplot in the PATH environment variable)
    --help
        displays this help
    --hide-codetags
        hides tilde-lines that delimit inner-computation blocks in the
        text part; unless such a hiding would obscured the (ends of)
        affected computation blocks
    --hide-labels
        Maxima run with --very-quiet option (default), that is the
        Maxima input/output line-wise labels are not displayed
    --include-input [inter-mode only]
        to put the sent commands alongside the results return by Maxima
        (default); notice that batches display both input and output
    --inter-mode
        the Maxima backend used at interactive session
        (displayed at a stacked user interface)
    --last-dir=<directory>
        <directory> used as the directory for the first file save
        or open actions (default is working directory)
    --license
        shows license information
    --line-size=<integer>
        length of the short (and split) lines; notice that only taken
        if between 40 and 200 chars (default is 90)
    --linked-tags-with-link
        (local) tag links get highlighted (along with the linked tags)
        when a linking is executed (this is default), allowing jumping
        back to the links (if the linking is local)
    --linked-tags-without-link
        tag links are not highlighted when a linking is executed
        (that is, only the linked tags get highlighted)
    --lisp-options=<string>
        a string passed to the Maxima's Lisp engine (like stack size)
        if some special Lisp setting is required (commonly not set)
    --lisp-path=<path>
        path to the used Maxima's engine Lisp; this requires to set
        path to non-executable Maxima core too: see --maxima-load-path
        this is for cases when Maxima is run without use of the
        maxima.sh/bat shell/batch startup scripts
    --logging=[all|maxima|maxima-input|maxima-output|maxima-status
        |minima|minima-status|none]
        for outputting the inner TGM Minima-Maxima communications
    --logging-limit=<integer>
        to only output an initial part of the logging
    --make-line-endings
        attempts to add semicolons to line ends;
        meant to be use for sets of simple lines only
    --maxima-exec-path=<path>
        path to the executable Maxima core (for e.g. GCL-backed Maxima);
        this is a counterpart to the --lisp-path / --maxima-load-path
        options;
        notice that these options are for cases when Maxima is run
        without use of the maxima.sh/bat shell/batch startup scripts
    --maxima-init=<file>
        tells Maxima to use <file> as the initialization file:
        via "--init-mac=<file>" when detected maxima suffix (like .mac)
        via "--init-lisp=<file>" when detected lisp suffix (like .lisp)
        via "--init=<file>" otherwise
    --maxima-load-path=<path>
        path to non-executable Maxima core (for e.g. SBCL-backed Maxima);
        this is used along with --lisp-path option (auch a pair baing
        a counterpart to the --maxima-exec-path option);
        these options are for cases when Maxima is run without use
        of the maxima.sh/bat shell/batch startup scripts
    --maxima-path=<file>
        uses <file> as the Maxima backend ("maxima" by default)
        alternatively Maxima can be run with use of --maxima-exec-path
        option or --lisp-path / --maxima-load-path options;
    --maxima-userdir=<directory>
        tells Maxima to set <directory> as the maxima_userdir directory
    --maxima-version=<string>
        tells to the Maxima startup script (if that is used)
        to use Maxima of the specified version
    --omit-autotags
        to not insert tilde-lines (for delimiting inner-computation blocks)
        when output is put into the text part outside inner computation
        blocks (default is to assure inner-computation blocks)
    --output-placing=[s|v|e]
        s: forcing the outputs in situ in the text part
        v: outputs on (effectively) empty lines kept in situ,
           otherwise put to the end (this is default)
        e: forcing the outputs to the end of the text part
    --plot-focus=[not|half|one|two]
        whether to (try to keep) focus at the TGM Minima plot widget after
        plotting, in seconds: 0s, 0.5s, 1s, 2s (maximally);
        notice that it does the (re)focusing only once per plotting
        (unless the --plot-focus-full option is set)
    --plot-focus-full
        whether to (try to keep) focus as set by the --plot-focus
        option for the full specified time; this is the opposite
        to do the (re)focusing just once per plotting
    --plot-topmost
        whether to set the plotting TGM Minima widget as top-most window,
        thus being kept over the Gnuplot output (if operating system
        allows it)
    --plot-select-only
        to only use selected ranges in plot widget to send them (under
        Control/Shift-Enter actions) to Gnuplot as actual commands
        (default is the --plot-select-whole way)
    --plot-select-whole
        to use selected ranges in the plot widget if any present,
        otherwise the whole text in plot widget for sending to Gnuplot
        as actual commands (this way is the default one)
    --plot-whole-only
        to only use the whole text at the plot widget (regardless of
        possibly selected parts in there) to send them to Gnuplot
        as actual commands (default is the --plot-select-whole way)
    --read-stderr [inter-mode only]
        reads maxima stderr (default is "2>/dev/null") and puts it into
        the content of the "history" widget (useful e.g. for debugging);
        notice that this option switches itself off under large stderr load
    --save-commands [inter-mode only]
        to save commands (along with the main-text content) by default
    --sbcl-home=<path>
        sets the SBCL_HOME environment variable
    --scan-all
        to scan in all specified directories, regardless whether they
        contain any ".twt" file (default is to do the restriction)
    --scan-txt
        to scan ".txt" files by default (along with ".twt" files)
        when searching for external tags
    --section-line-border=<integer>
        sets how pronounced should section lines be (default is 1)
    --set-warning-batch [batch-mode only]
        sets warning on non-empty batch parts at TGM Minima exit
    --set-warning-import
        sets warning on non-empty import parts at TGM Minima exit
    --set-warning-plot
        sets warning on non-empty plot parts at TGM Minima exit
    --set-warning-startup
        admits warning at TGM Minima startup for exceptional conditions
    --set-warning-tools
        sets the exit warnings for batch, import, plot parts
    --show-labels
        Maxima run with --quiet option (default is Maxima run
        with --very-quiet option), that is the Maxima input/output
        line-wise labels are displayed here
    --spell-ascii-only
        sets spell-checking for ASCII characters only
    --spell-concat-permissive
        spell-checking tends to admit concatenated words
    --spell-concat-restrictive
        spell-checking tends to prohibit concatenated words
    --spell-path=<path>
        path to the used spell-checker (aspell/hunspell/ispell)
    --system-clock-ticks=<integer>
        an inner value used for CPU usage tracking (default 100),
        should equal to output from the next command:
        python -c 'import os;print(os.sysconf("SC_CLK_TCK"))'
    --tab-size=<integer>
        size of tabulator (in spaces), value limited to 1--10 sizes
    --text-batch-action=[batch-inout|batch|plot|none] [batch-mode only]
        sets Control/Shift-Enter actions on selected text (in the main
        widget) at the batch mode:
        "batch-inout" for using for Maxima batches with output put
        back to the main widget, "batch" for use for Maxima batches
        too, though the output kept in the batch widget only,
        "plot" for using the selection for plotting via Gnuplot,
        "none" for no command-wise action (i.e. left for linking)
    --text-inter-action=[selection-only|selection-command|command-only|none]
      [inter-mode only]
        set the Control/Shift-Enter actions if triggered in the main
        widget (when TGM Minima is run at the "inter" mode), that is
        above the command field:
        "selection-only" for commands only executed from selected text
        there (that is at the main field above the command field),
        "selection-command" for commands executed from selected text
        in the main field if any text selected there, otherwise the same
        as if the triggering done at the command field,
        "command-only" for acting as if the triggering done at the
         command field
    --text-inter-output=[along|set] [inter-mode only]
        sets where to place the (in/out)put when Maxima commands
        are taken from text selection at the main text widget
        (that is above the command field) at the interactive mode:
        "along" is for placing by the selected text, "set" is for
        placing as if the command where run from the command field
    --temp-dir=<directory>
        sets the temporary directory that is (for some actions) used
        by both TGM Minima and Maxima
    --unbind-labels
        Maxima run with nolabels:true (default)
    --unset-warning-batch [batch-mode only]
        sets warning on non-empty batch parts at TGM Minima exit
    --unset-warning-import
        unsets warning on non-empty import parts at TGM Minima exit
    --unset-warning-plot
        unsets warning on non-empty plot parts at TGM Minima exit
    --unset-warning-startup
        disables warning at TGM Minima startup for exceptional conditions
    --unset-warning-tools
        unsets the exit warnings for batch, import, plot parts
    --use-lisp=<lisp>
        Maxima run with the <lisp> implementation: --lisp=<lisp>
        (the <lisp> implementation has to be available)
    --use-wish=<path> [for shell only]
        Maxima run with the specified wish Tcl/Tk interpreter
    --version
        displays TGM Minima version
    --with-eval-time
        to display evaluation time (as provided by Maxima) along with
        outputs (default is to not display it)
    --with-linked-tags-count
        to display the count of found tags on linking, if more than
        one tag was found (default is to not display this information)
    --with-names=<file>|<directory>
        loads names from <file> or from files in <directory> for
        name-completion within TGM Minima (this can be used multiple times)
    --without-eval-time
        to not display evaluation time along with outputs (default)
    --without-linked-tags-count
        to not display the count of found tags on linking, even if
        more than one tag was found (this is default)
    --without-names-functions
        does not load names from "functions" Maxima list for name-completion
        within TGM Minima (default is to load it during TGM Minima startup)
    --without-names-other [for shell only]
        does not load names from /usr/local/share/minima/names path
        for name-completion within TGM Minima (default is to load
        files in the directory during TGM Minima startup)
    --without-names-values
        does not load names from "values" Maxima list for name-completion
        within TGM Minima (default is to load it during TGM Minima startup)

TGM Minima website: minima.tangloid.net