.. @+leo-ver=5-thin
.. @+node:ekr.20100805165051.7155: * @file commands.txt
.. @@language rest
.. @@tabwidth -4

.. @+at @rst-options
..  call_docutils=False
..  code_mode=False
..  generate_rst=True
..  http_server_support = False
..  show_organizer_nodes=True
..  show_headlines=True
..  show_leo_directives=True
..  stylesheet_path=..\doc
..  write_intermediate_file = True
..  verbose=True
.. @@c

.. @+all
.. @+node:ekr.20050901101608.2: ** @rst html\commands.html
###########
Using Leo
###########

This chapter discusses the basics of using Leo, including all of Leo's
commands. It starts with a discussion of the Emacs-like minibuffer,
then continues with a discussion of commands in each of Leo's menus.

.. contents::
    :depth: 3

.. @+node:ekr.20050901101852: *3* @rst-no-head links
.. External links...
.. _CWEB:       http://www-cs-faculty.stanford.edu/~knuth/cweb.html
.. _noweb:      http://www.eecs.harvard.edu/~nr/noweb/

.. Relative links...
.. _`Writing Programs in Leo`:          directives.html
.. _`Customizing Leo`:                  customizing.html
.. _`Clones and views`:                 intro.html#clones-views
.. _`Creating script buttons`:          scripting.html#creating-script-buttons
.. _`A Tutorial Introduction to Leo`:   intro.html

.. @+node:ekr.20060420094611: *3* The minibuffer and minibuffer commands
The mini-buffer is a text area at the bottom of the body pane. You use it
like the Emacs mini-buffer to invoke commands by their so-called *long name*.

The ``full-command`` (Alt-x) command puts the focus in the minibuffer. Type
a full command name, then hit <Return> to execute the command. Tab
completion works, but not yet for file names. For example, to print a list
of all commands type::

    <Alt-X>print-commands<Return>
    
**Extremely important**: Like Emacs, many of Leo's commands have long-winded names.
It is **not**, repeat **not** necessary to type the entire name in the minibuffer!
Instead, you can use **tab completion** to shortcut your typing.  For example,
Suppose you want to execute the print-commands return. First, you type the first
few characters of the command, and hit the <tab> key::

    <Alt-x>pri<Tab>
    
You will see the following list of completions in the log window::

    print-all-uas
    print-bindings
    print-cmd-docstrings
    print-commands
    print-focus
    print-node-uas
    print-plugin-handlers
    print-plugins-info
    print-settings
    
The minibuffer now contains the **longest common prefix** of all the completions,
in this case::

    print-
    
So now, all you have to do is type::

    s<tab>
    
and the minibuffer will show::

    print-settings
    
Finally, execute the command by hitting the <return> key. Using tab
completion quickly becomes second nature. It saves a huge amount of typing.
More importantly, it means that not every command needs to be bound to a
keystroke in order to be conveniently available.

The ``keyboard-quit`` (Ctrl-g) commands exits any minibuffer mode and puts
the focus in the body pane. **Important**: Use ctrl-g whenever you are
unsure of what is happening.

..  The ``universal-argument`` (Alt-u) command acts like Emacs Ctrl-u.
.. It adds a repeat count for later command. Ctrl-u 999 a adds 999 a's.

The following sections list the various commands that you can invoke from
the minibuffer. **Important**: you may bind keystrokes to any of these
commands. See `Customizing Leo`_ for full details.
.. @+node:ekr.20060613062025.6: *4* Basic editing commands
Here is a list of Leo's basic editing commands with the default (EKR)
bindings shown::

    Left                back-char
    Shift-Left          back-char-extend-selection
                        back-paragraph
                        back-paragraph-extend-selection
                        back-sentence
                        back-sentence-extend-selection
                        back-to-indentation
    Alt-B or Ctrl-Left  back-word
    Alt-Shift-B         back-word-extend-selection
    Ctrl-Shift-Left     back-word-extend-selection
    BackSpace           backward-delete-char
    Shift-BackSpace     backward-delete-char
    Ctrl-BackSpace      backward-delete-word
                        backward-delete-word-smart
                        backward-kill-paragraph
                        backward-kill-sentence
                        backward-kill-word
    Ctrl-Home           beginning-of-buffer
    Ctrl-Shift-Home     beginning-of-buffer-extend-selection
    Home                beginning-of-line
    Shift-Home          beginning-of-line-extend-selection
    Ctrl-C              copy-text
    Ctrl-X              cut-text
    Delete              delete-char
    Ctrl-End            end-of-buffer
    Ctrl-Shift-End      end-of-buffer-extend-selection
    End                 end-of-line
    Shift-End           end-of-line-extend-selection
    Alt-M               exchange-point-mark
    Ctrl-W              extend-to-word
    Right               forward-char
    Shift-Right         forward-char-extend-selection
                        forward-paragraph
                        forward-paragraph-extend-selection
                        forward-sentence
                        forward-sentence-extend-selection
    Ctrl-Right          forward-word
    Ctrl-Shift-Right    forward-word-extend-selection
    Tab                 indent-region
    Return              insert-newline
                        move-lines-down
                        move-lines-up
                        move-past-close
                        move-past-close-extend-selection
    Ctrl-J or Tab       newline-and-indent
    Down                next-line
    Shift-Down          next-line-extend-selection
    Ctrl-V              paste-text
    Up                  previous-line
    Shift-Up            previous-line-extend-selection
    Shift-Ctrl-Z        redo
    Ctrl-A              select-all
    Ctrl-Z              undo
    Shift-Tab           unindent-region
.. @+node:ekr.20060613062025.1: *4* Debugging commands
These commands are for debugging Leo itself::

    collect-garbage
    debug
    disable-gc-trace
    dump-all-objects
    dump-new-objects
    dump-outline
    enable-gc-trace
    free-tree-widgets
    print-focus
    print-gc-summary
    print-stats
    verbose-dump-objects
