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:
cfa clone-find-all
cff clone-find-all-flattened
The clone-marked commands move clones of all marked nodes under an organizer node. Especially useful for gathering nodes by hand:
cfam clone-find-marked
cffm clone-find-flattened-marked
The clone-find-parents command creates clones of all parent nodes of c.p.
The clone-find-tag aka (cft) command creates clones of all nodes having a given tag.
The tag-children applies a given tag to all the children of the selected node.
cut-text (Ctrl-X)- Cut the selected text and put it to the clipboard.
copy-text (Ctrl-C)- Copy the selected text to the clipboard.
paste-text (Ctrl-V)- Paste test from the clipboard.
select-all(Ctrl-A)- Select all text in the text pane.
These commands work with either headline or body text.
indent-region (Tab)- Shift selected lines right one tab position. Inserts one unit of indentation 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_indent setting 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.
add-comments (Ctrl-))- Adds comments to the selected lines, using single-line comments if possible.
delete-comments (Ctrl-()- Deletes comments in the selected lines.
goto-global-line (Alt-G)- 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.
clean-lines- 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.
flush-lines- Deletes each line that contains a match for regexp, operating on the text after point.
In Transient Mark mode, if the region is active, the command operates on the region instead.
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/2003 8:31:55.
keep-lines- Deletes each line that does not contain a match for regexp, operating on the text after point. In Transient Mark mode, if the region is active, the command operates on the region instead.
pretty-print-python-code and pretty-print-all-python-codePretty prints body text. You can customize this code by overriding the following methods of class prettyPrinter in leoCommands.py:
putOperator: puts whitespace around operators.
putNormalToken: puts whitespace around everything else.
reformat-paragraph (Ctrl-Shift-P)- 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:
1. This is the first paragraph,
and it has a hanging indentation.
2. This is the second paragraph,
and it too has a hanging indentation.
replace-current-character- Replace the selected character with the next character typed.
toggle-angle-brackets- Adds or removes double angle brackets from the headline of the selected node.
unformat-paragraph (Ctrl-Shift-U)- Removes all extra whitespace from a paragraph, including leading whitespace. This command is useful when @wrap is in effect.
extract (Ctrl-Shift-D)- 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.
execute-script (Ctrl-B)- 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.
add-editor- Adds a new editor in the body pane and gives it the body editor focus.
delete-editor- Deletes the editor with body editor focus.
cycle-editor-focus- Cycles body editor focus between editors in the body text. The editor that has focus shows the content of the selected outline node; the other body editors continue to show the node contents they last had when they had the body editor focus.
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 @string undo_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 @data abbreviations-subst-env node contains a script defining the environment in which all abbreviations execute. This allows helper functions to be defined. Very handy.
Scripts may span multiple lines. Line starting with “:” (2 characters) continue a script. This allows abbreviations to define multi-line templates. Helpers defined in @data abbreviations-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: @bool scripting-abbreviations, default False. Scripting abbreviations will be enabled if either of the following is True:
@bool scripting-abbreviations
@bool scripting-at-script-nodes
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: @@data abbreviations examples. This contains
several extremely useful scripts.
Leo also supports Emacs-like abbreviation commands:
dabbrev-completion
dabbrev-expands
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):
back-word-smart
back-word-smart-extend-selection
forward-word-smart
forward-word-smart-extend-selection
delete-word-smart
backward-delete-word-smart
The following commands work much like the Emacs cursor commands:
back-char
back-char-extend-selection
back-page
back-page-extend-selection
back-paragraph
back-paragraph-extend-selection
back-sentence
back-sentence-extend-selection
back-to-home
back-to-home-extend-selection
back-to-indentation
back-word-extend-selection
backward-delete-char
backward-find-character
backward-find-character-extend-selection
backward-kill-paragraph
backward-kill-sentence
backward-kill-word
beginning-of-buffer
beginning-of-buffer-extend-selection
beginning-of-line
beginning-of-line-extend-selection
end-of-buffer
end-of-buffer-extend-selection
end-of-line
end-of-line-extend-selection
find-character
find-character-extend-selection
find-word-in-line
forward-char
forward-char-extend-selection
forward-end-word
forward-end-word-extend-selection
forward-page
forward-page-extend-selection
forward-paragraph
forward-paragraph-extend-selection
forward-sentence
forward-sentence-extend-selection
forward-word-extend-selection
move-past-close
move-past-close-extend-selection
next-line
next-line-extend-selection
previous-line
previous-line-extend-selection
The following commands typically work like the corresponding Emacs command. For details about any command use F11 (help-for-command):
add-space-to-lines
add-tab-to-lines
align-eq-signs
auto-complete
auto-complete-force
capitalize-word
center-line
center-region
clear-kill-ring
count-pages
count-region
delete-char
delete-indentation
delete-spaces
downcase-region
downcase-word
exchange-point-mark
extend-to-line
extend-to-paragraph
extend-to-sentence
extend-to-word
fill-paragraph
fill-region
fill-region-as-paragraph
hide-invisibles
how-many
indent-relative
indent-rigidly
indent-to-comment-column
insert-child
insert-file-name
insert-file-name
insert-hard-tab
insert-newline
insert-parentheses
insert-soft-tab
join-node-above
join-node-below
join-selection-to-node-below
line-number
move-lines-down
move-lines-up
newline-and-indent
open-url
open-url-under-cursor
remove-blank-lines
remove-newlines
remove-space-from-lines
remove-tab-from-lines
reverse-region
reverse-sort-lines
reverse-sort-lines-ignoring-case
select-to-matching-bracket
set-fill-column
set-fill-prefix
shell-command
shell-command-on-region
show-invisibles
set-comment-column
sort-columns
sort-fields
sort-lines
sort-lines-ignoring-case
split-line
tabify
transpose-chars
transpose-lines
transpose-words
untabify
upcase-region
upcase-word
view-lossage
what-line
The following commands emulate the Emacs macro commands:
macro-call
macro-call-last
macro-end-recording
macro-load-all
macro-name-last
macro-print-all
macro-print-last
macro-save-all
macro-start-recording
The following commands emulate the Emacs rectangle commands:
rectangle-clear
rectangle-close
rectangle-delete
rectangle-kill
rectangle-open
rectangle-string
rectangle-yank
Given:
I'm really glad the docs are being updated. I know that's a
monumental task. I only use a fraction of Leo's commands, mostly
because I don't even know what they're supposed to accomplish. A few
examples:
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's a
[largo] monumental task. I only use a fraction of Leo's commands, mostly
[largo] because I don't even know what they're supposed to accomplish. A few
[largo] examples:
The following commands typically work like the corresponding Emacs command. For details about any command use F11 (help-for-command):
backward-delete-char
backward-find-character
backward-find-character-extend-selection
backward-kill-paragraph
backward-kill-sentence
backward-kill-word
kill-line
kill-paragraph
kill-region
kill-region-save
kill-sentence
kill-to-end-of-line
kill-word
kill-ws
yank
yank-pop
zap-to-character
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-I or Insert)- 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.
delete-node- Deletes a node and all its descendants.
contract-all (Alt-hyphen)- Contracts every node in the outline.
contract-all-other-nodes- Contract all nodes except the parents of the selected node.
contract-node- Contracts a node.
contract-or-go-left (Alt-Left)- Contract the node if it is expanded. Otherwise, select the node’s parent.
contract-parent- Select the parent of the selected node and contract it.
expand-all- Expands every node in the outline.
expand-node- Expands a node.
expand-and-go-right (Alt-Right)- Expands a node if not expanded. Otherwise, selects the first child if there is one.
expand-all-subheads- Expand all the direct children of the selected node.
expand-ancestors-only- Expand all the ancestors of the selected node.
These commands expand all descendants of the selected nodes:
expand-next-level
expand-prev-level (reverses expand-next-level)
expand-to-level-1
expand-to-level-2
expand-to-level-3
expand-to-level-4
expand-to-level-5
expand-to-level-6
expand-to-level-7
expand-to-level-8
expand-to-level-9
abort-edit-headline- Ends editing of the headline, discarding any changes.
edit-headline- Begins editing of the headline of the presently-selected node.
end-edit-headline- Ends editing of the headline.
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:
go-back
go-forward
goto-char
goto-first-node
goto-first-visible-node
goto-last-node
goto-last-visible-node
goto-line
goto-next-changed
goto-next-clone
goto-next-history-node
goto-next-node
goto-next-sibling
goto-next-visible
goto-parent
goto-prev-history-node
goto-prev-node
goto-prev-sibling
goto-prev-visible
leoscreen-jump-to-error (Unix only)Jumps to the python error reported in the shell window, if the
file’s loaded in the current Leo session. Just looks for a line:
File "somefile.py", line NNN, in xxx
and looks for a node starting with “@” and ending with “somefile.py”,
then jumps to line NNN in that file.
copy-node (Ctrl-Shift-C)- 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.
move-outline-down (Ctrl-D or Shift-Down or Alt-Shift-Down)- Move the selected node down, if possible.
move-outline-left (Ctrl-L or Shift-Left or Alt-Shift-Left)- Move the selected node left, if possible.
move-outline-right (Ctrl-R or Shift-Right or Alt-Shift-Right)- Move the selected node right, if possible.
move-outline-up (Ctrl-U or Shift-Up Alt-Shift-Up)- Move the selected node up, if possible.
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.
code-to-rst- Format the presently selected node as computer code.
flatten-outline-to-node- Appends the headline and body text of all descendants of the selected node to the body text of the selected node.
head-to-prev-node- Moves non-empty text preceding a class, method or function definition to the end of the previous sibling node.
parse-body- Parse p.b as source code, creating a tree of descendant nodes.
This is essentially an import of p.b.
tail-to-next-node- Moves non-empty text following a class, method or function definition to the start of the next sibling node.
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.
copy-marked- 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.
clone-marked-nodes- Makes clones of all marked nodes and moves them to be children of the present position.
delete-marked-nodes- Deletes all marked nodes.
move-marked-nodes- Moves all nodes to be children of the present position.
file-compare-leo-files- 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.
chapter-next- Selects the next chapter.
chapter-back- Selects the previous chapter.
Associated settings:
@bool use_chapters- True: chapters are enabled.
beautify-node- Beautifies the Python code in the selected node.
beautify-tree- Beautifies all the Python code in the selected tree.
beautify-c- Reformats all C code in the selected tree.
These commands skip any nodes for which @language python (or c) is not in effect.
The Python beautifier (beautify-tree and beautify-node) is safe. It can never alter the meaning of a program because it compare the parse trees of the original and beautified code. The code remains unchanged if there is a mismatch. Such beautifier errors produce debugging dumps. Please report any such errors to Leo’s developers.
The Python beautifier works only on syntactically correct code. It issues a warning and does nothing for syntactically incorrect code.
The Python beautifier converts Leonine syntax (directives, section references and @doc parts) to comments, possibly with a trailing pass statement. Usually this produces syntactically correct text. As discussed below, the trailing pass can create SyntaxError’s.
The following sections describe how the beautify-tree and beautify-node commands work in more detail.
The beautifier will just work for most people.
The beautifier follows the Pep 8 recommendations for whitespace. It ensures that names, operators, strings and comments are separated by zero or one blanks:
def spam(a, b, c=5, *args, **keys):
foo(a, 25, b=2)
a = b + c - 5
b = -d
if 0 < b < 26:
...
Leo follows the pep 8 recommendations for blank lines between classes and defs, with minor variations due to Leo’s node structure.
Optionally, the beautifier can remove blank lines within classes and defs, controlled by the setting @bool tidy-keep-blank-lines.
The Python beautifier never creates new lines! The beautifier never adds or changes:
- Line breaks for “long” lines.
- Line breaks in function argument lists.
- Leading whitespace in continued argument lines.
- Line breaks call arguments.
- Leading whitespace in continue function call arguments.
- Whitespace (including line breaks) within statements.
Pep 8 allows considerable flexibility regarding continued lines. The beautifier will leave all of the following unchanged, whether or not they conform to the pep 8 recommendation:
def function1 (a, b, c):
pass
def function2 (
a = 2, # a comment
b = 3, # another comment
):
pass
def function3 (
a = 2, # a comment
b = 3, # another comment
):
pass
def function4(
a = 2, # a comment
b = 3, # another comment
):
pass
Similarly, the beautifier will not touch arguments in function calls.
@killbeautify- 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 for now.
@bool tidy-autobeautify = False- When True, Leo beautifies all changed files when saving an outline. The default must always be False in leoSettings.leo and in unitTest.leo.
@bool tidy-keep-blank-lines = False- When True, the beautifier retains blank lines within classes, functions and methods.
The following 5 problems are relatively minor. They apply only to the Python beautifier. The workaround in most cases is to use @nobeautify.
1. Syntax Errors
The pass hack converts:
to:
if 1:
#!!!!! << a section >>
pass
which is usually, but not always, syntactically correct Python. Here is an example from Leo’s core:
patterns = [
<< Sherlock patterns for pylint >>
]
The pass hack produces syntactically incorrect code:
patterns = [
#!!!!! << Sherlock patterns for pylint >>
pass
]
2. Alignment
The beautifier eliminates blanks used to align code. For example:
d = {
key1: value1,
longKey2: value2,
}
The beautifier might preserve such lines, but there are no plans at present to do so.
The regular expression: =([ ])*\{([^}])*$ will discover complex dictionaries that you may want to protect with @nobeautify.
3. Operator priority
Pep 8 suggests considering eliminating blanks around higher-priority operators. The beautifier puts blank lines about all operators, except unary operators.
This is a difficult problem of style, for which no approach works in all cases. Surprisingly, retaining blanks around * usually looks best in Leo’s own code.
4. @clean & @auto
Consider adding @nobeautify for all @auto and @clean nodes, on the theory that such nodes are not primarily your responsibility. But adding @nobeautify is completely up to you.
5. Extra blank lines
The beautifier will sometimes insert extra spaces between class/def lines and preceding comments.
You may invoke a lightly tested stand-alone version the Python beautifier from the command line.
You can run leoBeautify.py from any directory, provided that a copy of leoGlobals.py exists in the same directory.
Run the stand-alone beautifier as follows:
python -m leoBeautify file1, file2, ...
To get a usage message, do:
This produces:
Usage: python leoBeautify -m file1, file2, ...
Options:
-h, --help show this help message and exit
-d, --debug print the list of files and exit
-k, --keep-blank-lines keep-blank-lines
The following could be done only at the cost of more settings and debates about what the default settings should be.
- Splitting long lines.
- Improving spacing around operators.
- Moving or indenting comment lines.
All these involve significant personal judgments and preferences. Pep 8 explicitly allows various approaches.
Except for dictionary definitions, the beautifier does what is expected, leaving difficult or idiosyncratic cases completely at the user’s discretion.
- For the first time ever, Leo’s beautify commands work properly with Leonine syntax.
- All files in leoPy.leo can now be beautified without fuss.
- Except for spacing around operators, the beautifier mostly leaves your code as it is.
- The beautifier makes no difficult choices. It preserves your choices.
