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

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

Commands available only when the editor is in browse mode (used
for VI bindings and possibly others)

**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-block** ()

Turn on auto-select block 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; OS X: Shift-Command-F8*

**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; OS X: 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; OS X: 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-ctrl-c** ()

Perform vi mode ctrl-c action which either does a copy or nothing if
ctrl-x/v/c are not being used for clipboard actions. The default
is to map ctrl-c to clipboard on Windows and OS X. This can be overridden
by the VI Mode Ctrl-X/C/V preference.  *Key Bindings: VI/VIM: Ctrl-C*

**vi-ctrl-v** ()

Perform vi mode ctrl-v action which either does a paste or does
start-select-block.  The default is to map ctrl-v to clipboard on
Windows and OS X.  This can be overridden by the VI Mode Ctrl-X/C/V
preference.  *Key Bindings: VI/VIM: Ctrl-V*

**vi-ctrl-x** ()

Perform vi mode ctrl-x action which either does a cut or does
initiate-numeric-modified with the following digit key press. The default
is to map ctrl-x to clipboard on Windows and OS X. This can be overridden
by the VI Mode Ctrl-X/C/V preference.  *Key Bindings: VI/VIM: Ctrl-X*

**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 Insert Mode Commands
---------------------------

Commands available only when editor is in insert mode (used 
for VI bindings and possibly others)

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

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

**vi-ctrl-c** ()

Perform vi mode ctrl-c action which either does a copy or enters browse
mode if ctrl-x/v/c are not being used for clipboard actions. The default
is to map ctrl-c to clipboard on Windows and OS X. This can be overridden
by the VI Mode Ctrl-X/C/V preference.  *Key Bindings: VI/VIM: Ctrl-C*

**vi-ctrl-v** ()

Perform vi mode ctrl-v action which either does a paste or does
start-select-block.  The default is to map ctrl-v to clipboard on
Windows and OS X.  This can be overridden by the VI Mode Ctrl-X/C/V
preference.  *Key Bindings: VI/VIM: Ctrl-V*

**vi-ctrl-x** ()

Perform vi mode ctrl-x action which either does a cut or nothing 
depending on whether ctrl-x/v/c are mapped to clipboard actions. The default
is to map ctrl-x to clipboard on Windows and OS X. This can be overridden
by the VI Mode Ctrl-X/C/V preference.  *Key Bindings: VI/VIM: Ctrl-X*

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; OS X: Esc*

**start-select-block** ()

Turn on auto-select block 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; OS X: Shift-Command-F8*

**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; OS X: 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; OS X: Command-F8*

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

Commands that control splitting up an editor panel.  These are available
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 Replace Mode Commands
----------------------------

Commands available only when editor is in replace mode (used 
for VI bindings and possibly others)

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

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

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

Commands for a particular editor split, available when the editor
in that split has the keyboard focus.  Additional commands affecting
the editor's content are defined separately.

**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; OS X: 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-_; OS X: 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--; OS X: Back-button-click*

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

Commands available only when the editor is in visual mode (used
for VI bindings and some others)

**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; OS X: 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: :*

**vi-ctrl-c** ()

Perform vi mode ctrl-c action which either does a copy or nothing if
ctrl-x/v/c are not being used for clipboard actions. The default
is to map ctrl-c to clipboard on Windows and OS X. This can be overridden
by the VI Mode Ctrl-X/C/V preference.  *Key Bindings: VI/VIM: Ctrl-C*

**vi-ctrl-v** ()

Perform vi mode ctrl-v action which either does a paste or does
start-select-block.  The default is to map ctrl-v to clipboard on
Windows and OS X.  This can be overridden by the VI Mode Ctrl-X/C/V
preference.  *Key Bindings: VI/VIM: Ctrl-V*

**vi-ctrl-x** ()

Perform vi mode ctrl-x action which either does a cut or does
initiate-numeric-modified with the following digit key press. The default
is to map ctrl-x to clipboard on Windows and OS X. This can be overridden
by the VI Mode Ctrl-X/C/V preference.  *Key Bindings: VI/VIM: Ctrl-X*

Active Editor Commands
----------------------

Commands that only apply to editors when they have 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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); OS X: 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; OS X: 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-]; OS X: 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; OS X: 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; OS X: 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*

**drop-extra-selections** ()

Drop all exceptions except the main selection 

**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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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 

**hide-selections-popup** ()

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

**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-=; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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: OS X: 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: OS X: 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; OS X: 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; OS X: Option-Up*

**select-scope** ()

Select the scope the cursor is in. 

**select-statement** ()

Select the statement the cursor is in. 

**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); OS X: Command-Shift-D invokes selection-add-next-occurrence(skip_current=True)*

**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; OS X: Ctrl-space*

**show-selection** ()

Turn on display of the current text selection 

**show-selections-popup** ()

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

**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; OS X: 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; OS X: 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: Ctrl-G*

**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*

**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 

**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; OS X: Command-Z*

**yank-line** ()

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

General Editor Commands
-----------------------

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

**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 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.  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; OS X: 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; OS X: 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-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-debug-probe** (whole_lines=None)

Not documented

**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; OS X: Command-M*

**fill-paragraph** ()

Attempt to auto-justify the paragraph around the current start of
selection   *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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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-/; OS X: 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; OS X: 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->; OS X: 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-<; OS X: 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 > PEP 8 > 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; OS X: 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; OS X: 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-.*

**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-(; OS X: 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-); OS X: 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; OS X: 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; OS X: 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; OS X: 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; OS X: 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-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; OS X: 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; OS X: 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-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; OS X: Command-7 S*

**use-lexer-tcl** ()

Force syntax highlighting for TCL 

**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; OS X: Command-7 X*

**use-lexer-yaml** ()

Force syntax highlighting for YAML 

**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-_*

Shell Or Editor Commands
------------------------

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; OS X: 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; OS X: F4*

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

Commands for source assistant 

**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 View 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
----------------

Top-level commands for code snippets

**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 View Commands
---------------------

Commands available on a specific instance of the snippet manager tool

**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