.. @+node:ekr.20060613062025.4: *4* Emacs commands
The following commands work just like their Emacs counterparts.
Use the help-for-command command for further details::

                add-space-to-lines
                add-tab-to-lines
                advertised-undo
                capitalize-word
                center-line
                center-region
                clean-lines
                clear-extend-mode
                clear-kill-ring
                clear-rectangle
                clear-selected-text
                count-pages
                count-region
                dabbrev-completion
                dabbrev-expands
                delete-comments
                delete-file
                delete-indentation
                delete-rectangle
                delete-spaces
                diff
                digit-argument
                downcase-region
                downcase-word
                end-kbd-macro
                escape
                eval-expression
                expand-region-abbrevs
                fill-paragraph
                fill-region
                fill-region-as-paragraph
                flush-lines
                full-command
                goto-char
                how-many
                increment-register
                indent-region
                indent-relative
                indent-rigidly
                indent-to-comment-column
                insert-body-time
                insert-file
                insert-keyboard-macro
                insert-parentheses
                insert-register
                inverse-add-global-abbrev
                jump-to-register
                keep-lines
                keyboard-quit
                kill-all-abbrevs
                kill-buffer
    Ctrl-K      kill-line
                kill-paragraph
                kill-rectangle
                kill-region
                kill-region-save
                kill-sentence
                kill-word
                line-number
                list-abbrevs
                list-buffers-alphabetically
                load-file
                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
                make-directory
                match-bracket
                name-last-kbd-macro
                negative-argument
                number-command
                number-command-0
                number-command-1
                number-command-2
                number-command-3
                number-command-4
                number-command-5
                number-command-6
                number-command-7
                number-command-8
                number-command-9
                open-rectangle
                point-to-register
                prepend-to-buffer
                prepend-to-register
                read-abbrev-file
                rectangle-clear
                rectangle-close
                rectangle-delete
                rectangle-kill
                rectangle-open
                rectangle-string
                rectangle-yank
                register-append-to
                register-copy-rectangle-to
                register-copy-to
                register-increment
                register-insert
                register-jump-to
                register-point-to
                register-prepend-to
                register-view
                remove-blank-lines
                remove-directory
                remove-sentinels
                remove-space-from-lines
                remove-tab-from-lines
                rename-buffer
                repeat-complex-command
                reverse-region
                run-unit-tests
                select-paragraph
                set-comment-column
                set-fill-column
                set-fill-prefix
                shell-command
                shell-command-on-region
                sort-columns
                sort-fields
                sort-lines
                split-line
                start-kbd-macro
                string-rectangle
                suspend
                switch-to-buffer
                tabify
                transpose-chars
                transpose-lines
                transpose-words
                unindent-region
                universal-argument
                unmark-all
                untabify
                upcase-region
                upcase-word
                view-lossage
                what-line
    Ctrl-Y      yank
    Alt-Y       yank-pop
                zap-to-character
.. @+node:ekr.20060613062025.5: *4* Find commands
Here is a list of all of Leo's find commands. The apropos-find-commands
command will print a detailed help message discussing these commands::

                    clone-find-all
                    clone-find-all-flattened
                    find-all
    Ctrl+Key+2      find-character
    Ctrl+Shift-2    find-character-extend-selection
                    find-clone-all
                    find-clone-all-flattened
    F3              find-next
                    find-next-clone
    F2              find-prev
                    find-quick
    Ctrl+Shift+F    find-quick-selected
                    find-quick-test-failures
                    find-quick-timeline
                    find-tab-hide
                    find-tab-open
                    find-word
                    find-word-in-line
    Alt+R           isearch-backward
                    isearch-backward-regexp
    Alt+S           isearch-forward
                    isearch-forward-regexp
                    isearch-with-present-options
                    re-search-backward
                    re-search-forward
                    replace-string
                    search-again
                    search-backward
                    search-forward
    Ctrl-F          search-with-present-options
    Alt+Ctrl+E      set-find-everywhere
    Alt+Ctrl+N      set-find-node-only
    Alt+Ctrl+S      set-find-suboutline-only
                    toggle-find-collapses-nodes
    Alt+Ctrl+I      toggle-find-ignore-case-option
    Alt+Ctrl+B      toggle-find-in-body-option
    Alt+Ctrl+H      toggle-find-in-headline-option
    Alt+Ctrl+C      toggle-find-mark-changes-option
    Alt+Ctrl+F      toggle-find-mark-finds-option
    Alt+Ctrl+X      toggle-find-regex-option
    Alt+Ctrl+W      toggle-find-word-option
    Alt+Ctrl+A      toggle-find-wrap-around-option
                    word-search-backward
                    word-search-forward
