<type>documentation</type>
<domain>commands</domain>
<id>commands/edit</id>
<title>Editor Commands</title>
<product>per+</product>

Editor Non Modal Commands
-------------------------

Commands available only when the editor is in non-modal editing mode

**exit-visual-mode** ()

Exit visual mode and return back to default mode  *Key Bindings: Wing: Esc; Brief: Esc; Eclipse: Esc; Emacs: Esc; MATLAB: Esc; VI/VIM: Ctrl-[; Visual Studio: Esc; macOS: Esc*

**start-select-char** ()

Turn on auto-select mode character by character  *Key Bindings: Wing: Shift-F8; Brief: Shift-F8; Eclipse: Shift-F8; Emacs: Shift-F8; MATLAB: Shift-F8; VI/VIM: v; Visual Studio: Shift-F8; macOS: Shift-F8*

**start-select-line** ()

Turn on auto-select mode line by line  *Key Bindings: Wing: Ctrl-F8; Brief: Ctrl-F8; Eclipse: Ctrl-F8; Emacs: Ctrl-F8; MATLAB: Ctrl-F8; VI/VIM: Shift-V; Visual Studio: Ctrl-F8; macOS: Command-F8*

**start-select-rectangle** ()

Turn on auto-select rectangle mode  *Key Bindings: Wing: Shift-Ctrl-F8; Brief: Shift-Ctrl-F8; Eclipse: Shift-Ctrl-F8; Emacs: Shift-Ctrl-F8; MATLAB: Shift-Ctrl-F8; VI/VIM: Ctrl-Q; Visual Studio: Shift-Ctrl-F8; macOS: Shift-Command-F8*

Editor Panel Split Commands
---------------------------

Commands that control splits in an editor panel.  These are available
only when one split in the editor panel has the keyboard focus.

**split-horizontally** (new=0)

Split current view horizontally.   *Key Bindings: Emacs: Ctrl-X 3; VI/VIM: Ctrl-W v*

**split-horizontally-open-file** (filename)

Split current view horizontally and open selected file

**split-vertically** (new=0)

Split current view vertically.  Create new editor in new view when new==1.  *Key Bindings: Brief: F3; Emacs: Ctrl-X 2; VI/VIM: Ctrl-W n invokes split-vertically(new=1)*

**split-vertically-open-file** (filename)

Split current view vertically and open selected file

**unsplit** (action='current')

Unsplit all editors so there's only one.  Action specifies how to
choose the remaining displayed editor.  One of::

  current -- Show current editor
  close   -- Close current editor before unsplitting
  recent  -- Change to recent buffer before unsplitting
  recent-or-close -- Change to recent buffer before closing
  split, or close the current buffer if there is only
  one split left.  *Key Bindings: Brief: F4; Emacs: Ctrl-X 1; VI/VIM: Ctrl-W o*

Editor Split Commands
---------------------

Commands for a particular editor split, available when the editor
in that split has the keyboard focus.

**activate-file-option-menu** ()

Activate the file menu for the editor.   *Key Bindings: Wing: Ctrl-1; Brief: Ctrl-1; Eclipse: Ctrl-1; Emacs: Ctrl-1; MATLAB: Ctrl-1; VI/VIM: Ctrl-1; Visual Studio: Ctrl-1; macOS: Command-1*

**grow-split-horizontally** ()

Increase width of this split

**grow-split-vertically** ()

Increase height of this split  *Key Bindings: VI/VIM: Ctrl-W +*

**shrink-split-horizontally** ()

Decrease width of this split

**shrink-split-vertically** ()

Decrease height of this split  *Key Bindings: VI/VIM: Ctrl-W -*

**visit-history-next** ()

Move forward in history to next visited editor position  *Key Bindings: Wing: Forward-button-click; Brief: Forward-button-click; Eclipse: Alt-Right; Emacs: Forward-button-click; MATLAB: Forward-button-click; VI/VIM: Ctrl-I; Visual Studio: Ctrl-_; macOS: Forward-button-click*

**visit-history-previous** ()

Move back in history to previous visited editor position  *Key Bindings: Wing: Back-button-click; Brief: Back-button-click; Eclipse: Ctrl-Q; Emacs: Back-button-click; MATLAB: Back-button-click; VI/VIM: Ctrl-O; Visual Studio: Ctrl--; macOS: Back-button-click*

Editor VI Browse Mode Commands
------------------------------

Commands available only when the editor is in browse mode, used for VI bindings.

**enter-insert-mode** (pos='before')

Enter editor insert mode  *Key Bindings: VI/VIM: Shift-A invokes enter-insert-mode(pos="after")*

**enter-replace-mode** ()

Enter editor replace mode  *Key Bindings: VI/VIM: Shift-R*

**enter-visual-mode** (unit='char')

Enter editor visual mode.  Unit should be one of 'char', 'line',
or 'block'.

**previous-select** ()

Turn on auto-select using previous mode and selection  *Key Bindings: VI/VIM: g v*

**start-select-char** ()

Turn on auto-select mode character by character  *Key Bindings: Wing: Shift-F8; Brief: Shift-F8; Eclipse: Shift-F8; Emacs: Shift-F8; MATLAB: Shift-F8; VI/VIM: v; Visual Studio: Shift-F8; macOS: Shift-F8*

**start-select-line** ()

Turn on auto-select mode line by line  *Key Bindings: Wing: Ctrl-F8; Brief: Ctrl-F8; Eclipse: Ctrl-F8; Emacs: Ctrl-F8; MATLAB: Ctrl-F8; VI/VIM: Shift-V; Visual Studio: Ctrl-F8; macOS: Command-F8*

**start-select-rectangle** ()

Turn on auto-select rectangle mode  *Key Bindings: Wing: Shift-Ctrl-F8; Brief: Shift-Ctrl-F8; Eclipse: Shift-Ctrl-F8; Emacs: Shift-Ctrl-F8; MATLAB: Shift-Ctrl-F8; VI/VIM: Ctrl-Q; Visual Studio: Shift-Ctrl-F8; macOS: Shift-Command-F8*

**vi-command-by-name** ()

Execute a VI command by name.  This implements ":" commands for the
VI/Vim keyboard personality.  The following subset of VI/Vim : commands
are supported::

  r[!], e[dit], e!, e#, ene[w], w[rite], up[date], wa[ll], q[uit], q[!], qall, wq,
  x[it], xall, wqall, sp[lit], vs[plit], new, on[ly], buffers, files, !, s[ubstitute],
  d, delm, reg, marks, n[ext], N, p[revious], rew[ind], last, m[ove], co[py], cl[ose]
  (an approximation), and set.
  
The supported directives for 'set' are:: 

  ic, ignorecase, noic, noignorecase, ai, autoindent, noai, noautoindent, nu, number,
  nonu, nonumber, ro, readonly, noro, noreadonly, sm, showmatch, nosm, and noshowmatch.
      *Key Bindings: VI/VIM: :*

**vi-set** (command)

Perform vi's :set action. The command is the portion after :set.  Currently
supports ic, noic, ai, noai, number or nu, nonumber or nonu, ro, noro, sm, and
nosm.  Multiple options can be specied in one call as for :set ic sm ai

Editor VI Insert Mode Commands
------------------------------

Commands available only when editor is in insert mode, used for VI bindings.

**enter-browse-mode** (provisional=False)

Enter editor browse mode  *Key Bindings: VI/VIM: Ctrl-V*

Editor VI Replace Mode Commands
-------------------------------

Commands available only when editor is in replace, used for the VI bindings.

**enter-browse-mode** (provisional=False)

Enter editor browse mode  *Key Bindings: VI/VIM: Ctrl-V*

Editor VI Visual Mode Commands
------------------------------

Commands available only when the editor is in visual mode, used for VI bindings.

**enter-browse-mode** ()

Enter editor browse mode  *Key Bindings: VI/VIM: Ctrl-V*

**enter-insert-mode** (pos='delete-sel')

Enter editor insert mode  *Key Bindings: VI/VIM: Shift-A invokes enter-insert-mode(pos="after")*

**enter-visual-mode** (unit='char')

Alter type of editor visual mode or exit back to browse mode.  Unit should be 
one of 'char', 'line', or 'block'.

**exit-visual-mode** ()

Exit visual mode and return back to default mode  *Key Bindings: Wing: Esc; Brief: Esc; Eclipse: Esc; Emacs: Esc; MATLAB: Esc; VI/VIM: Ctrl-[; Visual Studio: Esc; macOS: Esc*

**select-inner** (extend=False)

Select a text object based on the following key press  *Key Bindings: VI/VIM: a invokes select-inner(extend=True)*

**vi-command-by-name** ()

Execute a VI command by name.  This implements ":" commands for the
VI/Vim keyboard personality.  The following subset of VI/Vim : commands
are supported::

  r[!], e[dit], e!, e#, ene[w], w[rite], up[date], wa[ll], q[uit], q[!], qall, wq,
  x[it], xall, wqall, sp[lit], vs[plit], new, on[ly], buffers, files, !, s[ubstitute],
  d, delm, reg, marks, n[ext], N, p[revious], rew[ind], last, m[ove], co[py], cl[ose]
  (an approximation), and set.
  
The supported directives for 'set' are:: 

  ic, ignorecase, noic, noignorecase, ai, autoindent, noai, noautoindent, nu, number,
  nonu, nonumber, ro, readonly, noro, noreadonly, sm, showmatch, nosm, and noshowmatch.
      *Key Bindings: VI/VIM: :*

Current Editor Commands
-----------------------

Editor commands that act on the current (most recently active) source 
editor, whether or not it currently has the keyboard focus.

**ai-suggest-cancel** ()

Terminate AI suggestion mode without making a suggestion

**ai-suggest-confirm** ()

Select the current suggested completion and terminate AI suggestion mode.

**ai-suggest-edit-context** ()

Edit the AI request context currently being used by AI suggestion

**ai-suggest-next** ()

Move to the next suggested completion in AI suggestion mode.  Starts
AI suggestion mode if not already running.

This command requires first configuring an AI provider as described in the
AI Assisted Development chapter of the product manual.  *Key Bindings: Wing: Alt-Tab; Brief: Alt-Tab; Eclipse: Alt-Tab; Emacs: Alt-Tab; MATLAB: Alt-Tab; VI/VIM: Alt-Tab; Visual Studio: Alt-Tab*

**ai-suggest-previous** ()

Move to the previous suggested completion in AI suggestion mode.  Starts
AI suggestion mode if not already running.

**ai-suggest-save-context** ()

Initiating saving a new AI request context based on the context currently being
used by AI suggestion

**black-file** (timeout=None)

Reformat the current file with Black, if installed in the active Python. The
command will time out after the given number of seconds, or if timeout is None the
timeout configured with the Editor > Auto-formatting > Reformat Timeout preference.

**black-selection** (start=None, end=None)

Reformat the current selection, or current line if there is no selection with Black.
Reformats the given range if start and end are given.

**check-indent-consistency** ()

Check whether indents consistently use spaces or tabs throughout the file. 

**comment-out-region** (style=None)

Comment out the selected region. The style of commenting can be controlled with the
style argument: 'indented' uses the default comment style indented at end of leading
white space, 'block' uses a block comment in column zero, and 'block-indented' uses a
block comment in the column determined by the least indented line.

Append '-pep8' to the style to conform to PEP 8 comment format rules (adding a space
after the comment character) in Python files.  This option is ignored in non-Python
files.
  
If not given, the style configured with the Editor / Block Comment Style preference is
used. Each call adds a level of commenting.  *Key Bindings: Wing: Ctrl-/; Eclipse: Ctrl-/; Emacs: Ctrl-C C; MATLAB: Ctrl-/; Visual Studio: Ctrl-K Ctrl-C; macOS: Command-'*

**comment-out-toggle** (style=None)

Comment out the selected lines. This command is not available if they
lines are already commented out. The style of commenting can be controlled
with the style argument: 'indented' uses the default comment style
indented at end of leading white space and 'block' uses a block comment in
column zero. Append '-pep8' to the style to conform to PEP 8 block comment
format rules.  If not given, the style configured with the Editor / Block
Comment Style preference is used.

**comment-toggle** (style=None)

Toggle commenting out of the selected lines. The style of commenting
can be controlled with the style argument: 'indented' uses the default
comment style indented at end of leading white space and 'block' uses a
block comment in column zero.  Append '-pep8' to the style to conform
to PEP 8 comment format rules.  If not given, the style configured with the
Editor / Block Comment Style preference is used.  *Key Bindings: Wing: Ctrl-.; Eclipse: Ctrl-.; Emacs: Ctrl-C #; MATLAB: Ctrl-.; Visual Studio: Ctrl-K Ctrl-T; macOS: Command-;*

**convert-indents-to-mixed** (indent_size)

Convert all lines with leading spaces to mixed tabs and spaces. 

**convert-indents-to-spaces-only** (indent_size)

Convert all lines containing leading tabs to spaces only. 

**convert-indents-to-tabs-only** ()

Convert all indentation to use tab characters only and no spaces 

**evaluate-code-in-debug-console** (code)

Evaluate the given code within the Debug Console tool. When invoking this command
directly, only one line can be entered. To enter multiple lines at once, invoke this
command with CAPIApplication.ExecuteCommand() in the scripting API.

**evaluate-code-in-shell** (code, restart=False)

Evaluate the given code within the Python Shell tool, optionally restarting the
shell first. When invoking this command directly, only one line can be entered. To
enter multiple lines at once, invoke this command with CAPIApplication.ExecuteCommand()
in the scripting API.

**evaluate-file-in-shell** (restart_shell=None)

Run or debug the contents of the editor within the Python Shell  *Key Bindings: Wing: Ctrl-Alt-V; Eclipse: Ctrl-Alt-V; MATLAB: Ctrl-Alt-V*

**evaluate-sel-in-debug-console** (whole_lines=None)

Evaluate the current selection from the editor within the Debug Console
tool. When whole_lines is set, the selection is rounded to whole lines
before evaluation. When unspecified (set to None), the setting from the
Shell's Option menu is used instead.  *Key Bindings: Wing: Ctrl-Alt-D; Eclipse: Ctrl-Alt-D; MATLAB: Ctrl-Alt-D*

**evaluate-sel-in-shell** (restart_shell=False, whole_lines=None)

Evaluate the current selection from the editor within the Python Shell
tool, optionally restarting the shell first. When whole_lines is set, the
selection is rounded to whole lines before evaluation. When unspecified
(set to None), the setting from the Shell's Option menu is used
instead.  *Key Bindings: Wing: Ctrl-Alt-E; Eclipse: Ctrl-Alt-E; Emacs: Ctrl-C |; MATLAB: F9*

**execute-kbd-macro** (register='a', repeat=<numeric modifier; default=1>)

Execute most recently recorded keyboard macro.  If register is None then the
user is asked to enter a letter a-z for the register where the macro is filed.
Otherwise, register 'a' is used by default.  *Key Bindings: Wing: Ctrl-M; Brief: F8; Eclipse: Ctrl-M; Emacs: Ctrl-X E; MATLAB: Ctrl-M; VI/VIM: @ invokes execute-kbd-macro(register=None); Visual Studio: Ctrl-M; macOS: Command-M*

**fill-paragraph** ()

Re-wrap the selected text or current line to the configured text wrap column. When
there is no selection, wrappable regions are delineated by surrounding blank lines.
Otherwise, when there is a selection, wrapping is constrained to occur only within
that selection. Wrapping behavior depends on context; for example, wrapping Python
code is different than wrapping plain text or the contents of comments and docstrings.
A shared leading prefix found on all lines is retained and only the content after the
prefix is wrapped.  *Key Bindings: Wing: Ctrl-J; Eclipse: Ctrl-Shift-F; Emacs: Alt-Q; MATLAB: Ctrl-J; VI/VIM: g q; Visual Studio: Ctrl-K Ctrl-F; macOS: Command-J*

**find-symbol** ()

Allow user to visit point of definition of a source symbol in the 
current editor context by typing a fragment of the name  *Key Bindings: Wing: Ctrl-Shift-T; Eclipse: Ctrl-O; Emacs: Ctrl-X G; MATLAB: Shift-F1; VI/VIM: Ctrl-Shift-T; Visual Studio: Ctrl-Shift-T; macOS: Command-Shift-T*

**find-symbol-in-project** (fragment=None)

Allow user to visit point of definition of a source symbol in the 
any file in the project by typing a fragment of the name  *Key Bindings: Wing: Ctrl-Shift-P; Eclipse: Ctrl-Shift-T; Emacs: Ctrl-X Ctrl-G; MATLAB: Ctrl-Shift-F1; VI/VIM: Ctrl-Shift-P; Visual Studio: Ctrl-Shift-P; macOS: Command-Shift-P*

**fold-collapse-all** ()

Collapse all fold points in the current file   *Key Bindings: Wing: Alt-Home; Brief: Alt-Home; Eclipse: Alt-Home; Emacs: Alt-Home; MATLAB: Ctrl-=; VI/VIM: z Shift-M; Visual Studio: Alt-Home; macOS: Command-Ctrl--*

**fold-collapse-all-clicked** ()

Collapse the clicked fold point completely 

**fold-collapse-all-current** ()

Collapse the current fold point completely   *Key Bindings: Wing: Alt-Page_Up; Brief: Alt-Page_Up; Eclipse: Alt-Page_Up; Emacs: Alt-Page_Up; MATLAB: Alt-Page_Up; VI/VIM: Alt-Page_Up; Visual Studio: Alt-Page_Up; macOS: Command--*

**fold-collapse-current** ()

Collapse the current fold point   *Key Bindings: Eclipse: Ctrl--; VI/VIM: z c*

**fold-collapse-more-clicked** ()

Collapse the clicked fold point one more level 

**fold-collapse-more-current** ()

Collapse the current fold point one more level   *Key Bindings: Wing: Alt-Up; Brief: Alt-Up; Eclipse: Alt-Up; Emacs: Alt-Up; MATLAB: Alt-Up; VI/VIM: Alt-Up; Visual Studio: Alt-Up; macOS: Command-_*

**fold-expand-all** ()

Expand all fold points in the current file   *Key Bindings: Wing: Alt-End; Brief: Alt-End; Eclipse: Ctrl-\*; Emacs: Alt-End; MATLAB: Ctrl-+; VI/VIM: z Shift-R; Visual Studio: Alt-End; macOS: Command-Ctrl-\**

**fold-expand-all-clicked** ()

Expand the clicked fold point completely 

**fold-expand-all-current** ()

Expand the current fold point completely   *Key Bindings: Wing: Alt-Page_Down; Brief: Alt-Page_Down; Eclipse: Alt-Page_Down; Emacs: Alt-Page_Down; MATLAB: Alt-Page_Down; VI/VIM: z Shift-O; Visual Studio: Alt-Page_Down; macOS: Command-\**

**fold-expand-current** ()

Expand the current fold point   *Key Bindings: Eclipse: Ctrl-+; VI/VIM: z o*

**fold-expand-more-clicked** ()

Expand the clicked fold point one more level 

**fold-expand-more-current** ()

Expand the current fold point one more level   *Key Bindings: Wing: Alt-Down; Brief: Alt-Down; Eclipse: Alt-Down; Emacs: Alt-Down; MATLAB: Alt-Down; VI/VIM: Alt-Down; Visual Studio: Alt-Down; macOS: Command-+*

**fold-toggle** ()

Toggle the current fold point   *Key Bindings: Wing: Alt-/; Brief: Alt-/; Eclipse: Ctrl-/; Emacs: Alt-\; MATLAB: Ctrl-.; VI/VIM: Alt-/; Visual Studio: Alt-/; macOS: Command-/*

**fold-toggle-clicked** ()

Toggle the clicked fold point 

**force-indent-style-to-match-file** ()

Force the indent style of the editor to match the indent style found in the majority
of the file 

**force-indent-style-to-mixed** ()

Force the indent style of the editor to mixed use of tabs and spaces, 
regardless of the file contents 

**force-indent-style-to-spaces-only** ()

Force the indent style of the editor to use spaces only, regardless of file contents 

**force-indent-style-to-tabs-only** ()

Force the indent style of the editor to use tabs only, regardless of file contents 

**goto-column** (column=<numeric modifier; default=0>)

Move cursor to given column  *Key Bindings: VI/VIM: |*

**goto-line** (lineno=<numeric modifier>)

Position cursor at start of given line number   *Key Bindings: Wing: Ctrl-L; Brief: Alt-G; Eclipse: Ctrl-L; Emacs: Alt-g; MATLAB: Ctrl-G; Visual Studio: Ctrl-G; macOS: Command-L*

**goto-line-select** (lineno=<numeric modifier>)

Scroll to and select the given line number

**goto-nth-line** (lineno=<numeric modifier; default=1>, cursor='start')

Position cursor at start of given line number (1=first, -1 = last).
This differs from goto-line in that it never prompts for a line number but
instead uses the previously entered numeric modifier or defaults to going
to line one. The cursor can be positioned at 'start', 'end', or 'fnb' for
first non-blank character.  *Key Bindings: VI/VIM: g g invokes goto-nth-line(cursor="fnb")*

**goto-nth-line-default-end** (lineno=<numeric modifier; default=0>, cursor='start')

Same as goto_nth_line but defaults to end of file if no lineno is given  *Key Bindings: VI/VIM: Shift-G invokes goto-nth-line-default-end(cursor="fnb")*

**goto-percent-line** (percent=<numeric modifier; default=0>, cursor='start')

Position cursor at start of line at given percent in file.  This
uses the previously entered numeric modifier or defaults to going
to line one.  The cursor can be positioned at 'start', 'end', or
'fnb' for first non-blank character, or in VI mode it will do 
brace matching operation to reflect how VI overrides this command.  *Key Bindings: VI/VIM: % invokes goto-percent-line(cursor="fnb")*

**hide-all-whitespace** ()

Turn off all special marks for displaying white space and end-of-line 

**hide-eol** ()

Turn off special marks for displaying end-of-line chars 

**hide-indent-guides** ()

Turn off special marks for displaying indent level 

**hide-whitespace** ()

Turn off special marks for displaying white space 

**indent-lines** (lines=None, levels=<numeric modifier; default=1>)

Indent selected number of lines from cursor position.  Set lines to None
to indent all the lines in current selection.  Set levels to indent more
than one level at a time.  *Key Bindings: Eclipse: Ctrl-| invokes indent-lines(lines=1); MATLAB: Ctrl-]; VI/VIM: >*

**indent-next-move** (num=<numeric modifier; default=1>)

Indent lines spanned by next cursor move  *Key Bindings: VI/VIM: >*

**indent-region** (sel=None)

Indent the selected region one level of indentation.  Set sel to None
to use preference to determine selection behavior, or "never-select" to
unselect after indent, "always-select" to always select after indent, or
"retain-select" to retain current selection after indent.  *Key Bindings: Wing: Ctrl->; Eclipse: Ctrl->; Emacs: Ctrl-C >; MATLAB: Ctrl->; VI/VIM: Ctrl-T; Visual Studio: Ctrl->; macOS: Command-]*

**indent-to-match-next-move** (num=<numeric modifier; default=1>)

Indent lines spanned by next cursor move to match, based on the preceding line  *Key Bindings: VI/VIM: =*

**insert-command** (cmd)

Insert the output for the given command at current cursor position.
Some special characters in the command line (if not escaped with \) will
be replaced as follows::

  % -- Current file's full path name
  # -- Previous file's full path name
  

**insert-file** (filename)

Insert a file at current cursor position, prompting user
for file selection   *Key Bindings: Brief: Alt-R; Emacs: Ctrl-X I*

**join-lines** (delim=' ', num=<numeric modifier; default=2>)

Join together specified number of lines after current line (replace
newlines with the given delimiter (single space by default)  *Key Bindings: VI/VIM: g Shift-J invokes join-lines(delim="")*

**join-selection** (delim=' ')

Join together all lines in given selection (replace newlines with
the given delimiter (single space by default)  *Key Bindings: VI/VIM: g Shift-J invokes join-selection(delim="")*

**kill-buffer** ()

Close the current text file   *Key Bindings: Brief: Ctrl--; Emacs: Ctrl-X K*

**outdent-lines** (lines=None, levels=<numeric modifier; default=1>)

Outdent selected number of lines from cursor position.  Set lines to None
to indent all the lines in current selection.  Set levels to outdent more
than one level at a time.  *Key Bindings: MATLAB: Ctrl-[; VI/VIM: <*

**outdent-next-move** (num=<numeric modifier; default=1>)

Outdent lines spanned by next cursor move  *Key Bindings: VI/VIM: <*

**outdent-region** (sel=None)

Outdent the selected region one level of indentation.  Set sel to None
to use preference to determine selection behavior, or "never-select" to
unselect after indent, "always-select" to always select after indent, or
"retain-select" to retain current selection after indent.  *Key Bindings: Wing: Ctrl-<; Eclipse: Shift-Tab; Emacs: Ctrl-C <; MATLAB: Ctrl-<; VI/VIM: Ctrl-D; Visual Studio: Ctrl-<; macOS: Command-[*

**page-setup** ()

Show printing page setup dialog 

**pep8-file** (indentation=None, timeout=None)

Reformat the current file to comply with PEP 8 formatting conventions. Indentation
is left unchanged unless indentation=True or indentation=None and the Editor > PEP 8 >
Reindent All Lines preference is enabled. Indentation within logical lines is always
updated. The command will time out after the given number of seconds, or if timeout is
None the timeout configured with the Editor > Auto-formatting > Reformat Timeout preference.

**pep8-selection** (start=None, end=None)

Reformat the current selection, or current line if there is no selection, to comply
with PEP 8 formatting conventions.  Reformats the given range if start and end are given.

**print-view** ()

Print active editor document  *Key Bindings: Wing: Ctrl-P; Eclipse: Ctrl-P; MATLAB: Ctrl-P; Visual Studio: Ctrl-P; macOS: Command-P*

**query-replace** (search_string, replace_string)

Initiate incremental mini-search query/replace from the cursor 
position.   *Key Bindings: Wing: Alt-comma; Eclipse: Alt-comma; Emacs: Alt-%; MATLAB: Alt-comma; Visual Studio: Alt-comma; macOS: Ctrl-R*

**query-replace-regex** (search_string, replace_string)

Initiate incremental mini-search query/replace from the cursor 
position.  The search string is treated as a regular expression.  *Key Bindings: Wing: Ctrl-Alt-Comma; Eclipse: Ctrl-Alt-Comma; Emacs: Ctrl-Alt-%; MATLAB: Ctrl-Alt-Comma; Visual Studio: Ctrl-Alt-Comma*

**range-replace** (search_string, replace_string, confirm, range_limit, match_limit, regex)

Initiate incremental mini-search query/replace within the given selection.
This is similar to query_replace but allows some additional options::

  confirm -- True to confirm each replace
  range_limit -- None to replace between current selection start and end of document,
    1 to limit operation to current selection or to current line if selection is empty,
    (start, end) to limit operation to within given selection range, or "first|last"
    to limit operating withing given range of lines (1=first).
  match_limit -- None to replace any number of matches, or limit of number of replaces.
    When set to "l" plus a number, limits to that number of matches per line,
    rather than as a whole.
  regex -- Treat search string as a regular expression
  

**repeat-replace** (repeat=<numeric modifier; default=1>)

Repeat the last query replace or range replace operation on the current line.
The first match is replaced without confirmation.  *Key Bindings: VI/VIM: &*

**replace-char** (line_mode='multiline', num=<numeric modifier; default=1>)

Replace num characters with given character.  Set line_mode to multiline to
allow replacing across lines, extend to replace on current line and then extend
the line length, and restrict to replace only if enough characters exist on
current line after cursor position.  *Key Bindings: VI/VIM: r*

**replace-string** (search_string, replace_string)

Replace all occurrences of a string from the cursor position to 
end of file.   *Key Bindings: Wing: Alt-.; Eclipse: Alt-.; Emacs: Alt-@; MATLAB: Alt-.; Visual Studio: Alt-.*

**replace-string-regex** (search_string, replace_string)

Replace all occurrences of a string from the cursor position to 
end of file.  The search string is treated as a regular expression.  *Key Bindings: Wing: Ctrl-Alt-.; Eclipse: Ctrl-Alt-.; Emacs: Ctrl-Alt-@; MATLAB: Ctrl-Alt-.; Visual Studio: Ctrl-Alt-.*

**ruff-file** (timeout=None)

Reformat the current file with Ruff, if installed in the active Python. The
command will time out after the given number of seconds, or if timeout is None the
timeout configured with the Editor > Auto-formatting > Reformat Timeout preference.

**ruff-selection** (start=None, end=None)

Reformat the current selection, or current line if there is no selection with Ruff.
Reformats the given range if start and end are given.

**save-buffer** ()

Save the current text file to disk 

**set-readonly** ()

Set editor to be readonly.  This cannot be done if the editor contains
any unsaved edits.

**set-visit-history-anchor** ()

Set anchor in the visit history to go back to 

**set-writable** ()

Set editor to be writable.  This can be used to override the read-only
state used initially for editors displaying files that are read-only on disk.

**show-all-whitespace** ()

Turn on all special marks for displaying white space and end-of-line  

**show-eol** ()

Turn on special marks for displaying end-of-line chars 

**show-indent-guides** ()

Turn on special marks for displaying indent level 

**show-indent-manager** ()

Display the indentation manager for this editor file 

**show-whitespace** ()

Turn on special marks for displaying white space 

**start-kbd-macro** (register='a')

Start definition of a keyboard macro.  If register=None then the user
is prompted to enter a letter a-z under which to file the macro.  Otherwise,
register 'a' is used by default.  *Key Bindings: Wing: Ctrl-(; Brief: F7; Eclipse: Ctrl-(; Emacs: Ctrl-X (; MATLAB: Ctrl-(; VI/VIM: q invokes start-kbd-macro(register=None); Visual Studio: Ctrl-(; macOS: Command-Shift-M*

**stop-kbd-macro** ()

Stop definition of a keyboard macro   *Key Bindings: Wing: Ctrl-); Brief: Shift-F7; Eclipse: Ctrl-); Emacs: Ctrl-X ); MATLAB: Ctrl-); VI/VIM: q; Visual Studio: Ctrl-); macOS: Command-Shift-M*

**toggle-auto-editing** ()

Toggle the global auto-editing switch.  When enabled, the editor
performs the auto-edits that have been selected in the Editor >
Auto-Editing preferences group.

**toggle-line-wrapping** ()

Toggles line wrapping preference for all editors 

**toggle-overtype** ()

Toggle status of overtyping mode   *Key Bindings: Wing: Insert; Brief: Alt-I; Eclipse: Ctrl-Shift-Insert; Emacs: Insert; MATLAB: Insert; VI/VIM: Insert; Visual Studio: Insert*

**uncomment-out-region** (one_level=True)

Uncomment out the selected region if commented out.  If one_level is 
True then each call removes only one level of commenting.  *Key Bindings: Wing: Ctrl-?; Eclipse: Ctrl-\; Emacs: Ctrl-C U; MATLAB: Ctrl-?; Visual Studio: Ctrl-K Ctrl-U; macOS: Command-"*

**uncomment-out-toggle** (style=None)

Remove commenting from the selected lines, if any.  This command is
not available if the lines are not commented out.

**use-lexer-ada** ()

Force syntax highlighting Ada source 

**use-lexer-apache-conf** ()

Force syntax highlighting for Apache configuration file format 

**use-lexer-asm** ()

Force syntax highlighting for Masm assembly language 

**use-lexer-ave** ()

Force syntax highlighting for Avenue GIS language 

**use-lexer-baan** ()

Force syntax highlighting for Baan 

**use-lexer-bash** ()

Force syntax highlighting for bash scripts 

**use-lexer-bullant** ()

Force syntax highlighting for Bullant 

**use-lexer-by-doctype** ()

Use syntax highlighting appropriate to the file type 

**use-lexer-cmake** ()

Force syntax highlighting for CMake file 

**use-lexer-coffee-script** ()

Force syntax highlighting for Coffee Script source file 

**use-lexer-cpp** ()

Force syntax highlighting for C/C++ source  *Key Bindings: Wing: Ctrl-7 C; Eclipse: Ctrl-7 C; Emacs: Ctrl-X L C; MATLAB: Ctrl-7 C; Visual Studio: Ctrl-7 C; macOS: Command-7 C*

**use-lexer-css2** ()

Force syntax highlighting for CSS2 

**use-lexer-cython** ()

Force syntax highlighting for Cython source

**use-lexer-diff** ()

Force syntax highlighting for diff/cdiff files 

**use-lexer-django** ()

Force syntax highlighting for Django template file 

**use-lexer-dos-batch** ()

Force syntax highlighting for DOS batch files 

**use-lexer-eiffel** ()

Force syntax highlighting for Eiffel source 

**use-lexer-errlist** ()

Force syntax highlighting for error list format 

**use-lexer-escript** ()

Force syntax highlighting for EScript 

**use-lexer-fortran** ()

Force syntax highlighting for Fortran 

**use-lexer-hss** ()

Force syntax highlighting for HSS CSS extension language

**use-lexer-html** ()

Force syntax highlighting for HTML  *Key Bindings: Wing: Ctrl-7 H; Eclipse: Ctrl-7 H; Emacs: Ctrl-X L H; MATLAB: Ctrl-7 H; Visual Studio: Ctrl-7 H; macOS: Command-7 H*

**use-lexer-idl** ()

Force syntax highlighting for XP IDL 

**use-lexer-java** ()

Force syntax highlighting for Java source 

**use-lexer-javascript** ()

Force syntax highlighting for Javascript 

**use-lexer-latex** ()

Force syntax highlighting for LaTeX 

**use-lexer-less** ()

Force syntax highlighting for Less CSS extension language

**use-lexer-lisp** ()

Force syntax highlighting for Lisp source 

**use-lexer-lout** ()

Force syntax highlighting for LOUT typesetting language 

**use-lexer-lua** ()

Force syntax highlighting for Lua 

**use-lexer-makefile** ()

Force syntax highlighting for make files   *Key Bindings: Wing: Ctrl-7 M; Eclipse: Ctrl-7 M; Emacs: Ctrl-X L M; MATLAB: Ctrl-7 M; Visual Studio: Ctrl-7 M; macOS: Command-7 M*

**use-lexer-mako** ()

Force syntax highlighting for Mako template file 

**use-lexer-matlab** ()

Force syntax highlighting for Matlab 

**use-lexer-mmixal** ()

Force syntax highlighting for MMIX assembly language 

**use-lexer-msidl** ()

Force syntax highlighting for MS IDL

**use-lexer-nix** ()

Force syntax highlighting for Nix file 

**use-lexer-nncrontab** ()

Force syntax highlighting for NNCrontab files 

**use-lexer-none** ()

Use no syntax highlighting   *Key Bindings: Wing: Ctrl-7 N; Eclipse: Ctrl-7 N; Emacs: Ctrl-X L N; MATLAB: Ctrl-7 N; Visual Studio: Ctrl-7 N; macOS: Command-7 N*

**use-lexer-nsis** ()

Force syntax highlighting for NSIS 

**use-lexer-pascal** ()

Force syntax highlighting for Pascal source 

**use-lexer-perl** ()

Force syntax highlighting for Perl source 

**use-lexer-php** ()

Force syntax highlighting for PHP source 

**use-lexer-plsql** ()

Force syntax highlighting for PL/SQL files

**use-lexer-pov** ()

Force syntax highlighting for POV ray tracer scene description language 

**use-lexer-properties** ()

Force syntax highlighting for properties files 

**use-lexer-ps** ()

Force syntax highlighting for Postscript 

**use-lexer-python** ()

Force syntax highlighting for Python source  *Key Bindings: Wing: Ctrl-7 P; Eclipse: Ctrl-7 P; Emacs: Ctrl-X L P; MATLAB: Ctrl-7 P; Visual Studio: Ctrl-7 P; macOS: Command-7 P*

**use-lexer-qss** ()

Force syntax highlighting for QSS (Qt Style sheets) 

**use-lexer-r** ()

Force syntax highlighting for R source file 

**use-lexer-rc** ()

Force syntax highlighting for RC file format 

**use-lexer-ruby** ()

Force syntax highlighting for Ruby source 

**use-lexer-rust** ()

Force syntax highlighting for Rust source file 

**use-lexer-scriptol** ()

Force syntax highlighting for Scriptol 

**use-lexer-scss** ()

Force syntax highlighting for SCSS formatted SASS

**use-lexer-sql** ()

Force syntax highlighting for SQL   *Key Bindings: Wing: Ctrl-7 S; Eclipse: Ctrl-7 S; Emacs: Ctrl-X L S; MATLAB: Ctrl-7 S; Visual Studio: Ctrl-7 S; macOS: Command-7 S*

**use-lexer-tcl** ()

Force syntax highlighting for TCL 

**use-lexer-toml** ()

Force syntax highlighting for TOML file 

**use-lexer-vb** ()

Force syntax highlighting for Visual Basic 

**use-lexer-vxml** ()

Force syntax highlighting for VXML 

**use-lexer-xcode** ()

Force syntax highlighting for XCode files 

**use-lexer-xml** ()

Force syntax highlighting for XML files   *Key Bindings: Wing: Ctrl-7 X; Eclipse: Ctrl-7 X; MATLAB: Ctrl-7 X; Visual Studio: Ctrl-7 X; macOS: Command-7 X*

**use-lexer-yaml** ()

Force syntax highlighting for YAML 

**wrap-selection** ()

Re-wrap the selected text or current line to the configured text wrap column. When
there is no selection, wrappable regions are delineated by surrounding blank lines.
Otherwise, when there is a selection, wrapping is constrained to occur only within
that selection. Wrapping behavior depends on context; for example, wrapping Python
code is different than wrapping plain text or the contents of comments and docstrings.
A shared leading prefix found on all lines is retained and only the content after the
prefix is wrapped.

**yapf-file** (timeout=None)

Reformat the current file with YAPF, if installed in the active Python. The
command will time out after the given number of seconds, or if timeout is None the
timeout configured with the Editor > Auto-formatting > Reformat Timeout preference.

**yapf-selection** (start=None, end=None)

Reformat the current selection, or current line if there is no selection with YAPF.
Reformats the given range if start and end are given.

**zoom-in** ()

Zoom in, increasing the text display size temporarily by one font size   *Key Binding: Ctrl-+*

**zoom-out** ()

Zoom out, increasing the text display size temporarily by one font size   *Key Binding: Ctrl--*

**zoom-reset** ()

Reset font zoom factor back to zero  *Key Binding: Ctrl-_*

Editor Multiple Selection Commands
----------------------------------

Commands for creating and manager multiple selections in the editor.

**drop-current-selection** ()

Drop current selection when there's 2+ selections 

**drop-extra-selections** ()

Drop all exceptions except the main selection 

**drop-one-extra-selection** (sel_n)

Drop one extra selection. The sel_n is the index of the selection to
drop in the list ordered by the start of the selection. If sel_n can be
negative to count from the end of the list. 

**hide-selections-popup** ()

Hide the selections popup; this overrides the preference setting
for the current file 

**next-extra-selection** ()

Make the next extra selection the current selection. The selection
made current will wrap; the next selection after the last will be the
first. 

**previous-extra-selection** ()

Make the previous extra selection the current selection. The selection
made current will wrap; the previous selection before the first will be the
last. 

**selection-add-all-occurrences-in-block** (stop_at_blank=True, match_case=None, whole_words=None)

Add an extra selection for all occurrences of the main selection text
in blocks that contain one or more selections 

**selection-add-all-occurrences-in-class** (match_case=None, whole_words=None)

Add an extra selection for all occurrences of the main selection text
in classes that contain one or more selections 

**selection-add-all-occurrences-in-def** (match_case=None, whole_words=None)

Add an extra selection for all occurrences of the main selection text
in functions / methods that contain one or more selections 

**selection-add-all-occurrences-in-file** (match_case=None, whole_words=None)

Add an extra selection for all occurrences of the main selection text
in the file 

**selection-add-next-occurrence** (skip_current=False, reverse=False, match_case=None, whole_words=None, wrap=None)

Add another selection containing the text of the current selection.
If skip_current is true, the current selection will be deselected.  If 
nothing is currently selected, select the current word.  Searches 
backwards if reverse is true.   *Key Bindings: Wing: Ctrl-Shift-D invokes selection-add-next-occurrence(skip_current=True); Eclipse: Ctrl-Shift-D invokes selection-add-next-occurrence(skip_current=True); Emacs: Ctrl-Alt-> invokes selection-add-next-occurrence(skip_current=True); MATLAB: Ctrl-Shift-D invokes selection-add-next-occurrence(skip_current=True); Visual Studio: Ctrl-Shift-D invokes selection-add-next-occurrence(skip_current=True); macOS: Command-Shift-D invokes selection-add-next-occurrence(skip_current=True)*

**show-selections-popup** ()

Show the selections popup; this overrides the preference setting
for the current file 

**toggle-selection-add-match-case** ()

Toggle the value of the default flag for whether the selection add
commands match case or not when looking for additional occurrences 

**toggle-selection-add-whole-words** ()

Toggle the value of the default flag for whether the selection add
commands only add whole words when looking for additional occurrences 

**toggle-selection-add-wrap** ()

Toggle the value of the default flag for whether the selection add
commands wrap when looking for additional occurrences 

Focused Editor Commands
-----------------------

Editor commands that are only available when the editor has the keyboard focus.

These commands are also available for the Python Shell, Debug Console, and Debug I/O tools, which
subclass the source editor, although some of the commands are modified or disabled as appropriate
in those contexts.

**activate-symbol-option-menu-1** ()

Activate the 1st symbol menu for the editor.   *Key Bindings: Wing: Ctrl-2; Brief: Ctrl-2; Eclipse: Ctrl-2; Emacs: Ctrl-2; MATLAB: Ctrl-2; VI/VIM: Ctrl-2; Visual Studio: Ctrl-2; macOS: Command-2*

**activate-symbol-option-menu-2** ()

Activate the 2nd symbol menu for the editor.   *Key Bindings: Wing: Ctrl-3; Brief: Ctrl-3; Eclipse: Ctrl-3; Emacs: Ctrl-3; MATLAB: Ctrl-3; VI/VIM: Ctrl-3; Visual Studio: Ctrl-3; macOS: Command-3*

**activate-symbol-option-menu-3** ()

Activate the 3rd symbol menu for the editor.   *Key Bindings: Wing: Ctrl-4; Brief: Ctrl-4; Eclipse: Ctrl-4; Emacs: Ctrl-4; MATLAB: Ctrl-4; VI/VIM: Ctrl-4; Visual Studio: Ctrl-4; macOS: Command-4*

**activate-symbol-option-menu-4** ()

Activate the 4th symbol menu for the editor.   *Key Bindings: Wing: Ctrl-5; Brief: Ctrl-5; Eclipse: Ctrl-5; Emacs: Ctrl-5; MATLAB: Ctrl-5; VI/VIM: Ctrl-5; Visual Studio: Ctrl-5; macOS: Command-5*

**activate-symbol-option-menu-5** ()

Activate the 5th symbol menu for the editor.   *Key Bindings: Wing: Ctrl-6; Brief: Ctrl-6; Eclipse: Ctrl-6; Emacs: Ctrl-6; MATLAB: Ctrl-6; VI/VIM: Ctrl-6; Visual Studio: Ctrl-6; macOS: Command-6*

**backward-char** (wrap=1, repeat=<numeric modifier; default=1>)

Move cursor backward one character   *Key Bindings: Wing: Left; Brief: Left; Eclipse: Left; Emacs: Ctrl-B; MATLAB: Left; VI/VIM: Ctrl-h; Visual Studio: Left; macOS: Ctrl-b*

**backward-char-extend** (wrap=1, repeat=<numeric modifier; default=1>)

Move cursor backward one character, adjusting the selection 
range to new position   *Key Binding: Shift-Left*

**backward-char-extend-rect** (wrap=1, repeat=<numeric modifier; default=1>)

Move cursor backward one character, adjusting the rectangular selection 
range to new position   *Key Bindings: Wing: Shift-Alt-Left; Brief: Shift-Alt-Left; Eclipse: Shift-Alt-Left; Emacs: Shift-Alt-Left; MATLAB: Shift-Alt-Left; VI/VIM: Shift-Alt-Left; Visual Studio: Shift-Alt-Left; macOS: Ctrl-Option-Left*

**backward-delete-char** (repeat=<numeric modifier; default=1>)

Delete one character behind the cursor, or the current selection
if not empty.   *Key Bindings: Wing: Shift-BackSpace; Brief: Shift-BackSpace; Eclipse: Shift-BackSpace; Emacs: Ctrl-H; MATLAB: Shift-BackSpace; VI/VIM: Ctrl-H; Visual Studio: Shift-BackSpace; macOS: Ctrl-h*

**backward-delete-word** (delimiters=None, repeat=<numeric modifier; default=1>)

Delete one word behind of the cursor   *Key Bindings: Wing: Alt-Delete; Brief: Alt-Delete; Eclipse: Alt-Delete; Emacs: Alt-Delete; MATLAB: Alt-Delete; VI/VIM: Ctrl-W; Visual Studio: Alt-Delete; macOS: Option-Backspace*

**backward-page** (repeat=<numeric modifier; default=1>)

Move cursor backward one page   *Key Bindings: Wing: Ctrl-Prior; Brief: Ctrl-Prior; Eclipse: Ctrl-Prior; Emacs: Alt-V; MATLAB: Ctrl-Prior; VI/VIM: Ctrl-B; Visual Studio: Ctrl-Prior; macOS: Option-Page_Up*

**backward-page-extend** (repeat=<numeric modifier; default=1>)

Move cursor backward one page, adjusting the selection 
range to new position   *Key Bindings: Wing: Ctrl-Shift-Page_Up; Brief: Ctrl-Shift-Page_Up; Eclipse: Ctrl-Shift-Page_Up; Emacs: Ctrl-Shift-Page_Up; MATLAB: Ctrl-Shift-Page_Up; VI/VIM: Ctrl-Shift-Page_Up; Visual Studio: Ctrl-Shift-Page_Up; macOS: Shift-Page_Up*

**backward-paragraph** (repeat=<numeric modifier; default=1>)

Move cursor backward one paragraph (to next all-whitespace line).  *Key Bindings: VI/VIM: {*

**backward-paragraph-extend** (repeat=<numeric modifier; default=1>)

Move cursor backward one paragraph (to next all-whitespace line),
adjusting the selection range to new position.

**backward-tab** ()

Outdent line at current position   *Key Binding: Shift-Tab*

**backward-word** (delimiters=None, gravity='start', repeat=<numeric modifier; default=1>)

Move cursor backward one word. Optionally, provide a string that
contains the delimiters to define which characters are part of a word.
Gravity may be "start" or "end" to indicate whether cursor is placed at
start or end of the word.  *Key Bindings: Wing: Ctrl-Left; Brief: Ctrl-Left; Eclipse: Ctrl-Left; Emacs: Alt-B; MATLAB: Ctrl-Left; VI/VIM: Ctrl-W; Visual Studio: Ctrl-Left; macOS: Ctrl-Left invokes backward-word(delimiters="_`~!@#$%^&*()+-={}[]\\|;:\'\",.<>/? \t\r\n")*

**backward-word-extend** (delimiters=None, gravity='start', repeat=<numeric modifier; default=1>)

Move cursor backward one word, adjusting the selection range to new
position. Optionally, provide a string that contains the delimiters to
define which characters are part of a word. Gravity may be "start" or
"end" to indicate whether cursor is placed at start or end of the word.  *Key Bindings: Wing: Ctrl-Shift-Left; Brief: Ctrl-Shift-Left; Eclipse: Ctrl-Shift-Left; Emacs: Ctrl-Shift-Left; MATLAB: Ctrl-Shift-Left; VI/VIM: Ctrl-Shift-Left; Visual Studio: Ctrl-Shift-Left; macOS: Option-Shift-Left*

**beginning-of-line** (toggle=True)

Move to beginning of current line. When toggle is True, moves to the
end of the leading white space if already at the beginning of the line
(and vice versa).  *Key Bindings: Brief: Shift-Home; Emacs: Ctrl-A; VI/VIM: 0 invokes beginning-of-line(toggle=0); macOS: Ctrl-a*

**beginning-of-line-extend** (toggle=True)

Move to beginning of current line, adjusting the selection range to
the new position. When toggle is True, moves to the end of the leading
white space if already at the beginning of the line (and vice versa).  *Key Bindings: Emacs: Shift-Home; macOS: Command-Shift-Left*

**beginning-of-line-text** (toggle=True)

Move to end of the leading white space, if any, on the current line.
If toggle is True, moves to the beginning of the line if already at the
end of the leading white space (and vice versa).  *Key Bindings: Wing: Home; Brief: Home; Eclipse: Home; Emacs: Home; MATLAB: Home; VI/VIM: _; Visual Studio: Home*

**beginning-of-line-text-extend** (toggle=True)

Move to end of the leading white space, if any, on the current line,
adjusting the selection range to the new position.  If toggle is True,
moves to the beginning of the line if already at the end of the leading
white space (and vice versa).  *Key Bindings: Wing: Shift-Home; Brief: Shift-Home; Eclipse: Shift-Home; Emacs: Shift-Home; MATLAB: Shift-Home; VI/VIM: Shift-Home; Visual Studio: Shift-Home*

**beginning-of-screen-line** ()

Move to beginning of current wrapped line  *Key Bindings: VI/VIM: g 0*

**beginning-of-screen-line-extend** ()

Move to beginning of current wrapped line, extending selection

**beginning-of-screen-line-text** ()

Move to first non-blank character at beginning of current wrapped line  *Key Bindings: VI/VIM: g ^*

**beginning-of-screen-line-text-extend** ()

Move to first non-blank character at beginning of current wrapped line,
extending selection

**brace-match** ()

Match brace at current cursor position, selecting all text between
the two and hilighting the braces   *Key Bindings: Wing: Ctrl-]; Eclipse: Ctrl-Shift-P; Emacs: Ctrl-M; MATLAB: Ctrl-]; Visual Studio: Ctrl-]; macOS: Command-)*

**cancel** ()

Cancel current editor command 

**cancel-autocompletion** ()

Cancel any active autocompletion. 

**case-lower** (repeat=<numeric modifier; default=1>)

Change case of the current selection, or character ahead of the cursor if
there is no selection, to lower case  *Key Bindings: Visual Studio: Ctrl-U*

**case-lower-next-move** (repeat=<numeric modifier; default=1>)

Change case of text spanned by next cursor movement to lower case  *Key Bindings: VI/VIM: g u*

**case-swap** (repeat=<numeric modifier; default=1>)

Change case of the current selection, or character ahead of the cursor if
there is no selection, so each letter is the opposite of its current case  *Key Bindings: VI/VIM: ~*

**case-swap-next-move** (repeat=<numeric modifier; default=1>)

Change case of text spanned by next cursor movement so each letter is
the opposite of its current case  *Key Bindings: VI/VIM: g ~*

**case-title** (repeat=<numeric modifier; default=1>)

Change case of the current selection, or character ahead of the cursor if
there is no selection, to title case (first letter of each word capitalized)

**case-title-next-move** (repeat=<numeric modifier; default=1>)

Change case of text spanned by next cursor movement to title case
(first letter of each word capitalized)

**case-upper** (repeat=<numeric modifier; default=1>)

Change case of the current selection, or character ahead of the cursor if
there is no selection, to upper case  *Key Bindings: Visual Studio: Ctrl-Shift-U*

**case-upper-next-move** (repeat=<numeric modifier; default=1>)

Change case of text spanned by next cursor movement to upper case  *Key Bindings: VI/VIM: g Shift-U*

**center-cursor** ()

Scroll so cursor is centered on display   *Key Bindings: Brief: Ctrl-C; Emacs: Ctrl-L; MATLAB: Ctrl-G; VI/VIM: z z*

**clear** ()

Clear selected text 

**clear-move-command** ()

Clear any pending move command action, as for VI mode  *Key Bindings: VI/VIM: Esc*

**complete-autocompletion** (append='')

Complete the current active autocompletion. 

**copy** ()

Copy selected text   *Key Bindings: Wing: Ctrl-C; Brief: Ctrl-C; Eclipse: Ctrl-C; Emacs: Alt-W; MATLAB: Ctrl-C; VI/VIM: Ctrl-Insert; Visual Studio: Ctrl-C; macOS: Command-C*

**copy-line** ()

Copy the current lines(s) to clipboard

**copy-range** (start_line, end_line, target_line)

Copy the given range of lines to the given target line.  Copies to current
line if target_line is '.'.

**copy-selection-or-line** ()

Copy the current selection or current line if there is no
selection.  The text is placed on the clipboard. 

**cursor-move-to-bottom** (offset=<numeric modifier; default=0>)

Move cursor to bottom of display (without scrolling), optionally
at an offset of given number of lines before bottom  *Key Bindings: VI/VIM: Shift-L*

**cursor-move-to-center** ()

Move cursor to center of display (without scrolling)   *Key Bindings: VI/VIM: Shift-M*

**cursor-move-to-top** (offset=<numeric modifier; default=0>)

Move cursor to top of display (without scrolling), optionally
at an offset of given number of lines below top  *Key Bindings: VI/VIM: Shift-H*

**cursor-to-bottom** ()

Scroll so cursor is centered at bottom of display   *Key Bindings: VI/VIM: z b*

**cursor-to-top** ()

Scroll so cursor is centered at top of display   *Key Bindings: VI/VIM: z +*

**cut** ()

Cut selected text   *Key Bindings: Wing: Ctrl-X; Brief: Ctrl-X; Eclipse: Ctrl-X; Emacs: Ctrl-W; MATLAB: Ctrl-X; VI/VIM: Shift-Delete; Visual Studio: Ctrl-X; macOS: Command-X*

**cut-line** ()

Cut the current line(s) to clipboard.   *Key Bindings: Visual Studio: Ctrl-L*

**cut-selection-or-line** ()

Cut the current selection or current line if there is no
selection.  The text is placed on the clipboard.   *Key Bindings: Visual Studio: Shift-Delete*

**delete-line** (repeat=<numeric modifier; default=1>)

Delete the current line or lines when the selection spans multiple
lines or given repeat is > 1  *Key Bindings: Wing: Ctrl-Shift-C; Eclipse: Ctrl-D; MATLAB: Ctrl-Shift-C*

**delete-line-insert** (repeat=<numeric modifier; default=1>)

Delete the current line or lines when the selection spans multiple
lines or given repeat is > 1.  Enters insert mode (when working with
modal key bindings).  *Key Bindings: VI/VIM: Shift-S*

**delete-next-move** (repeat=<numeric modifier; default=1>)

Delete the text covered by the next cursor move command.  *Key Bindings: VI/VIM: d*

**delete-next-move-insert** (repeat=<numeric modifier; default=1>)

Delete the text covered by the next cursor move command and then
enter insert mode (when working in a modal editor key binding)  *Key Bindings: VI/VIM: c*

**delete-range** (start_line, end_line, register=None)

Delete given range of lines, copying them into given register (or
currently selected default register if register is None

**delete-to-end-of-line** (repeat=<numeric modifier; default=1>, post_offset=0)

Delete everything between the cursor and end of line  *Key Bindings: MATLAB: Ctrl-K; VI/VIM: Shift-D invokes delete-to-end-of-line(post_offset=-1)*

**delete-to-end-of-line-insert** (repeat=<numeric modifier; default=1>)

Delete everything between the cursor and end of line and enter insert
move (when working in a modal editor key binding)  *Key Bindings: VI/VIM: Shift-C*

**delete-to-start-of-line** ()

Delete everything between the cursor and start of line  *Key Bindings: VI/VIM: Ctrl-U*

**duplicate-line** (pos='below')

Duplicate the current line or lines. Places the duplicate on the line
following the selection if pos is 'below' or before the selection if it is
'above'.  *Key Bindings: Wing: Ctrl-Shift-V; Eclipse: Ctrl-Alt-Down; MATLAB: Ctrl-Shift-V*

**duplicate-line-above** ()

Duplicate the current line or lines above the selection.  *Key Bindings: Wing: Ctrl-Shift-Y; Eclipse: Ctrl-Alt-Up; MATLAB: Ctrl-Shift-Y*

**enclose** (start='(', end=')')

Enclose the selection or the rest of the current line when there is no
selection with the given start and end strings.  The caret is moved to the
end of the enclosed text.  *Key Bindings: Wing: Ctrl-< invokes enclose(start="<", end=">"); Brief: Ctrl-< invokes enclose(start="<", end=">"); Eclipse: Ctrl-< invokes enclose(start="<", end=">"); Emacs: Ctrl-< invokes enclose(start="<", end=">"); MATLAB: Ctrl-< invokes enclose(start="<", end=">"); VI/VIM: Ctrl-< invokes enclose(start="<", end=">"); Visual Studio: Ctrl-< invokes enclose(start="<", end=">")*

**end-of-document** ()

Move cursor to end of document   *Key Bindings: Wing: Ctrl-End; Brief: Ctrl-PageDown; Eclipse: Ctrl-End; Emacs: Ctrl-X ]; MATLAB: Ctrl-End; VI/VIM: Ctrl-End; Visual Studio: Ctrl-End; macOS: Command-Down*

**end-of-document-extend** ()

Move cursor to end of document, adjusting the selection 
range to new position   *Key Bindings: Wing: Ctrl-Shift-End; Brief: Ctrl-Shift-End; Eclipse: Ctrl-Shift-End; Emacs: Ctrl-Shift-End; MATLAB: Ctrl-Shift-End; VI/VIM: Ctrl-Shift-End; Visual Studio: Ctrl-Shift-End; macOS: Shift-End*

**end-of-line** (count=<numeric modifier; default=1>)

Move to end of current line  *Key Bindings: Wing: End; Brief: Shift-End; Eclipse: End; Emacs: Ctrl-E; MATLAB: Ctrl-E; VI/VIM: $; Visual Studio: End; macOS: Ctrl-e*

**end-of-line-extend** (count=<numeric modifier; default=1>)

Move to end of current line, adjusting the selection range 
to new position   *Key Bindings: Wing: Shift-End; Brief: Shift-End; Eclipse: Shift-End; Emacs: Shift-End; MATLAB: Shift-End; VI/VIM: Shift-End; Visual Studio: Shift-End; macOS: Command-Shift-Right*

**end-of-screen-line** (count=<numeric modifier; default=1>)

Move to end of current wrapped line  *Key Bindings: VI/VIM: g $*

**end-of-screen-line-extend** (count=<numeric modifier; default=1>)

Move to end of current wrapped line, extending selection

**exchange-point-and-mark** ()

When currently marking text, this exchanges the current position
and mark ends of the current selection  *Key Bindings: Emacs: Ctrl-X Ctrl-X; VI/VIM: Shift-O*

**filter-next-move** (repeat=<numeric modifier; default=1>)

Filter the lines covered by the next cursor move command
through an external command and replace the lines with the result  *Key Bindings: VI/VIM: !*

**filter-range** (cmd, start_line=0, end_line=-1)

Filter a range of lines in the editor through an external command
and replace the lines with the result.  Filters the whole file by
default.  Filters nothing and opens up a scratch buffer with the
output of the command if start_line and end_line are both -1.

**filter-selection** (cmd)

Filter the current selection through an external command and replace
the lines with the result  *Key Bindings: VI/VIM: !*

**form-feed** ()

Place a form feed character at the current cursor position 

**forward-char** (wrap=1, repeat=<numeric modifier; default=1>)

Move cursor forward one character   *Key Bindings: Wing: Right; Brief: Right; Eclipse: Right; Emacs: Ctrl-F; MATLAB: Right; VI/VIM: l invokes forward-char(wrap=0); Visual Studio: Right; macOS: Ctrl-f*

**forward-char-extend** (wrap=1, repeat=<numeric modifier; default=1>)

Move cursor forward one character, adjusting the selection 
range to new position   *Key Binding: Shift-Right*

**forward-char-extend-rect** (wrap=1, repeat=<numeric modifier; default=1>)

Move cursor forward one character, adjusting the rectangular selection 
range to new position   *Key Bindings: Wing: Shift-Alt-Right; Brief: Shift-Alt-Right; Eclipse: Shift-Alt-Right; Emacs: Shift-Alt-Right; MATLAB: Shift-Alt-Right; VI/VIM: Shift-Alt-Right; Visual Studio: Shift-Alt-Right; macOS: Ctrl-Option-Right*

**forward-delete-char** (repeat=<numeric modifier; default=1>)

Delete one character in front of the cursor   *Key Bindings: Wing: Delete; Brief: Delete; Eclipse: Delete; Emacs: Ctrl-D; MATLAB: Delete; VI/VIM: Delete; Visual Studio: Delete; macOS: Ctrl-d*

**forward-delete-char-insert** (repeat=<numeric modifier; default=1>)

Delete one char in front of the cursor and enter insert mode (when
working in modal key bindings)  *Key Bindings: VI/VIM: s*

**forward-delete-char-within-line** (repeat=<numeric modifier; default=1>)

Delete one character in front of the cursor unless at end of line,
in which case delete backward.  Do nothing if the line is empty.  This 
is VI style 'x' in browser mode.  *Key Bindings: VI/VIM: x*

**forward-delete-word** (delimiters=None, repeat=<numeric modifier; default=1>)

Delete one word in front of the cursor   *Key Bindings: Wing: Ctrl-Delete; Brief: Ctrl-K; Eclipse: Ctrl-Delete; Emacs: Alt-D; MATLAB: Ctrl-Delete; VI/VIM: Ctrl-Delete; Visual Studio: Ctrl-Delete; macOS: Option-Delete*

**forward-delete-word-insert** (delimiters=None, repeat=<numeric modifier; default=1>)

Delete one word in front of the cursor and enter insert mode (when
working in modal key bindings)

**forward-page** (repeat=<numeric modifier; default=1>)

Move cursor forward one page   *Key Bindings: Wing: Ctrl-Next; Brief: Ctrl-Next; Eclipse: Ctrl-Next; Emacs: Ctrl-V; MATLAB: Ctrl-Next; VI/VIM: Ctrl-F; Visual Studio: Ctrl-Next; macOS: Ctrl-v*

**forward-page-extend** (repeat=<numeric modifier; default=1>)

Move cursor forward one page, adjusting the selection 
range to new position   *Key Bindings: Wing: Ctrl-Shift-Page_Down; Brief: Ctrl-Shift-Page_Down; Eclipse: Ctrl-Shift-Page_Down; Emacs: Ctrl-Shift-Page_Down; MATLAB: Ctrl-Shift-Page_Down; VI/VIM: Ctrl-Shift-Page_Down; Visual Studio: Ctrl-Shift-Page_Down; macOS: Shift-Page_Down*

**forward-paragraph** (repeat=<numeric modifier; default=1>)

Move cursor forward one paragraph (to next all-whitespace line).  *Key Bindings: VI/VIM: }*

**forward-paragraph-extend** (repeat=<numeric modifier; default=1>)

Move cursor forward one paragraph (to next all-whitespace line),
adjusting the selection range to new position.

**forward-tab** ()

Place a tab character at the current cursor position   *Key Bindings: Wing: Ctrl-T; Brief: Ctrl-T; Eclipse: Ctrl-T; Emacs: Ctrl-T; MATLAB: Tab; VI/VIM: Ctrl-T; Visual Studio: Ctrl-T; macOS: Ctrl-T*

**forward-word** (delimiters=None, gravity='start', repeat=<numeric modifier; default=1>)

Move cursor forward one word. Optionally, provide a string that
contains the delimiters to define which characters are part of a word.
Gravity may be "start" or "end" to indicate whether cursor is placed
at start or end of the word.  *Key Bindings: Wing: Ctrl-Right; Brief: Ctrl-Right; Eclipse: Ctrl-Right; Emacs: Alt-F; MATLAB: Ctrl-Right; VI/VIM: Shift-E invokes forward-word(delimiters=" \t\n\r", gravity="endm1"); Visual Studio: Ctrl-Right; macOS: Option-Right*

**forward-word-extend** (delimiters=None, gravity='start', repeat=<numeric modifier; default=1>)

Move cursor forward one word, adjusting the selection range to new
position. Optionally, provide a string that contains the delimiters to
define which characters are part of a word. Gravity may be "start" or
"end" to indicate whether cursor is placed at start or end of the word.  *Key Bindings: Wing: Ctrl-Shift-Right; Brief: Ctrl-Shift-Right; Eclipse: Ctrl-Shift-Right; Emacs: Ctrl-Shift-Right; MATLAB: Ctrl-Shift-Right; VI/VIM: Ctrl-Shift-Right; Visual Studio: Ctrl-Shift-Right; macOS: Ctrl-Shift-Right invokes forward-word-extend(delimiters="_`~!@#$%^&*()+-={}[]\\|;:\'\",.<>/? \t\r\n")*

**goto-overridden-method** ()

Goes to the method that is overridden by the current method 

**hide-selection** ()

Turn off display of the current text selection 

**indent-to-match** (toggle=False)

Indent the current line or selected region to match indentation of 
preceding non-blank line.  Set toggle=True to indent instead of one
level higher if already at the matching position.  *Key Bindings: Wing: Ctrl-=; Brief: Ctrl-=; Eclipse: Ctrl-=; Emacs: Ctrl-=; MATLAB: Ctrl-=; VI/VIM: Ctrl-=; Visual Studio: Ctrl-=; macOS: Command-\*

**indent-to-next-indent-stop** ()

Indent to next indent stop from the current position.  Acts like indent command
if selection covers multiple lines. 

**isearch-backward** (search_string=None, repeat=<numeric modifier; default=1>)

Initiate incremental mini-search backward from the cursor position,
optionally entering the given search string   *Key Bindings: Wing: Ctrl-Shift-U; Eclipse: Ctrl-Shift-J; Emacs: Ctrl-R; MATLAB: Ctrl-Shift-R; Visual Studio: Ctrl-Shift-U; macOS: Command-Shift-U*

**isearch-backward-regex** (search_string=None, repeat=<numeric modifier; default=1>)

Initiate incremental regular expression mini-search backward from the
cursor position, optionally entering the given search string   *Key Bindings: Emacs: Ctrl-Alt-R; VI/VIM: ?*

**isearch-forward** (search_string=None, repeat=<numeric modifier; default=1>)

Initiate incremental mini-search forward from the cursor position,
optionally entering the given search string   *Key Bindings: Wing: Ctrl-U; Eclipse: Ctrl-J; Emacs: Ctrl-S; MATLAB: Ctrl-Shift-S; Visual Studio: Ctrl-I; macOS: Command-U*

**isearch-forward-regex** (search_string=None, repeat=<numeric modifier; default=1>)

Initiate incremental regular expression mini-search forward from the
cursor position, optionally entering the given search string   *Key Bindings: Emacs: Ctrl-Alt-S; VI/VIM: /*

**isearch-repeat** (reverse=False, repeat=<numeric modifier; default=1>)

Repeat the most recent isearch, using same string and regex/text.
Reverse direction when reverse is True.  *Key Bindings: VI/VIM: Shift-N invokes isearch-repeat(reverse=1)*

**isearch-sel-backward** (persist=True, whole_word=False, repeat=<numeric modifier; default=1>)

Initiate incremental mini-search backward from the cursor position,
using current selection as the search string.  Set persist=False to
do the search but end the interactive search session immediately.  *Key Bindings: Wing: Ctrl-Shift-B; Eclipse: Ctrl-Shift-B; Emacs: Ctrl-C R; MATLAB: Ctrl-Shift-B; VI/VIM: # invokes isearch-sel-backward(persist=0, whole_word=1); Visual Studio: Ctrl-Shift-B*

**isearch-sel-forward** (persist=True, whole_word=False, repeat=<numeric modifier; default=1>)

Initiate incremental mini-search forward from the cursor position,
using current selection as the search string.  Set persist=False to
do the search but end the interactive search session immediately.  *Key Bindings: Wing: Ctrl-B; Eclipse: Ctrl-B; Emacs: Ctrl-C S; MATLAB: Ctrl-B; VI/VIM: \* invokes isearch-sel-forward(persist=0, whole_word=1); Visual Studio: Ctrl-B*

**kill-line** ()

Kill rest of line from cursor to end of line, and place
it into the clipboard with any other contiguously removed
lines.  End-of-line is removed only if there is nothing
between the cursor and the end of the line.   *Key Bindings: Brief: Alt-K; Emacs: Ctrl-K; macOS: Ctrl-k*

**middle-of-screen-line** ()

Move to middle of current wrapped line  *Key Bindings: VI/VIM: g m*

**middle-of-screen-line-extend** ()

Move to middle of current wrapped line, extending selection

**move-line-down** (indent=True, repeat=<numeric modifier; default=1>)

Move the current line or lines up down line, optionally
indenting to match the new position  *Key Bindings: Wing: Ctrl-Shift-Down; Eclipse: Alt-Down invokes move-line-down(indent=True); MATLAB: Ctrl-Shift-Down*

**move-line-up** (indent=True, repeat=<numeric modifier; default=1>)

Move the current line or lines up one line, optionally
indenting to match the new position  *Key Bindings: Wing: Ctrl-Shift-Up; Eclipse: Alt-Up invokes move-line-up(indent=True); MATLAB: Ctrl-Shift-Up*

**move-range** (start_line, end_line, target_line)

Move the given range of lines to the given target line.  Moves to current
line if target_line is '.'.

**move-to-register** (unit='char', cut=0, num=<numeric modifier; default=1>)

Cut or copy a specified number of characters or lines, or the current
selection. Set cut=1 to remove the range of text from the editor after
moving to register (otherwise it is just copied). Unit should be one of
'char' or 'line' or 'sel' for current selection.  *Key Bindings: VI/VIM: Shift-Y invokes move-to-register(unit="line")*

**move-to-register-next-move** (cut=0, repeat=<numeric modifier; default=1>)

Move the text spanned by the next cursor motion to a register  *Key Bindings: VI/VIM: y*

**new-line** (auto_indent=None)

Place a new line at the current cursor position.  Override the auto-indent
preference by setting auto_indent to 'never' to avoid indent, 'always' to
auto-indent, and 'blank-only' to auto-indent only on blank lines.  *Key Bindings: Wing: Alt-Return; Brief: Alt-Return; Eclipse: Alt-Return; Emacs: Alt-Return; MATLAB: Shift-Return invokes new-line(auto_indent="never"); VI/VIM: Ctrl-J; Visual Studio: Alt-Return; macOS: Option-Return*

**new-line-after** ()

Place a new line after the current line   *Key Bindings: Wing: Ctrl-Return; Brief: Ctrl-Return; Eclipse: Shift-Enter; Emacs: Ctrl-Return; MATLAB: Ctrl-Return; VI/VIM: Ctrl-Return; Visual Studio: Ctrl-Return*

**new-line-before** ()

Place a new line before the current line   *Key Bindings: Wing: Shift-Return; Brief: Shift-Return; Eclipse: Ctrl-Shift-Enter; Emacs: Shift-Return; MATLAB: Shift-Return; VI/VIM: Shift-Return; Visual Studio: Shift-Return*

**next-blank-line** (threshold=0, repeat=<numeric modifier; default=1>)

Move to the next blank line in the file, if any.  If threshold>0 then a
line is considered blank if it contains less than that many characters
after leading and trailing whitespace are removed.  *Key Bindings: Emacs: Alt-} invokes next-blank-line(threshold=1)*

**next-block** (count=1, ignore_indented=True)

Select the next block.  Will ignore indented blocks
under the current block unless ignore_indented is False.
Specify a count of more than 1 to go forward multiple blocks.   *Key Bindings: MATLAB: Ctrl-Down*

**next-line** (cursor='same', repeat=<numeric modifier; default=1>)

Move to screen next line, optionally repositioning character within
line: 'same' to leave in same horizontal position, 'start' at start, 'end'
at end, or 'fnb' for first non-blank char.  *Key Bindings: Wing: Down; Brief: Down; Eclipse: Down; Emacs: Ctrl-N; MATLAB: Down; VI/VIM: Ctrl-N; Visual Studio: Down; macOS: Ctrl-n*

**next-line-extend** (cursor='same', repeat=<numeric modifier; default=1>)

Move to next screen line, adjusting the selection range to new
position, optionally repositioning character within line: same' to leave
in same horizontal position, 'start' at start, 'end' at end, 'fnb' for
first non-blank char, or 'xcode' to simulate XCode style Shift-Alt line
selection.  *Key Bindings: Wing: Shift-Down; Brief: Shift-Down; Eclipse: Shift-Down; Emacs: Shift-Down; MATLAB: Shift-Down; VI/VIM: Shift-Down; Visual Studio: Shift-Down; macOS: Shift-Alt-Down invokes next-line-extend(cursor="xcode")*

**next-line-extend-rect** (cursor='same', repeat=<numeric modifier; default=1>)

Move to next screen line, adjusting the rectangular selection range to new
position, optionally repositioning character within line: same' to leave
in same horizontal position, 'start' at start, 'end' at end, or 'fnb' for
first non-blank char.  *Key Bindings: Wing: Shift-Alt-Down; Brief: Shift-Alt-Down; Eclipse: Shift-Alt-Down; Emacs: Shift-Alt-Down; MATLAB: Shift-Alt-Down; VI/VIM: Shift-Alt-Down; Visual Studio: Shift-Alt-Down; macOS: Ctrl-Option-Down*

**next-line-in-file** (cursor='start', repeat=<numeric modifier; default=1>)

Move to next line in file, repositioning character within line:
'start' at start, 'end' at end, or 'fnb' for first non-blank char.  *Key Bindings: VI/VIM: Ctrl-M invokes next-line-in-file(cursor="fnb")*

**next-scope** (count=1, sibling_only=False)

Select the next scope.  Specify a count of more than 1 to go
forward multiple scopes.  If sibling_only is true, move only to other
scopes of the same parent.   *Key Bindings: Eclipse: Ctrl-Shift-Down*

**next-statement** (count=1, ignore_indented=True)

Select the next statement.  Will ignore indented statements
under the current statements unless ignore_indented is False.
Specify a count of more than 1 to go forward multiple statements.   *Key Bindings: Eclipse: Alt-Shift-Right*

**open-line** ()

Open the current line by inserting a newline after the caret  *Key Bindings: Emacs: Ctrl-O*

**paste** ()

Paste text from clipboard   *Key Bindings: Wing: Ctrl-V; Brief: Ctrl-V; Eclipse: Ctrl-V; Emacs: Ctrl-Y; MATLAB: Ctrl-V; VI/VIM: Shift-Insert; Visual Studio: Ctrl-V; macOS: Command-V*

**paste-register** (pos=1, indent=0, cursor=-1)

Paste text from register as before or after the current position. If
the register contains only lines, then the lines are pasted before or
after current line (rather than at cursor).  If the register contains 
fragments of lines, the text is pasted over the current selection or
either before or after the cursor.  Set pos = 1 to paste after, or
-1 to paste before. Set indent=1 to indent the pasted text to match
current line. Set cursor=-1 to place cursor before lines or cursor=1 to
place it after lines after paste completes.  *Key Bindings: VI/VIM: g Shift-P invokes paste-register(pos=-1, cursor=1)*

**previous-blank-line** (threshold=0, repeat=<numeric modifier; default=1>)

Move to the previous blank line in the file, if any.  If threshold>0 then a
line is considered blank if it contains less than that many characters
after leading and trailing whitespace are removed.  *Key Bindings: Emacs: Alt-{ invokes previous-blank-line(threshold=1)*

**previous-block** (count=1, ignore_indented=True)

Select the previous block.  Will ignore indented blocks
under the current block unless ignore_indented is False.
Specify a count of more than 1 to go backward multiple blocks.   *Key Bindings: MATLAB: Ctrl-Up*

**previous-line** (cursor='same', repeat=<numeric modifier; default=1>)

Move to previous screen line, optionally repositioning character
within line: same' to leave in same horizontal position, 'start' at start,
'end' at end, or 'fnb' for first non-blank char.  *Key Bindings: Wing: Up; Brief: Up; Eclipse: Up; Emacs: Ctrl-P; MATLAB: Up; VI/VIM: Ctrl-P; Visual Studio: Up; macOS: Ctrl-p*

**previous-line-extend** (cursor='same', repeat=<numeric modifier; default=1>)

Move to previous screen line, adjusting the selection range to new
position, optionally repositioning character within line: same' to leave
in same horizontal position, 'start' at start, 'end' at end, 'fnb' for
first non-blank char, or 'xcode' to simulate XCode style Shift-Alt line
selection.  *Key Bindings: Wing: Shift-Up; Brief: Shift-Up; Eclipse: Shift-Up; Emacs: Shift-Up; MATLAB: Shift-Up; VI/VIM: Shift-Up; Visual Studio: Shift-Up; macOS: Shift-Alt-Up invokes previous-line-extend(cursor="xcode")*

**previous-line-extend-rect** (cursor='same', repeat=<numeric modifier; default=1>)

Move to previous screen line, adjusting the rectangular selection range to new
position, optionally repositioning character within line: same' to leave
in same horizontal position, 'start' at start, 'end' at end, or 'fnb' for
first non-blank char.  *Key Bindings: Wing: Shift-Alt-Up; Brief: Shift-Alt-Up; Eclipse: Shift-Alt-Up; Emacs: Shift-Alt-Up; MATLAB: Shift-Alt-Up; VI/VIM: Shift-Alt-Up; Visual Studio: Shift-Alt-Up; macOS: Ctrl-Option-Up*

**previous-line-in-file** (cursor='start', repeat=<numeric modifier; default=1>)

Move to previous line in file, repositioning character within line:
'start' at start, 'end' at end, or 'fnb' for first non-blank char.  *Key Bindings: VI/VIM: - invokes previous-line-in-file(cursor="fnb")*

**previous-scope** (count=1, sibling_only=False)

Select the previous scope.  Specify a count of more than 1 to go
backward multiple scopes.  If sibling_only is true, move only to other
scopes of the same parent.   *Key Bindings: Eclipse: Ctrl-Shift-Up*

**previous-statement** (count=1, ignore_indented=True)

Select the previous statement.  Will ignore indented statements
under the current statements unless ignore_indented is False.
Specify a count of more than 1 to go back multiple statements.   *Key Bindings: Eclipse: Alt-Shift-Left*

**profile-editor-start** ()

Turn on profiling for the current source editor

**profile-editor-stop** ()

Stop profiling and print stats to stdout

**reanalyze-file** ()

Rescan file for code analysis. 

**redo** ()

Redo last action   *Key Bindings: Wing: Ctrl-Shift-Z; Brief: Ctrl-U; Eclipse: Ctrl-Shift-Z; Emacs: Ctrl-.; MATLAB: Alt-Shift-Backspace; VI/VIM: Ctrl-R; Visual Studio: Ctrl-Shift-Z; macOS: Command-Shift-Z*

**repeat-command** (repeat=<numeric modifier; default=1>)

Repeat the last editor command  *Key Bindings: VI/VIM: .*

**repeat-search-char** (opposite=0, repeat=<numeric modifier; default=1>)

Repeat the last search_char operation, optionally in the opposite
direction.  *Key Bindings: VI/VIM: , invokes repeat-search-char(opposite=1)*

**rstrip-each-line** ()

Strip trailing whitespace from each line. 

**scroll-text-down** (repeat=<numeric modifier; default=1>, move_cursor=True)

Scroll text down a line w/o moving cursor's relative position on screen.
Repeat is number of lines or if >0 and <1.0 then percent of screen.  Set move_cursor
to False to leave cursor in current position within the source, otherwise it is
moved so the cursor remains on same screen line.  *Key Bindings: Wing: Ctrl-Shift-Down; Brief: Ctrl-D; Eclipse: Ctrl-Shift-Down; Emacs: Ctrl-Shift-Down; MATLAB: Ctrl-Down; VI/VIM: Ctrl-D invokes scroll-text-down(repeat=0.5); Visual Studio: Ctrl-Shift-Down*

**scroll-text-left** (repeat=<numeric modifier; default=1>)

Scroll text left a column w/o moving cursor's relative position on screen.
Repeat is number of columns or if >0 and <1.0 then percent of screen.  *Key Bindings: VI/VIM: z Shift-L invokes scroll-text-left(repeat=0.5)*

**scroll-text-page-down** (repeat=<numeric modifier; default=1>, move_cursor=True)

Scroll text down a page w/o moving cursor's relative position on screen.
Repeat is number of pages or if >0 and <1.0 then percent of screen.  Set move_cursor
to False to leave cursor in current position within the source, otherwise it is
moved so the cursor remains on same screen line.

**scroll-text-page-up** (repeat=<numeric modifier; default=1>, move_cursor=True)

Scroll text up a page w/o moving cursor's relative position on screen.
Repeat is number of pages or if >0 and <1.0 then percent of screen.  Set move_cursor
to False to leave cursor in current position within the source, otherwise it is
moved so the cursor remains on same screen line.

**scroll-text-right** (repeat=<numeric modifier; default=1>)

Scroll text right a column w/o moving cursor's relative position on screen.
Repeat is number of columns or if >0 and <1.0 then percent of screen.  *Key Bindings: VI/VIM: z Shift-H invokes scroll-text-right(repeat=0.5)*

**scroll-text-up** (repeat=<numeric modifier; default=1>, move_cursor=True)

Scroll text up a line w/o moving cursor's relative position on screen.
Repeat is number of lines or if >0 and <1.0 then percent of screen.  Set move_cursor
to False to leave cursor in current position within the source, otherwise it is
moved so the cursor remains on same screen line.  *Key Bindings: Wing: Ctrl-Shift-Up; Brief: Ctrl-E; Eclipse: Ctrl-Shift-Up; Emacs: Ctrl-Shift-Up; MATLAB: Ctrl-Up; VI/VIM: Ctrl-U invokes scroll-text-up(repeat=0.5); Visual Studio: Ctrl-Shift-Up*

**scroll-to-cursor** ()

Scroll to current cursor position, if not already visible 

**scroll-to-end** (move_caret=False)

Scroll to the end of the text in the editor.  Set move_caret to control
whether the caret is moved.  *Key Bindings: macOS: End*

**scroll-to-start** (move_caret=False)

Scroll to the top of the text in the editor.  Set move_caret to control
whether the the caret is moved.  *Key Bindings: macOS: Home*

**search-char** (dir=1, pos=0, repeat=<numeric modifier; default=1>, single_line=0)

Search for the given character. Searches to right if dir > 0 and to
left if dir < 0. Optionally place cursor pos characters to left or right
of the target (e.g., use -1 to place one to left). If repeat > 1, the Nth
match is found. Set single_line=1 to search only within the current
line.  *Key Bindings: VI/VIM: Shift-T invokes search-char(dir=-1, pos=1, single_line=1)*

**select-all** ()

Select all text in the editor   *Key Bindings: Wing: Ctrl-A; Eclipse: Ctrl-A; MATLAB: Ctrl-A; Visual Studio: Ctrl-A; macOS: Command-A*

**select-block** ()

Select the block the cursor is in. 

**select-less** ()

Select less code; undoes the last select-more command   *Key Bindings: Wing: Ctrl-Down; Brief: Ctrl-Down; Eclipse: Alt-Shift-Down; Emacs: Ctrl-Down; MATLAB: Ctrl-Down; VI/VIM: Ctrl-Down; Visual Studio: Ctrl-Down*

**select-lines** ()

Select the current line or lines 

**select-more** ()

Select more code on either the current line or larger multi-line
blocks.   *Key Bindings: Wing: Ctrl-Up; Brief: Ctrl-Up; Eclipse: Alt-Shift-Up; Emacs: Ctrl-Up; MATLAB: Ctrl-Up; VI/VIM: Ctrl-Up; Visual Studio: Ctrl-Up; macOS: Option-Up*

**select-scope** ()

Select the scope the cursor is in. 

**select-statement** ()

Select the statement the cursor is in. 

**send-keys** (keys)

Send one or more keys to the editor. Send a string to enter each key in the string,
or a list of strings and/or (mod, key) tuples where mod is a string containing any of
case insensitive 'shift', 'ctrl', or 'alt'.  Valid examples::

  "testme"
  "TestMe"
  ["test", ('Alt', 'X'), "m"]
  [('ctrl-Shift', 'X'), ('shift','E'),]  *Key Binding: Shift-Space invokes send-keys(keys=" ")*

**set-mark-command** (unit='char')

Set start of text marking for selection at current cursor
position.  Subsequently, all cursor move operations will automatically
extend the text selection until stop-mark-command is issued.  Unit
defines what is selected: can be one of char, line, or block (rectangle).  *Key Bindings: Emacs: Ctrl-@*

**set-register** ()

Set the register to use for subsequent cut/copy/paste operations  *Key Bindings: VI/VIM: "*

**show-autocompleter** ()

Show the auto-completer for current cursor position  *Key Bindings: Wing: Ctrl-space; Eclipse: Ctrl-space; Emacs: Alt-/; MATLAB: Ctrl-space; Visual Studio: Ctrl-space; macOS: Ctrl-space*

**show-selection** ()

Turn on display of the current text selection 

**smart-tab** ()

Implement smart handling of tab key.  The behavior varies by context
as follows:

* In Non-Python code, always indents to the next indent stop
* On a non-blank line when cursor is at end or before a comment, insert tab
* On a where indent does not match the computed indent level, 
  move to the matching indent level
* Otherwise decrease indent one level (thus a non-blank line toggles 
  between matching position and one block higher)
    *Key Bindings: MATLAB: Ctrl-I*

**start-of-document** ()

Move cursor to start of document   *Key Bindings: Wing: Ctrl-Home; Brief: Home Home Home; Eclipse: Ctrl-Home; Emacs: Ctrl-X [; MATLAB: Ctrl-Home; VI/VIM: Ctrl-Home; Visual Studio: Ctrl-Home; macOS: Command-Up*

**start-of-document-extend** ()

Move cursor to start of document, adjusting the selection 
range to new position   *Key Bindings: Wing: Ctrl-Shift-Home; Brief: Ctrl-Shift-Home; Eclipse: Ctrl-Shift-Home; Emacs: Ctrl-Shift-Home; MATLAB: Ctrl-Shift-Home; VI/VIM: Ctrl-Shift-Home; Visual Studio: Ctrl-Shift-Home; macOS: Shift-Home*

**stop-mark-command** (deselect=True)

Stop text marking for selection at current cursor position,
leaving the selection set as is.  Subsequent cursor move operations
will deselect the range and set selection to cursor position.  
Deselect immediately when deselect is True.  *Key Bindings: Emacs: Esc Esc*

**swap-lines** (previous=False)

Swap the line at start of current selection with the line that follows it,
or the preceding line if previous is True.  *Key Bindings: Wing: Ctrl-Shift-L; Eclipse: Ctrl-Shift-L; Emacs: Ctrl-X Ctrl-T invokes swap-lines(previous=True); MATLAB: Ctrl-Shift-L*

**tab-key** ()

Implement the tab key, the action of which is configurable by preference  *Key Binding: Tab*

**undo** ()

Undo last action   *Key Bindings: Wing: Ctrl-Z; Brief: Ctrl-Z; Eclipse: Ctrl-Z; Emacs: Ctrl-X U; MATLAB: Alt-Backspace; VI/VIM: u; Visual Studio: Ctrl-Z; macOS: Command-Z*

**yank-line** ()

Yank contents of kill buffer created with kill-line into
the edit buffer   *Key Bindings: Emacs: Ctrl-Y*

**yank-range** (start_line, end_line, register=None)

Copy given range of lines into given register (or
currently selected default register if register is None

Goto Symbol Definition Commands
-------------------------------

Goto symbol definition commands available when working either in the shell or editor

**goto-clicked-symbol-defn** (other_split=None)

Goto the definition of the source symbol that was last clicked on. If
other_split is true, the definition will be displayed if a split other
than the current split; if other_split is false, it will be displayed in
the current editor; if other_split is not specified or None, the split to
be used is determined by the Split Reuse Policy preference value.  *Key Bindings: Wing: Ctrl-left-button-click; Brief: Ctrl-left-button-click; Eclipse: Ctrl-left-button-click; Emacs: Ctrl-left-button-click; MATLAB: Ctrl-left-button-click; VI/VIM: Ctrl-left-button-click; Visual Studio: Ctrl-left-button-click; macOS: Command-left-button-click*

**goto-selected-symbol-defn** (other_split=None)

Goto the definition of the selected source symbol.  If other_split is
true, the definition will be displayed if a split other than the current
split; if other_split is false, it will be displayed in the current editor;
if other_split is not specified or None, the split to be used is determined
by the Split Reuse Policy preference value.   *Key Bindings: Wing: F4; Brief: Alt-H; Eclipse: Ctrl-G; Emacs: Alt-.; MATLAB: F4; VI/VIM: g Shift-D; Visual Studio: F4; macOS: F4*

Source Assistant Commands
-------------------------

Commands for controlling the Source Assistant tool.

**hide-assistant-resolution-steps** (path='')

Hide the steps used to determine likely types in the source
assistant 

**show-assistant-resolution-steps** (path='')

Show the steps used to determine likely types in the source
assistant 

Bookmark Tool Commands
----------------------

Commands available on a specific instance of the bookmark manager tool

**bookmarks-export-selected** (filename)

Export the selected bookmarks

**bookmarks-export-visible** (filename)

Export all visible bookmarks

**bookmarks-import** (filename)

Not documented

**bookmarks-remove-all** (confirm=1)

Remove all bookmarks

**bookmarks-selected-edit** ()

Edit the selected bookmark

**bookmarks-selected-goto** ()

Goto the selected bookmarks

**bookmarks-selected-remove** (confirm=1)

Remove the selected bookmark

**bookmarks-show-docs** ()

Show the Wing documentation section for the bookmarks manager

Snippet Commands
----------------

High level commands for initiating use of code snippets defined in the Snippets tool.
These commands are available regardless of keyboard focus.

**snippet** (snippet_name)

Insert given snippet into current editor, selecting the snippet
appropriate for that file type from universal snippets if not found.
This will preprocess the snippet to match indentation style to the
target file, adjusts indentation based on context, and starts inline
argument collection..

**snippet-file** (snippet_name, mime_type='', context='all')

Create a new file with given snippet and start inline snippet 
argument collection.  If mime type is given, a file of that type is
created.  Otherwise, all snippets are searched and the first found
snippet of given name is used, and file type matches the type of
the snippet

Snippet Tool Commands
---------------------

Commands for managing and using snippets defined in the Snippets tool.  These commands are
availoable only when the Snippets tool has keyboard focus.

**snippet-add** (new_snippet_name, ttype='')

Add a new snippet to the current Snippets tool page or the given
page

**snippet-add-file-type** (file_extension)

Add a file type to the snippet manager. The file type is the file
extension. It is added to the last directory on the snippet path.

**snippet-assign-key-binding** ()

Assign/reassign/unassign the key binding associated with
the given snippet by name.

**snippet-clear-key-binding** ()

Clear the key binding associated with the given snippet

**snippet-reload-all** ()

Reload all the snippet files.  The snippet manager does this
automatically most of the time, but reload can be useful to cause
the snippet panel display to update when snippets are added or
removed from outside of Wing.

**snippet-remove-file-type** ()

Remove a file type from the snippet manager, including any snippets
defined for it. This operates only on the last directory on the snippet path.

**snippet-rename-file-type** (new_file_extension)

Rename a file type to the snippet manager. The file type is the file
extension. This operates on the last directory on the snippet path.

**snippet-restore-defaults** (delete=False)

Restore the factory default snippets. If delete is True, this will
completely remove all snippets first so any changes made to to snippets will
be lost. If delete is False, only missing snippet files will be restored.

**snippet-selected-copy** (new_name)

Copy the selected snippet to a new name in the same context

**snippet-selected-edit** ()

Edit the selected snippet

**snippet-selected-new-file** ()

Paste the currently selected snippet into a new editor

**snippet-selected-paste** ()

Paste the currently selected snippet into the current editor

**snippet-selected-remove** ()

Remove the selected snippet

**snippet-selected-rename** (new_name)

Rename the selected snippet

**snippet-show-docs** ()

Show the Wing documentation section for the snippet manager

Open Files Tool Commands
------------------------

Commands for controlling the Open Files tool

**close** ()

Close the currently selected items in the Open Files tool  *Key Bindings: Wing: Ctrl-W; Brief: Ctrl-F4; Eclipse: Ctrl-W; Emacs: Ctrl-F4; MATLAB: Ctrl-W; VI/VIM: Ctrl-W q invokes close(close_window=1); Visual Studio: Ctrl-W; macOS: Command-Shift-W*

**close-others** ()

Close all the open files except those selected in the Open Files tool
