Leo’s minibuffer appears at the bottom of Leo’s main window. You use the minibuffer to execute commands by name, and also to accumulate arguments to commands.
Every Leo command has a command name. In this document, keystrokes that invoke a command will be followed by the command name in parentheses. For example, Ctrl-S(save-file) saves a Leo file.
Very Important: Leo has hundreds of commands, but because of tab completion you do not have to remember, or even know about any of them. Feel free to ignore commands that you don’t use. The following prefixes help find commands by name:
Very Important: Leo has hundreds of commands, but because of tab completion you do not have to remember, or even know about any of them. Feel free to ignore commands that you don’t use.
You could type the full command name in the minibuffer, followed by the <Return> key to invoke the command, but that would be way too much work. Instead, you can avoid most typing using tab completion. With tab completion, there is no need to remember the exact names of Leo’s commands.
For example, suppose you want to show the list of Leo’s commands. You might remember only that there are several related commands and that they all start with “print”. Just type <Alt-X>showTab>
You will see show- in the minibuffer. This is the longest common prefix of all the command names that start with show. The Completion tab in the log pane shows all the commands that start with show-.
Now just type c<Tab> You will see the print-commands command in the minibuffer.
Finally, <Return> executes the print-commands command. The output of the print-commands command appears in the commands tab, and focus returns to the body pane.
Prompts for a filename. This command completes the name of files and directories as in command completion. As a result, this command can be very fast. You may want to bind this command to Ctrl-O instead of the default open-outline command.
Exits Leo. Leo will prompt you to save any unsaved outlines.
A session specifies a list of .leo files that Leo opens automatically when Leo first starts. Leo will reload the last session provided that command-line arguments don’t contain any file names.
You may select, expand and contract outline nodes with the mouse as usual, but using arrow keys is highly recommended. When focus is in the outline pane, plain arrows keys change the selected node:
Right-arrow(expand-and-go-right)
Expands a node or selects its first child.
Left-arrow(contract-or-go-left)
Contracts a node if its children are visible, and selects the node’s parent otherwise.
Up-arrow(goto-prev-visible)
Selects the previous visible outline node.
Down-arrow(goto-next-visible)
Selects the next visible outline node.
Regardless of focus, Alt-arrow select outline nodes:
Alt-Home(goto-first-visible-node)
Selects the first outline node and collapses all nodes.
Alt-End(goto-last-visible-node)
Selects the last visible outline node and collapses all nodes except the node and its ancestors.
Alt-arrowkeys
Select the outline pane, and then act just like the plain arrow keys when the outline pane has focus.
This section explains how to use Leo’s standard search/replace commands.
Note: you can also use the Nav Tab (in the Log pane) to search for text.
Ctrl-F(start-search) shows the Find Tab and puts the focus in the text box labeled Find:.
Aside: You can select radio buttons and toggle check boxes in the Find Tab with Ctrl-Altkeys. The capitalized words of the radio buttons or check boxes indicate which key to use. For example, Ctrl-Alt-X(toggle-find-regex-option) toggles the regeXp checkbox.
After typing Ctrl-F, type the search string, say def, in the text box.
Start the find command by typing <Return>.
But suppose you want to replace def with foo, instead of just finding def.
Just type <Tab> before typing <Return>. Focus shifts to the text box labeled Replace:.
Finally, type <Return> to start the find-next command. When Leo finds the next instance of def, it will select it.
You may now type any command. The following are most useful:
Ctrl-minus(replace-then-find) replaces the selected text.
F3(find-next) continues searching without making a replacement.
F2(find-previous) continues the search in reverse.
Converts @rst nodes to restructured text. This command automatically creates underlining for rST sections. To reorganize a document, just reorganize the corresponding Leo outline: you don’t have to change markup by hand. Search or “rst” in leoSettings.leo to see the pertinent settings.
adoc
Converts @adoc nodes to asciidoc text. This command automatically creates markup for asciidoctor sections. To reorganize a document, just reorganize the corresponding Leo outline: you don’t have to change markup by hand.
The clone find commands, cfa and cff are extraordinarily useful. These commands move clones of all nodes matching the search pattern under a single organizer node, created as the last top-level node. Flattened searches put all nodes as direct children of the organizer node:
cfaclone-find-allcffclone-find-all-flattened
The clone-marked commands move clones of all marked nodes under an organizer node. Especially useful for gathering nodes by hand:
The check-nodes command finds dubious nodes, that is, nodes that:
contain multiple defs.
start with leading blank lines.
are non-organizer nodes containing no body text.
This command is specially useful when using @clean nodes in a collaborative
environment. Leo’s @clean update algorithm will update @clean nodes when
others have added, deleted or moved code, but the update algorithm won’t
assign changed code to the optimal nodes. This script highlights nodes that
needed attention.
Settings: You can customize the behavior of this command with @data nodes:
@datacheck-nodes-ok-patterns
The body of the @data node contains a list of regexes (strings), one per
line. This command compiles each regex as if it were a raw string.
Headlines matching any of these compiled regexes are not considered
dubious. The defaults ignore unit tests:
.*test_.*Test
@datacheck-nodes-ok-prefixes
The body of the @data node contains a list of strings, one per line.
Headlines starting with any of these strings are not considered dubious.
The defaults ignore top-level @<file> nodes and marker nodes:
@**==--
@datacheck-nodes-suppressions
The body of the @data node contains a list of strings, one per line.
Headlines that match these suppressions exactly are not considered
dubious. Default: None.
Shows a help message appears in the viewrendered pane. Alt-0 (vr-toggle) hides or shows this pane.
F11(help-for-command)
Shows the documentation for any Leo command. F11 prompts for the name of a Leo command in the minibuffer. Use tab completion to see the list of all commands that start with a given prefix.
F12(help-for-python)
Shows the documentation from Python’s help system. Typing completion is not available: type the full name of any Python module, class, function or statement.
These commands clarify which settings are in effect, and where they came from:
Start a Leo’s integrated debugger in a separate thread.
Start the debugger from any part of any @<file> tree. Now you are ready
to execute all the db-* commands.
You can execute these commands from the minibuffer, or, if the
xdb_pane.py plugin is enabled, from the the Debug pane.
The following commands correspond to the pdb commands:
db-b
Set a breakpoint at the line shown in Leo.
It should be an executable line.
db-c
Continue, that is, run until the next breakpoint.
db-h
Print the help message (in the console, for now)
db-l
List a few lines around present location.
db-n
Execute the next line.
db-q
End the debugger.
db-r
Return from the present function/method.
db-s
Step into the next line.
db-w
Print the stack.
There are two additional commands:
db-again
Run the previous db-command.
db-input
Prompt for any pdb command, then execute it.
The db-input command allows you can enter any pdb command at all.
For example: “print c”.
But you don’t have to run these commands from the minibuffer, as discussed next.
Setting breakpoints in the gutter
When @booluse_gutter is True, Leo shows a border in the body pane. By default, the line-numbering.py plugin is enabled, and if so, the gutter shows correct line number in the external file.
After executing the xdb command, you can set a breakpoint on any executable line by clicking in the gutter to the right of the line number. You can also set a breakpoint any time the debugger is stopped.
Using the gutter is optional. You can also set breakpoints with the db-b command or by typing dline-number or dfile-name:line-number using the db-input command, or by using the Debug pane (see below)
The Debug pane
The xdb_pane.py plugin creates the Debug pane in the Log pane. The pane contains buttons corresponding to all the commands listed above. In addition, there is an input area in which you can enter pdb commands. This is a bit easier to use than the db-input command.
Settings
When @booluse_xdb_pane_output_area is True, all debugger output is sent to an output area in the Debug pane. The default is True, so you need this setting only if you don’t want output set to the Debug pane.
The clone find commands, cfa and cff, move clones of all nodes matching the search pattern under a single organizer node, created as the last top-level node. Flattened searches put all nodes as direct children of the organizer node:
cfaclone-find-allcffclone-find-all-flattened
The clone-marked commands move clones of all marked nodes under an organizer node. Especially useful for gathering nodes by hand:
Run flake8 on all nodes of the selected tree, or the first ancestor @<file> node.
pyflakes
Runs pyflakes on the Python source files in the selected tree, or the first ancestor @<file> node. Prints results in the console window and Leo’s log pane.
pylint
Runs pylint on the Python source files in the selected tree, or the first ancestor @<file> node. This command is also available from the popup menus created by the contextmenu plugin.
Makes sure an external file written by Leo can be read properly.
check-leo-file
Performs a full check of the consistency of a .leo file. As of Leo 5.1, Leo performs checks of gnx’s and outline structure before writes and after reads, pastes and undo/redo.
check-outline
Checks the outline for consistency. Leo automatically checks the syntax of Python external files when Leo writes the external file.
clear-all-caches
Clear all file caches in g.app.leoHomeDir/db
clear-cache
Clear the outline’s file cache.
escape
Enter watch escape mode.
find-long-lines
Report lines longer than specified by:
@boolmax-find-long-lines-length=110
find-missing-docstrings
Report python classes, functions and methods lacking python docstrings.
Does not report nodes that are descendants of @nopylint.
pdb
Drops into debugger, in the middle of the command-handling logic. Get the commander by stepping out into k.masterKeyHandler or k.masterCommandHandler. Using c, one can then get all other info.
show-buttons
Show all @button and @command commands, their bindings and their source.
Shift selected lines right one tab position. Inserts one unit of indentation if no text is selected.
indent-region(Tab)
Shift selected lines right one tab position. Inserts a tab (or spaces) if no text is selected.
unindent-region(Shift-Tab)
Shifts selected lines left one tab position. Deletes one unit of indentation if no text is selected.
Notes:
These commands shift the entire line if any characters in that line are selected. If no text is selected.
The @tabwidth directive determines which characters these commands insert or delete.
Leo auto indents unless @nocolor is in effect. Typing a newline automatically inserts the same leading whitespace present on the previous line.
If Python is the present language, Leo inserts an additional tab if the previous line ends with a colon. When the smart_auto_indentsetting is True, Leo uses Emacs-style auto-indentation instead. This style of auto-indent aligns newly created lines with unmatched ([{ brackets in the previous line.
Adds comments to the selected lines, according to the @language
directive in effect. These commands use single-line comments if
possible. It’s not necessary to select all of the first or last lines.
Selects the locations in your outlines corresponding to a line in a external file.
match-brackets
Enabled if the cursor is next to one of these characters in the body pane: ()[]{}<> The command looks for the matching character, searching backwards through the body text if the cursor is next to )]} or > and searching forward through the text otherwise. If the cursor is between two brackets the search is made for the bracket matching the leftmost bracket. If a match is found, the entire range of characters delimited by the brackets is highlighted and the cursor is placed just to the left of the matching characters. Thus, executing this command twice highlights the range of matched characters without changing the cursor.
Removes trailing whitespace from all lines, preserving newlines.
clear-selected-text
Delete the selected text.
convert-tabs
Converts leading tabs to blanks in a single node.
convert-blanks
Converts blanks to tabs in a single node.
convert-all-tabs
Converts leading tabs to blanks throughout the selected tree.
convert-all-blanks
Converts leading blanks to tabs throughout the selected tree.
@tabwidth: The convert-* commands convert between tabs and blanks using the @tabwidth setting presently in effect.
insert-body-time and insert-headline-time
Insert formatted time and date into body or headline text. You must be editing a headline to be able to insert the time/date into the headline. The body_time_format_string and headline_time_format_string settings specify the format of the inserted text. These settings are the format string passed to time.strftime.
Time format: For format options see Python’s time module. By default, the commands use %m/%d/%Y%H:%M:%S, giving timestamps like 1/30/20038:31:55.
pretty-print-python-code and pretty-print-all-python-code
Pretty prints body text. You can customize this code by overriding the following methods of class prettyPrinter in leoCommands.py:
Rearranges the words in a text paragraph to fill each line as full as possible, up to the @pagewidth setting. A paragraph is delimited by blank lines, Leo directives, and (of course) start and end of text in a node. The width of the line used by the reformatting operation is governed by @pagewidth and the indentation that would be applied to the node when Leo writes the file.
The command operates on the paragraph containing the insert cursor. If the insert cursor is on a blank line or directive, nothing happens. If the cursor is on a line containing text, then the paragraph containing that text line is reformatted and the insert cursor is moved to the next paragraph.
Note: Hanging indentation is preserved. This is most useful for bulleted or numbered lists, such as:
Creates a new node whose headline is the first line of selected body text and whose body is all other lines of selected text. Previously selected text is deleted from the original body text.
extract-names(Ctrl-Shift-N)
Creates one or more child nodes, one for each section name in the selected body text. The headline of each created node is the section name.
line-to-headline
Creates a new node whose headline is the selected body line.
Executes body text as a Python script. Leo execute the selected text, or the entire body text if no text is selected. The Execute Script command pre-defines the values c, g and p as follows:
c is the commander of the outline containing the script.
g is the leoGlobals modules.
p is c.p, that is, c.currentPosition().
Important: Body text may contain Leo directives and section references. You can use all of Leo’s features to organize scripts that you execute interactively. Section definitions must appear in the node containing the script or in descendant nodes.
Leo preprocesses all scripts by simulating the writing of a external file to a string. The execute-script command sets app.scriptDict[“script1”] to the value of the script before preprocessing, and sets app.scriptDict[“script2”] to the value of the script after preprocessing. Scripts may examine and change app.scriptDict as they please.
Leo supports unlimited undo and redo with the undo (Ctrl-Z) and redo (Ctrl-Shift-Z) commands. Think of actions that may be undone or redone as a string of beads. A “bead pointer” points to the present bead. Performing an operation creates a new bead after the present bead and removes all following beads. Undoing an operation moves the bead pointer backwards; redoing an operation moves the bead pointer forwards. The undo command is disabled when the bead pointer moves in front of the first bead; the redo command is disabled when the bead pointer points to the last bead.
The @stringundo_granularity setting controls the granularity of undo. There are four possible values:
node
Starts a new undo unit when typing moves to a new node.
line(default)
Starts a new undo unit when typing moves to new line.
word
Starts a new undo unit when typing starts a new word.
char (not recommended)
Starts a new undo unit for each character typed.
This wastes lots of computer memory.
Important: The following describes Leo’s new abbreviation scheme. Such abbreviations fire immediately whenever they are completed. You do not have to execute a command! By convention, abbreviations end with ;;, something you are not likely to type by accident, but you can pick any abbreviation you like.
Note:
The @dataabbreviations-subst-env node contains a script defining the environment in which all abbreviations execute. This allows helper functions to be defined. Very handy.
2. Scripts may span multiple lines. Line starting with “:” (2 characters) continue a script. This allows abbreviations to define multi-line templates.
Helpers defined in @dataabbreviations-subst-env can fill in templates with calculated (not predefined) data.
Templates may contain placeholders that the user can fill in. By default, the double comma binding selects the next placeholder.
Added a new setting: @boolscripting-abbreviations, default False. Scripting abbreviations will be enabled if either of the following is True:
This is a safety feature: it allows scripting abbreviations to be enabled without enabling the (very dangerous in general) scripting-at-script-nodes setting.
Added a new example node: @dataabbreviations examples. This contains
several extremely useful scripts.
Smart cursor moves: Many editors allow you to jump over, select and delete words, especially those containing or surrounded by special characters, in a smarter way than just “going to the beginning of the word before” (back-word) or “going to the end of the next word” (forward-word):
I'm really glad the docs are being updated. I know that'samonumentaltask.IonlyuseafractionofLeo's commands, mostlybecauseIdon't even know what they'resupposedtoaccomplish.Afewexamples:
Placing the cursor immediately before the first “I”, holding shift and moving it to immediately before the word``examples`` selects a zero width rectangle from the beginning to the end of the selection (zero width because the selection starts and ends in the same column. Then running rectangle-string[largo]<space><enter> yields:
[largo]I'm really glad the docs are being updated. I know that'sa[largo]monumentaltask.IonlyuseafractionofLeo's commands, mostly[largo]becauseIdon't even know what they'resupposedtoaccomplish.Afew[largo]examples:
Prompts for the name of a file and put the selected text into it.
flatten-outline
Creates a text file in MORE format from the selected outline.
import-file
Import a file into an @file node. This command handles files regardless of whether they contain sentinels. This command can also read files in MORE outline format.
import-MORE-file
Import one or MORE files into @file nodes.
import-tabbed-files
Import one or more tab-or-space-delimited files into @file nodes.
import-zim-folder
Imports a zim folder, http://zim-wiki.org/, as the last top-level node of the outline. This command uses the following Leo settings:
Closes all tabs except the presently selected tab.
session-create
Creates a new @session node.
session-refresh
Refreshes the current @session node.
session-restore
Opens a tab for each item the selected @session node.
session-snapshot-load
Loads a snapshot of a session from the leo.session file.
session-snapshot-save
Saves a snapshot of the present session to the leo.session file.
A session specifies a list of .leo files that Leo opens automatically when Leo first starts. Leo will reload the last session provided that command-line arguments don’t contain any file names.
Leo creates a temporary file and invokes an external program. Leo periodically checks whether this temporary file has changed; Leo changes the corresponding node in the outline if so. You must create the entries using an @openwith node in myLeoSettings.leo. See the documentation there.
All open-with commands require that the corresponding @openwith node correctly specifies an editor.
Converts c or c++ text to python text. The conversion is not perfect, but it eliminates a lot of tedious text manipulation. This command is a rewrapping of the first Python script I ever wrote.
import-free-mind-files
Prompts for FreeMind files and imports them.
typescript-to-py
Converts typescript text to python text. The conversion is not perfect, but it eliminates a lot of tedious text manipulation.
click-click-boxclick-headlineclick-icon-boxctrl-click-at-cursorctrl-click-icondouble-click-headlinedouble-click-icon-box# Invokes vim or xemacs plugin if enabled.simulate-begin-dragsimulate-end-drag
clone-node(Ctrl-\`) (Grave accent, not a single quote)
Creates a clone as the immediate sibling of a selected node.
clone-node-to-last-node
Creates a clone as the last top-level node of the outline.
insert-node(Ctrl-IorInsert)
Inserts a new node into the outline. The new node becomes the first child of the present node if the present node is expanded. Otherwise, the new node becomes the next sibling of the present node.
insert-node-before
Inserts a node before the presently selected node.
Arrow keys: When focus is in the outline pane, you can move about the outline using plain arrow keys. Regardless of focus, Alt-Arrow keys select nodes in the outline pane.
goto-first-sibling
Select the first sibling of the selected node.
goto-last-sibling
Select the last sibling of the selected node.
Similarly, these commands select various nodes in the outline:
Copies a node and all its descendants to the clipboard
cut-node(Ctrl-Shift-X)
Copies a node and all its descendants to the clipboard and then delete them.
delete-node
Deletes a node and all its descendants.
paste-node(Ctrl-Shift-V)
Pastes a node and its descendants from the outline. This commands creates copies of nodes, not clones.
past-retaining-clones
Pastes a node and its descendants from the outline. This command preserves the identify (gnx’s) of the pasted nodes, thereby preserving any clone links. This command ensures that no newly-pasted node is an ancestor of itself.
Outline representation: When cutting or copying an outline to the clipboard, Leo writes the outline in the same xml (text) format used in .leo files. You may copy this text representation into a body pane (or into any other text editor) using Ctrl-V.
Alt Modifiers not needed in the outline pane: When focus is in the outline pane, you can move nodes without adding the Alt modifier. Shift-Up moves the select node up, etc.
Important: The following commands reorganize groups of nodes:
de-hoist
Undoes the effect of the previous hoist command.
demote(Ctrl-])
Makes all following siblings of a node children of the node.
hoist
Redraws the screen so presently selected tree becomes the only visible part of the outline. You may hoist an outline as many times as you wish.
promote(Ctrl-[)
Makes all the children of a node siblings of the node.
sort-children
Sort all children of the children of the present node by their headlines.
sort-siblings(Alt-A)
Sort the present node and all its siblings by their headlines.
You may drag a node (including all its descendants) from one place to another in an outline. To start a drag, press the main (left) mouse button while the cursor is over the icon for a node. The cursor will change to a hand icon. If you release the mouse button while the hand cursor is above another node, Leo will move the dragged node after that node. If you release the mouse button when the hand cursor is not over a node, Leo will leave the outline pane as it is. Leo scrolls the outline pane as the result of mouse-moved events, so to continue scrolling you must keep moving the mouse.
If the recipient node has children and is expanded, the dropped node will be inserted as the first child of the recipient node, otherwise the dropped node will be inserted after the recipient node.
Holding down Alt before releasing the node will force insertion as a child of the recipient node, even if the recipient node is not expanded. Holding down Control before releasing the node will cause a clone to be dropped, leaving the original where it was.
Copies all marked nodes as children of a new node.
diff-marked-nodes
When exactly two nodes are marked, this command creates a diff node as the last top-level node whose children are clones of the marked nodes.
goto-next-marked
Selects the next marked node.
mark(Ctrl-M)
Marks node if it is unmarked, and unmarks the node if it is already marked.
mark-changed-items
Marks all nodes whose headline or body text has been changed since the file was last saved.
mark-subheads
Marks all children of the presently selected node.
marked-list
Lists all marked nodes in the Nav pane.
unmark-all
Unmarks all marked nodes in the outline.
Marking groups of nodes: Leo’s find and change commands mark nodes if the “Mark Changes” and “Mark Finds” checkboxes are checked. You can change these checkboxes with the toggle-find-mark-changes-option and toggle-find-mark-finds-option commands.
Prompts for another (presumably similar) .leo file that will be compared with the presently selected outline file (main window). It then creates clones of all inserted, deleted and changed nodes.
file-diff-files
Creates a node and puts the diff between 2 files into it.
@chapter trees define chapters. Selecting a chapter makes only those nodes in the chapter visible, much like a hoist. The main chapter represents the entire outline. Selecting the main chapter shows all outline nodes.
chapter-select-main
Selects the main chapter.
chapter-select-<chapter-name>
Each @chapter node in the outline creates a corresponding chapter-select command.
Prompts for a search string. Typing the Return key puts the search string in the Find tab and executes a search based on all the settings in the Find tab. Type Tab to enter replacement text.
find-next(F3)
Continues a search started with Ctrl-F.
find-previous(F2)
Searches backwards using the present search options.
replace(Ctrl-=)
Replaces the selected text with the ‘change’ text in the Find tab.
replace-then-find(Ctrl--)
Replaces the selected text with the ‘change’ text in the Find tab, then executes the find command again.
Batch searches:
find-all
Prints all matches in the log pane.
replace-all
Changes all occurrences of the ‘find’ text with the ‘change’ text.
When using the minibuffer to specify search and replace patterns,
first enter then search pattern,
then type Tab and enter the replacement pattern:
Prompts for a find, then creates clones of all found nodes in an organizer node.
clone-find-all aka (cfa)
Same as clone-find-all-flattened, but does not create duplicate cloned nodes. If a node is a descendant of another found node, no duplicate top-level node (in the organizer) is created.
clone-find-marked aka (cfm) and clone-find-marked-flattened aka (cfmf)
Creates clones of all marked nodes.
clone-find-parents
Creates an organizer node containing clones of all the parents of the selected node.
Incremental find commands move through the text as you type individual characters. Typing BackSpace backtracks the search. To repeat an incremental search, type the shortcut for that command again. Here are Leo’s incremental find commands:
When checked, the Find and Change commands search body text.
Alt+Ctrl+B(toggle-find-in-body-option) toggles this checkbox.
SearchHeadlineText
When checked, the Find and Change commands search headline text.
Alt+Ctrl+H(toggle-find-in-headline-option) toggles this checkbox.
WholeWord
When selected, the find pattern must match an entire word. Words consist of an alphabetic character or underscore, followed by zero or more alphabetic characters, numbers or underscores.
Alt+Ctrl+W(toggle-find-word-option) toggles this checkbox.
WrapAround
When checked, the Find and Change commands continues at the top of the file when the command reaches the bottom of the file. For reverse searches, the find or change command continues at the bottom of the file when the command reaches the top of the file.
Alt+Ctrl+A(toggle-find-wrap-around-option) toggles this checkbox.
The following commands refer to spell-as-you-type mode:
spell-as-you-type-next
Cycle the word behind (left of, for ltr languages) the cursor through the full list of suggestions.
spell-as-you-type-toggle
Toggle spell as you type mode. When enabled, word ending keystrokes will put a short list of suggestions in the log window, if the word is unknown to the speller. Only shows the first 5 suggestions, even if there are more.
spell-as-you-type-undo
Undo the last spelling correction.
spell-as-you-type-wrap
Toggle wrapping in spell-as-you-type mode.
The following commands refer to the Spell Tab:
spell-tab-open
Leo’s beautify command differs from Black as follows:
beautify never changes Leo’s sentinel comments.
beautify never splits or joints lines (with the default settings).
Black sometimes inserts horrible line breaks.
beautify never converts single-quote strings to double-quote strings.
That is, beautify simulates Black’s --skip-string-normalization command-line option.
beautify doesn’t insert extra blank lines at the end of nodes.
Technically, this is a pep8 violation, but these extra lines are not Leonine.
This directive completely disables beautification for an entire tree. This is typically required for files containing @all.
@beautify and @nobeautify
These directives apply to a node and its descendants, until overridden later in a descendants. Both these directives may appear in the same node. Such ambiguous directives do not affect the beautification of descendant nodes. If both @beautify and @nobeautify appear in a node, the first directive determines whether the node will be beautified.
For example:
@beautify...@nobeautify
beautifies the entire node. Otoh:
@nobeautify...@beautify
skips beautification of the entire node. Yes, this is less precise than one could imagine, but it’s good enough.
Adjusts the sizes of the outline and body panes so that they are the same height.
minimize-all
Minimizes (hides) all Leo windows.
show-colors
Opens a tab in the log pane showing various color pickers.
(Not implemented in Qt)
show-fonts
Open a tab in the log pane showing a font picker.
suspend
Minimizes the present Leo window.
toggle-split-direction
Switches between vertical and horizontal orientations of the Leo window.
In the vertical orientation, the body pane appears below the pane containing the outline and log panes. In the horizontal orientation, the body pane appears to the left the pane containing the outline and log panes. By default, the ratio of pane outline pane to the body pane is 0.5 in the vertical orientation and 0.3 in the horizontal orientation. These two ratios may be changed using settings.