.. @+node:ekr.20060613062025.9: *4* Gui commands
The following commands simulate mouse clicks, double-clicks or drags::

                    abort-edit-headline
                    activate-cmds-menu
                    activate-edit-menu
                    activate-file-menu
                    activate-help-menu
                    activate-outline-menu
                    activate-plugins-menu
                    activate-window-menu
                    add-editor
                    cascade-windows
                    click-click-box
                    click-headline
                    click-icon-box
                    close-window
                    contract-body-pane
                    contract-log-pane
                    contract-outline-pane
    Alt-Ctrl-Minus  contract-pane
    Ctrl-Shift-Tab  cycle-all-focus
                    cycle-editor-focus
                    cycle-focus
                    delete-editor
                    double-click-headline
                    double-click-icon-box
                    edit-headline
                    end-edit-headline
                    equal-sized-panes
                    expand-body-pane
                    expand-log-pane
                    expand-outline-pane
    Alt-Ctrl-Plus   expand-pane
    Alt-D           focus-to-body
                    focus-to-log
                    focus-to-minibuffer
    Alt-T           focus-to-tree
                    fully-expand-body-pane
                    fully-expand-log-pane
                    fully-expand-outline-pane
                    fully-expand-pane
                    hide-body-pane
                    hide-find-tab
                    hide-invisibles
                    hide-log-pane
                    hide-outline-pane
                    hide-pane
                    hide-spell-tab
                    iconify-frame
                    minimize-all
                    open-compare-window
                    open-spell-tab
                    resize-to-screen
    Shift+Next      scroll-down-half-page
                    scroll-down-line
    Next            scroll-down-page
                    scroll-outline-down-line
                    scroll-outline-down-page
                    scroll-outline-left
                    scroll-outline-right
                    scroll-outline-up-line
                    scroll-outline-up-page
    Shift+Prior     scroll-up-half-page
                    scroll-up-line
    Prior           scroll-up-page
                    simulate-begin-drag
                    simulate-end-drag
    Ctrl-T          toggle-active-pane
                    toggle-invisibles
                    toggle-split-direction
.. @+node:ekr.20060613062025.2: *4* Help commands
The following commands print various helpful messages.
Apropos commands print longer discussions of specific topics.
The help-for-command command prompts for a command name
(you can use typing completion to specify the command)
and then prints a brief description of that command::

        apropos-autocompletion
        apropos-bindings
        apropos-find-commands
        help
    F1  help-for-command
        help-for-python
        mode-help
        print-bindings
        print-commands
.. @+node:ekr.20060613062025.10: *4* Mode commands
These commands put Leo into various kinds of modes.

- The enter-x-mode commands enter modes defined by \@mode nodes in leoSettings.leo
  (or in other .leo files).

- The set-command-state, set-insert-state, set-overwrite-state commands
  determine how treats unbound plain keys. Leo ignores such keys in command
  state, inserts them into the body pane in insert state, and overwrites the
  character at the cursor position in overwrite state.

- Other commands determine whether autocompletion or calltips are in effect.

- When extend mode is effect, basic editing commands that move the cursor also
  extend the selected text.
  For example, in extend mode the back-char command works the same as the
  back-char-extend-selection command.

Here is the full list of mode-related commands::

                auto-complete
    Ctrl-Space  auto-complete-force
                disable-autocompleter
                disable-calltips
                enable-autocompleter
                enable-calltips
                enter-apropos-mode
                enter-commands-mode
                enter-edit-mode
                enter-emacs-mode
                enter-extract-mode
                enter-file-mode
                enter-gui-mode
                enter-help-mode
                enter-kill-mode
                enter-modes-mode
                enter-move-outline-mode
                enter-outline-mode
                enter-quick-command-mode
                enter-toggle-find-mode
                exit-named-mode
                set-command-state
                set-extend-mode
                set-insert-state
                set-overwrite-state
                set-silent-mode
                show-calltips
                show-calltips-force
    Alt-1       toggle-autocompleter
    Alt-2       toggle-calltips
                toggle-extend-mode
                toggle-input-state
.. @+node:ekr.20060613062025.7: *4* Outline commands
The following commands invoke Leo's outline commands::

    Ctrl-`          clone-node
    Alt-Minus       contract-all
                    contract-node
    Left            contract-or-go-left
                    contract-parent
    Ctrl-Shift-C    copy-node
                    cut-node
                    de-hoist
                    delete-node
    Ctrl-]          demote
                    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
                    expand-all
                    expand-and-go-right
                    expand-next-level
    Alt-}           expand-node
                    expand-or-go-right
                    expand-prev-level
                    go-back
                    go-forward
                    goto-first-node
                    goto-first-sibling
                    goto-last-node
                    goto-last-sibling
                    goto-last-visible
                    goto-line
                    goto-line-number
                    goto-next-changed
                    goto-next-clone
                    goto-next-marked
                    goto-next-node
                    goto-next-sibling
                    goto-next-visible
                    goto-parent
                    goto-prev-node
                    goto-prev-sibling
                    goto-prev-visible
                    hoist
                    insert-node
    Ctrl-M          mark
                    mark-changed-items
                    mark-subheads
    Ctrl+D          move-outline-down
    Shift+Down      move-outline-down
    Alt+Shift+Down  move-outline-down
    Shift+Left      move-outline-left
    Alt+Shift+Left  move-outline-left
    Shift+Right     move-outline-right
    Alt+Shift+Up    move-outline-up
    Ctrl+U          move-outline-up
                    outline-to-CWEB
                    outline-to-noweb
                    paste-node
                    paste-retaining-clones
    Ctrl-[          promote
                    sort-children
    Alt-A           sort-siblings
.. @+node:ekr.20060613062025.8: *4* Miscellaneous commands
Here are various miscellaneous minibuffer commands::

    about-leo
    add-comments
    check-all-python-code
    check-outline
    check-python-code
    clear-recent-files
    convert-all-blanks
    convert-all-tabs
    convert-blanks
    convert-tabs
    execute-script
    export-headlines
    exit-leo
    extract
    extract-names
    extract-section
    flatten-outline
    goto-global-line
    import-at-file
    import-at-root
    import-cweb-files
    import-derived-file
    import-flattened-outline
    import-noweb-files
    insert-headline-time
    new
    open-leoDocs-leo
    open-leoPlugins-leo
    open-leoSettings-leo
    open-offline-tutorial
    open-online-home
    open-online-tutorial
    open-outline
    open-outline-by-name
    open-python-window
    open-with
    open-with-idle
    open-with-word
    open-with-wordpad
    pretty-print-all-python-code
    pretty-print-python-code
    read-at-file-nodes
    read-outline-only
    reformat-paragraph
    revert
    save-buffers-kill-leo
    save-file
    save-file-as
    save-file-to
    settings
    set-colors
    set-font
    show-colors
    show-find-options
    show-fonts
    show-invisibles
    spell-change
    spell-change-then-find
    spell-find
    spell-ignore
    toggle-angle-brackets
    weave
    write-abbrev-file
    write-at-file-nodes
    write-dirty-at-file-nodes
    write-missing-at-file-nodes
    write-outline-only
.. @+node:ekr.20120229094652.15103: *3* Autocompletion
Leo's autocompletion feature suggests **completions**, text may be valid in
a given point, or **context** in source code. For example, suppose the
context is::

    os.path.s
    
That is, suppose the cursor follows ``os.path.s`` in the body pane. The
valid completions are all the members of Python's os.path module whose
names start with 's', namely::

    samefile
    sameopenfile
    sep
    split
    splitdrive
    splitext
    splitunc
    stat
    supports_unicode_filenames
    sys
    
How Leo displays these completions depends on the setting::

    @bool use_qcompleter
    
True: Leo shows completions in the QCompleter popup window.
False: Leo shows completions in the log pane.
    
To compute the list of completions, Leo first computes **Leo-specific**
completions. These completions assume that c is a commander, g is the
leoGlobals object and p is a position. If there are no such completions, Leo
computes completions using ctags data. In order to use these additional
completions you must create the ctags data as described in a later section.
.. @+node:ekr.20120229094652.15104: *4* Starting autocompletion
There are two ways to have Leo show completions. **Manual autocompletion**
shows autocompletions whenever you execute the auto-complete-force
(ctrl-space) command. **Automatic autocompletion** shows completions
whenever you type a period in the body pane.

You can enable autocompletion in two ways:

1. By setting @bool enable_autocompleter_initially = True.

2. By using the toggle-autocompleter (Alt-1) command.
.. @+node:ekr.20120229094652.15106: *4* Using the QCompleter
When the ``@bool use_qcompleter`` setting is False, Leo shows all completions in a
popup window, regardless of how many completions there are. To **accept** a
completion, use the up and down arrows to select a completion, then type the
return key. To **cancel** completion, type the escape key. As an important
shortcut, if the popup window contains only one entry, you may accept a
completion by simply typing the return key.
.. @+node:ekr.20120229094652.15107: *4* Using the Log pane completer
When the ``@bool use_qcompleter`` setting is True, Leo shows completions in in
Leo's log pane. When there are more than 20 completions, Leo shows only the
characters that start a completions. For example, when completing ``os.path.``
the log pane will show::

    _ 17
    a 2
    b 1
    c 2
    d 3
    e 4
    g 5
    i 5
    j 1
    l 1
    n 2
    o 1
    p 2
    r 2
    s 10
    
To see the complete list, type the '!' character.  You will see::

    __all__
    __builtins__
    __cached__
    __doc__
    __file__
    __name__
    __package__
    _get_altsep
    _get_bothseps
    _get_colon
    _get_dot
    _get_empty
    _get_sep
    _get_special
    _getfileinformation
    _getfinalpathname
    _getfullpathname
    abspath
    altsep
    basename
    commonprefix
    curdir
    defpath
    devnull
    dirname
    exists
    ...

Typically, however, you would simply type one of the valid prefix characters.
For example, typing the letter 'a' would create the context ``os.path.a`` and
the log pane would show::

    abspath
    altsep
    
As you type, Leo enters the longest common prefix of all completions into the
body pane. Typing return, escape or ctrl-g (or any other alt or ctrl key) ends
completion.
.. @+node:ekr.20120229094652.15108: *4* Showing docstrings
Regardless of the setting of ``@bool use_qcompleter``, typing '?' while
autocompleting will show the docstring of the present context. For example,
if the context is ``os.path.join``, typing '?' will show::

    Join two or more pathname components, inserting "\" as needed.
    If any component is an absolute path, all previous path components
    will be discarded.
    
It is not possible at present to copy the docstring from the log pane when
using the QCompleter because the QCompleter popup window is a modal dialog.
.. @+node:ekr.20120229094652.15116: *4* Autocompleter settings
These are found in leoSettings.leo: @settings-->Autocompleter::

**@bool use_qcompleter = True**

    True:  show completions in a QCompleter popup.
    False: show completions in Leo's Completions tab.
    
**@bool auto_tab_complete = False**
    
    True: Automatically extend the completed text to the longest common
    prefix of all completions.
    
**@bool autocomplete-brackets = False**
    
    True: When typing an opening bracket '(','[' or '{', immediately type
    the corresponding closing bracket. To move past the closing bracket,
    just type it.
    
**@bool enable_calltips_initially = False**
    
**@bool forbid_invalid_completions = False**
    
    True: Don't add characters during autocompletion that are not part of
    any computed completion.
.. @+node:ekr.20120229094652.15102: *4* Creating ctags data
This section describes how to create ctags data files describing the
desired completions. You must do this when the use_codewise setting is
True.

1. Make sure you have exuberant ctags (not just regular ctags)
   installed. It's an Ubuntu package, so its easy to install if
   you're using Ubuntu.
   
2. Execute the following commands from Leo's external/codewise.py
   module. **Note**: On Windows, you can use codewise.bat to
   execute these commands. For example::

        python <path to leo>\external\codewise.py %*
    
A. [Optional] Create a custom ~/.ctags file containing default
   configuration settings for ctags::
    
        codewise setup
        
    This command will leave the ~/.ctags file unchanged if it
    exists.  Otherwise, the ``codewise setup`` command will
    create a ~/.ctags file containing the following defaults::
    
        --exclude=*.html
        --exclude=*.css
    
    http://ctags.sourceforge.net/ctags.html#FILES for more
    details about the .ctags file.
    
B. [Optional] Delete the existing ctags database in ~/.codewise.db::
   
        codewise init
        
C. Add ctags data to the existing ctags database::

        codewise parse <path to directory>
        
   You can add data from multiple sources by running
   the ``codewise parse`` command on multiple directories.
.. @+node:ekr.20100504092040.17423: *3* Calltips
Calltips appear after you type an open parenthesis in code. Calltips shows the
expected arguments to a function or method. Calltips work for any Python
function or method, including Python's global functions. Typing Return or
Control-g (keyboard-quit) exits calltips.

Examples:

a)  'g.toUnicode('  gives 'g.toUnicode(s, encoding, reportErrors=False'
b) 'c.widgetWantsFocusNow' gives 'c.widgetWantsFocusNow(w'
c) 'reduce(' gives 'reduce(function, sequence[, initial]) -> value'

The calltips appear directly in the text and the argument list is highlighted so
you can just type to replace it. The calltips appear also in the status line for
reference after you have started to replace the args.

Options

Both autocompletion and calltips are initially enabled or disabled by the
enable_autocompleter and enable_calltips settings in leoSettings.leo. You may
enable or disable these features at any time with these commands:
enable-auto-completer-command, enable-calltips-command,
disable-auto-completer-command and disable-calltips-command.
.. @+node:EKR.20040524104904.100: *3* File commands
.. @+node:EKR.20040524104904.101: *4* Loading, Saving and Reverting Files
The ``new`` (Ctrl-N) command creates a new Leo main window. The
``open-outline`` (Ctrl-O) command opens an existing Leo file and shows it
in a main window. The ``close-window`` (Ctrl-F4) command closes the
selected Leo window, giving you an opportunity to save your work if you
haven't yet done so.

The ``save-file`` (Ctrl-S), ``save-file-as`` and ``save-file-to`` commands
save the Leo window to a file. The ``save-files-as`` command changes the
name of the outline being edited; the ``save-file-to`` command does not.
The ``save-file-as-zipped`` command is the same as the ``save-file-as``
command except that the resulting .leo file is compressed with Python's
zipfile module. Similarly, the ``save-file-as-unzipped`` command is the
same as the ``save-as`` command except that the resulting .leo file is not
compressed. The ``save-file``, ``save-file-as`` and ``save-file-to``
commands compress the file if it was originally compressed. **Note**: Leo
writes files with .leo extension, regardless of whether the file is zipped
or not. Zipped .leo files contain a single archive, whose name is the same
as the .leo file itself. Outside of Leo you can change the extension to
.leo.zip and use stuffit or other program to expand the .leo file contained
within. The ``revert`` command reloads a file, discarding any changes made
to the file since it was last saved.

The Recent Files menu shows a list of recently opened files. Choosing an
item in this submenu opens the selected file or brings it to the front. The
``clear-recent-files`` command deletes all entries in the Recent Files
submenu except the most recent file. The files themselves are not affected,
just the menu entries.

The following commands are located in the File:Read/Write menu...

The ``read-outline-only`` command reads an outline using only the .leo
file, not any files derived from @file nodes. This command is useful for
reverting a project to a previously saved state. The ``read-at-file-nodes``
command updates all @file nodes in an outline. This ensures that the state
of an outline matches all files derived from \@file nodes. The
``write-outline-only`` command saves an outline without writing any \@file
trees. Useful for inserting an @file node into an outline without modifying
a external file with the same name. The ``write-at-file-nodes`` command
forces an update of all @file trees. The ``write-dirty-at-file-nodes``
command writes all @file trees that have been changed.
.. @+node:EKR.20040524104904.102: *4* Communicating with external editors
The ``open-with`` command allows you to communicate with external editor.
When you select this command 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 in myLeoSettings.leo. See the
documentation in leoSettings.leo.
.. @+node:EKR.20040524104904.108: *4* Importing Files into Leo Outlines
The ``import-file`` command imports a file in various ways depending on the
contents of the file. For plain files, the command creates an \@file node.
If the file looks like an external file written by Leo, the import command
will recreate the outline structure based on the sentinels in the file.
This command can also read files written in MORE outline format.
.. @+node:EKR.20040524104904.109: *4* Exporting Files from Leo Outlines
The ``outline-to-cweb`` command creates a `CWEB`_ file from the selected
outline. The ``outline-to-noweb`` command creates a `noweb`_ file from the
selected outline. The ``flatten-outline`` command creates a text file in
MORE format from the selected outline. The ``remove-sentinels`` command
removes all sentinel lines from a file derived from an @file node. The
``weave`` command formats the selected text and writes it to a file.
.. @+node:EKR.20040524104904.110: *4* Quitting Leo
The ``exit-leo`` (Ctrl-Q or Alt-F4) command causes Leo to exit. You may
also exit Leo by closing the main window. You will be prompted to save any
file that has been altered but not saved.
.. @+node:EKR.20040524104904.111: *3* Edit commands
.. @+node:EKR.20040524104904.112: *4* Undoing changes
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.
.. @+node:EKR.20040524104904.113: *4* Cutting, pasting and selecting text
Leo supports the standard editing commands: ``cut-text`` (Ctrl-X),
``copy-text`` (Ctrl-C) and ``paste-text`` (Ctrl-V), and ``select-all``
(Ctrl-A) commands. These commands work with either headline or body text.
.. @+node:EKR.20040524104904.114: *4* Indenting body text
The ``indent-region`` (Ctrl-Tab) and ``unindent-region`` (Tab) commands
shift selected lines in the body text left or right one tab position. These
commands shift the entire line if any characters in that line are selected.
If no text is selected, the Tab character insert a hard or soft tab
depending on the value of the \@tabwidth directive in effect.
.. @+node:ekr.20050313102319: *4* Adding and deleting comments in body text
The ``add-comments`` (Ctrl-)) command puts comments around a block of code.
This command uses single-line comments if possible. The ``delete-comments``
(Ctrl-() command deletes the comments.
.. @+node:EKR.20040524104904.115: *4* Creating nodes from body text
The ``extract`` (Ctrl-Shift-D) command 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. The ``extract-names`` (Ctrl-Shift-Command) command 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.
.. @+node:EKR.20040524104904.116: *4* Converting leading blanks and tabs in body text
The ``convert-tabs`` command converts leading tabs to blanks in a single
node. The ``convert-blanks`` command converts blanks to tabs in a single
node. The ``convert-all-tabs`` command converts leading tabs to blanks
throughout the selected tree. The ``convert-all-blanks`` command converts
leading blanks to tabs throughout the selected tree. All these commands
convert between tabs and blanks using the \@tabwidth setting presently in
effect.
.. @+node:EKR.20040524104904.117: *4* Executing Python scripts in body text
The ``execute-script`` (Ctrl-B) command 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.
.. @+node:EKR.20040524104904.118: *4* Finding and changing text
.. @+node:ekr.20120319065417.8792: *5* Overview
Leo supports a wide array of commands for searching and replacing
text. The typical way to find text is with the
``search-with-present-options`` (Ctrl-F). Focus moves to the
minibuffer. Type the search pattern, followed by a <Return>. To search
and replace, type <Ctrl-F>, followed by the search pattern, followed
by ``replace-string`` (Ctrl-Shift-R) command, followed by the
replacement pattern, and finally a <Return> to start the search.

The following sections discuss all of Leo's find and change commands.
**Important**: The radio buttons in the Find tab (Entire Outline,
Suboutline Only and Node only) control how much of the outline is
affected by Leo's find and change commands.
.. @+node:ekr.20120319065417.8790: *5* Basic searches
The ``search-with-present-options`` (Ctrl-F) 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. This is a recommended default search command. The ``find-next``
(F3) command continues a search started with
``search-with-present-options``. The ``find-previous`` (F2) commands
searches backwards using the present search options.

To search and replace, type <Ctrl-F>, followed by the search pattern,
followed by the ``replace-string`` (Ctrl-Shift-R) command, followed by
the replacement pattern, and finally a <Return> to start the search.
.. @+node:ekr.20120319065417.8791: *5* find-all, clone-find-all & clone-find-all-flattened
The ``find-all`` command prints all matches in the log pane. The
``clone-find-all`` command searches the outline and creates a new root node
called Found: *<your search pattern>*. This node contains clones of the
found nodes. The ``clone-find-all-flattened`` commands includes all found
nodes, even if they are also children of previously found nodes.
.. @+node:ekr.20120319065417.8797: *5* Change commands
The ``replace-string`` (Ctrl-Shift-R) command prompts for a search string.
Type <Return> to end the search string. The command will then prompt for
the replacement string. Typing a second <Return> key will place both
strings in the Find tab and executes a **find** command, that is,
search-with-present-options.

The ``change`` (Ctrl-=) command replaces the selected text with the
'change' text in the Find tab. The ``change-then-find`` (Ctrl--) command
replaces the selected text with the 'change' text in the Find tab, then
executes the find command again. These commands can simulate any kind of
query-replace command. The ``change-all`` changes all occurrences of the
'find' text with the 'change' text.
.. @+node:ekr.20120319065417.8798: *5* Incremental find commands
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::

    Alt+R isearch-backward
          isearch-backward-regexp
    Alt+S isearch-forward
          isearch-forward-regexp
          isearch-with-present-options
.. @+node:ekr.20120319065417.8794: *5* Commands that set find options
Several commands toggle the checkboxes and radio buttons in the Find tab,
and thus affect the operation of the search-with-present-options command.
You may bind these commands to keys or toggle these options in a mode.
These commands toggle checkboxes::

    Alt+Ctrl+I  toggle-find-ignore-case-option
    Alt+Ctrl+B  toggle-find-in-body-option
    Alt+Ctrl+H  toggle-find-in-headline-option
    Alt+Ctrl+C  toggle-find-mark-changes-option
    Alt+Ctrl+F  toggle-find-mark-finds-option
    Alt+Ctrl+X  toggle-find-regex-option
    Alt+Ctrl+W  toggle-find-word-option
    Alt+Ctrl+A  toggle-find-wrap-around-option

These commands set radio buttons::

    Alt+Ctrl+E  set-find-everywhere
    Alt+Ctrl+N  set-find-node-only
    Alt+Ctrl+S  set-find-suboutline-only
.. @+node:ekr.20120319065417.8795: *5* Word search and regex search commands
The following commands set an option in the Find tab, then work
exactly like the ``search-with-present-options`` command. The
``search-backward`` and ``search-forward`` commands set the 'Whole
Word' checkbox to False. The ``word-search-backward`` and
``word-search-forward`` set the 'Whole Word' checkbox to True. The
``re-search-forward`` and ``re-search-backward`` set the 'Regexp'
checkbox to True.
.. @+node:ekr.20120319065417.8788: *5* Find settings
The following check boxes options appear in the search dialog and control
the operations of the find and change commands.

Ignore Case
    When checked, the Find and Change commands ignore the case of
    alphabetic characters when determining matches.

Mark Changes
    When checked, the Change command marks all headlines whose headline or
    body text are changed by the command.

Mark Matches
    When checked, the Find and Change commands mark all headlines in which
    a match is found with the pattern.

Pattern Match
    When checked, the Find and Change commands treat several characters
    specially in the find pattern.

    - '*'  matches any sequence of zero or more characters.
    - '.'  matches any single character.
    - '^'  matches a newline at the start of a pattern.
    - '$'  matches a newline at the end of a pattern.

Examples::

    "^abc$" matches lines that only contain "abc".
    "^a" matches any line starting with "A".
    "a$" matches any line ending with "a".
    "^*$" matches any line at all.

Search Body Text
    When checked, the Find and Change commands search body text.

Search Headline Text
    When checked, the Find and Change commands search headline text.

Suboutline Only
    When checked, the Find and Change commands search only the currently
    selected headline and its offspring.

Whole Word
    When checked, 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.

Wrap Around
    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.
.. @+node:EKR.20040524104904.134: *4* Go To Line Number
The ``goto-global-line`` (Alt-G) command selects the locations in your
outlines corresponding to a line in a external file.
.. @+node:EKR.20040524104904.136: *4* Inserting the date and time
The ``insert-body-time`` and ``insert-headline-time`` commands 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. For a complete list of the format options see
http://www.python.org/doc/current/lib/module-time.html The "%m/%d/%Y
%H:%M:%S" format is used by default, resulting in a time/date format like::

    1/30/2003 8:31:55
.. @+node:EKR.20040524104904.137: *4* Reformatting paragraphs in body text
The ``reformat-paragraph`` (Ctrl-Shift-P) command 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.
.. @+node:EKR.20040524104904.139: *4* Matching brackets and parenthesis
The ``match-brackets`` command is enabled if the cursor is next to one of the
following characters in the body pane:

    ( ) [ ] { } < >

This 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.
.. @+node:ekr.20120319170934.6104: *4* Indenting body text automatically
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 ( [ or { brackets in the previous line.
.. @+node:ekr.20120319170934.6105: *4* Creating and destroying multiple body editors
The ``add-editor`` command adds a new editor in the body pane and gives it
the body editor focus. The ``delete-editor`` command deletes the editor
with body editor focus. The ``cycle-editor-focus`` command 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.
.. @+node:ekr.20120319170934.6109: *4* Opening URL's
The ``open-url`` (Ctrl-F3 or Ctrl-Left-Click) command looks for a headline
in either the headline or body text of the node. If the headline or first
body line of the node looks like an URL, the ``open-url`` command attempts
to open that URL using either os.startfile or a web browser.

Leo checks that the URL is valid before doing so. A valid URL is:

-   3 or more lowercase alphas
-   followed by one :
-   followed by one or more of:
-   ``$%&'()*+,-./0-9:=?@A-Z_a-z{}~``
-   followed by one of: ``$%&'()*+/0-9:=?@A-Z_a-z}~`` 

That is, a comma, hyphen and open curly brace may not be the last character)
URL's should contain no spaces: use %20 to indicate spaces. You may use any
type of URL that your browser supports: http, mailto, ftp, file, etc.
.. @+node:ekr.20120319170934.6110: *4* Using chapters
Chapters are regions of a Leo outline whose root is an ``@chapter`` node. They
are available in an outline if the ``@bool usechapters`` option is True.
``@chapter`` nodes may appear anywhere in an outline, but the ``create-chapter``
command (see below) creates ``@chapter`` nodes as children of the first
``@chapters`` (note the ``s``) node in the outline.

One selects a chapter with the ``select-chapter`` command, after which Leo shows
only the nodes in the selected chapter; in this respect, chapters are like
hoists. The ``main`` chapter represents the entire outline and can not be
deleted by name. When chapters are in effect, Leo creates an ``@chapters`` node
for the use of ``create-chapter``.

Associated settings:

- The ``@bool use_chapters`` setting determines whether chapters are enabled.
- The ``@bool use_chapter_tabs`` setting determines whether the chapters
  pop-up menu appears in the icon area. Choosing a chapter name from this list selects a chapter.

When chapters are enabled, the Cmds->Chapters menu shows all available chapter commands:

- The ``chapter-create`` command creates an @chapter node and populates it with a single node.
- The ``chapter-remove`` command deletes the currently selected chapter.
- The ``chapter-select`` command prompts for a chapter name and makes only the nodes of the selected chapter visible.
- The ``chapter-move-node-to``, ``chapter-clone-node-to`` and ``chapter-copy-node-to`` commands
  prompt for a chapter name and add the currently selected node (and its descendants) to another chapter.
.. @+node:EKR.20040524104904.143: *3* Outline commands
.. @+node:ekr.20120319170934.6096: *4* Creating and destroying nodes
The ``insert-node`` (Ctrl-I or Insert) command inserts a new node into the
outline. When invoked, (from any pane), it inserts a new node below the
presently selected node, and at the same level as that node, or at the
child level if it has a visible child. The ``delete-node`` command deletes
a node and all its children. To retain the children, just promote all the
children before you do the delete.
.. @+node:ekr.20120319170934.6095: *4* Expanding & contracting nodes
You can expand or contract a node by clicking in the tree view icon to the
left of the headline. The icon in the Qt gui matches the native OS's tree
view icon, i.e. for Mac's, a triangle pointing right or down; on Windows, a
square containing a plus or minus. Expanding a node shows its immediate
children; contracting a node hides all its children.

The ``expand-node`` and ``contract-node`` commands also expand and contract
nodes. For more convenient navigation, there are ``expand-and-go-right``
(Alt-Right) and ``contract-or-go-up`` (Alt-Left) commands.

The ``expand-all`` command expands every node in the outline.
``contract-all`` (Alt-hyphen) contracts every node in the outline. In all
but the smallest outlines, ``expand-all`` is rarely used, and it does not
have a default key binding.
.. @+node:ekr.20120319170934.6097: *4* Cutting, pasting and deleting nodes
The ``cut-node`` (Ctrl-Shift-X) ``paste-node`` (Ctrl-Shift-V),
``copy-node`` (Ctrl-Shift-C) and ``delete-node`` commands work on nodes
rather than text. The ``cut-node`` and ``copy-node`` commands copy a text
representation of the outline to the clipboard. This representation is the
same as Leo's .leo file format with some information deleted. You may copy
this text representation into a body pane (or into any other text editor)
using Edit->Paste in the menus, Ctrl-V, or Alt-X paste-text.

**Warning**: If you want to preserve the "cloned" attribute of a node, or
want to paste the node as a clone of the node you cut or copied, use the
``past-retaining-clones`` command, which in the Outline menu is called
"Paste Node as Clone". The ``paste-node`` command instead creates a new,
distinct version of the node you previously cut or copied, though if there
were descendant nodes which were clones of each other, the new version will
have parallel, distinct nodes that are also clones of each other (just not
of the originals). You may paste a node between .leo files, but there can
be no clone relationship across files.

The ``paste-retaining-clones`` command is disabled if it would cause a node
to become a parent of itself. The Leo outline is thus mathematically a
*directed acyclic graph*: clones make it more flexible than a tree, but not
a generalized graph.
.. @+node:ekr.20120319170934.6094: *4* Navigating through the outline
Leo has many commands that select nodes in the outline. These commands can be
found in the Outline:Go To menu.

As described in the tutorial, you can move about the outline by clicking on the
headlines or using Alt+arrow keys.
.. @+node:ekr.20120319170934.6098: *4* Moving & Reorganizing nodes
The ``move-outline-up`` (Ctrl-U or Alt-Shift-Up), ``move-outline-down``
(Ctrl-D or Alt-Shift-Down), ``move-outline-left`` (Ctrl-L or
Alt-Shift-Left), and ``move-outline-right`` (Ctrl-R or Alt-Shift-Right)
commands move the currently selected node. **Important**: When focus is in
the outline pane, you can move nodes without adding the Alt modifier.
Shift-Up moves the select node up, etc.

The ``promote`` (Ctrl-[) command makes all the children of
a node siblings of the node. The ``demote`` (Ctrl-]) command makes all following
siblings of a node children of the node.
.. @+node:ekr.20120319170934.6099: *4* Cloning nodes
A cloned node is a copy of a node that changes when the original changes.
One may also think of it as a single node that is hooked into the outline
at multiple positions. Because that single node brings along all its
descendants, changes are maintained across all the the clones of a node,
along with changes to its offspring (children, grandchildren, etc.), i.e.,
any changes are simultaneously made to the corresponding offspring of all
of those clones. A small red arrow in the icon box marks cloned nodes. You
can think of the arrow as pointing out that there are other paths to get to
this same node. There is no real distinction between the "original" node
and any of its clones. Any headline or body update of a clone headed
subtree affects all of its clones simultaneously. A cloned node becomes a
regular node whenever deletion of its other clones makes it the only one
left. Clones are useful for making alternate views of a program. See
`Clones and views`_ for full details.

The ``clone-node`` (Ctrl-\`) command creates a clone as the immediate
sibling of a selected node. You have to place it where you want it by
either using move commands, or cutting and paste the clone.
.. @+node:ekr.20120319170934.6100: *4* Marking nodes
The ``mark`` (Ctrl-M) marks a node if it is unmarked, and unmarks the node
if it is already marked. The ``mark-subheads`` command marks all offspring
of the presently selected node. The ``mark-changed-items`` command marks
all nodes whose headline or body text has been changed since the file
was last saved.

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.

The ``goto-next-marked`` command selects the next marked node.
.. @+node:ekr.20120319170934.6101: *4* Dragging nodes
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
the icon for another node, Leo will move the dragged node after that node.
If you release the mouse button when the hand cursor is not over an icon,
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.
.. @+node:EKR.20040524104904.148: *4* Hoisting & De-hoisting nodes
The ``hoist`` command 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. The ``dehoist`` command undoes the effect of the
previous ``hoist`` command.
.. @+node:EKR.20040524104904.144: *4* Checking outlines
The ``check-outline`` command checks the outline for consistency. Leo
automatically check the syntax of Python external files when Leo
writes the external file.

The ``pretty-print-python-code`` and ``pretty-print-all-python-code``
pretty print 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.
.. @+node:ekr.20120319170934.6108: *4* Resizing panes
You can change the relative sizes of the outline and body panes by dragging
the splitter bar. The ``equal-sized-panes`` command resizes the panes so
that each fills half of the main window.
.. @+node:EKR.20040524104904.151: *3* Window commands
-   The Equal Sized Panes command adjusts the sizes of the outline and body
    panes so that they are the same height.
-   The Cascade command cleans up the screen by cascading all Leo windows.
-   The Minimize All command minimizes all Leo windows.
-   The Toggle Active Pane command toggles keyboard focus between the outline and body panes.
-   The Toggle Split Direction command 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.
-   The Open Compare Window command opens a dialog that allows you to compare
    two files, one containing sentinels and one not.
.. @+node:EKR.20040524104904.157: *3* Help commands
-   The About Leo command puts up a dialog box showing the version of Leo.
-   The Online Home Page command opens Leo's home page at http://webpages.charter.net/edreamleo/front.html.
-   The Open Online Tutorial command opens Joe Orr's excellent ScreenBook tutorial at
    http://www.evisa.com/e/sbooks/leo/sbframetoc_ie.htm.
-   The Open Offline Tutorial command opens the file sbooks.chm if it exists.
    Otherwise, you will be asked whether you want to download it from Leo's SourceForge web site.
    If you say yes, the page http://sourceforge.net/project/showfiles.php?group_id=3458 will open.
    You may then download sbooks.sbm to the folder containing leo.py.
-   The Open LeoDocs.leo command opens LeoDocs.leo.
-   The Open LeoPlugins.leo command opens LeoPlugins.leo.
-   The Open LeoSettings.leo command opens LeoSettings.leo.

.. @-all
.. @-leo
