Textadept API Documentation

  1. _G
  2. _L
  3. _M
  4. _M.ansi_c
  5. _M.lua
  6. _SCINTILLA
  7. args
  8. assert
  9. buffer
  10. events
  11. io
  12. keys
  13. lexer
  14. lfs
  15. os
  16. string
  17. textadept
  18. textadept.bookmarks
  19. textadept.editing
  20. textadept.file_types
  21. textadept.keys
  22. textadept.macros
  23. textadept.menu
  24. textadept.run
  25. textadept.session
  26. textadept.snippets
  27. ui
  28. ui.command_entry
  29. ui.dialogs
  30. ui.find
  31. view

The _G Module


Extends Lua’s _G table to provide extra functions and fields for Textadept.

Fields defined by _G

BSD (bool)

Whether or not Textadept is running on BSD.

CURSES (bool)

Whether or not Textadept is running in a terminal. Curses feature incompatibilities are listed in the Appendix.

LINUX (bool)

Whether or not Textadept is running on Linux.

OSX (bool)

Whether or not Textadept is running on macOS as a GUI application.

WIN32 (bool)

Whether or not Textadept is running on Windows.

_CHARSET (string)

The filesystem’s character encoding. This is used when working with files.

_HOME (string)

The path to Textadept’s home, or installation, directory.

_RELEASE (string)

The Textadept release version string.

_USERHOME (string)

The path to the user’s ~/.textadept/ directory, where all preferences and user-data is stored. On Windows machines ~/ is the value of the “USERHOME” environment variable (typically C:\Users\username\ or C:\Documents and Settings\username\). On Linux, BSD, and macOS machines ~/ is the value of “$HOME” (typically /home/username/ and /Users/username/ respectively).

Functions defined by _G

quit()

Emits a QUIT event, and unless any handler returns false, quits Textadept.

See also:

reset()

Resets the Lua State by reloading all initialization scripts. Language modules for opened files are NOT reloaded. Re-opening the files that use them will reload those modules instead. This function is useful for modifying user scripts (such as ~/.textadept/init.lua and ~/.textadept/modules/textadept/keys.lua) on the fly without having to restart Textadept. arg is set to nil when reinitializing the Lua State. Any scripts that need to differentiate between startup and reset can test arg.

timeout(interval, f, …)

Calls function f with the given arguments after interval seconds. If f returns true, calls f repeatedly every interval seconds as long as f returns true. A nil or false return value stops repetition.

Parameters:

Tables defined by _G

_BUFFERS

Table of all open buffers in Textadept. Numeric keys have buffer values and buffer keys have their associated numeric keys.

Usage:

See also:

_VIEWS

Table of all views in Textadept. Numeric keys have view values and view keys have their associated numeric keys.

Usage:

See also:

arg

Table of command line parameters passed to Textadept.

See also:

_G.buffer

The current buffer in the current view.

_G.view

The current view.


The _L Module


Map of all messages used by Textadept to their localized form. If the table does not contain the localized version of a given message, it returns a string that starts with “No Localization:” via a metamethod. Note: the terminal version ignores any “_” mnemonics the GUI version would use.


The _M Module


A table of loaded Textadept language modules.

Language modules are a special kind of module that Textadept automatically loads when editing source code in a particular programming language. The only thing “special” about them is they are named after a lexer. Otherwise they are plain Lua modules. The ~/.textadept/modules/ directory houses language modules (along with other modules).

A language module is designed to provide extra functionality for a single programming language. Some examples of what language modules can do:

Examples of these features are described in the sections below.

Block Comment

Many languages have different syntaxes for single line comments and multi-line comments in source code. Textadept’s block comment feature only uses one of those syntaxes for a given language. If you prefer the other syntax, or if Textadept does not support block comments for a particular language, modify the textadept.editing.comment_string table. For example:

textadept.editing.comment_string.ansi_c = '//' -- change from /* ... */

Compile and Run

Textadept knows most of the commands that compile and/or run code in source files. However, it does not know all of them, and the ones that it does know may not be completely accurate in all cases. Compile and run commands are read from the textadept.run.compile_commands and textadept.run.run_commands tables using the appropriate lexer name key, and thus can be defined or modified. For Lua, it would look like:

textadept.run.compile_commands.lua = 'luac "%f"'
textadept.run.run_commands.lua = 'lua "%f"'

Double-clicking on compile or runtime errors jumps to the error’s location. If Textadept does not recognize your language’s errors properly, add an error pattern to textadept.run.error_patterns. The Lua error pattern looks like:

local patterns = textadept.run.error_patterns
if not patterns.lua then patterns.lua = {} end
patterns.lua[#patterns.lua + 1] = '^luac?: (.-):(%d+): (.+)$'

Buffer Properties

By default, Textadept uses 2 spaces for indentation. Some languages have different indentation guidelines, however. As described in the manual, use events.LEXER_LOADED to change this and any other language-specific editor properties. For example:

events.connect(events.LEXER_LOADED, function(name)
  if name ~= 'python' then return end
  buffer.tab_width = 4
  buffer.use_tabs = false
  view.view_ws = view.WS_VISIBLEALWAYS
end

Autocompletion and Documentation

Textadept has the capability to autocomplete symbols for programming languages and display API documentation. In order for these to work for a given language, an autocompleter and API file(s) must exist. All of Textadept’s included language modules have examples of autocompleters and API documentation, as well as most of its officially supported language modules.

Snippets

Snippets for common language constructs are useful. Some snippets for common Lua control structures look like this:

snippets.lua = {
  f = "function %1(name)(%2(args))\n\t%0\nend",
  ['for'] = "for i = %1(1), %2(10)%3(, -1) do\n\t%0\nend",
  fori = "for %1(i), %2(val) in ipairs(%3(table)) do\n\t%0\nend",
  forp = "for %1(k), %2(v) in pairs(%3(table)) do\n\t%0\nend",
}

Commands

Additional editing features for the language can be useful. For example, a C++ module might have a feature to add a ‘;’ to the end of the current line and insert a new line. This command could be bound to the Shift+Enter (⇧↩ on macOS | S-Enter in the terminal version) key for easy access:

keys.cpp = {
  ['s\n'] = function()
    buffer:line_end()
    buffer:add_text(';')
    buffer:new_line()
  end
}

When defining key bindings for other commands, you may make use of a Ctrl+L (⌘L on macOS | M-L in the terminal version) keychain. Traditionally this prefix has been reserved for use by language modules (although neither Textadept nor its modules utilize it at the moment). Users may define this keychain for new or existing modules and it will not conflict with any default key bindings. For example:

keys.lua[CURSES and 'meta+l' or OSX and 'cmd+l' or 'ctrl+l'] = {
  ...
}

It may be useful to add language-specific menu options to the top-level menu and/or right-click context menu in order to access module features without using key bindings. For example:

local lua_menu = {
  title = 'Lua',
  {'Item 1', function() ... end},
  {'Item 2', function() ... end}
}
local tools = textadept.menu.menubar[_L['Tools']]
tools[#tools + 1] = lua_menu
textadept.menu.context_menu[#textadept.menu.context_menu + 1] = lua_menu

The _M.ansi_c Module


The ansi_c module. It provides utilities for editing C code.

Fields defined by _M.ansi_c

_M.ansi_c.autocomplete_snippets (boolean)

Whether or not to include snippets in autocompletion lists. The default value is true.

Tables defined by _M.ansi_c

keys.ansi_c

Table of C-specific key bindings.

snippets.ansi_c

Table of C-specific snippets.

_M.ansi_c.tags

List of ctags files to use for autocompletion in addition to the current project’s top-level tags file or the current directory’s tags file.


The _M.lua Module


The lua module. It provides utilities for editing Lua code.

Fields defined by _M.lua

_M.lua.autocomplete_snippets (boolean)

Whether or not to include snippets in autocompletion lists. The default value is false.

Tables defined by _M.lua

keys.lua

Container for Lua-specific key bindings.

snippets.lua

Container for Lua-specific snippets.

_M.lua.expr_types

Map of expression patterns to their types. Used for type-hinting when showing autocompletions for variables. Expressions are expected to match after the ‘=’ sign of a statement.

Usage:

_M.lua.tags

List of “fake” ctags files (or functions that return such files) to use for autocompletion. The kind ‘m’ is recognized as a module, ‘f’ as a function, ‘t’ as a table and ‘F’ as a module or table field. The modules/lua/tadoc.lua script can generate tags and api files for Lua modules via LuaDoc.


The _SCINTILLA Module


Scintilla constants, functions, and properties. Do not modify anything in this module. Doing so will have unpredictable consequences.

Functions defined by _SCINTILLA

_SCINTILLA.next_image_type()

Returns a unique image type identier number for use with view.register_image() and view.register_rgba_image(). Use this function for custom image types in order to prevent clashes with identifiers of other custom image types.

Usage:

See also:

_SCINTILLA.next_indic_number()

Returns a unique indicator number for use with custom indicators. Use this function for custom indicators in order to prevent clashes with identifiers of other custom indicators.

Usage:

See also:

_SCINTILLA.next_marker_number()

Returns a unique marker number for use with view.marker_define(). Use this function for custom markers in order to prevent clashes with identifiers of other custom markers.

Usage:

See also:

_SCINTILLA.next_user_list_type()

Returns a unique user list identier number for use with buffer.user_list_show(). Use this function for custom user lists in order to prevent clashes with list identifiers of other custom user lists.

Usage:

See also:

Tables defined by _SCINTILLA

_SCINTILLA.constants

Map of Scintilla constant names to their numeric values.

See also:

_SCINTILLA.events

Map of Scintilla event IDs to tables of event names and event parameters.

_SCINTILLA.functions

Map of Scintilla function names to tables containing their IDs, return types, wParam types, and lParam types. Types are as follows:

_SCINTILLA.properties

Map of Scintilla property names to table values containing their “get” function IDs, “set” function IDs, return types, and wParam types. The wParam type will be non-zero if the property is indexable. Types are the same as in the functions table.

See also:


The args Module


Processes command line arguments for Textadept.

Fields defined by args

events.ARG_NONE (string)

Emitted when no command line arguments are passed to Textadept on startup.

Functions defined by args

args.register(short, long, narg, f, description)

Registers a command line switch with short and long versions short and long, respectively. narg is the number of arguments the switch accepts, f is the function called when the switch is tripped, and description is the switch’s description when displaying help.

Parameters:


The assert Module


Extends _G with formatted assertions and function argument type checks.

Functions defined by assert

_G.assert(v, message, …)

Asserts that value v is not false or nil and returns v, or calls error() with message as the error message, defaulting to “assertion failed!”. If message is a format string, the remaining arguments are passed to string.format() and the resulting string becomes the error message.

Parameters:

_G.assert_type(v, expected_type, narg)

Asserts that value v has type string expected_type and returns v, or calls error() with an error message that implicates function argument number narg. This is intended to be used with API function arguments so users receive more helpful error messages.

Parameters:

Usage:


The buffer Module


A Textadept buffer object. Constants are documented in the fields they apply to. While you can work with individual buffer instances, it is really only useful to work with the global one. Many of these functions and fields are derived from buffer-specific functionality of the Scintilla editing component, and additional information can be found on the Scintilla website. Note that with regard to Scintilla-specific functionality, this API is a suggestion, not a hard requirement. All of that functionality also exists in view, even if undocumented. Any buffer fields set on startup (e.g. in ~/.textadept/init.lua) will be the default, initial values for all buffers.

Fields defined by buffer

buffer.CARETSTICKY_OFF (number, Read-only)

buffer.CARETSTICKY_ON (number, Read-only)

buffer.CARETSTICKY_WHITESPACE (number, Read-only)

buffer.CASEINSENSITIVEBEHAVIOR_IGNORECASE (number, Read-only)

buffer.CASEINSENSITIVEBEHAVIOR_RESPECTCASE (number, Read-only)

buffer.EOL_CR (number, Read-only)

buffer.EOL_CRLF (number, Read-only)

buffer.EOL_LF (number, Read-only)

buffer.FIND_MATCHCASE (number, Read-only)

buffer.FIND_REGEXP (number, Read-only)

buffer.FIND_WHOLEWORD (number, Read-only)

buffer.FIND_WORDSTART (number, Read-only)

buffer.FOLDLEVELBASE (number, Read-only)

buffer.FOLDLEVELHEADERFLAG (number, Read-only)

buffer.FOLDLEVELNUMBERMASK (number, Read-only)

buffer.FOLDLEVELWHITEFLAG (number, Read-only)

buffer.INDICATOR_MAX (number, Read-only)

buffer.MARKER_MAX (number, Read-only)

buffer.MARKNUM_FOLDER (number, Read-only)

buffer.MARKNUM_FOLDEREND (number, Read-only)

buffer.MARKNUM_FOLDERMIDTAIL (number, Read-only)

buffer.MARKNUM_FOLDEROPEN (number, Read-only)

buffer.MARKNUM_FOLDEROPENMID (number, Read-only)

buffer.MARKNUM_FOLDERSUB (number, Read-only)

buffer.MARKNUM_FOLDERTAIL (number, Read-only)

buffer.MARK_AVAILABLE (number, Read-only)

buffer.MULTIAUTOC_EACH (number, Read-only)

buffer.MULTIAUTOC_ONCE (number, Read-only)

buffer.MULTIPASTE_EACH (number, Read-only)

buffer.MULTIPASTE_ONCE (number, Read-only)

buffer.ORDER_CUSTOM (number, Read-only)

buffer.ORDER_PERFORMSORT (number, Read-only)

buffer.ORDER_PRESORTED (number, Read-only)

buffer.SEL_LINES (number, Read-only)

buffer.SEL_RECTANGLE (number, Read-only)

buffer.SEL_STREAM (number, Read-only)

buffer.SEL_THIN (number, Read-only)

buffer.UPDATE_CONTENT (number, Read-only)

buffer.UPDATE_SELECTION (number, Read-only)

buffer.VS_NONE (number, Read-only)

buffer.VS_RECTANGULARSELECTION (number, Read-only)

buffer.VS_USERACCESSIBLE (number, Read-only)

buffer.additional_selection_typing (bool)

Type into multiple selections. The default value is false.

buffer.anchor (number)

The anchor’s position.

buffer.annotation_lines (table, Read-only)

Table of the number of annotation text lines per line number.

buffer.annotation_style (table)

Table of style numbers for annotation text per line number. Only some style attributes are active in annotations: font, size/size_fractional, bold/weight, italics, fore, back, and character_set.

buffer.annotation_text (table)

Table of annotation text per line number.

buffer.auto_c_auto_hide (bool)

Automatically cancel an autocompletion or user list when no entries match typed text. The default value is true.

buffer.auto_c_cancel_at_start (bool)

Cancel an autocompletion list when backspacing to a position before where autocompletion started (instead of before the word being completed). This option has no effect for a user list. The default value is true.

buffer.auto_c_case_insensitive_behavior (number)

The behavior mode for a case insensitive autocompletion or user list when buffer.auto_c_ignore_case is true.

The default value is buffer.CASEINSENSITIVEBEHAVIOR_RESPECTCASE.

buffer.auto_c_choose_single (bool)

Automatically choose the item in a single-item autocompletion list. This option has no effect for a user list. The default value is false.

buffer.auto_c_current (number, Read-only)

The index of the currently selected item in an autocompletion or user list.

buffer.auto_c_current_text (string, Read-only)

The text of the currently selected item in an autocompletion or user list.

buffer.auto_c_drop_rest_of_word (bool)

Delete any word characters immediately to the right of autocompleted text. The default value is false.

buffer.auto_c_fill_ups (string, Write-only)

The set of characters that choose the currently selected item in an autocompletion or user list when the user types one of them. The default value is ''.

buffer.auto_c_ignore_case (bool)

Ignore case when searching an autocompletion or user list for matches. The default value is false.

buffer.auto_c_multi (number)

The multiple selection autocomplete mode.

The default value is buffer.MULTIAUTOC_ONCE.

buffer.auto_c_order (number)

The order setting for autocompletion and user lists.

The default value is buffer.ORDER_PRESORTED.

buffer.auto_c_separator (number)

The byte value of the character that separates autocompletion and user list list items. The default value is 32 (‘ ‘).

buffer.auto_c_type_separator (number)

The character byte that separates autocompletion and user list items and their image types. Autocompletion and user list items can display both an image and text. Register images and their types using view.register_image() or view.register_rgba_image() before appending image types to list items after type separator characters. The default value is 63 (‘?’).

buffer.back_space_un_indents (bool)

Un-indent text when backspacing within indentation. The default value is false.

buffer.caret_sticky (number)

The caret’s preferred horizontal position when moving between lines.

The default value is buffer.CARETSTICKY_OFF.

buffer.char_at (table, Read-only)

Table of character bytes per position.

buffer.column (table, Read-only)

Table of column numbers (taking tab widths into account) per position. Multi-byte characters count as single characters.

buffer.current_pos (number)

The caret’s position. When set, does not scroll the caret into view.

buffer.encoding (string or nil)

The string encoding of the file, or nil for binary files.

buffer.end_styled (number, Read-only)

The current styling position or the last correctly styled character’s position.

buffer.eol_annotation_style (table)

Table of style numbers for EOL annotation text per line number. Only some style attributes are active in annotations: font, size/size_fractional, bold/weight, italics, fore, back, and character_set.

buffer.eol_annotation_text (table)

Table of EOL annotation text per line number.

buffer.eol_mode (number)

The current end of line mode. Changing the current mode does not convert any of the buffer’s existing end of line characters. Use buffer.convert_eols() to do so.

The default value is buffer.EOL_CRLF on Windows platforms, buffer.EOL_LF otherwise.

buffer.filename (string)

The absolute file path associated with the buffer.

buffer.fold_level (table)

Table of fold level bit-masks per line number. Fold level masks comprise of an integer level combined with any of the following bit flags:

buffer.fold_parent (table, Read-only)

Table of fold point line numbers per child line number. A line number of -1 means no line was found.

buffer.indent (number)

The number of spaces in one level of indentation. The default value is 0, which uses the value of buffer.tab_width.

buffer.indicator_current (number)

The indicator number in the range of 1 to 32 used by buffer.indicator_fill_range() and buffer.indicator_clear_range().

buffer.length (number, Read-only)

The number of bytes in the buffer.

buffer.line_count (number, Read-only)

The number of lines in the buffer. There is always at least one.

buffer.line_end_position (table, Read-only)

Table of positions at the ends of lines, but before any end of line characters, per line number.

buffer.line_indent_position (table, Read-only)

Table of positions at the ends of indentation per line number.

buffer.line_indentation (table)

Table of column indentation amounts per line number.

buffer.main_selection (number)

The number of the main or most recent selection. Only an existing selection can be made main.

buffer.margin_style (table)

Table of style numbers in the text margin per line number. Only some style attributes are active in text margins: font, size, bold, italics, fore, and back.

buffer.margin_text (table)

Table of text displayed in text margins per line number.

buffer.modify (bool, Read-only)

Whether or not the buffer has unsaved changes.

buffer.move_extends_selection (bool, Read-only)

Whether or not regular caret movement alters the selected text. buffer.selection_mode dictates this property.

buffer.multi_edge_column (table, Read-only)

Table of edge column positions per edge column number. A position of -1 means no edge column was found.

buffer.multi_paste (number)

The multiple selection paste mode.

The default value is buffer.MULTIPASTE_ONCE.

buffer.multiple_selection (bool)

Enable multiple selection. The default value is false.

buffer.overtype (bool)

Enable overtype mode, where typed characters overwrite existing ones. The default value is false.

buffer.punctuation_chars (string)

The string set of characters recognized as punctuation characters. Set this only after setting buffer.word_chars. The default value is a string that contains all non-word and non-whitespace characters.

buffer.read_only (bool)

Whether or not the buffer is read-only. The default value is false.

buffer.rectangular_selection_anchor (number)

The rectangular selection’s anchor position.

buffer.rectangular_selection_anchor_virtual_space (number)

The amount of virtual space for the rectangular selection’s anchor.

buffer.rectangular_selection_caret (number)

The rectangular selection’s caret position.

buffer.rectangular_selection_caret_virtual_space (number)

The amount of virtual space for the rectangular selection’s caret.

buffer.search_flags (number)

The bit-mask of search flags used by buffer.search_in_target().

The default value is 0.

buffer.selection_empty (bool, Read-only)

Whether or not no text is selected.

buffer.selection_end (number)

The position of the end of the selected text. When set, becomes the current position, but is not scrolled into view.

buffer.selection_is_rectangle (bool, Read-only)

Whether or not the selection is a rectangular selection.

buffer.selection_mode (number)

The selection mode.

When set, caret movement alters the selected text until this field is set again to the same value or until buffer.cancel() is called.

buffer.selection_n_anchor (table)

Table of positions at the beginning of existing selections numbered from 1, the main selection.

buffer.selection_n_anchor_virtual_space (table)

Table of positions at the beginning of virtual space selected in existing selections numbered from 1, the main selection.

buffer.selection_n_caret (table)

Table of positions at the end of existing selections numbered from 1, the main selection.

buffer.selection_n_caret_virtual_space (table)

Table of positions at the end of virtual space selected in existing selections numbered from 1, the main selection.

buffer.selection_n_end (table)

Table of positions at the end of existing selections numbered from 1, the main selection.

buffer.selection_n_end_virtual_space (number, Read-only)

Table of positions at the end of virtual space selected in existing selections numbered from 1, the main selection.

buffer.selection_n_start (table)

Table of positions at the beginning of existing selections numbered from 1, the main selection.

buffer.selection_n_start_virtual_space (number, Read-only)

Table of positions at the beginning of virtual space selected in existing selections numbered from 1, the main selection.

buffer.selection_start (number)

The position of the beginning of the selected text. When set, becomes the anchor, but is not scrolled into view.

buffer.selections (number, Read-only)

The number of active selections. There is always at least one selection.

buffer.style_at (table, Read-only)

Table of style numbers per position.

buffer.tab_indents (bool)

Indent text when tabbing within indentation. The default value is false.

buffer.tab_label (string)

The buffer’s tab label in the tab bar.

buffer.tab_width (number)

The number of space characters represented by a tab character. The default value is 8.

buffer.tag (table, Read-only)

List of capture text for capture numbers from a regular expression search.

buffer.target_end (number)

The position of the end of the target range. This is also set by a successful buffer.search_in_target().

buffer.target_end_virtual_space (number)

The position of the end of virtual space in the target range. This is set to 1 when buffer.target_start or buffer.target_end is set, or when buffer.set_target_range() is called.

buffer.target_start (number)

The position of the beginning of the target range. This is also set by a successful buffer.search_in_target().

buffer.target_start_virtual_space (number)

The position of the beginning of virtual space in the target range. This is set to 1 when buffer.target_start or buffer.target_end is set, or when buffer.set_target_range() is called.

buffer.target_text (string, Read-only)

The text in the target range.

buffer.text_length (number, Read-only)

The number of bytes in the buffer.

buffer.use_tabs (bool)

Use tabs instead of spaces in indentation. Changing the current setting does not convert any of the buffer’s existing indentation. Use textadept.editing.convert_indentation() to do so. The default value is true.

buffer.virtual_space_options (number)

The virtual space mode.

When virtual space is enabled, the caret may move into the space past end of line characters. The default value is buffer.VS_NONE.

buffer.whitespace_chars (string)

The string set of characters recognized as whitespace characters. Set this only after setting buffer.word_chars. The default value is a string that contains all non-newline characters less than ASCII value 33.

buffer.word_chars (string)

The string set of characters recognized as word characters. The default value is a string that contains alphanumeric characters, an underscore, and all characters greater than ASCII value 127.

Functions defined by buffer

buffer.add_selection(buffer, end_pos, start_pos)

Selects the range of text between positions start_pos to end_pos as the main selection, retaining all other selections as additional selections. Since an empty selection (i.e. the current position) still counts as a selection, use buffer.set_selection() first when setting a list of selections.

Parameters:

See also:

buffer.add_text(buffer, text)

Adds string text to the buffer at the caret position and moves the caret to the end of the added text without scrolling it into view.

Parameters:

buffer.annotation_clear_all(buffer)

Clears annotations from all lines.

Parameters:

buffer.append_text(buffer, text)

Appends string text to the end of the buffer without modifying any existing selections or scrolling the text into view.

Parameters:

buffer.auto_c_active(buffer)

Returns whether or not an autocompletion or user list is visible.

Parameters:

Return:

buffer.auto_c_cancel(buffer)

Cancels the displayed autocompletion or user list.

Parameters:

buffer.auto_c_complete(buffer)

Completes the current word with the one selected in an autocompletion list.

Parameters:

buffer.auto_c_pos_start(buffer)

Returns the position where autocompletion started or where a user list was shown.

Parameters:

Return:

buffer.auto_c_select(buffer, prefix)

Selects the first item that starts with string prefix in an autocompletion or user list, using the case sensitivity setting buffer.auto_c_ignore_case.

Parameters:

buffer.auto_c_show(buffer, len_entered, items)

Displays an autocompletion list constructed from string items (whose items are delimited by buffer.auto_c_separator characters) using len_entered number of characters behind the caret as the prefix of the word to be autocompleted. The sorted order of items (buffer.auto_c_order) must have already been defined.

Parameters:

See also:

buffer.auto_c_stops(buffer, chars)

Allows the user to type any character in string set chars in order to cancel an autocompletion or user list. The default set is empty.

Parameters:

buffer.back_tab(buffer)

Un-indents the text on the selected lines.

Parameters:

buffer.begin_undo_action(buffer)

Starts a sequence of actions to be undone or redone as a single action. May be nested.

Parameters:

buffer.brace_match(buffer, pos, max_re_style)

Returns the position of the matching brace for the brace character at position pos, taking nested braces into account, or -1. The brace characters recognized are ‘(‘, ‘)’, ‘[’, ‘]’, ‘{‘, ‘}’, ‘<’, and ‘>’ and must have the same style.

Parameters:

Return:

buffer.can_redo(buffer)

Returns whether or not there is an action to be redone.

Parameters:

Return:

buffer.can_undo(buffer)

Returns whether or not there is an action to be undone.

Parameters:

Return:

buffer.cancel(buffer)

Cancels the active selection mode, autocompletion or user list, call tip, etc.

Parameters:

buffer.char_left(buffer)

Moves the caret left one character.

Parameters:

buffer.char_left_extend(buffer)

Moves the caret left one character, extending the selected text to the new position.

Parameters:

buffer.char_left_rect_extend(buffer)

Moves the caret left one character, extending the rectangular selection to the new position.

Parameters:

buffer.char_right(buffer)

Moves the caret right one character.

Parameters:

buffer.char_right_extend(buffer)

Moves the caret right one character, extending the selected text to the new position.

Parameters:

buffer.char_right_rect_extend(buffer)

Moves the caret right one character, extending the rectangular selection to the new position.

Parameters:

buffer.choose_caret_x(buffer)

Identifies the current horizontal caret position as the caret’s preferred horizontal position when moving between lines.

Parameters:

See also:

buffer.clear(buffer)

Deletes the selected text or the character at the caret.

Parameters:

buffer.clear_all(buffer)

Deletes the buffer’s text.

Parameters:

buffer.clear_document_style(buffer)

Clears all styling and folding information.

Parameters:

buffer.close(buffer, force)

Closes the buffer, prompting the user to continue if there are unsaved changes (unless force is true), and returns true if the buffer was closed.

Parameters:

Return:

buffer.colorize(buffer, start_pos, end_pos)

Instructs the lexer to style and mark fold points in the range of text between start_pos and end_pos. If end_pos is -1, styles and marks to the end of the buffer.

Parameters:

buffer.convert_eols(buffer, mode)

Converts all end of line characters to those in end of line mode mode.

Parameters:

buffer.copy(buffer)

Copies the selected text to the clipboard. Multiple selections are copied in order with no delimiters. Rectangular selections are copied from top to bottom with end of line characters. Virtual space is not copied.

Parameters:

buffer.copy_range(buffer, start_pos, end_pos)

Copies the range of text between positions start_pos and end_pos to the clipboard.

Parameters:

buffer.copy_text(buffer, text)

Copies string text to the clipboard.

Parameters:

buffer.count_characters(buffer, start_pos, end_pos)

Returns the number of whole characters (taking multi-byte characters into account) between positions start_pos and end_pos.

Parameters:

Return:

buffer.cut(buffer)

Cuts the selected text to the clipboard. Multiple selections are copied in order with no delimiters. Rectangular selections are copied from top to bottom with end of line characters. Virtual space is not copied.

Parameters:

buffer.del_line_left(buffer)

Deletes the range of text from the caret to the beginning of the current line.

Parameters:

buffer.del_line_right(buffer)

Deletes the range of text from the caret to the end of the current line.

Parameters:

buffer.del_word_left(buffer)

Deletes the word to the left of the caret, including any leading non-word characters. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.del_word_right(buffer)

Deletes the word to the right of the caret, including any trailing non-word characters. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.del_word_right_end(buffer)

Deletes the word to the right of the caret, excluding any trailing non-word characters. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.delete(buffer)

Deletes the buffer. Do not call this function. Call buffer:close() instead. Emits a BUFFER_DELETED event.

Parameters:

See also:

buffer.delete_back(buffer)

Deletes the character behind the caret if no text is selected. Otherwise, deletes the selected text.

Parameters:

buffer.delete_back_not_line(buffer)

Deletes the character behind the caret unless either the caret is at the beginning of a line or text is selected. If text is selected, deletes it.

Parameters:

buffer.delete_range(buffer, pos, length)

Deletes the range of text from position pos to pos + length.

Parameters:

buffer.document_end(buffer)

Moves the caret to the end of the buffer.

Parameters:

buffer.document_end_extend(buffer)

Moves the caret to the end of the buffer, extending the selected text to the new position.

Parameters:

buffer.document_start(buffer)

Moves the caret to the beginning of the buffer.

Parameters:

buffer.document_start_extend(buffer)

Moves the caret to the beginning of the buffer, extending the selected text to the new position.

Parameters:

buffer.drop_selection_n(buffer, n)

Drops existing selection number n.

Parameters:

buffer.edit_toggle_overtype(buffer)

Toggles buffer.overtype.

Parameters:

buffer.empty_undo_buffer(buffer)

Deletes the undo and redo history.

Parameters:

buffer.end_undo_action(buffer)

Ends a sequence of actions to be undone or redone as a single action.

Parameters:

buffer.eol_annotation_clear_all(buffer)

Clears EOL annotations from all lines.

Parameters:

buffer.find_column(buffer, line, column)

Returns the position of column number column on line number line (taking tab and multi-byte characters into account), or the position at the end of line line.

Parameters:

buffer.get_cur_line(buffer)

Returns the current line’s text and the caret’s position on that line.

Parameters:

Return:

buffer.get_last_child(buffer, line, level)

Returns the line number of the last line after line number line whose fold level is greater than level. If level is -1, returns the level of line.

Parameters:

buffer.get_lexer(buffer, current)

Returns the buffer’s lexer name. If current is true, returns the name of the lexer under the caret in a multiple-language lexer.

Parameters:

buffer.get_line(buffer, line)

Returns the text on line number line, including end of line characters.

Parameters:

Return:

buffer.get_sel_text(buffer)

Returns the selected text. Multiple selections are included in order with no delimiters. Rectangular selections are included from top to bottom with end of line characters. Virtual space is not included.

Parameters:

Return:

buffer.get_text(buffer)

Returns the buffer’s text.

Parameters:

buffer.goto_line(buffer, line)

Moves the caret to the beginning of line number line and scrolls it into view, regardless of whether or not line is hidden.

Parameters:

buffer.goto_pos(buffer, pos)

Moves the caret to position pos and scrolls it into view.

Parameters:

buffer.home(buffer)

Moves the caret to the beginning of the current line.

Parameters:

buffer.home_display(buffer)

Moves the caret to the beginning of the current wrapped line.

Parameters:

buffer.home_display_extend(buffer)

Moves the caret to the beginning of the current wrapped line, extending the selected text to the new position.

Parameters:

buffer.home_extend(buffer)

Moves the caret to the beginning of the current line, extending the selected text to the new position.

Parameters:

buffer.home_rect_extend(buffer)

Moves the caret to the beginning of the current line, extending the rectangular selection to the new position.

Parameters:

buffer.home_wrap(buffer)

Moves the caret to the beginning of the current wrapped line or, if already there, to the beginning of the actual line.

Parameters:

buffer.home_wrap_extend(buffer)

Like buffer.home_wrap(), but extends the selected text to the new position.

Parameters:

buffer.indicator_all_on_for(buffer, pos)

Returns a bit-mask that represents which indicators are on at position pos. The first bit is set if indicator 1 is on, the second bit for indicator 2, etc.

Parameters:

Return:

buffer.indicator_clear_range(buffer, pos, length)

Clears indicator number buffer.indicator_current over the range of text from position pos to pos + length.

Parameters:

buffer.indicator_end(buffer, indicator, pos)

Returns the next boundary position, starting from position pos, of indicator number indicator, in the range of 1 to 32. Returns 1 if indicator was not found.

Parameters:

buffer.indicator_fill_range(buffer, pos, length)

Fills the range of text from position pos to pos + length with indicator number buffer.indicator_current.

Parameters:

buffer.indicator_start(buffer, indicator, pos)

Returns the previous boundary position, starting from position pos, of indicator number indicator, in the range of 1 to 32. Returns 1 if indicator was not found.

Parameters:

buffer.insert_text(buffer, pos, text)

Inserts string text at position pos, removing any selections. If pos is -1, inserts text at the caret position. If the caret is after the pos, it is moved appropriately, but not scrolled into view.

Parameters:

buffer.is_range_word(buffer, start_pos, end_pos)

Returns whether or not the the positions start_pos and end_pos are at word boundaries.

Parameters:

buffer.line_copy(buffer)

Copies the current line to the clipboard.

Parameters:

buffer.line_cut(buffer)

Cuts the current line to the clipboard.

Parameters:

buffer.line_delete(buffer)

Deletes the current line.

Parameters:

buffer.line_down(buffer)

Moves the caret down one line.

Parameters:

buffer.line_down_extend(buffer)

Moves the caret down one line, extending the selected text to the new position.

Parameters:

buffer.line_down_rect_extend(buffer)

Moves the caret down one line, extending the rectangular selection to the new position.

Parameters:

buffer.line_duplicate(buffer)

Duplicates the current line on a new line below.

Parameters:

buffer.line_end(buffer)

Moves the caret to the end of the current line.

Parameters:

buffer.line_end_display(buffer)

Moves the caret to the end of the current wrapped line.

Parameters:

buffer.line_end_display_extend(buffer)

Moves the caret to the end of the current wrapped line, extending the selected text to the new position.

Parameters:

buffer.line_end_extend(buffer)

Moves the caret to the end of the current line, extending the selected text to the new position.

Parameters:

buffer.line_end_rect_extend(buffer)

Moves the caret to the end of the current line, extending the rectangular selection to the new position.

Parameters:

buffer.line_end_wrap(buffer)

Moves the caret to the end of the current wrapped line or, if already there, to the end of the actual line.

Parameters:

buffer.line_end_wrap_extend(buffer)

Like buffer.line_end_wrap(), but extends the selected text to the new position.

Parameters:

buffer.line_from_position(buffer, pos)

Returns the line number of the line that contains position pos. Returns 1 if pos is less than 1 or buffer.line_count if pos is greater than buffer.length + 1.

Parameters:

Return:

buffer.line_length(buffer, line)

Returns the number of bytes on line number line, including end of line characters. To get line length excluding end of line characters, use buffer.line_end_position[line] - buffer.position_from_line(line).

Parameters:

Return:

buffer.line_reverse(buffer)

Reverses the order of the selected lines.

Parameters:

buffer.line_transpose(buffer)

Swaps the current line with the previous one.

Parameters:

buffer.line_up(buffer)

Moves the caret up one line.

Parameters:

buffer.line_up_extend(buffer)

Moves the caret up one line, extending the selected text to the new position.

Parameters:

buffer.line_up_rect_extend(buffer)

Moves the caret up one line, extending the rectangular selection to the new position.

Parameters:

buffer.lines_join(buffer)

Joins the lines in the target range, inserting spaces between the words joined at line boundaries.

Parameters:

buffer.lines_split(buffer, pixel_width, width)

Splits the lines in the target range into lines width pixels wide. If width is 0, splits the lines in the target range into lines as wide as the view.

Parameters:

buffer.lower_case(buffer)

Converts the selected text to lower case letters.

Parameters:

buffer.margin_text_clear_all(buffer)

Clears all text in text margins.

Parameters:

buffer.marker_add(buffer, line, marker)

Adds marker number marker, in the range of 1 to 32, to line number line, returning the added marker’s handle which can be used in buffer.marker_delete_handle() and buffer.marker_line_from_handle(), or -1 if line is invalid.

Parameters:

Return:

buffer.marker_add_set(buffer, line, marker_mask)

Adds the markers specified in marker bit-mask marker_mask to line number line. The first bit is set to add marker number 1, the second bit for marker number 2, and so on up to marker number 32.

Parameters:

buffer.marker_delete(buffer, line, marker)

Deletes marker number marker, in the range of 1 to 32, from line number line. If marker is -1, deletes all markers from line.

Parameters:

buffer.marker_delete_all(buffer, marker)

Deletes marker number marker, in the range of 1 to 32, from any line that has it. If marker is -1, deletes all markers from all lines.

Parameters:

buffer.marker_delete_handle(buffer, handle)

Deletes the marker with handle handle returned by buffer.marker_add().

Parameters:

buffer.marker_get(buffer, line)

Returns a bit-mask that represents the markers on line number line. The first bit is set if marker number 1 is present, the second bit for marker number 2, and so on.

Parameters:

Return:

buffer.marker_handle_from_line(buffer, line, n)

Returns the handle of the nth marker on line number line, or -1 if no such marker exists.

Parameters:

buffer.marker_line_from_handle(buffer, handle)

Returns the line number of the line that contains the marker with handle handle (returned buffer.marker_add()), or -1 if the line was not found.

Parameters:

Return:

buffer.marker_next(buffer, line, marker_mask)

Returns the first line number, starting at line number line, that contains all of the markers represented by marker bit-mask marker_mask. Returns -1 if no line was found. The first bit is set if marker 1 is set, the second bit for marker 2, etc., up to marker 32.

Parameters:

Return:

buffer.marker_number_from_line(buffer, line, n)

Returns the number of the nth marker on line number line, or -1 if no such marker exists.

Parameters:

buffer.marker_previous(buffer, line, marker_mask)

Returns the last line number, before or on line number line, that contains all of the markers represented by marker bit-mask marker_mask. Returns -1 if no line was found. The first bit is set if marker 1 is set, the second bit for marker 2, etc., up to marker 32.

Parameters:

Return:

buffer.move_caret_inside_view(buffer)

Moves the caret into view if it is not already, removing any selections.

Parameters:

buffer.move_selected_lines_down(buffer)

Shifts the selected lines down one line.

Parameters:

buffer.move_selected_lines_up(buffer)

Shifts the selected lines up one line.

Parameters:

buffer.multiple_select_add_each(buffer)

Adds to the set of selections each occurrence of the main selection within the target range. If there is no selected text, the current word is used.

Parameters:

buffer.multiple_select_add_next(buffer)

Adds to the set of selections the next occurrence of the main selection within the target range, makes that occurrence the new main selection, and scrolls it into view. If there is no selected text, the current word is used.

Parameters:

buffer.name_of_style(buffer, style)

Returns the name of style number style, which is between 1 and 256.

Parameters:

Return:

buffer.new()

Creates a new buffer, displays it in the current view, and returns it. Emits a BUFFER_NEW event.

Return:

See also:

buffer.new_line(buffer)

Types a new line at the caret position according to buffer.eol_mode.

Parameters:

buffer.page_down(buffer)

Moves the caret down one page.

Parameters:

buffer.page_down_extend(buffer)

Moves the caret down one page, extending the selected text to the new position.

Parameters:

buffer.page_down_rect_extend(buffer)

Moves the caret down one page, extending the rectangular selection to the new position.

Parameters:

buffer.page_up(buffer)

Moves the caret up one page.

Parameters:

buffer.page_up_extend(buffer)

Moves the caret up one page, extending the selected text to the new position.

Parameters:

buffer.page_up_rect_extend(buffer)

Moves the caret up one page, extending the rectangular selection to the new position.

Parameters:

buffer.para_down(buffer)

Moves the caret down one paragraph. Paragraphs are surrounded by one or more blank lines.

Parameters:

buffer.para_down_extend(buffer)

Moves the caret down one paragraph, extending the selected text to the new position. Paragraphs are surrounded by one or more blank lines.

Parameters:

buffer.para_up(buffer)

Moves the caret up one paragraph. Paragraphs are surrounded by one or more blank lines.

Parameters:

buffer.para_up_extend(buffer)

Moves the caret up one paragraph, extending the selected text to the new position. Paragraphs are surrounded by one or more blank lines.

Parameters:

buffer.paste(buffer)

Pastes the clipboard’s contents into the buffer, replacing any selected text according to buffer.multi_paste.

Parameters:

buffer.position_after(buffer, pos)

Returns the position of the character after position pos (taking multi-byte characters into account), or buffer.length + 1 if there is no character after pos.

Parameters:

buffer.position_before(buffer, pos)

Returns the position of the character before position pos (taking multi-byte characters into account), or 1 if there is no character before pos.

Parameters:

Return:

buffer.position_from_line(buffer, line)

Returns the position at the beginning of line number line. Returns -1 if line is greater than buffer.line_count + 1.

Parameters:

Return:

buffer.position_relative(buffer, pos, n)

Returns the position n characters before or after position pos (taking multi-byte characters into account). Returns 1 if the position is less than 1 or greater than buffer.length + 1.

Parameters:

Return:

buffer.redo(buffer)

Redoes the next undone action.

Parameters:

buffer.reload(buffer)

Reloads the buffer’s file contents, discarding any changes. Emits FILE_BEFORE_RELOAD and FILE_AFTER_RELOAD events if the buffer is the current one.

Parameters:

buffer.replace_sel(buffer, text)

Replaces the selected text with string text, scrolling the caret into view.

Parameters:

buffer.replace_target(buffer, text)

Replaces the text in the target range with string text sans modifying any selections or scrolling the view. Setting the target and calling this function with an empty string is another way to delete text.

Parameters:

Return:

buffer.replace_target_re(buffer, text)

Replaces the text in the target range with string text but first replaces any “\d” sequences with the text of capture number d from the regular expression (or the entire match for d = 0), and then returns the replacement text’s length.

Parameters:

Return:

buffer.rotate_selection(buffer)

Designates the next additional selection to be the main selection.

Parameters:

buffer.save(buffer)

Saves the buffer to its file. Emits FILE_BEFORE_SAVE and FILE_AFTER_SAVE events.

Parameters:

buffer.save_as(buffer, filename)

Saves the buffer to file filename or the user-specified filename. Emits a FILE_AFTER_SAVE event.

Parameters:

buffer.search_anchor(buffer)

Anchors the position that buffer.search_next() and buffer.search_prev() start at to the beginning of the current selection or caret position.

Parameters:

buffer.search_in_target(buffer, text)

Searches for the first occurrence of string text in the target range bounded by buffer.target_start and buffer.target_end using search flags buffer.search_flags and, if found, sets the new target range to that occurrence, returning its position or -1 if text was not found.

Parameters:

Return:

See also:

buffer.search_next(buffer, flags, text)

Searches for and selects the first occurrence of string text starting at the search anchor using search flags flags, returning that occurrence’s position or -1 if text was not found. Selected text is not scrolled into view.

Parameters:

Return:

See also:

buffer.search_prev(buffer, flags, text)

Searches for and selects the last occurrence of string text before the search anchor using search flags flags, returning that occurrence’s position or -1 if text was not found.

Parameters:

Return:

See also:

buffer.select_all(buffer)

Selects all of the buffer’s text without scrolling the view.

Parameters:

buffer.selection_duplicate(buffer)

Duplicates the selected text to its right. If no text is selected, duplicates the current line on a new line below.

Parameters:

buffer.set_chars_default(buffer)

Resets buffer.word_chars, buffer.whitespace_chars, and buffer.punctuation_chars to their respective defaults.

Parameters:

See also:

buffer.set_empty_selection(buffer, pos)

Moves the caret to position pos without scrolling the view and removes any selections.

Parameters:

buffer.set_encoding(buffer, encoding)

Converts the current buffer’s contents to encoding encoding.

Parameters:

Usage:

buffer.set_lexer(buffer, name)

Associates string lexer name name or the auto-detected lexer name with the buffer and then loads the appropriate language module if that module exists.

Parameters:

Usage:

buffer.set_save_point(buffer)

Indicates the buffer has no unsaved changes.

Parameters:

buffer.set_sel(buffer, start_pos, end_pos)

Selects the range of text between positions start_pos and end_pos, scrolling the selected text into view.

Parameters:

buffer.set_selection(buffer, end_pos, start_pos)

Selects the range of text between positions start_pos to end_pos, removing all other selections.

Parameters:

buffer.set_styling(buffer, length, style)

Assigns style number style, in the range from 1 to 256, to the next length characters, starting from the current styling position, and increments the styling position by length. buffer:start_styling should be called before buffer:set_styling().

Parameters:

buffer.set_target_range(buffer, start_pos, end_pos)

Defines the target range’s beginning and end positions as start_pos and end_pos, respectively.

Parameters:

buffer.set_text(buffer, text)

Replaces the buffer’s text with string text.

Parameters:

buffer.start_styling(buffer, position, unused)

Begins styling at position position with styling bit-mask style_mask. style_mask specifies which style bits can be set with buffer.set_styling().

Parameters:

Usage:

See also:

buffer.stuttered_page_down(buffer)

Moves the caret to the bottom of the page or, if already there, down one page.

Parameters:

buffer.stuttered_page_down_extend(buffer)

Like buffer.stuttered_page_down(), but extends the selected text to the new position.

Parameters:

buffer.stuttered_page_up(buffer)

Moves the caret to the top of the page or, if already there, up one page.

Parameters:

buffer.stuttered_page_up_extend(buffer)

Like buffer.stuttered_page_up(), but extends the selected text to the new position.

Parameters:

buffer.style_of_name(buffer, style_name, string)

Returns the style number associated with string style_name, or view.STYLE_DEFAULT if style_name is not in use.

Parameters:

Return:

See also:

buffer.swap_main_anchor_caret(buffer)

Swaps the main selection’s beginning and end positions.

Parameters:

buffer.tab(buffer)

Indents the text on the selected lines or types a Tab character (“\t”) at the caret position.

Parameters:

buffer.target_from_selection(buffer)

Defines the target range’s beginning and end positions as the beginning and end positions of the main selection, respectively.

Parameters:

buffer.target_whole_document(buffer)

Defines the target range’s beginning and end positions as the beginning and end positions of the document, respectively.

Parameters:

buffer.text_range(buffer, start_pos, end_pos)

Returns the range of text between positions start_pos and end_pos.

Parameters:

buffer.toggle_caret_sticky(buffer)

Cycles between buffer.caret_sticky option settings buffer.CARETSTICKY_ON and buffer.CARETSTICKY_OFF.

Parameters:

See also:

buffer.undo(buffer)

Undoes the most recent action.

Parameters:

buffer.upper_case(buffer)

Converts the selected text to upper case letters.

Parameters:

buffer.user_list_show(buffer, id, items)

Displays a user list identified by list identifier number id and constructed from string items (whose items are delimited by buffer.auto_c_separator characters). The sorted order of items (buffer.auto_c_order) must have already been defined. When the user selects an item, id is sent in a USER_LIST_SELECTION event along with the selection.

Parameters:

See also:

buffer.vc_home(buffer)

Moves the caret to the first visible character on the current line or, if already there, to the beginning of the current line.

Parameters:

buffer.vc_home_display(buffer)

Moves the caret to the first visible character on the current wrapped line or, if already there, to the beginning of the current wrapped line.

Parameters:

buffer.vc_home_display_extend(buffer)

Like buffer.vc_home_display(), but extends the selected text to the new position.

Parameters:

buffer.vc_home_extend(buffer)

Like buffer.vc_home(), but extends the selected text to the new position.

Parameters:

buffer.vc_home_rect_extend(buffer)

Like buffer.vc_home(), but extends the rectangular selection to the new position.

Parameters:

buffer.vc_home_wrap(buffer)

Moves the caret to the first visible character on the current wrapped line or, if already there, to the beginning of the actual line.

Parameters:

buffer.vc_home_wrap_extend(buffer)

Like buffer.vc_home_wrap(), but extends the selected text to the new position.

Parameters:

buffer.word_end_position(buffer, pos, only_word_chars)

Returns the position of the end of the word at position pos. buffer.word_chars contains the set of characters that constitute words. If pos has a non-word character to its right and only_word_chars is false, returns the first word character’s position.

Parameters:

buffer.word_left(buffer)

Moves the caret left one word. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_left_end(buffer)

Moves the caret left one word, positioning it at the end of the previous word. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_left_end_extend(buffer)

Like buffer.word_left_end(), but extends the selected text to the new position.

Parameters:

buffer.word_left_extend(buffer)

Moves the caret left one word, extending the selected text to the new position. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_part_left(buffer)

Moves the caret to the previous part of the current word. Word parts are delimited by underscore characters or changes in capitalization. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_part_left_extend(buffer)

Moves the caret to the previous part of the current word, extending the selected text to the new position. Word parts are delimited by underscore characters or changes in capitalization. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_part_right(buffer)

Moves the caret to the next part of the current word. Word parts are delimited by underscore characters or changes in capitalization. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_part_right_extend(buffer)

Moves the caret to the next part of the current word, extending the selected text to the new position. Word parts are delimited by underscore characters or changes in capitalization. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_right(buffer)

Moves the caret right one word. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_right_end(buffer)

Moves the caret right one word, positioning it at the end of the current word. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_right_end_extend(buffer)

Like buffer.word_right_end(), but extends the selected text to the new position.

Parameters:

buffer.word_right_extend(buffer)

Moves the caret right one word, extending the selected text to the new position. buffer.word_chars contains the set of characters that constitute words.

Parameters:

buffer.word_start_position(buffer, pos, only_word_chars)

Returns the position of the beginning of the word at position pos. buffer.word_chars contains the set of characters that constitute words. If pos has a non-word character to its left and only_word_chars is false, returns the last word character’s position.

Parameters:


The events Module


Textadept’s core event structure and handlers.

Textadept emits events when you do things like create a new buffer, press a key, click on a menu, etc. You can even emit events yourself using Lua. Each event has a set of event handlers, which are simply Lua functions called in the order they were connected to an event. For example, if you created a module that needs to do something each time Textadept creates a new buffer, connect a Lua function to the events.BUFFER_NEW event:

events.connect(events.BUFFER_NEW, function()
  -- Do something here.
end)

Events themselves are nothing special. You do not have to declare one before using it. Events are simply strings containing arbitrary event names. When either you or Textadept emits an event, Textadept runs all event handlers connected to the event, passing any given arguments to the event’s handler functions. If an event handler explicitly returns a value that is not nil, Textadept will not call subsequent handlers. This is useful if you want to stop the propagation of an event like a keypress if your event handler handled it, or if you want to use the event framework to pass values.

Fields defined by events

events.APPLEEVENT_ODOC (string)

Emitted when macOS tells Textadept to open a file. Arguments:

events.AUTO_C_CANCELED (string)

Emitted when canceling an autocompletion or user list.

events.AUTO_C_CHAR_DELETED (string)

Emitted after deleting a character while an autocompletion or user list is active.

events.AUTO_C_COMPLETED (string)

Emitted after inserting an item from an autocompletion list into the buffer. Arguments:

events.AUTO_C_SELECTION (string)

Emitted after selecting an item from an autocompletion list, but before inserting that item into the buffer. Automatic insertion can be canceled by calling buffer:auto_c_cancel() before returning from the event handler. Arguments:

events.AUTO_C_SELECTION_CHANGE (string)

Emitted as items are highlighted in an autocompletion or user list. Arguments:

events.BUFFER_AFTER_SWITCH (string)

Emitted right after switching to another buffer. The buffer being switched to is buffer. Emitted by view.goto_buffer().

events.BUFFER_BEFORE_SWITCH (string)

Emitted right before switching to another buffer. The buffer being switched from is buffer. Emitted by view.goto_buffer().

events.BUFFER_DELETED (string)

Emitted after deleting a buffer. Emitted by buffer.delete().

events.BUFFER_NEW (string)

Emitted after creating a new buffer. The new buffer is buffer. Emitted on startup and by buffer.new().

events.CALL_TIP_CLICK (string)

Emitted when clicking on a calltip. Arguments:

events.CHAR_ADDED (string)

Emitted after the user types a text character into the buffer. Arguments:

events.COMMAND_TEXT_CHANGED (string)

Emitted when the text in the command entry changes. ui.command_entry:get_text() returns the current text.

events.CSI (string)

Emitted when the terminal version receives an unrecognized CSI sequence. Arguments:

events.DOUBLE_CLICK (string)

Emitted after double-clicking the mouse button. Arguments:

events.DWELL_END (string)

Emitted after DWELL_START when the user moves the mouse, presses a key, or scrolls the view. Arguments:

events.DWELL_START (string)

Emitted when the mouse is stationary for view.mouse_dwell_time milliseconds. Arguments:

events.ERROR (string)

Emitted when an error occurs. Arguments:

events.FIND (string)

Emitted to find text via the Find & Replace Pane. Arguments:

events.FIND_TEXT_CHANGED (string)

Emitted when the text in the “Find” field of the Find & Replace Pane changes. ui.find.find_entry_text contains the current text.

events.FOCUS (string)

Emitted when Textadept receives focus. This event is never emitted when Textadept is running in the terminal.

events.INDICATOR_CLICK (string)

Emitted when clicking the mouse on text that has an indicator present. Arguments:

events.INDICATOR_RELEASE (string)

Emitted when releasing the mouse after clicking on text that has an indicator present. Arguments:

events.INITIALIZED (string)

Emitted after Textadept finishes initializing.

events.KEYPRESS (string)

Emitted when pressing a key. If any handler returns true, the key is not inserted into the buffer. Arguments:

events.MARGIN_CLICK (string)

Emitted when clicking the mouse inside a sensitive margin. Arguments:

events.MENU_CLICKED (string)

Emitted after selecting a menu item. Arguments:

events.MOUSE (string)

Emitted by the terminal version for an unhandled mouse event. A handler should return true if it handled the event. Otherwise Textadept will try again. (This side effect for a false or nil return is useful for sending the original mouse event to a different view that a handler has switched to.) Arguments:

events.QUIT (string)

Emitted when quitting Textadept. When connecting to this event, connect with an index of 1 if the handler needs to run before Textadept closes all open buffers. If a handler returns true, Textadept does not quit. It is not recommended to return false from a quit handler, as that may interfere with Textadept’s normal shutdown procedure. Emitted by quit().

events.REPLACE (string)

Emitted to replace selected (found) text. Arguments:

events.REPLACE_ALL (string)

Emitted to replace all occurrences of found text. Arguments:

events.RESET_AFTER (string)

Emitted after resetting the Lua state. Emitted by reset(). Arguments:

events.RESET_BEFORE (string)

Emitted before resetting the Lua state. Emitted by reset(). Arguments:

events.RESUME (string)

Emitted when resuming Textadept from a suspended state. This event is only emitted by the terminal version.

events.SAVE_POINT_LEFT (string)

Emitted after leaving a save point.

events.SAVE_POINT_REACHED (string)

Emitted after reaching a save point.

events.SUSPEND (string)

Emitted when suspending Textadept. If any handler returns true, Textadept does not suspend. This event is only emitted by the terminal version.

events.TAB_CLICKED (string)

Emitted when the user clicks on a buffer tab. When connecting to this event, connect with an index of 1 if the handler needs to run before Textadept switches between buffers. Note that Textadept always displays a context menu on right-click. Arguments:

events.UPDATE_UI (string)

Emitted after the view is visually updated. Arguments:

events.URI_DROPPED (string)

Emitted after dragging and dropping a URI into a view. Arguments:

events.USER_LIST_SELECTION (string)

Emitted after selecting an item in a user list. Arguments:

events.VIEW_AFTER_SWITCH (string)

Emitted right after switching to another view. The view being switched to is view. Emitted by ui.goto_view().

events.VIEW_BEFORE_SWITCH (string)

Emitted right before switching to another view. The view being switched from is view. Emitted by ui.goto_view().

events.VIEW_NEW (string)

Emitted after creating a new view. The new view is view. Emitted on startup and by view.split().

events.ZOOM (string)

Emitted after changing view.zoom. Emitted by view.zoom_in() and view.zoom_out().

Functions defined by events

events.connect(event, f, index)

Adds function f to the set of event handlers for event event at position index. If index not given, appends f to the set of handlers. event may be any arbitrary string and does not need to have been previously defined.

Parameters:

Usage:

See also:

events.disconnect(event, f)

Removes function f from the set of handlers for event event.

Parameters:

See also:

events.emit(event, …)

Sequentially calls all handler functions for event event with the given arguments. event may be any arbitrary string and does not need to have been previously defined. If any handler explicitly returns a value that is not nil, emit() returns that value and ceases to call subsequent handlers. This is useful for stopping the propagation of an event like a keypress after it has been handled, or for passing back values from handlers.

Parameters:

Usage:

Return:


The io Module


Extends Lua’s io library with Textadept functions for working with files.

Fields defined by io

events.FILE_AFTER_RELOAD (string)

Emitted after reloading the current file. Emitted by buffer:reload().

events.FILE_AFTER_SAVE (string)

Emitted right after saving a file to disk. Emitted by buffer:save() and buffer:save_as(). Arguments:

events.FILE_BEFORE_RELOAD (string)

Emitted before reloading the current file. Emitted by buffer:reload().

events.FILE_BEFORE_SAVE (string)

Emitted right before saving a file to disk. Emitted by buffer:save(). Arguments:

events.FILE_CHANGED (string)

Emitted when Textadept detects that an open file was modified externally. When connecting to this event, connect with an index of 1 in order to override the default prompt to reload the file. Arguments:

events.FILE_OPENED (string)

Emitted after opening a file in a new buffer. Emitted by io.open_file(). Arguments:

io.quick_open_max (number)

The maximum number of files listed in the quick open dialog. The default value is 1000.

Functions defined by io

io.close_all_buffers()

Closes all open buffers, prompting the user to continue if there are unsaved buffers, and returns true if the user did not cancel. No buffers are saved automatically. They must be saved manually.

Return:

See also:

io.get_project_root(path)

Returns the root directory of the project that contains filesystem path path. In order to be recognized, projects must be under version control. Recognized VCSes are Bazaar, Fossil, Git, Mercurial, and SVN.

Parameters:

Return:

io.open_file(filenames, encodings)

Opens filenames, a string filename or list of filenames, or the user-selected filename(s). Emits a FILE_OPENED event.

Parameters:

See also:

io.open_recent_file()

Prompts the user to select a recently opened file to be reopened.

See also:

io.quick_open(paths, filter, opts)

Prompts the user to select files to be opened from paths, a string directory path or list of directory paths, using a filtered list dialog. If paths is nil, uses the current project’s root directory, which is obtained from io.get_project_root(). String or list filter determines which files to show in the dialog, with the default filter being io.quick_open_filters[path] (if it exists) or lfs.default_filter. A filter consists of Lua patterns that match file and directory paths to include or exclude. Patterns are inclusive by default. Exclusive patterns begin with a ‘!’. If no inclusive patterns are given, any path is initially considered. As a convenience, file extensions can be specified literally instead of as a Lua pattern (e.g. ‘.lua’ vs. ‘%.lua$’), and ‘/’ also matches the Windows directory separator (‘[/\]’ is not needed). The number of files in the list is capped at quick_open_max. If filter is nil and paths is ultimately a string, the filter from the io.quick_open_filters table is used. If that filter does not exist, lfs.default_filter is used. opts is an optional table of additional options for ui.dialogs.filteredlist().

Parameters:

Usage:

See also:

io.save_all_files()

Saves all unsaved buffers to their respective files.

See also:

Tables defined by io

io.encodings

List of encodings to attempt to decode files as. You should add to this list if you get a “Conversion failed” error when trying to open a file whose encoding is not recognized. Valid encodings are GNU iconv’s encodings and include:

Usage:

io.quick_open_filters

Map of directory paths to filters used by io.quick_open().

See also:

io.recent_files

List of recently opened files, the most recent being towards the top.


The keys Module


Manages key bindings in Textadept.

Overview

Define key bindings in the global keys table in key-value pairs. Each pair consists of either a string key sequence and its associated command, a string lexer name (from the lexers/ directory) with a table of key sequences and commands, a string key mode with a table of key sequences and commands, or a key sequence with a table of more sequences and commands. The latter is part of what is called a “key chain”, to be discussed below. When searching for a command to run based on a key sequence, Textadept considers key bindings in the current key mode to have priority. If no key mode is active, language-specific key bindings have priority, followed by the ones in the global table. This means if there are two commands with the same key sequence, Textadept runs the language-specific one. However, if the command returns the boolean value false, Textadept also runs the lower-priority command. (This is useful for language modules to override commands like autocompletion, but fall back to word autocompletion if the first command fails.)

Key Sequences

Key sequences are strings built from an ordered combination of modifier keys and the key’s inserted character. Modifier keys are “Control”, “Shift”, and “Alt” on Windows, Linux, BSD, and in the terminal version. On macOS they are “Control” (^), “Alt/Option” (), “Command” (), and “Shift” (). These modifiers have the following string representations:

Modifier Linux / Win32 macOS Terminal
Control 'ctrl' 'ctrl' 'ctrl'
Alt 'alt' 'alt' 'meta'
Command N/A 'cmd' N/A
Shift 'shift' 'shift' 'shift'

The string representation of key values less than 255 is the character that Textadept would normally insert if the “Control”, “Alt”, and “Command” modifiers were not held down. Therefore, a combination of Ctrl+Alt+Shift+A has the key sequence ctrl+alt+A on Windows and Linux, but a combination of Ctrl+Shift+Tab has the key sequence ctrl+shift+\t. On a United States English keyboard, since the combination of Ctrl+Shift+, has the key sequence ctrl+< (Shift+, inserts a <), Textadept recognizes the key binding as Ctrl+<. This allows key bindings to be language and layout agnostic. For key values greater than 255, Textadept uses the keys.KEYSYMS lookup table. Therefore, Ctrl+Right Arrow has the key sequence ctrl+right. Uncommenting the print() statements in core/keys.lua causes Textadept to print key sequences to standard out (stdout) for inspection.

Commands

A command bound to a key sequence is simply a Lua function. For example:

keys['ctrl+n'] = buffer.new
keys['ctrl+z'] = buffer.undo
keys['ctrl+u'] = function() io.quick_open(_USERHOME) end

Textadept handles buffer references properly in static contexts.

Modes

Modes are groups of key bindings such that when a key mode is active, Textadept ignores all key bindings defined outside the mode until the mode is unset. Here is a simple vi mode example:

keys.command_mode = {
  ['h'] = buffer.char_left,
  ['j'] = buffer.line_up,
  ['k'] = buffer.line_down,
  ['l'] = buffer.char_right,
  ['i'] = function()
    keys.mode = nil
    ui.statusbar_text = 'INSERT MODE'
  end
}
keys['esc'] = function() keys.mode = 'command_mode' end
events.connect(events.UPDATE_UI, function()
  if keys.mode == 'command_mode' then return end
  ui.statusbar_text = 'INSERT MODE'
end)
keys.mode = 'command_mode' -- default mode

Warning: When creating a mode, be sure to define a way to exit the mode, otherwise you will probably have to restart Textadept.

Key Chains

Key chains are a powerful concept. They allow you to assign multiple key bindings to one key sequence. By default, the Esc key cancels a key chain, but you can redefine it via keys.CLEAR. An example key chain looks like:

keys['alt+a'] = {
  a = function1,
  b = function2,
  c = {...}
}

Fields defined by keys

keys.CLEAR (string)

The key that clears the current key chain. It cannot be part of a key chain. The default value is 'esc' for the Esc key.

keys.mode (string)

The current key mode. When non-nil, all key bindings defined outside of keys[mode] are ignored. The default value is nil.

Tables defined by keys

keys.KEYSYMS

Lookup table for string representations of key codes higher than 255. Key codes can be identified by temporarily uncommenting the print() statements in core/keys.lua. Recognized codes are: esc, \b, \t, \n, down, up, left, right, home, end, pgup, pgdn, del, ins, and f1-f12. The GUI version also recognizes: kpenter, kphome, kpend, kpleft, kpup, kpright, kpdown, kppgup, kppgdn, kpmul, kpadd, kpsub, kpdiv, kpdec, and kp0-kp9.

_G.keys

Map of key bindings to commands, with language-specific key tables assigned to a lexer name key.

keys.keychain

The current chain of key sequences. (Read-only.)


The lexer Module


Lexes Scintilla documents and source code with Lua and LPeg.

Writing Lua Lexers

Lexers highlight the syntax of source code. Scintilla (the editing component behind Textadept and SciTE) traditionally uses static, compiled C++ lexers which are notoriously difficult to create and/or extend. On the other hand, Lua makes it easy to to rapidly create new lexers, extend existing ones, and embed lexers within one another. Lua lexers tend to be more readable than C++ lexers too.

Lexers are Parsing Expression Grammars, or PEGs, composed with the Lua LPeg library. The following table comes from the LPeg documentation and summarizes all you need to know about constructing basic LPeg patterns. This module provides convenience functions for creating and working with other more advanced patterns and concepts.

Operator Description
lpeg.P(string) Matches string literally.
lpeg.P(n) Matches exactly n number of characters.
lpeg.S(string) Matches any character in set string.
lpeg.R("xy") Matches any character between range x and y.
patt^n Matches at least n repetitions of patt.
patt^-n Matches at most n repetitions of patt.
patt1 * patt2 Matches patt1 followed by patt2.
patt1 + patt2 Matches patt1 or patt2 (ordered choice).
patt1 - patt2 Matches patt1 if patt2 does not also match.
-patt Equivalent to ("" - patt).
#patt Matches patt but consumes no input.

The first part of this document deals with rapidly constructing a simple lexer. The next part deals with more advanced techniques, such as custom coloring and embedding lexers within one another. Following that is a discussion about code folding, or being able to tell Scintilla which code blocks are “foldable” (temporarily hideable from view). After that are instructions on how to use Lua lexers with the aforementioned Textadept and SciTE editors. Finally there are comments on lexer performance and limitations.

Lexer Basics

The lexers/ directory contains all lexers, including your new one. Before attempting to write one from scratch though, first determine if your programming language is similar to any of the 100+ languages supported. If so, you may be able to copy and modify that lexer, saving some time and effort. The filename of your lexer should be the name of your programming language in lower case followed by a .lua extension. For example, a new Lua lexer has the name lua.lua.

Note: Try to refrain from using one-character language names like “c”, “d”, or “r”. For example, Scintillua uses “ansi_c”, “dmd”, and “rstats”, respectively.

New Lexer Template

There is a lexers/template.txt file that contains a simple template for a new lexer. Feel free to use it, replacing the ‘?’s with the name of your lexer. Consider this snippet from the template:

-- ? LPeg lexer.

local lexer = require('lexer')
local token, word_match = lexer.token, lexer.word_match
local P, S = lpeg.P, lpeg.S

local lex = lexer.new('?')

-- Whitespace.
local ws = token(lexer.WHITESPACE, lexer.space^1)
lex:add_rule('whitespace', ws)

[...]

return lex

The first 3 lines of code simply define often used convenience variables. The fourth and last lines define and return the lexer object Scintilla uses; they are very important and must be part of every lexer. The fifth line defines something called a “token”, an essential building block of lexers. You will learn about tokens shortly. The sixth line defines a lexer grammar rule, which you will learn about later, as well as token styles. (Be aware that it is common practice to combine these two lines for short rules.) Note, however, the local prefix in front of variables, which is needed so-as not to affect Lua’s global environment. All in all, this is a minimal, working lexer that you can build on.

Tokens

Take a moment to think about your programming language’s structure. What kind of key elements does it have? In the template shown earlier, one predefined element all languages have is whitespace. Your language probably also has elements like comments, strings, and keywords. Lexers refer to these elements as “tokens”. Tokens are the fundamental “building blocks” of lexers. Lexers break down source code into tokens for coloring, which results in the syntax highlighting familiar to you. It is up to you how specific your lexer is when it comes to tokens. Perhaps only distinguishing between keywords and identifiers is necessary, or maybe recognizing constants and built-in functions, methods, or libraries is desirable. The Lua lexer, for example, defines 11 tokens: whitespace, keywords, built-in functions, constants, built-in libraries, identifiers, strings, comments, numbers, labels, and operators. Even though constants, built-in functions, and built-in libraries are subsets of identifiers, Lua programmers find it helpful for the lexer to distinguish between them all. It is perfectly acceptable to just recognize keywords and identifiers.

In a lexer, tokens consist of a token name and an LPeg pattern that matches a sequence of characters recognized as an instance of that token. Create tokens using the lexer.token() function. Let us examine the “whitespace” token defined in the template shown earlier:

local ws = token(lexer.WHITESPACE, lexer.space^1)

At first glance, the first argument does not appear to be a string name and the second argument does not appear to be an LPeg pattern. Perhaps you expected something like:

local ws = token('whitespace', S('\t\v\f\n\r ')^1)

The lexer module actually provides a convenient list of common token names and common LPeg patterns for you to use. Token names include lexer.DEFAULT, lexer.WHITESPACE, lexer.COMMENT, lexer.STRING, lexer.NUMBER, lexer.KEYWORD, lexer.IDENTIFIER, lexer.OPERATOR, lexer.ERROR, lexer.PREPROCESSOR, lexer.CONSTANT, lexer.VARIABLE, lexer.FUNCTION, lexer.CLASS, lexer.TYPE, lexer.LABEL, lexer.REGEX, and lexer.EMBEDDED. Patterns include lexer.any, lexer.alpha, lexer.digit, lexer.alnum, lexer.lower, lexer.upper, lexer.xdigit, lexer.graph, lexer.print, lexer.punct, lexer.space, lexer.newline, lexer.nonnewline, lexer.dec_num, lexer.hex_num, lexer.oct_num, lexer.integer, lexer.float, lexer.number, and lexer.word. You may use your own token names if none of the above fit your language, but an advantage to using predefined token names is that your lexer’s tokens will inherit the universal syntax highlighting color theme used by your text editor.

Example Tokens

So, how might you define other tokens like keywords, comments, and strings? Here are some examples.

Keywords

Instead of matching n keywords with n P('keyword_n') ordered choices, use another convenience function: lexer.word_match(). It is much easier and more efficient to write word matches like:

local keyword = token(lexer.KEYWORD, lexer.word_match[[
  keyword_1 keyword_2 ... keyword_n
]])

local case_insensitive_keyword = token(lexer.KEYWORD, lexer.word_match([[
  KEYWORD_1 keyword_2 ... KEYword_n
]], true))

local hyphened_keyword = token(lexer.KEYWORD, lexer.word_match[[
  keyword-1 keyword-2 ... keyword-n
]])

In order to more easily separate or categorize keyword sets, you can use Lua line comments within keyword strings. Such comments will be ignored. For example:

local keyword = token(lexer.KEYWORD, lexer.word_match[[
  -- Version 1 keywords.
  keyword_11, keyword_12 ... keyword_1n
  -- Version 2 keywords.
  keyword_21, keyword_22 ... keyword_2n
  ...
  -- Version N keywords.
  keyword_m1, keyword_m2 ... keyword_mn
]])

Comments

Line-style comments with a prefix character(s) are easy to express with LPeg:

local shell_comment = token(lexer.COMMENT, lexer.to_eol('#'))
local c_line_comment = token(lexer.COMMENT, lexer.to_eol('//', true))

The comments above start with a ‘#’ or “//” and go to the end of the line. The second comment recognizes the next line also as a comment if the current line ends with a ‘' escape character.

C-style “block” comments with a start and end delimiter are also easy to express:

local c_comment = token(lexer.COMMENT, lexer.range('/*', '*/'))

This comment starts with a “/*” sequence and contains anything up to and including an ending “*/” sequence. The ending “*/” is optional so the lexer can recognize unfinished comments as comments and highlight them properly.

Strings

Most programming languages allow escape sequences in strings such that a sequence like “\"” in a double-quoted string indicates that the ‘"’ is not the end of the string. lexer.range() handles escapes inherently.

local dq_str = lexer.range('"')
local sq_str = lexer.range("'")
local string = token(lexer.STRING, dq_str + sq_str)

In this case, the lexer treats ‘' as an escape character in a string sequence.

Numbers

Most programming languages have the same format for integer and float tokens, so it might be as simple as using a predefined LPeg pattern:

local number = token(lexer.NUMBER, lexer.number)

However, some languages allow postfix characters on integers.

local integer = P('-')^-1 * (lexer.dec_num * S('lL')^-1)
local number = token(lexer.NUMBER, lexer.float + lexer.hex_num + integer)

Your language may need other tweaks, but it is up to you how fine-grained you want your highlighting to be. After all, you are not writing a compiler or interpreter!

Rules

Programming languages have grammars, which specify valid token structure. For example, comments usually cannot appear within a string. Grammars consist of rules, which are simply combinations of tokens. Recall from the lexer template the lexer.add_rule() call, which adds a rule to the lexer’s grammar:

lex:add_rule('whitespace', ws)

Each rule has an associated name, but rule names are completely arbitrary and serve only to identify and distinguish between different rules. Rule order is important: if text does not match the first rule added to the grammar, the lexer tries to match the second rule added, and so on. Right now this lexer simply matches whitespace tokens under a rule named “whitespace”.

To illustrate the importance of rule order, here is an example of a simplified Lua lexer:

lex:add_rule('whitespace', token(lexer.WHITESPACE, ...))
lex:add_rule('keyword', token(lexer.KEYWORD, ...))
lex:add_rule('identifier', token(lexer.IDENTIFIER, ...))
lex:add_rule('string', token(lexer.STRING, ...))
lex:add_rule('comment', token(lexer.COMMENT, ...))
lex:add_rule('number', token(lexer.NUMBER, ...))
lex:add_rule('label', token(lexer.LABEL, ...))
lex:add_rule('operator', token(lexer.OPERATOR, ...))

Note how identifiers come after keywords. In Lua, as with most programming languages, the characters allowed in keywords and identifiers are in the same set (alphanumerics plus underscores). If the lexer added the “identifier” rule before the “keyword” rule, all keywords would match identifiers and thus incorrectly highlight as identifiers instead of keywords. The same idea applies to function, constant, etc. tokens that you may want to distinguish between: their rules should come before identifiers.

So what about text that does not match any rules? For example in Lua, the ‘!’ character is meaningless outside a string or comment. Normally the lexer skips over such text. If instead you want to highlight these “syntax errors”, add an additional end rule:

lex:add_rule('whitespace', ws)
...
lex:add_rule('error', token(lexer.ERROR, lexer.any))

This identifies and highlights any character not matched by an existing rule as a lexer.ERROR token.

Even though the rules defined in the examples above contain a single token, rules may consist of multiple tokens. For example, a rule for an HTML tag could consist of a tag token followed by an arbitrary number of attribute tokens, allowing the lexer to highlight all tokens separately. That rule might look something like this:

lex:add_rule('tag', tag_start * (ws * attributes)^0 * tag_end^-1)

Note however that lexers with complex rules like these are more prone to lose track of their state, especially if they span multiple lines.

Summary

Lexers primarily consist of tokens and grammar rules. At your disposal are a number of convenience patterns and functions for rapidly creating a lexer. If you choose to use predefined token names for your tokens, you do not have to define how the lexer highlights them. The tokens will inherit the default syntax highlighting color theme your editor uses.

Advanced Techniques

Styles and Styling

The most basic form of syntax highlighting is assigning different colors to different tokens. Instead of highlighting with just colors, Scintilla allows for more rich highlighting, or “styling”, with different fonts, font sizes, font attributes, and foreground and background colors, just to name a few. The unit of this rich highlighting is called a “style”. Styles are simply Lua tables of properties. By default, lexers associate predefined token names like lexer.WHITESPACE, lexer.COMMENT, lexer.STRING, etc. with particular styles as part of a universal color theme. These predefined styles are contained in lexer.styles, and you may define your own styles. See that table’s documentation for more information. As with token names, LPeg patterns, and styles, there is a set of predefined color names, but they vary depending on the current color theme in use. Therefore, it is generally not a good idea to manually define colors within styles in your lexer since they might not fit into a user’s chosen color theme. Try to refrain from even using predefined colors in a style because that color may be theme-specific. Instead, the best practice is to either use predefined styles or derive new color-agnostic styles from predefined ones. For example, Lua “longstring” tokens use the existing lexer.styles.string style instead of defining a new one.

Example Styles

Defining styles is pretty straightforward. An empty style that inherits the default theme settings is simply an empty table:

local style_nothing = {}

A similar style but with a bold font face looks like this:

local style_bold = {bold = true}

You can derive new styles from predefined ones without having to rewrite them. This operation leaves the old style unchanged. For example, if you had a “static variable” token whose style you wanted to base off of lexer.styles.variable, it would probably look like:

local style_static_var = lexer.styles.variable .. {italics = true}

The color theme files in the lexers/themes/ folder give more examples of style definitions.

Token Styles

Lexers use the lexer.add_style() function to assign styles to particular tokens. Recall the token definition and from the lexer template:

local ws = token(lexer.WHITESPACE, lexer.space^1)
lex:add_rule('whitespace', ws)

Why is a style not assigned to the lexer.WHITESPACE token? As mentioned earlier, lexers automatically associate tokens that use predefined token names with a particular style. Only tokens with custom token names need manual style associations. As an example, consider a custom whitespace token:

local ws = token('custom_whitespace', lexer.space^1)

Assigning a style to this token looks like:

lex:add_style('custom_whitespace', lexer.styles.whitespace)

Do not confuse token names with rule names. They are completely different entities. In the example above, the lexer associates the “custom_whitespace” token with the existing style for lexer.WHITESPACE tokens. If instead you prefer to color the background of whitespace a shade of grey, it might look like:

lex:add_style('custom_whitespace',
              lexer.styles.whitespace .. {back = lexer.colors.grey})

Remember to refrain from assigning specific colors in styles, but in this case, all user color themes probably define colors.grey.

Line Lexers

By default, lexers match the arbitrary chunks of text passed to them by Scintilla. These chunks may be a full document, only the visible part of a document, or even just portions of lines. Some lexers need to match whole lines. For example, a lexer for the output of a file “diff” needs to know if the line started with a ‘+’ or ‘-‘ and then style the entire line accordingly. To indicate that your lexer matches by line, create the lexer with an extra parameter:

local lex = lexer.new('?', {lex_by_line = true})

Now the input text for the lexer is a single line at a time. Keep in mind that line lexers do not have the ability to look ahead at subsequent lines.

Embedded Lexers

Lexers embed within one another very easily, requiring minimal effort. In the following sections, the lexer being embedded is called the “child” lexer and the lexer a child is being embedded in is called the “parent”. For example, consider an HTML lexer and a CSS lexer. Either lexer stands alone for styling their respective HTML and CSS files. However, CSS can be embedded inside HTML. In this specific case, the CSS lexer is the “child” lexer with the HTML lexer being the “parent”. Now consider an HTML lexer and a PHP lexer. This sounds a lot like the case with CSS, but there is a subtle difference: PHP embeds itself into HTML while CSS is embedded in HTML. This fundamental difference results in two types of embedded lexers: a parent lexer that embeds other child lexers in it (like HTML embedding CSS), and a child lexer that embeds itself into a parent lexer (like PHP embedding itself in HTML).

Parent Lexer

Before embedding a child lexer into a parent lexer, the parent lexer needs to load the child lexer. This is done with the lexer.load() function. For example, loading the CSS lexer within the HTML lexer looks like:

local css = lexer.load('css')

The next part of the embedding process is telling the parent lexer when to switch over to the child lexer and when to switch back. The lexer refers to these indications as the “start rule” and “end rule”, respectively, and are just LPeg patterns. Continuing with the HTML/CSS example, the transition from HTML to CSS is when the lexer encounters a “style” tag with a “type” attribute whose value is “text/css”:

local css_tag = P('<style') * P(function(input, index)
  if input:find('^[^>]+type="text/css"', index) then
    return index
  end
end)

This pattern looks for the beginning of a “style” tag and searches its attribute list for the text “type="text/css"”. (In this simplified example, the Lua pattern does not consider whitespace between the ‘=’ nor does it consider that using single quotes is valid.) If there is a match, the functional pattern returns a value instead of nil. In this case, the value returned does not matter because we ultimately want to style the “style” tag as an HTML tag, so the actual start rule looks like this:

local css_start_rule = #css_tag * tag

Now that the parent knows when to switch to the child, it needs to know when to switch back. In the case of HTML/CSS, the switch back occurs when the lexer encounters an ending “style” tag, though the lexer should still style the tag as an HTML tag:

local css_end_rule = #P('</style>') * tag

Once the parent loads the child lexer and defines the child’s start and end rules, it embeds the child with the lexer.embed() function:

lex:embed(css, css_start_rule, css_end_rule)
Child Lexer

The process for instructing a child lexer to embed itself into a parent is very similar to embedding a child into a parent: first, load the parent lexer into the child lexer with the lexer.load() function and then create start and end rules for the child lexer. However, in this case, call lexer.embed() with switched arguments. For example, in the PHP lexer:

local html = lexer.load('html')
local php_start_rule = token('php_tag', '<?php ')
local php_end_rule = token('php_tag', '?>')
lex:add_style('php_tag', lexer.styles.embedded)
html:embed(lex, php_start_rule, php_end_rule)

Lexers with Complex State

A vast majority of lexers are not stateful and can operate on any chunk of text in a document. However, there may be rare cases where a lexer does need to keep track of some sort of persistent state. Rather than using lpeg.P function patterns that set state variables, it is recommended to make use of Scintilla’s built-in, per-line state integers via lexer.line_state. It was designed to accommodate up to 32 bit flags for tracking state. lexer.line_from_position() will return the line for any position given to an lpeg.P function pattern. (Any positions derived from that position argument will also work.)

Writing stateful lexers is beyond the scope of this document.

Code Folding

When reading source code, it is occasionally helpful to temporarily hide blocks of code like functions, classes, comments, etc. This is the concept of “folding”. In the Textadept and SciTE editors for example, little indicators in the editor margins appear next to code that can be folded at places called “fold points”. When the user clicks an indicator, the editor hides the code associated with the indicator until the user clicks the indicator again. The lexer specifies these fold points and what code exactly to fold.

The fold points for most languages occur on keywords or character sequences. Examples of fold keywords are “if” and “end” in Lua and examples of fold character sequences are ‘{‘, ‘}’, “/*”, and “*/” in C for code block and comment delimiters, respectively. However, these fold points cannot occur just anywhere. For example, lexers should not recognize fold keywords that appear within strings or comments. The lexer.add_fold_point() function allows you to conveniently define fold points with such granularity. For example, consider C:

lex:add_fold_point(lexer.OPERATOR, '{', '}')
lex:add_fold_point(lexer.COMMENT, '/*', '*/')

The first assignment states that any ‘{‘ or ‘}’ that the lexer recognized as an lexer.OPERATOR token is a fold point. Likewise, the second assignment states that any “/*” or “*/” that the lexer recognizes as part of a lexer.COMMENT token is a fold point. The lexer does not consider any occurrences of these characters outside their defined tokens (such as in a string) as fold points. How do you specify fold keywords? Here is an example for Lua:

lex:add_fold_point(lexer.KEYWORD, 'if', 'end')
lex:add_fold_point(lexer.KEYWORD, 'do', 'end')
lex:add_fold_point(lexer.KEYWORD, 'function', 'end')
lex:add_fold_point(lexer.KEYWORD, 'repeat', 'until')

If your lexer has case-insensitive keywords as fold points, simply add a case_insensitive_fold_points = true option to lexer.new(), and specify keywords in lower case.

If your lexer needs to do some additional processing in order to determine if a token is a fold point, pass a function that returns an integer to lex:add_fold_point(). Returning 1 indicates the token is a beginning fold point and returning -1 indicates the token is an ending fold point. Returning 0 indicates the token is not a fold point. For example:

local function fold_strange_token(text, pos, line, s, symbol)
  if ... then
    return 1 -- beginning fold point
  elseif ... then
    return -1 -- ending fold point
  end
  return 0
end

lex:add_fold_point('strange_token', '|', fold_strange_token)

Any time the lexer encounters a ‘|’ that is a “strange_token”, it calls the fold_strange_token function to determine if ‘|’ is a fold point. The lexer calls these functions with the following arguments: the text to identify fold points in, the beginning position of the current line in the text to fold, the current line’s text, the position in the current line the fold point text starts at, and the fold point text itself.

Fold by Indentation

Some languages have significant whitespace and/or no delimiters that indicate fold points. If your lexer falls into this category and you would like to mark fold points based on changes in indentation, create the lexer with a fold_by_indentation = true option:

local lex = lexer.new('?', {fold_by_indentation = true})

Using Lexers

Textadept

Put your lexer in your ~/.textadept/lexers/ directory so you do not overwrite it when upgrading Textadept. Also, lexers in this directory override default lexers. Thus, Textadept loads a user lua lexer instead of the default lua lexer. This is convenient for tweaking a default lexer to your liking. Then add a file type for your lexer if necessary.

SciTE

Create a .properties file for your lexer and import it in either your SciTEUser.properties or SciTEGlobal.properties. The contents of the .properties file should contain:

file.patterns.[lexer_name]=[file_patterns]
lexer.$(file.patterns.[lexer_name])=[lexer_name]

where [lexer_name] is the name of your lexer (minus the .lua extension) and [file_patterns] is a set of file extensions to use your lexer for.

Please note that Lua lexers ignore any styling information in .properties files. Your theme file in the lexers/themes/ directory contains styling information.

Migrating Legacy Lexers

Legacy lexers are of the form:

local l = require('lexer')
local token, word_match = l.token, l.word_match
local P, R, S = lpeg.P, lpeg.R, lpeg.S

local M = {_NAME = '?'}

[... token and pattern definitions ...]

M._rules = {
  {'rule', pattern},
  [...]
}

M._tokenstyles = {
  'token' = 'style',
  [...]
}

M._foldsymbols = {
  _patterns = {...},
  ['token'] = {['start'] = 1, ['end'] = -1},
  [...]
}

return M

While Scintillua will handle such legacy lexers just fine without any changes, it is recommended that you migrate yours. The migration process is fairly straightforward:

  1. Replace all instances of l with lexer, as it’s better practice and results in less confusion.
  2. Replace local M = {_NAME = '?'} with local lex = lexer.new('?'), where ? is the name of your legacy lexer. At the end of the lexer, change return M to return lex.
  3. Instead of defining rules towards the end of your lexer, define your rules as you define your tokens and patterns using lex:add_rule().
  4. Similarly, any custom token names should have their styles immediately defined using lex:add_style().
  5. Convert any table arguments passed to lexer.word_match() to a space-separated string of words.
  6. Replace any calls to lexer.embed(M, child, ...) and lexer.embed(parent, M, ...) with lex:embed(child, ...) and parent:embed(lex, ...), respectively.
  7. Define fold points with simple calls to lex:add_fold_point(). No need to mess with Lua patterns anymore.
  8. Any legacy lexer options such as M._FOLDBYINDENTATION, M._LEXBYLINE, M._lexer, etc. should be added as table options to lexer.new().
  9. Any external lexer rule fetching and/or modifications via lexer._RULES should be changed to use lexer.get_rule() and lexer.modify_rule().

As an example, consider the following sample legacy lexer:

local l = require('lexer')
local token, word_match = l.token, l.word_match
local P, R, S = lpeg.P, lpeg.R, lpeg.S

local M = {_NAME = 'legacy'}

local ws = token(l.WHITESPACE, l.space^1)
local comment = token(l.COMMENT, '#' * l.nonnewline^0)
local string = token(l.STRING, l.delimited_range('"'))
local number = token(l.NUMBER, l.float + l.integer)
local keyword = token(l.KEYWORD, word_match{'foo', 'bar', 'baz'})
local custom = token('custom', P('quux'))
local identifier = token(l.IDENTIFIER, l.word)
local operator = token(l.OPERATOR, S('+-*/%^=<>,.()[]{}'))

M._rules = {
  {'whitespace', ws},
  {'keyword', keyword},
  {'custom', custom},
  {'identifier', identifier},
  {'string', string},
  {'comment', comment},
  {'number', number},
  {'operator', operator}
}

M._tokenstyles = {
  'custom' = l.STYLE_KEYWORD .. ',bold'
}

M._foldsymbols = {
  _patterns = {'[{}]'},
  [l.OPERATOR] = {['{'] = 1, ['}'] = -1}
}

return M

Following the migration steps would yield:

local lexer = require('lexer')
local token, word_match = lexer.token, lexer.word_match
local P, S = lpeg.P, lpeg.S

local lex = lexer.new('legacy')

lex:add_rule('whitespace', token(lexer.WHITESPACE, lexer.space^1))
lex:add_rule('keyword', token(lexer.KEYWORD, word_match[[foo bar baz]]))
lex:add_rule('custom', token('custom', P('quux')))
lex:add_style('custom', lexer.styles.keyword .. {bold = true})
lex:add_rule('identifier', token(lexer.IDENTIFIER, lexer.word))
lex:add_rule('string', token(lexer.STRING, lexer.range('"')))
lex:add_rule('comment', token(lexer.COMMENT, lexer.to_eol('#')))
lex:add_rule('number', token(lexer.NUMBER, lexer.number))
lex:add_rule('operator', token(lexer.OPERATOR, S('+-*/%^=<>,.()[]{}')))

lex:add_fold_point(lexer.OPERATOR, '{', '}')

return lex

Considerations

Performance

There might be some slight overhead when initializing a lexer, but loading a file from disk into Scintilla is usually more expensive. On modern computer systems, I see no difference in speed between Lua lexers and Scintilla’s C++ ones. Optimize lexers for speed by re-arranging lexer.add_rule() calls so that the most common rules match first. Do keep in mind that order matters for similar rules.

In some cases, folding may be far more expensive than lexing, particularly in lexers with a lot of potential fold points. If your lexer is exhibiting signs of slowness, try disabling folding in your text editor first. If that speeds things up, you can try reducing the number of fold points you added, overriding lexer.fold() with your own implementation, or simply eliminating folding support from your lexer.

Limitations

Embedded preprocessor languages like PHP cannot completely embed in their parent languages in that the parent’s tokens do not support start and end rules. This mostly goes unnoticed, but code like

<div id="<?php echo $id; ?>">

will not style correctly.

Troubleshooting

Errors in lexers can be tricky to debug. Lexers print Lua errors to io.stderr and _G.print() statements to io.stdout. Running your editor from a terminal is the easiest way to see errors as they occur.

Risks

Poorly written lexers have the ability to crash Scintilla (and thus its containing application), so unsaved data might be lost. However, I have only observed these crashes in early lexer development, when syntax errors or pattern errors are present. Once the lexer actually starts styling text (either correctly or incorrectly, it does not matter), I have not observed any crashes.

Acknowledgements

Thanks to Peter Odding for his lexer post on the Lua mailing list that provided inspiration, and thanks to Roberto Ierusalimschy for LPeg.

Fields defined by lexer

lexer.CLASS (string)

The token name for class tokens.

lexer.COMMENT (string)

The token name for comment tokens.

lexer.CONSTANT (string)

The token name for constant tokens.

lexer.DEFAULT (string)

The token name for default tokens.

lexer.ERROR (string)

The token name for error tokens.

lexer.FOLD_BASE (number)

The initial (root) fold level.

lexer.FOLD_BLANK (number)

Flag indicating that the line is blank.

lexer.FOLD_HEADER (number)

Flag indicating the line is fold point.

lexer.FUNCTION (string)

The token name for function tokens.

lexer.IDENTIFIER (string)

The token name for identifier tokens.

lexer.KEYWORD (string)

The token name for keyword tokens.

lexer.LABEL (string)

The token name for label tokens.

lexer.NUMBER (string)

The token name for number tokens.

lexer.OPERATOR (string)

The token name for operator tokens.

lexer.PREPROCESSOR (string)

The token name for preprocessor tokens.

lexer.REGEX (string)

The token name for regex tokens.

lexer.STRING (string)

The token name for string tokens.

lexer.TYPE (string)

The token name for type tokens.

lexer.VARIABLE (string)

The token name for variable tokens.

lexer.WHITESPACE (string)

The token name for whitespace tokens.

lexer.alnum (pattern)

A pattern that matches any alphanumeric character (‘A’-‘Z’, ‘a’-‘z’, ‘0’-‘9’).

lexer.alpha (pattern)

A pattern that matches any alphabetic character (‘A’-‘Z’, ‘a’-‘z’).

lexer.any (pattern)

A pattern that matches any single character.

lexer.ascii (pattern)

A pattern that matches any ASCII character (codes 0 to 127).

lexer.cntrl (pattern)

A pattern that matches any control character (ASCII codes 0 to 31).

lexer.dec_num (pattern)

A pattern that matches a decimal number.

lexer.digit (pattern)

A pattern that matches any digit (‘0’-‘9’).

lexer.extend (pattern)

A pattern that matches any ASCII extended character (codes 0 to 255).

lexer.float (pattern)

A pattern that matches a floating point number.

lexer.fold_by_indentation (boolean)

Whether or not to fold based on indentation level if a lexer does not have a folder. Some lexers automatically enable this option. It is disabled by default. This is an alias for lexer.property['fold.by.indentation'] = '1|0'.

lexer.fold_compact (boolean)

Whether or not blank lines after an ending fold point are included in that fold. This option is disabled by default. This is an alias for lexer.property['fold.compact'] = '1|0'.

lexer.fold_level (table, Read-only)

Table of fold level bit-masks for line numbers starting from 1. Fold level masks are composed of an integer level combined with any of the following bits:

lexer.fold_line_groups (boolean)

Whether or not to fold multiple, consecutive line groups (such as line comments and import statements) and only show the top line. This option is disabled by default. This is an alias for lexer.property['fold.line.groups'] = '1|0'.

lexer.fold_on_zero_sum_lines (boolean)

Whether or not to mark as a fold point lines that contain both an ending and starting fold point. For example, } else { would be marked as a fold point. This option is disabled by default. This is an alias for lexer.property['fold.on.zero.sum.lines'] = '1|0'.

lexer.folding (boolean)

Whether or not folding is enabled for the lexers that support it. This option is disabled by default. This is an alias for lexer.property['fold'] = '1|0'.

lexer.graph (pattern)

A pattern that matches any graphical character (‘!’ to ‘~’).

lexer.hex_num (pattern)

A pattern that matches a hexadecimal number.

lexer.indent_amount (table, Read-only)

Table of indentation amounts in character columns, for line numbers starting from 1.

lexer.integer (pattern)

A pattern that matches either a decimal, hexadecimal, or octal number.

lexer.line_state (table)

Table of integer line states for line numbers starting from 1. Line states can be used by lexers for keeping track of persistent states.

lexer.lower (pattern)

A pattern that matches any lower case character (‘a’-‘z’).

lexer.newline (pattern)

A pattern that matches a sequence of end of line characters.

lexer.nonnewline (pattern)

A pattern that matches any single, non-newline character.

lexer.number (pattern)

A pattern that matches a typical number, either a floating point, decimal, hexadecimal, or octal number.

lexer.oct_num (pattern)

A pattern that matches an octal number.

lexer.print (pattern)

A pattern that matches any printable character (‘ ‘ to ‘~’).

lexer.property (table)

Map of key-value string pairs.

lexer.property_expanded (table, Read-only)

Map of key-value string pairs with $() and %() variable replacement performed in values.

lexer.property_int (table, Read-only)

Map of key-value pairs with values interpreted as numbers, or 0 if not found.

lexer.punct (pattern)

A pattern that matches any punctuation character (‘!’ to ‘/’, ‘:’ to ‘@’, ‘[’ to ‘’’, ‘{‘ to ‘~’).

lexer.space (pattern)

A pattern that matches any whitespace character (‘\t’, ‘\v’, ‘\f’, ‘\n’, ‘\r’, space).

lexer.style_at (table, Read-only)

Table of style names at positions in the buffer starting from 1.

lexer.upper (pattern)

A pattern that matches any upper case character (‘A’-‘Z’).

lexer.word (pattern)

A pattern that matches a typical word. Words begin with a letter or underscore and consist of alphanumeric and underscore characters.

lexer.xdigit (pattern)

A pattern that matches any hexadecimal digit (‘0’-‘9’, ‘A’-‘F’, ‘a’-‘f’).

Functions defined by lexer

lexer.add_fold_point(lexer, token_name, start_symbol, end_symbol)

Adds to lexer lexer a fold point whose beginning and end tokens are string token_name tokens with string content start_symbol and end_symbol, respectively. In the event that start_symbol may or may not be a fold point depending on context, and that additional processing is required, end_symbol may be a function that ultimately returns 1 (indicating a beginning fold point), -1 (indicating an ending fold point), or 0 (indicating no fold point). That function is passed the following arguments:

Parameters:

Usage:

lexer.add_rule(lexer, id, rule)

Adds pattern rule identified by string id to the ordered list of rules for lexer lexer.

Parameters:

See also:

lexer.add_style(lexer, token_name, style)

Associates string token_name in lexer lexer with style table style. style may have the following fields:

Field values may also contain “$(property.name)” expansions for properties defined in Scintilla, theme files, etc.

Parameters:

Usage:

lexer.embed(lexer, child, start_rule, end_rule)

Embeds child lexer child in parent lexer lexer using patterns start_rule and end_rule, which signal the beginning and end of the embedded lexer, respectively.

Parameters:

Usage:

lexer.fold(lexer, text, start_pos, start_line, start_level)

Determines fold points in a chunk of text text using lexer lexer, returning a table of fold levels associated with line numbers. text starts at position start_pos on line number start_line with a beginning fold level of start_level in the buffer.

Parameters:

Return:

lexer.fold_consecutive_lines(prefix)

Returns for lexer.add_fold_point() the parameters needed to fold consecutive lines that start with string prefix.

Parameters:

Usage:

lexer.get_rule(lexer, id)

Returns the rule identified by string id.

Parameters:

Return:

lexer.last_char_includes(s)

Creates and returns a pattern that verifies the first non-whitespace character behind the current match position is in string set s.

Parameters:

Usage:

Return:

lexer.lex(lexer, text, init_style)

Lexes a chunk of text text (that has an initial style number of init_style) using lexer lexer, returning a table of token names and positions.

Parameters:

Return:

lexer.line_from_position(pos)

Returns the line number (starting from 1) of the line that contains position pos, which starts from 1.

Parameters:

Return:

lexer.load(name, alt_name, cache)

Initializes or loads and returns the lexer of string name name. Scintilla calls this function in order to load a lexer. Parent lexers also call this function in order to load child lexers and vice-versa. The user calls this function in order to load a lexer when using Scintillua as a Lua library.

Parameters:

Return:

lexer.modify_rule(lexer, id, rule)

Replaces in lexer lexer the existing rule identified by string id with pattern rule.

Parameters:

lexer.new(name, opts)

Creates a returns a new lexer with the given name.

Parameters:

Usage:

lexer.range(s, e, single_line, escapes, balanced)

Creates and returns a pattern that matches a range of text bounded by strings or patterns s and e. This is a convenience function for matching more complicated ranges like strings with escape characters, balanced parentheses, and block comments (nested or not). e is optional and defaults to s. single_line indicates whether or not the range must be on a single line; escapes indicates whether or not to allow ‘' as an escape character; and balanced indicates whether or not to handle balanced ranges like parentheses, and requires s and e to be different.

Parameters:

Usage:

Return:

lexer.starts_line(patt)

Creates and returns a pattern that matches pattern patt only at the beginning of a line.

Parameters:

Usage:

Return:

lexer.to_eol(prefix, escape)

Creates and returns a pattern that matches from string or pattern prefix until the end of the line. escape indicates whether the end of the line can be escaped with a ‘' character.

Parameters:

Usage:

Return:

lexer.token(name, patt)

Creates and returns a token pattern with token name name and pattern patt. If name is not a predefined token name, its style must be defined via lexer.add_style().

Parameters:

Usage:

Return:

lexer.word_match(words, case_insensitive, word_chars)

Creates and returns a pattern that matches any single word in string words. case_insensitive indicates whether or not to ignore case when matching words. This is a convenience function for simplifying a set of ordered choice word patterns. If words is a multi-line string, it may contain Lua line comments (--) that will ultimately be ignored.

Parameters:

Usage:

Return:

Tables defined by lexer

lexer.colors

Map of color name strings to color values in 0xBBGGRR or "#RRGGBB" format. Note: for applications running within a terminal emulator, only 16 color values are recognized, regardless of how many colors a user’s terminal actually supports. (A terminal emulator’s settings determines how to actually display these recognized color values, which may end up being mapped to a completely different color set.) In order to use the light variant of a color, some terminals require a style’s bold attribute must be set along with that normal color. Recognized color values are black (0x000000), red (0x000080), green (0x008000), yellow (0x008080), blue (0x800000), magenta (0x800080), cyan (0x808000), white (0xC0C0C0), light black (0x404040), light red (0x0000FF), light green (0x00FF00), light yellow (0x00FFFF), light blue (0xFF0000), light magenta (0xFF00FF), light cyan (0xFFFF00), and light white (0xFFFFFF).

lexer.styles

Map of style names to style definition tables.

Style names consist of the following default names as well as the token names defined by lexers.

Style definition tables may contain the following fields:


The lfs Module


Extends the lfs library to find files in directories and determine absolute file paths.

Functions defined by lfs

lfs.abspath(filename, prefix)

Returns the absolute path to string filename. prefix or lfs.currentdir() is prepended to a relative filename. The returned path is not guaranteed to exist.

Parameters:

Return:

lfs.walk(dir, filter, n, include_dirs)

Returns an iterator that iterates over all files and sub-directories (up to n levels deep) in directory dir and yields each file found. String or list filter determines which files to yield, with the default filter being lfs.default_filter. A filter consists of Lua patterns that match file and directory paths to include or exclude. Exclusive patterns begin with a ‘!’. If no inclusive patterns are given, any path is initially considered. As a convenience, file extensions can be specified literally instead of as a Lua pattern (e.g. ‘.lua’ vs. ‘%.lua$’), and ‘/’ also matches the Windows directory separator (‘[/\]’ is not needed).

Parameters:

See also:

Tables defined by lfs

lfs.default_filter

The filter table containing common binary file extensions and version control directories to exclude when iterating over files and directories using walk. Extensions excluded: a, bmp, bz2, class, dll, exe, gif, gz, jar, jpeg, jpg, o, pdf, png, so, tar, tgz, tif, tiff, xz, and zip. Directories excluded: .bzr, .git, .hg, .svn, FOSSIL, and node_modules.

See also:


The os Module


Extends Lua’s os library to provide process spawning capabilities.

Functions defined by os

os.spawn(cmd, cwd, env, stdout_cb, stderr_cb, exit_cb)

Spawns an interactive child process cmd in a separate thread, returning a handle to that process. On Windows, cmd is passed to cmd.exe: %COMSPEC% /c [cmd]. At the moment, only the Windows terminal version spawns processes in the same thread.

Parameters:

Usage:

Return:

spawn_proc:close()

Closes standard input for process spawn_proc, effectively sending an EOF (end of file) to it.

spawn_proc:kill(signal)

Kills running process spawn_proc, or sends it Unix signal signal.

Parameters:

spawn_proc:read(arg)

Reads and returns stdout from process spawn_proc, according to string format or number arg. Similar to Lua’s io.read() and blocks for input. spawn_proc must still be running. If an error occurs while reading, returns nil, an error code, and an error message. Ensure any read operations read all stdout available, as the stdout callback function passed to os.spawn() will not be called until the stdout buffer is clear.

Parameters:

Return:

spawn_proc:status()

Returns the status of process spawn_proc, which is either “running” or “terminated”.

Return:

spawn_proc:wait()

Blocks until process spawn_proc finishes (if it has not already done so) and returns its status code.

Return:

spawn_proc:write()

Writes string input to the stdin of process spawn_proc. Note: On Linux, if more than 65536 bytes (64K) are to be written, it is possible those bytes need to be written in 65536-byte (64K) chunks, or the process may not receive all input. However, it is also possible that there is a limit on how many bytes can be written in a short period of time, perhaps 196608 bytes (192K).

Parameters:


The string Module


Extends Lua’s string library to provide character set conversions.

Functions defined by string

string.iconv(text, new, old)

Converts string text from encoding old to encoding new using GNU libiconv, returning the string result. Valid encodings are GNU libiconv’s encodings and include:

Parameters:


The textadept Module


The textadept module. It provides utilities for editing text in Textadept.


The textadept.bookmarks Module


Bookmarks for Textadept.

Fields defined by textadept.bookmarks

textadept.bookmarks.MARK_BOOKMARK (number)

The bookmark mark number.

Functions defined by textadept.bookmarks

textadept.bookmarks.clear()

Clears all bookmarks in the current buffer.

textadept.bookmarks.goto_mark(next)

Prompts the user to select a bookmarked line to move the caret to the beginning of unless next is given. If next is true or false, moves the caret to the beginning of the next or previously bookmarked line, respectively.

Parameters:

textadept.bookmarks.toggle()

Toggles a bookmark on the current line.


The textadept.editing Module


Editing features for Textadept.

Fields defined by textadept.editing

textadept.editing.INDIC_BRACEMATCH (number)

The matching brace highlight indicator number.

textadept.editing.INDIC_HIGHLIGHT (number)

The word highlight indicator number.

textadept.editing.auto_enclose (bool)

Whether or not to auto-enclose selected text when typing a punctuation character, taking textadept.editing.auto_pairs into account. The default value is false.

textadept.editing.auto_indent (bool)

Match the previous line’s indentation level after inserting a new line. The default value is true.

textadept.editing.autocomplete_all_words (bool)

Autocomplete the current word using words from all open buffers. If true, performance may be slow when many buffers are open. The default value is false.

textadept.editing.highlight_words (number)

The word highlight mode.

The default value is textadept.editing.HIGHLIGHT_NONE.

textadept.editing.strip_trailing_spaces (bool)

Strip trailing whitespace before saving files. The default value is false.

Functions defined by textadept.editing

textadept.editing.autocomplete(name)

Displays an autocompletion list provided by the autocompleter function associated with string name, and returns true if completions were found.

Parameters:

See also:

textadept.editing.convert_indentation()

Converts indentation between tabs and spaces according to buffer.use_tabs. If buffer.use_tabs is true, buffer.tab_width indenting spaces are converted to tabs. Otherwise, all indenting tabs are converted to buffer.tab_width spaces.

See also:

textadept.editing.enclose(left, right)

Encloses the selected text or the current word within strings left and right, taking multiple selections into account.

Parameters:

textadept.editing.filter_through(command)

Passes the selected text or all buffer text to string shell command command as standard input (stdin) and replaces the input text with the command’s standard output (stdout). command may contain shell pipes (‘|’). Standard input is as follows:

  1. If no text is selected, the entire buffer is used.
  2. If text is selected and spans a single line, only the selected text is used.
  3. If text is selected and spans multiple lines, all text on the lines that have text selected is passed as stdin. However, if the end of the selection is at the beginning of a line, only the line ending delimiters from the previous line are included. The rest of the line is excluded.

Parameters:

textadept.editing.goto_line(line)

Moves the caret to the beginning of line number line or the user-specified line, ensuring line is visible.

Parameters:

textadept.editing.join_lines()

Joins the currently selected lines or the current line with the line below it. As long as any part of a line is selected, the entire line is eligible for joining.

textadept.editing.paste_reindent()

Pastes the text from the clipboard, taking into account the buffer’s indentation settings and the indentation of the current and preceding lines.

textadept.editing.select_enclosed(left, right)

Selects the text between strings left and right that enclose the caret. If that range is already selected, toggles between selecting left and right as well. If left and right are not provided, they are assumed to be one of the delimiter pairs specified in auto_pairs and are inferred from the current position or selection.

Parameters:

See also:

textadept.editing.select_line()

Selects the current line.

textadept.editing.select_paragraph()

Selects the current paragraph. Paragraphs are surrounded by one or more blank lines.

textadept.editing.select_word(all)

Selects the current word or, if all is true, all occurrences of the current word. If a word is already selected, selects the next occurrence as a multiple selection.

Parameters:

See also:

textadept.editing.show_documentation(pos, ignore_case)

Displays a call tip with documentation for the symbol under or directly behind position pos or the caret position. Documentation is read from API files in the api_files table. If a call tip is already shown, cycles to the next one if it exists. Symbols are determined by using buffer.word_chars.

Parameters:

See also:

textadept.editing.toggle_comment()

Comments or uncomments the selected lines based on the current language. As long as any part of a line is selected, the entire line is eligible for commenting/uncommenting.

See also:

textadept.editing.transpose_chars()

Transposes characters intelligently. If the caret is at the end of a line, transposes the two characters before the caret. Otherwise, the characters to the left and right are.

Tables defined by textadept.editing

textadept.editing.XPM_IMAGES

Map of image names to registered image numbers.

Fields:

textadept.editing.api_files

Map of lexer names to API documentation file tables. File tables contain API file paths or functions that return such paths. Each line in an API file consists of a symbol name (not a fully qualified symbol name), a space character, and that symbol’s documentation. “\n” represents a newline character.

See also:

textadept.editing.auto_pairs

Map of auto-paired characters like parentheses, brackets, braces, and quotes. The ASCII values of opening characters are assigned to strings that contain complement characters. The default auto-paired characters are “()”, “[]”, “{}”, “''”, and “""”.

Usage:

textadept.editing.autocompleters

Map of autocompleter names to autocompletion functions. Names are typically lexer names and autocompletion functions typically autocomplete symbols. Autocompletion functions must return two values: the number of characters behind the caret that are used as the prefix of the entity to be autocompleted, and a list of completions to be shown. Autocompletion lists are sorted automatically.

See also:

textadept.editing.brace_matches

Table of brace characters to highlight. The ASCII values of brace characters are keys and are assigned non-nil values. The default brace characters are ‘(‘, ‘)’, ‘[’, ‘]’, ‘{‘, and ‘}’.

Usage:

textadept.editing.comment_string

Map of lexer names to line comment strings for programming languages, used by the toggle_comment() function. Keys are lexer names and values are either the language’s line comment prefixes or block comment delimiters separated by a ‘|’ character.

See also:

textadept.editing.typeover_chars

Table of characters to move over when typed. The ASCII values of characters are keys and are assigned non-nil values. The default characters are ‘)’, ‘]’, ‘}’, ‘'’, and ‘"’.

Usage:


The textadept.file_types Module


Handles file type detection for Textadept.

Fields defined by textadept.file_types

events.LEXER_LOADED (string)

Emitted after loading a language lexer. This is useful for overriding a language module’s key bindings or other properties since the module is not loaded when Textadept starts. Arguments:

Functions defined by textadept.file_types

textadept.file_types.select_lexer()

Prompts the user to select a lexer for the current buffer.

See also:

Tables defined by textadept.file_types

textadept.file_types.extensions

Map of file extensions to their associated lexer names. If the file type is not recognized by its first-line, each file extension is matched against the file’s extension.

textadept.file_types.patterns

Map of first-line patterns to their associated lexer names. Each pattern is matched against the first line in the file.


The textadept.keys Module


Defines key bindings for Textadept. This set of key bindings is pretty standard among other text editors, at least for basic editing commands and movements.

Key Bindings

Win32, Linux, BSD macOS Terminal Command
File      
Ctrl+N ⌘N M-^N New file
Ctrl+O ⌘O ^O Open file
Ctrl+Alt+O ^⌘O M-^O Open recent file…
Ctrl+Shift+O ⌘⇧O M-O Reload file
Ctrl+S ⌘S ^S Save file
Ctrl+Shift+S ⌘⇧S M-^S Save file as..
None None None Save all files
Ctrl+W ⌘W ^W Close file
Ctrl+Shift+W ⌘⇧W M-^W Close all files
None None None Load session…
None None None Save session…
Ctrl+Q ⌘Q ^Q Quit
Edit      
Ctrl+Z
Alt+Bksp
⌘Z ^Z^(†)
M-Z
Undo
Ctrl+Y
Ctrl+Shift+Z
⌘⇧Z ^Y
M-S-Z
Redo
Ctrl+X
Shift+Del
⌘X
⇧⌦
^X Cut
Ctrl+C
Ctrl+Ins
⌘C ^C Copy
Ctrl+V
Shift+Ins
⌘V ^V Paste
Ctrl+Shift+V ⌘⇧V M-V Paste Reindent
Ctrl+D ⌘D None Duplicate line
Del
^D
Del
^D
Delete
Alt+Del ^⌦ M-Del
M-D
Delete word
Ctrl+A ⌘A M-A Select all
Ctrl+M ^M M-M Match brace
Ctrl+Enter ^Esc M-Enter^(‡) Complete word
Ctrl+/ ^/ M-/ Toggle block comment
Ctrl+T ^T ^T Transpose characters
Ctrl+Shift+J ^J M-J Join lines
Ctrl+| ⌘| ^\ Filter text through
Ctrl+Shift+M ^⇧M M-S-M Select between delimiters
Ctrl+< ⌘< M-< Select between XML tags
Ctrl+> ⌘> None Select in XML tag
Ctrl+Shift+D ⌘⇧D M-S-W Select word
Ctrl+Shift+N ⌘⇧N M-S-N Select line
Ctrl+Shift+P ⌘⇧P M-S-P Select paragraph
Ctrl+Alt+U ^U M-^U Upper case selection
Ctrl+Alt+Shift+U ^⇧U M-^L Lower case selection
Alt+< ^< M-> Enclose as XML tags
Alt+> ^> None Enclose as single XML tag
Alt+” ^” None Enclose in double quotes
Alt+’ ^’ None Enclose in single quotes
Alt+( ^( M-) Enclose in parentheses
Alt+[ ^[ M-] Enclose in brackets
Alt+{ ^{ M-} Enclose in braces
Ctrl+Shift+Up ^⇧⇡ S-^Up Move selected lines up
Ctrl+Shift+Down ^⇧⇣ S-^Down Move selected lines down
Ctrl+P ⌘, M-~ Preferences
Search      
Ctrl+F ⌘F M-F
M-S-F
Find
Ctrl+G
F3
⌘G M-G Find next
Ctrl+Shift+G
Shift+F3
⌘⇧G M-S-G Find previous
Ctrl+Alt+R ^R M-R Replace
Ctrl+Alt+Shift+R ^⇧R M-S-R Replace all
Ctrl+Alt+F ^⌘F M-^F Find incremental
Ctrl+Shift+F ⌘⇧F None Find in files
Ctrl+Alt+G ^⌘G None Goto next file found
Ctrl+Alt+Shift+G ^⌘⇧G None Goto previous file found
Ctrl+J ⌘J ^J Jump to line
Tools      
Ctrl+E ⌘E M-C Command entry
Ctrl+Shift+E ⌘⇧E M-S-C Select command
Ctrl+R ⌘R ^R Run
Ctrl+Shift+R ⌘⇧R M-^R Compile
Ctrl+Shift+A ⌘⇧A None Set Arguments…
Ctrl+Shift+B ⌘⇧B M-^B Build
Ctrl+Shift+X ⌘⇧X M-^X Stop
Ctrl+Alt+E ^⌘E M-X Next Error
Ctrl+Alt+Shift+E ^⌘⇧E M-S-X Previous Error
Ctrl+F2 ⌘F2 F1 Toggle bookmark
Ctrl+Shift+F2 ⌘⇧F2 F6 Clear bookmarks
F2 F2 F2 Next bookmark
Shift+F2 ⇧F2 F3 Previous bookmark
Alt+F2 ⌥F2 F4 Goto bookmark…
F9 F9 F9 Start/stop recording macro
Shift+F9 ⇧F9 F10 Play recorded macro
Ctrl+U ⌘U ^U Quickly open _USERHOME
None None None Quickly open _HOME
Ctrl+Alt+Shift+O ^⌘⇧O M-S-O Quickly open current directory
Ctrl+Alt+Shift+P ^⌘⇧P M-^P Quickly open current project
Ctrl+Shift+K ⌥⇧⇥ M-S-K Insert snippet…
Tab Tab Expand snippet or next placeholder
Shift+Tab ⇧⇥ S-Tab Previous snippet placeholder
Esc Esc Esc Cancel snippet
Ctrl+K ⌥⇥ M-K Complete trigger word
Ctrl+Space ⌥Esc ^Space Complete symbol
Ctrl+H ^H M-H
M-S-H
Show documentation
Ctrl+I ⌘I M-S-I Show style
Buffer      
Ctrl+Tab ^⇥ M-N Next buffer
Ctrl+Shift+Tab ^⇧⇥ M-P Previous buffer
Ctrl+B ⌘B M-B
M-S-B
Switch to buffer…
None None None Tab width: 2
None None None Tab width: 3
None None None Tab width: 4
None None None Tab width: 8
Ctrl+Alt+Shift+T ^⇧T M-T
M-S-T
Toggle use tabs
Ctrl+Alt+I ^I M-I Convert indentation
None None None CR+LF EOL mode
None None None LF EOL mode
None None None UTF-8 encoding
None None None ASCII encoding
None None None CP-1252 encoding
None None None UTF-16 encoding
Ctrl+Alt+\ ^\ None Toggle wrap mode
Ctrl+Alt+Shift+S ^⇧S None Toggle view whitespace
Ctrl+Shift+L ⌘⇧L M-S-L Select lexer…
View      
Ctrl+Alt+N ^⌥⇥ M-^V N Next view
Ctrl+Alt+P ^⌥⇧⇥ M-^V P Previous view
Ctrl+Alt+S
Ctrl+Alt+H
^S M-^V S
M-^V H
Split view horizontal
Ctrl+Alt+V ^V M-^V V Split view vertical
Ctrl+Alt+W ^W M-^V W Unsplit view
Ctrl+Alt+Shift+W ^⇧W M-^V S-W Unsplit all views
Ctrl+Alt++
Ctrl+Alt+=
^+
^=
M-^V +
M-^V =
Grow view
Ctrl+Alt+- ^- M-^V - Shrink view
Ctrl+* ⌘* M-* Toggle current fold
Ctrl+Alt+Shift+I ^⇧I N/A Toggle indent guides
Ctrl+Alt+Shift+V ^⇧V None Toggle virtual space
Ctrl+= ⌘= N/A Zoom in
Ctrl+- ⌘- N/A Zoom out
Ctrl+0 ⌘0 N/A Reset zoom
Help      
F1 F1 None Open manual
Shift+F1 ⇧F1 None Open LuaDoc
None None None About
Movement      
Down
^N
^N
Down
Line down
Shift+Down ⇧⇣
^⇧N
S-Down Line down extend selection
Ctrl+Down ^⇣ ^Down Scroll line down
Alt+Shift+Down ⌥⇧⇣ M-S-Down Line down extend rect. selection
Up
^P
^P
Up
Line up
Shift+Up ⇧⇡
^⇧P
S-Up Line up extend selection
Ctrl+Up ^⇡ ^Up Scroll line up
Alt+Shift+Up ⌥⇧⇡ M-S-Up Line up extend rect. selection
Left
^B
^B
Left
Char left
Shift+Left ⇧⇠
^⇧B
S-Left Char left extend selection
Ctrl+Left ⌥⇠
^⌘B
^Left Word left
Ctrl+Shift+Left ^⇧⇠
^⌘⇧B
S-^Left Word left extend selection
Alt+Shift+Left ⌥⇧⇠ M-S-Left Char left extend rect. selection
Right
^F
^F
Right
Char right
Shift+Right ⇧⇢
^⇧F
S-Right Char right extend selection
Ctrl+Right ⌥⇢
^⌘F
^Right Word right
Ctrl+Shift+Right ^⇧⇢
^⌘⇧F
S-^Right Word right extend selection
Alt+Shift+Right ⌥⇧⇢ M-S-Right Char right extend rect. selection
Home ⌘⇠
^A
^A
Home
Line start
Shift+Home ⌘⇧⇠
^⇧A
M-S-A Line start extend selection
Ctrl+Home ⌘⇡
⌘↖
M-^A Document start
Ctrl+Shift+Home ⌘⇧⇡
⌘⇧↖
None Document start extend selection
Alt+Shift+Home ⌥⇧↖ None Line start extend rect. selection
End ⌘⇢
^E
^E
End
Line end
Shift+End ⌘⇧⇢
^⇧E
M-S-E Line end extend selection
Ctrl+End ⌘⇣
⌘↘
M-^E Document end
Ctrl+Shift+End ⌘⇧⇣
⌘⇧↘
None Document end extend selection
Alt+Shift+End ⌥⇧↘ None Line end extend rect. selection
PgUp PgUp Page up
Shift+PgUp ⇧⇞ M-S-U Page up extend selection
Alt+Shift+PgUp ⌥⇧⇞ None Page up extend rect. selection
PgDn PgDn Page down
Shift+PgDn ⇧⇟ M-S-D Page down extend selection
Alt+Shift+PgDn ⌥⇧⇟ None Page down extend rect. selection
Ctrl+Del ⌘⌦ ^Del Delete word right
Ctrl+Shift+Del ⌘⇧⌦ S-^Del Delete line right
Ins Ins Ins Toggle overtype
Bksp
⇧⌫
^H
Bksp
Delete back
Ctrl+Bksp ⌘⌫ None Delete word left
Ctrl+Shift+Bksp ⌘⇧⌫ None Delete line left
Tab Tab
^I
Insert tab or indent
Shift+Tab ⇧⇥ S-Tab Dedent
None ^K ^K Cut to line end
None ^L None Center line vertically
N/A N/A ^^ Mark text at the caret position
N/A N/A ^] Swap caret and mark anchor
UTF-8 Input      
Ctrl+Shift+U xxxx Enter ⌘⇧U xxxx M-U xxxx Enter Insert U-xxxx char.
Find Fields      
Left
^B
^B
Left
Cursor left
Right
^F
^F
Right
Cursor right
Del Del Delete forward
Bksp ^H
Bksp
Delete back
Ctrl+V ⌘V ^V Paste
N/A N/A ^X Cut all
N/A N/A ^Y Copy all
N/A N/A ^U Erase all
Home
⌘⇠
^A
^A Home
End
⌘⇢
^E
^E End
N/A N/A ^T Transpose characters
N/A N/A Tab Toggle find/replace buttons
Tab Down Focus replace field
Shift+Tab ⇧⇥ Up Focus find field
Up ^P Cycle back through history
Down ^N Cycle forward through history
N/A N/A F1 Toggle “Match Case”
N/A N/A F2 Toggle “Whole Word”
N/A N/A F3 Toggle “Regex”
N/A N/A F4 Toggle “Find in Files”

†: Some terminals interpret ^Z as suspend; see FAQ for workaround.

‡: Ctrl+Enter in Windows terminal version.


The textadept.macros Module


A module for recording, playing, saving, and loading keyboard macros. Menu commands are also recorded. At this time, typing into multiple cursors during macro playback is not supported.

Functions defined by textadept.macros

textadept.macros.load(filename)

Loads a macro from file filename or the user-selected file.

Parameters:

textadept.macros.play()

Plays a recorded or loaded macro.

See also:

textadept.macros.record()

Toggles between starting and stopping macro recording.

textadept.macros.save(filename)

Saves a recorded macro to file filename or the user-selected file.

Parameters:


The textadept.menu Module


Defines the menus used by Textadept. Menus are simply tables of menu items and submenus and may be edited in place. A menu item itself is a table whose first element is a menu label and whose second element is a menu command to run. Submenus have title keys assigned to string text.

Functions defined by textadept.menu

textadept.menu.select_command()

Prompts the user to select a menu command to run.

Tables defined by textadept.menu

textadept.menu.context_menu

The default right-click context menu. Submenus, and menu items can be retrieved by name in addition to table index number.

Usage:

textadept.menu.menubar

The default main menubar. Individual menus, submenus, and menu items can be retrieved by name in addition to table index number.

Usage:

textadept.menu.tab_context_menu

The default tabbar context menu. Submenus, and menu items can be retrieved by name in addition to table index number.


The textadept.run Module


Compile and run source code files with Textadept. Language modules may tweak the compile_commands, run_commands, and error_patterns tables for particular languages. The user may tweak build_commands for particular projects.

Fields defined by textadept.run

textadept.run.MARK_ERROR (number)

The run or compile error marker number.

textadept.run.MARK_WARNING (number)

The run or compile warning marker number.

events.BUILD_OUTPUT (string)

Emitted when executing a project’s build shell command. By default, output is printed to the message buffer. In order to override this behavior, connect to the event with an index of 1 and return true. Arguments:

events.COMPILE_OUTPUT (string)

Emitted when executing a language’s compile shell command. By default, compiler output is printed to the message buffer. In order to override this behavior, connect to the event with an index of 1 and return true. Arguments:

events.RUN_OUTPUT (string)

Emitted when executing a language’s run shell command. By default, output is printed to the message buffer. In order to override this behavior, connect to the event with an index of 1 and return true. Arguments:

textadept.run.run_in_background (bool)

Run shell commands silently in the background. This only applies when the message buffer is open, though it does not have to be visible. The default value is false.

Functions defined by textadept.run

textadept.run.build(root_directory)

Builds the project whose root path is root_directory or the current project using the shell command from the build_commands table. If a “makefile” type of build file is found, prompts the user for the full build command. The current project is determined by either the buffer’s filename or the current working directory. Emits BUILD_OUTPUT events.

Parameters:

See also:

textadept.run.compile(filename)

Compiles file filename or the current file using an appropriate shell command from the compile_commands table. The shell command is determined from the file’s filename, extension, or language in that order. Emits COMPILE_OUTPUT events.

Parameters:

See also:

textadept.run.goto_error(line_num, next)

Jumps to the source of the recognized compile/run warning or error on line number line_num in the message buffer. If line_num is nil, jumps to the next or previous warning or error, depending on boolean next. Displays an annotation with the warning or error message if possible.

Parameters:

See also:

textadept.run.run(filename)

Runs file filename or the current file using an appropriate shell command from the run_commands table. The shell command is determined from the file’s filename, extension, or language in that order. Emits RUN_OUTPUT events.

Parameters:

See also:

textadept.run.stop()

Stops the currently running process, if any.

Tables defined by textadept.run

textadept.run.build_commands

Map of project root paths and “makefiles” to their associated “build” shell command line strings or functions that return such strings. Functions may also return a working directory to operate in. By default, it is the project’s root directory.

textadept.run.compile_commands

Map of filenames, file extensions, and lexer names to their associated “compile” shell command line strings or functions that return such strings. Command line strings may have the following macros:

Functions may also return a working directory to operate in. By default, it is the current file’s parent directory.

textadept.run.error_patterns

Map of file extensions and lexer names to their associated lists of string patterns that match warning and error messages emitted by compile and run commands for those file extensions and lexers. Patterns match single lines and contain captures for a filename, line number, column number (optional), and warning or error message (optional). Double-clicking a warning or error message takes the user to the source of that warning/error. Note: (.-) captures in patterns are interpreted as filenames; (%d+) captures are interpreted as line numbers first, and then column numbers; and any other capture is treated as warning/error message text.

textadept.run.run_commands

Map of filenames, file extensions, and lexer names to their associated “run” shell command line strings or functions that return strings. Command line strings may have the following macros:

Functions may also return a working directory to operate in. By default, it is the current file’s parent directory.


The textadept.session Module


Session support for Textadept.

Fields defined by textadept.session

events.SESSION_LOAD (string)

Emitted when loading a session. Arguments:

events.SESSION_SAVE (string)

Emitted when saving a session. Arguments:

textadept.session.save_on_quit (bool)

Save the session when quitting. The default value is true unless the user passed the command line switch -n or --nosession to Textadept.

Functions defined by textadept.session

textadept.session.load(filename)

Loads session file filename or the user-selected session, returning true if a session file was opened and read. Textadept restores split views, opened buffers, cursor information, recent files, and bookmarks.

Parameters:

Usage:

Return:

textadept.session.save(filename)

Saves the session to file filename or the user-selected file. Saves split views, opened buffers, cursor information, recent files, and bookmarks. Upon quitting, the current session is saved to filename again, unless textadept.session.save_on_quit is false.

Parameters:

Usage:


The textadept.snippets Module


Snippets for Textadept.

Overview

Define snippets in the global snippets table in key-value pairs. Each pair consists of either a string trigger word and its snippet text, or a string lexer name (from the lexers/ directory) with a table of trigger words and snippet texts. When searching for a snippet to insert based on a trigger word, Textadept considers snippets in the current lexer to have priority, followed by the ones in the global table. This means if there are two snippets with the same trigger word, Textadept inserts the one specific to the current lexer, not the global one.

Special Sequences

%n(text)

Represents a placeholder, where n is an integer and text is default placeholder text. Textadept moves the caret to placeholders in numeric order each time it calls textadept.snippets.insert(), finishing at either the “%0” placeholder if it exists or at the end of the snippet. Examples are

snippets['foo'] = 'foobar%1(baz)'
snippets['bar'] = 'start\n\t%0\nend'

%n{list}

Also represents a placeholder (where n is an integer), but presents a list of choices for placeholder text constructed from comma-separated list. Examples are

snippets['op'] = 'operator(%1(1), %2(1), "%3{add,sub,mul,div}")'

%n

Represents a mirror, where n is an integer. Mirrors with the same n as a placeholder mirror any user input in the placeholder. If no placeholder exists for n, the first occurrence of that mirror in the snippet becomes the placeholder, but with no default text. Examples are

snippets['foo'] = '%1(mirror), %1, on the wall'
snippets['q'] = '"%1"'

%n<Lua code>
%n[Shell code]

Represents a transform, where n is an integer that has an associated placeholder, Lua code is arbitrary Lua code, and Shell code is arbitrary Shell code. Textadept executes the code as text is typed into placeholder n. If the transform omits n, Textadept executes the transform’s code the moment the editor inserts the snippet.

Textadept runs Lua code in its Lua State and replaces the transform with the code’s return text. The code may use the temporary text and selected_text global variables which contain placeholder n’s text and the text originally selected when the snippet was inserted, respectively. An example is

snippets['attr'] = [[
%1(int) %2(foo) = %3;

%1 get%2<text:gsub('^.', function(c) return c:upper() end)>() {
	return %2;
}
void set%2<text:gsub('^.', function(c) return c:upper() end)>(%1 value) {
	%2 = value;
}
]]

Textadept executes shell code using Lua’s io.popen() and replaces the transform with the process’ standard output (stdout). The code may use a % character to represent placeholder n’s text. An example is

snippets['env'] = '$%1(HOME) = %1[echo $%]'

%%

Stands for a single ‘%’ since ‘%’ by itself has a special meaning in snippets.

%(
%{

Stands for a single ‘(‘ or ‘{‘, respectively, after a %n mirror. Otherwise, the mirror would be interpreted as a placeholder or transform. Note: it is currently not possible to escape a ‘<’ or ‘[’ immediately after a %n mirror due to %<...> and %[...] sequences being interpreted as code to execute.

\t

A single unit of indentation based on the buffer’s indentation settings (buffer.use_tabs and buffer.tab_width).

\n

A single set of line ending delimiters based on the buffer’s end of line mode (buffer.eol_mode).

Fields defined by textadept.snippets

textadept.snippets.INDIC_PLACEHOLDER (number)

The snippet placeholder indicator number.

textadept.editing.autocompleters.snippet (function)

Autocompleter function for snippet trigger words.

Functions defined by textadept.snippets

textadept.snippets.cancel_current()

Cancels the active snippet, removing all inserted text. Returns false if no snippet is active.

Return:

textadept.snippets.insert(text)

Inserts snippet text text or the snippet assigned to the trigger word behind the caret. Otherwise, if a snippet is active, goes to the active snippet’s next placeholder. Returns false if no action was taken.

Parameters:

Return:

See also:

textadept.snippets.previous()

Jumps back to the previous snippet placeholder, reverting any changes from the current one. Returns false if no snippet is active.

Return:

textadept.snippets.select()

Prompts the user to select a snippet to insert from a list of global and language-specific snippets.

Tables defined by textadept.snippets

_G.snippets

Map of snippet triggers with their snippet text or functions that return such text, with language-specific snippets tables assigned to a lexer name key.

textadept.snippets.paths

List of directory paths to look for snippet files in. Filenames are of the form lexer.trigger.ext or trigger.ext (.ext is an optional, arbitrary file extension). If the global snippets table does not contain a snippet for a given trigger, this table is consulted for a matching filename, and the contents of that file is inserted as a snippet. Note: If a directory has multiple snippets with the same trigger, the snippet chosen for insertion is not defined and may not be constant.


The ui Module


Utilities for interacting with Textadept’s user interface.

Fields defined by ui

ui.buffer_statusbar_text (string, Write-only)

The text displayed in the buffer statusbar.

ui.clipboard_text (string)

The text on the clipboard.

ui.context_menu (userdata)

The buffer’s context menu, a ui.menu(). This is a low-level field. You probably want to use the higher-level textadept.menu.context_menu.

ui.maximized (bool)

Whether or not Textadept’s window is maximized.

ui.silent_print (bool)

Whether or not to print messages to buffers silently. This is not guaranteed to be a constant value, as Textadept may change it for the editor’s own purposes. This flag should be used only in conjunction with a group of ui.print() and ui._print() function calls. The default value is false, and focuses buffers when messages are printed to them.

ui.statusbar_text (string, Write-only)

The text displayed in the statusbar.

ui.tab_context_menu (userdata)

The context menu for the buffer’s tab, a ui.menu(). This is a low-level field. You probably want to use the higher-level textadept.menu.tab_context_menu.

ui.tabs (bool)

Whether or not to display the tab bar when multiple buffers are open. The default value is true.

ui.title (string, Write-only)

The title text of Textadept’s window.

Functions defined by ui

ui._print(buffer_type, …)

Prints the given string messages to the buffer of string type buffer_type. Opens a new buffer for printing messages to if necessary. If the message buffer is already open in a view, the message is printed to that view. Otherwise the view is split (unless ui.tabs is true) and the message buffer is displayed before being printed to.

Parameters:

Usage:

ui.dialog(kind, …)

Low-level function for prompting the user with a gtdialog of kind kind with the given string and table arguments, returning a formatted string of the dialog’s output. You probably want to use the higher-level functions in the ui.dialogs module. Table arguments containing strings are allowed and expanded in place. This is useful for filtered list dialogs with many items.

Parameters:

Return:

ui.get_split_table()

Returns a split table that contains Textadept’s current split view structure. This is primarily used in session saving.

Return:

ui.goto_file(filename, split, preferred_view, sloppy)

Switches to the existing view whose buffer’s filename is filename. If no view was found and split is true, splits the current view in order to show the requested file. If split is false, shifts to the next or preferred_view view in order to show the requested file. If sloppy is true, requires only the basename of filename to match a buffer’s filename. If the requested file was not found, it is opened in the desired view.

Parameters:

ui.goto_view(view)

Shifts to view view or the view view number of views relative to the current one. Emits VIEW_BEFORE_SWITCH and VIEW_AFTER_SWITCH events.

Parameters:

See also:

ui.menu(menu_table)

Low-level function for creating a menu from table menu_table and returning the userdata. You probably want to use the higher-level textadept.menu.menubar, textadept.menu.context_menu, or textadept.menu.tab_context_menu tables. Emits a MENU_CLICKED event when a menu item is selected.

Parameters:

Usage:

See also:

ui.print()

Prints the given string messages to the message buffer. Opens a new buffer if one has not already been opened for printing messages.

Parameters:

ui.switch_buffer(zorder)

Prompts the user to select a buffer to switch to. Buffers are listed in the order they were opened unless zorder is true, in which case buffers are listed by their z-order (most recently viewed to least recently viewed).

Parameters:

ui.update()

Processes pending GTK events, including reading from spawned processes. This function is primarily used in unit tests.

Tables defined by ui

ui.menubar

A table of menus defining a menubar. (Write-only). This is a low-level field. You probably want to use the higher-level textadept.menu.menubar.

See also:

ui.size

A table containing the width and height pixel values of Textadept’s window.


The ui.command_entry Module


Textadept’s Command Entry. It supports multiple modes that each have their own functionality (such as running Lua code and filtering text through shell commands) and history.

Fields defined by ui.command_entry

ui.command_entry.active (boolean)

Whether or not the command entry is active.

ui.command_entry.height (number)

The height in pixels of the command entry.

Functions defined by ui.command_entry

ui.command_entry.focus()

Opens the command entry.

ui.command_entry.run(f, keys, lang, height)

Opens the command entry, subjecting it to any key bindings defined in table keys, highlighting text with lexer name lang, and displaying height number of lines at a time, and then when the Enter key is pressed, closes the command entry and calls function f (if non-nil) with the command entry’s text as an argument. By default with no arguments given, opens a Lua command entry. The command entry does not respond to Textadept’s default key bindings, but instead to the key bindings defined in keys and in ui.command_entry.editing_keys.

Parameters:

Usage:

See also:

Tables defined by ui.command_entry

ui.command_entry.editing_keys

A metatable with typical platform-specific key bindings for text entries. This metatable may be used to add basic editing and movement keys to command entry modes. It is automatically added to command entry modes unless a metatable was previously set.

Usage:


The ui.dialogs Module


Provides a set of interactive dialog prompts for user input.

Functions defined by ui.dialogs

ui.dialogs.colorselect(options)

Prompts the user with a color selection dialog defined by dialog options table options, returning the color selected. If the user canceled the dialog, returns nil.

Parameters:

Usage:

Return:

ui.dialogs.dropdown(options)

Prompts the user with a drop-down item selection dialog defined by dialog options table options, returning the selected button’s index along with the index of the selected item. If options.string_output is true, returns the selected button’s label along with the selected item’s text. If the dialog closed due to options.exit_onchange, returns 4 along with either the selected item’s index or its text. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Usage:

Return:

ui.dialogs.filesave(options)

Prompts the user with a file save dialog defined by dialog options table options, returning the string file chosen. If the user canceled the dialog, returns nil.

Parameters:

Return:

ui.dialogs.fileselect(options)

Prompts the user with a file selection dialog defined by dialog options table options, returning the string file selected. If options.select_multiple is true, returns the list of files selected. If the user canceled the dialog, returns nil.

Parameters:

Usage:

Return:

ui.dialogs.filteredlist(options)

Prompts the user with a filtered list item selection dialog defined by dialog options table options, returning the selected button’s index along with the index or indices of the selected item or items (depending on whether or not options.select_multiple is true). If options.string_output is true, returns the selected button’s label along with the text of the selected item or items. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete". Spaces in the filter text are treated as wildcards.

Parameters:

Usage:

Return:

ui.dialogs.fontselect(options)

Prompts the user with a font selection dialog defined by dialog options table options, returning the font selected (including style and size). If the user canceled the dialog, returns nil.

Parameters:

Usage:

Return:

ui.dialogs.inputbox(options)

Prompts the user with an inputbox dialog defined by dialog options table options, returning the selected button’s index along with the user’s input text (the latter as a string or table, depending on the type of options.informative_text). If options.string_output is true, returns the selected button’s label along with the user’s input text. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Usage:

Return:

ui.dialogs.msgbox(options)

Prompts the user with a generic message box dialog defined by dialog options table options, returning the selected button’s index. If options.string_output is true, returns the selected button’s label. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Usage:

Return:

ui.dialogs.ok_msgbox(options)

Prompts the user with a generic message box dialog defined by dialog options table options and with localized “Ok” and “Cancel” buttons, returning the selected button’s index. If options.string_output is true, returns the selected button’s label. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Return:

ui.dialogs.optionselect(options)

Prompts the user with an option selection dialog defined by dialog options table options, returning the selected button’s index along with the indices of the selected options. If options.string_output is true, returns the selected button’s label along with the text of the selected options. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Usage:

Return:

ui.dialogs.progressbar(options, f)

Displays a progressbar dialog, defined by dialog options table options, that receives updates from function f. Returns “stopped” if options.stoppable is true and the user clicked the “Stop” button. Otherwise, returns nil.

Parameters:

Usage:

Return:

ui.dialogs.secure_inputbox(options)

Prompts the user with a masked inputbox dialog defined by dialog options table options, returning the selected button’s index along with the user’s input text (the latter as a string or table, depending on the type of options.informative_text). If options.string_output is true, returns the selected button’s label along with the user’s input text. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Return:

ui.dialogs.secure_standard_inputbox(options)

Prompts the user with a masked inputbox dialog defined by dialog options table options and with localized “Ok” and “Cancel” buttons, returning the selected button’s index along with the user’s input text (the latter as a string or table, depending on the type of options.informative_text). If options.string_output is true, returns the selected button’s label along with the user’s input text. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Return:

ui.dialogs.standard_dropdown(options)

Prompts the user with a drop-down item selection dialog defined by dialog options table options and with localized “Ok” and “Cancel” buttons, returning the selected button’s index along with the selected item’s index. If options.string_output is true, returns the selected button’s label along with the selected item’s text. If the dialog closed due to options.exit_onchange, returns 4 along with either the selected item’s index or its text. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Return:

ui.dialogs.standard_inputbox(options)

Prompts the user with an inputbox dialog defined by dialog options table options and with localized “Ok” and “Cancel” buttons, returning the selected button’s index along with the user’s input text (the latter as a string or table, depending on the type of options.informative_text). If options.string_output is true, returns the selected button’s label along with the user’s input text. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Return:

ui.dialogs.textbox(options)

Prompts the user with a multiple-line textbox dialog defined by dialog options table options, returning the selected button’s index. If options.string_output is true, returns the selected button’s label. If options.editable is true, also returns the textbox’s text. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Usage:

Return:

ui.dialogs.yesno_msgbox(options)

Prompts the user with a generic message box dialog defined by dialog options table options and with localized “Yes”, “No”, and “Cancel” buttons, returning the selected button’s index. If options.string_output is true, returns the selected button’s label. If the dialog timed out, returns 0 or "timeout". If the user canceled the dialog, returns -1 or "delete".

Parameters:

Return:


The ui.find Module


Textadept’s Find & Replace pane.

Fields defined by ui.find

ui.find.INDIC_FIND (number)

The find results highlight indicator number.

events.FIND_RESULT_FOUND (string)

Emitted when a result is found. It is selected and has been scrolled into view.

events.FIND_WRAPPED (string)

Emitted when a text search wraps (passes through the beginning of the buffer), either from bottom to top (when searching for a next occurrence), or from top to bottom (when searching for a previous occurrence). This is useful for implementing a more visual or audible notice when a search wraps in addition to the statusbar message.

ui.find.active (boolean)

Whether or not the Find & Replace pane is active.

ui.find.find_entry_text (string)

The text in the “Find” entry.

ui.find.find_label_text (string, Write-only)

The text of the “Find” label. This is primarily used for localization.

ui.find.find_next_button_text (string, Write-only)

The text of the “Find Next” button. This is primarily used for localization.

ui.find.find_prev_button_text (string, Write-only)

The text of the “Find Prev” button. This is primarily used for localization.

ui.find.highlight_all_matches (boolean)

Whether or not to highlight all occurrences of found text in the current buffer. The default value is false.

ui.find.in_files (bool)

Find search text in a directory of files. The default value is false.

ui.find.in_files_label_text (string, Write-only)

The text of the “In files” label. This is primarily used for localization.

ui.find.incremental (bool)

Find search text incrementally as it is typed. The default value is false.

ui.find.match_case (bool)

Match search text case sensitively. The default value is false.

ui.find.match_case_label_text (string, Write-only)

The text of the “Match case” label. This is primarily used for localization.

ui.find.regex (bool)

Interpret search text as a Regular Expression. The default value is false.

ui.find.regex_label_text (string, Write-only)

The text of the “Regex” label. This is primarily used for localization.

ui.find.replace_all_button_text (string, Write-only)

The text of the “Replace All” button. This is primarily used for localization.

ui.find.replace_button_text (string, Write-only)

The text of the “Replace” button. This is primarily used for localization.

ui.find.replace_entry_text (string)

The text in the “Replace” entry. When searching for text in a directory of files, this is the current file and directory filter.

ui.find.replace_label_text (string, Write-only)

The text of the “Replace” label. This is primarily used for localization.

ui.find.whole_word (bool)

Match search text only when it is surrounded by non-word characters in searches. The default value is false.

ui.find.whole_word_label_text (string, Write-only)

The text of the “Whole word” label. This is primarily used for localization.

Functions defined by ui.find

ui.find.find_in_files(dir, filter)

Searches directory dir or the user-specified directory for files that match search text and search options (subject to optional filter filter), and prints the results to a buffer titled “Files Found”, highlighting found text. Use the find_entry_text, match_case, whole_word, and regex fields to set the search text and option flags, respectively. A filter determines which files to search in, with the default filter being ui.find.find_in_files_filters[dir] (if it exists) or lfs.default_filter. A filter consists of Lua patterns that match file and directory paths to include or exclude. Patterns are inclusive by default. Exclusive patterns begin with a ‘!’. If no inclusive patterns are given, any filename is initially considered. As a convenience, file extensions can be specified literally instead of as a Lua pattern (e.g. ‘.lua’ vs. ‘%.lua$’), and ‘/’ also matches the Windows directory separator (‘[/\]’ is not needed). If filter is nil, the filter from the ui.find.find_in_files_filters table for dir is used. If that filter does not exist, lfs.default_filter is used.

Parameters:

See also:

ui.find.find_next()

Mimics pressing the “Find Next” button.

ui.find.find_prev()

Mimics pressing the “Find Prev” button.

ui.find.focus(options)

Displays and focuses the Find & Replace Pane.

Parameters:

ui.find.goto_file_found(line_num, next)

Jumps to the source of the find in files search result on line number line_num in the buffer titled “Files Found” or, if line_num is nil, jumps to the next or previous search result, depending on boolean next.

Parameters:

ui.find.replace()

Mimics pressing the “Replace” button.

ui.find.replace_all()

Mimics pressing the “Replace All” button.

Tables defined by ui.find

ui.find.find_in_files_filters

Map of directory paths to filters used in ui.find.find_in_files(). This table is updated when the user manually specifies a filter in the “Filter” entry during an “In files” search.

See also:


The view Module


A Textadept view object. Constants are documented in the fields they apply to. While you can work with individual view instances, it is often useful to work with just the global one. Many of these functions and fields are derived from view-specific functionality of the Scintilla editing component, and additional information can be found on the Scintilla website. Note that with regard to Scintilla-specific functionality, this API is a suggestion, not a hard requirement. All of that functionality also exists in buffer, even if undocumented. Any view fields set on startup (e.g. in ~/.textadept/init.lua) will be the default, initial values for all views.

Fields defined by view

view.ALPHA_NOALPHA (number, Read-only)

view.ALPHA_OPAQUE (number, Read-only)

view.ALPHA_TRANSPARENT (number, Read-only)

view.ANNOTATION_BOXED (number, Read-only)

view.ANNOTATION_HIDDEN (number, Read-only)

view.ANNOTATION_INDENTED (number, Read-only)

view.ANNOTATION_STANDARD (number, Read-only)

view.CARETSTYLE_BLOCK (number, Read-only)

view.CARETSTYLE_INVISIBLE (number, Read-only)

view.CARETSTYLE_LINE (number, Read-only)

view.CARET_EVEN (number, Read-only)

view.CARET_JUMPS (number, Read-only)

view.CARET_SLOP (number, Read-only)

view.CARET_STRICT (number, Read-only)

view.CASE_CAMEL (number, Read-only)

view.CASE_LOWER (number, Read-only)

view.CASE_MIXED (number, Read-only)

view.CASE_UPPER (number, Read-only)

view.CURSORARROW (number, Read-only)

view.CURSORNORMAL (number, Read-only)

view.CURSORREVERSEARROW (number, Read-only)

view.CURSORWAIT (number, Read-only)

view.EDGE_BACKGROUND (number, Read-only)

view.EDGE_LINE (number, Read-only)

view.EDGE_MULTILINE (number, Read-only)

view.EDGE_NONE (number, Read-only)

view.FOLDACTION_CONTRACT (number, Read-only)

view.FOLDACTION_EXPAND (number, Read-only)

view.FOLDACTION_TOGGLE (number, Read-only)

view.FOLDDISPLAYTEXT_BOXED (number, Read-only)

view.FOLDDISPLAYTEXT_HIDDEN (number, Read-only)

view.FOLDDISPLAYTEXT_STANDARD (number, Read-only)

view.FOLDFLAG_LEVELNUMBERS (number, Read-only)

view.FOLDFLAG_LINEAFTER_CONTRACTED (number, Read-only)

view.FOLDFLAG_LINEAFTER_EXPANDED (number, Read-only)

view.FOLDFLAG_LINEBEFORE_CONTRACTED (number, Read-only)

view.FOLDFLAG_LINEBEFORE_EXPANDED (number, Read-only)

view.FOLDFLAG_LINESTATE (number, Read-only)

view.INDIC_BOX (number, Read-only)

view.INDIC_COMPOSITIONTHICK (number, Read-only)

view.INDIC_COMPOSITIONTHIN (number, Read-only)

view.INDIC_DASH (number, Read-only)

view.INDIC_DIAGONAL (number, Read-only)

view.INDIC_DOTBOX (number, Read-only)

view.INDIC_DOTS (number, Read-only)

view.INDIC_FULLBOX (number, Read-only)

view.INDIC_GRADIENT (number, Read-only)

view.INDIC_GRADIENTCENTER (number, Read-only)

view.INDIC_HIDDEN (number, Read-only)

view.INDIC_PLAIN (number, Read-only)

view.INDIC_POINT (number, Read-only)

view.INDIC_POINTCHARACTER (number, Read-only)

view.INDIC_ROUNDBOX (number, Read-only)

view.INDIC_SQUIGGLE (number, Read-only)

view.INDIC_SQUIGGLELOW (number, Read-only)

view.INDIC_SQUIGGLEPIXMAP (number, Read-only)

view.INDIC_STRAIGHTBOX (number, Read-only)

view.INDIC_STRIKE (number, Read-only)

view.INDIC_TEXTFORE (number, Read-only)

view.INDIC_TT (number, Read-only)

view.IV_LOOKBOTH (number, Read-only)

view.IV_LOOKFORWARD (number, Read-only)

view.IV_NONE (number, Read-only)

view.IV_REAL (number, Read-only)

view.MARGINOPTION_NONE (number, Read-only)

view.MARGINOPTION_SUBLINESELECT (number, Read-only)

view.MARGIN_BACK (number, Read-only)

view.MARGIN_COLOR (number, Read-only)

view.MARGIN_FORE (number, Read-only)

view.MARGIN_NUMBER (number, Read-only)

view.MARGIN_RTEXT (number, Read-only)

view.MARGIN_SYMBOL (number, Read-only)

view.MARGIN_TEXT (number, Read-only)

view.MARK_ARROW (number, Read-only)

view.MARK_ARROWDOWN (number, Read-only)

view.MARK_ARROWS (number, Read-only)

view.MARK_BACKGROUND (number, Read-only)

view.MARK_BOOKMARK (number, Read-only)

view.MARK_BOXMINUS (number, Read-only)

view.MARK_BOXMINUSCONNECTED (number, Read-only)

view.MARK_BOXPLUS (number, Read-only)

view.MARK_BOXPLUSCONNECTED (number, Read-only)

view.MARK_CHARACTER (number, Read-only)

view.MARK_CIRCLE (number, Read-only)

view.MARK_CIRCLEMINUS (number, Read-only)

view.MARK_CIRCLEMINUSCONNECTED (number, Read-only)

view.MARK_CIRCLEPLUS (number, Read-only)

view.MARK_CIRCLEPLUSCONNECTED (number, Read-only)

view.MARK_DOTDOTDOT (number, Read-only)

view.MARK_EMPTY (number, Read-only)

view.MARK_FULLRECT (number, Read-only)

view.MARK_LCORNER (number, Read-only)

view.MARK_LCORNERCURVE (number, Read-only)

view.MARK_LEFTRECT (number, Read-only)

view.MARK_MINUS (number, Read-only)

view.MARK_PIXMAP (number, Read-only)

view.MARK_PLUS (number, Read-only)

view.MARK_RGBAIMAGE (number, Read-only)

view.MARK_ROUNDRECT (number, Read-only)

view.MARK_SHORTARROW (number, Read-only)

view.MARK_SMALLRECT (number, Read-only)

view.MARK_TCORNER (number, Read-only)

view.MARK_TCORNERCURVE (number, Read-only)

view.MARK_UNDERLINE (number, Read-only)

view.MARK_VERTICALBOOKMARK (number, Read-only)

view.MARK_VLINE (number, Read-only)

view.MASK_FOLDERS (number, Read-only)

view.MOD_ALT (number, Read-only)

view.MOD_CTRL (number, Read-only)

view.MOD_META (number, Read-only)

view.MOD_SHIFT (number, Read-only)

view.MOD_SUPER (number, Read-only)

view.MOUSE_DRAG (number, Read-only)

view.MOUSE_PRESS (number, Read-only)

view.MOUSE_RELEASE (number, Read-only)

view.STYLE_BRACEBAD (number, Read-only)

view.STYLE_BRACELIGHT (number, Read-only)

view.STYLE_CALLTIP (number, Read-only)

view.STYLE_CONTROLCHAR (number, Read-only)

view.STYLE_DEFAULT (number, Read-only)

view.STYLE_FOLDDISPLAYTEXT (number, Read-only)

view.STYLE_INDENTGUIDE (number, Read-only)

view.STYLE_LINENUMBER (number, Read-only)

view.STYLE_MAX (number, Read-only)

view.TD_LONGARROW (number, Read-only)

view.TD_STRIKEOUT (number, Read-only)

view.TIME_FOREVER (number, Read-only)

view.UPDATE_H_SCROLL (number, Read-only)

view.UPDATE_V_SCROLL (number, Read-only)

view.VISIBLE_SLOP (number, Read-only)

view.VISIBLE_STRICT (number, Read-only)

view.WRAPINDENT_DEEPINDENT (number, Read-only)

view.WRAPINDENT_FIXED (number, Read-only)

view.WRAPINDENT_INDENT (number, Read-only)

view.WRAPINDENT_SAME (number, Read-only)

view.WRAPVISUALFLAGLOC_DEFAULT (number, Read-only)

view.WRAPVISUALFLAGLOC_END_BY_TEXT (number, Read-only)

view.WRAPVISUALFLAGLOC_START_BY_TEXT (number, Read-only)

view.WRAPVISUALFLAG_END (number, Read-only)

view.WRAPVISUALFLAG_MARGIN (number, Read-only)

view.WRAPVISUALFLAG_NONE (number, Read-only)

view.WRAPVISUALFLAG_START (number, Read-only)

view.WRAP_CHAR (number, Read-only)

view.WRAP_NONE (number, Read-only)

view.WRAP_WHITESPACE (number, Read-only)

view.WRAP_WORD (number, Read-only)

view.WS_INVISIBLE (number, Read-only)

view.WS_VISIBLEAFTERINDENT (number, Read-only)

view.WS_VISIBLEALWAYS (number, Read-only)

view.WS_VISIBLEONLYININDENT (number, Read-only)

view.additional_caret_fore (number)

The foreground color, in “0xBBGGRR” format, of additional carets.

Allow additional carets to blink. The default value is true.

view.additional_carets_visible (bool)

Display additional carets. The default value is true.

view.additional_sel_alpha (number)

The alpha value, ranging from 0 (transparent) to 255 (opaque), of additional selections. The default value is view.ALPHA_NOALPHA, for no alpha.

view.additional_sel_back (number, Write-only)

The background color, in “0xBBGGRR” format, of additional selections. This field has no effect when calling view:set_sel_back(false, ...).

view.additional_sel_fore (number, Write-only)

The foreground color, in “0xBBGGRR” format, of additional selections. This field has no effect when calling view:set_sel_fore(false, ...).

view.all_lines_visible (bool, Read-only)

Whether or not all lines are visible.

view.annotation_visible (number)

The annotation visibility mode.

The default value is view.ANNOTATION_HIDDEN.

view.auto_c_max_height (number)

The maximum number of items per page to show in autocompletion and user lists. The default value is 5.

view.auto_c_max_width (number)

The maximum number of characters per item to show in autocompletion and user lists. The default value is 0, which automatically sizes the width to fit the longest item.

view.call_tip_fore_hlt (number, Write-only)

A call tip’s highlighted text foreground color, in “0xBBGGRR” format.

view.call_tip_pos_start (number, Write-only)

The position in which backspacing beyond it hides a visible call tip.

view.call_tip_position (boolean)

Display a call tip above the current line instead of below it. The default value is false.

view.call_tip_use_style (number)

The pixel width of tab characters in call tips. When non-zero, also enables the use of style number view.STYLE_CALLTIP instead of view.STYLE_DEFAULT for call tip styles. The default value is 0.

view.caret_fore (number)

The caret’s foreground color, in “0xBBGGRR” format.

view.caret_line_back (number)

The background color, in “0xBBGGRR” format, of the line that contains the caret.

view.caret_line_back_alpha (number)

The caret line’s background alpha value, ranging from 0 (transparent) to 255 (opaque). The default value is view.ALPHA_NOALPHA, for no alpha.

view.caret_line_frame (number)

The caret line’s frame width in pixels. When non-zero, the line that contains the caret is framed instead of colored in. The view.caret_line_back and view.caret_line_back_alpha properties apply to the frame. The default value is 0.

view.caret_line_visible (bool)

Color the background of the line that contains the caret a different color. The default value is false.

view.caret_line_visible_always (bool)

Always show the caret line, even when the window is not in focus. The default value is false, showing the line only when the window is in focus.

view.caret_period (number)

The time between caret blinks in milliseconds. A value of 0 stops blinking. The default value is 500.

view.caret_style (number)

The caret’s visual style.

Any block setting may be combined with view.CARETSTYLE_BLOCK_AFTER via bitwise OR (|) in order to draw the caret after the end of a selection, as opposed to just inside it.

The default value is view.CARETSTYLE_LINE.

view.caret_width (number)

The line caret’s pixel width in insert mode, between 0 and 20. The default value is 1.

view.cursor (number)

The display cursor type.

The default value is view.CURSORNORMAL.

view.edge_color (number)

The color, in “0xBBGGRR” format, of the single edge or background for long lines according to view.edge_mode.

view.edge_column (number)

The column number to mark long lines at.

view.edge_mode (number)

The long line mark mode.

view.end_at_last_line (bool)

Disable scrolling past the last line. The default value is true.

view.eol_annotation_visible (number)

The EOL annotation visibility mode.

The default value is view.EOLANNOTATION_HIDDEN.

view.extra_ascent (number)

The amount of pixel padding above lines. The default value is 0.

view.extra_descent (number)

The amount of pixel padding below lines. The default is 0.

view.first_visible_line (number)

The line number of the line at the top of the view.

view.fold_display_text_style (number)

The fold display text mode.

The default value is view.FOLDDISPLAYTEXT_HIDDEN.

view.fold_expanded (table)

Table of flags per line number that indicate whether or not fold points are expanded for those line numbers. Setting expanded fold states does not toggle folds; it only updates fold margin markers. Use view.toggle_fold() instead.

view.fold_flags (number, Read-only)

Bit-mask of folding lines to draw in the buffer.

The default value is 0.

view.h_scroll_bar (bool)

Display the horizontal scroll bar. The default value is true.

view.highlight_guide (number)

The indentation guide column number to also highlight when highlighting matching braces, or 0 to stop indentation guide highlighting.

view.idle_styling (number)

The idle styling mode. This mode has no effect when view.wrap_mode is on.

The default value is view.IDLESTYLING_NONE.

view.indentation_guides (number)

The indentation guide drawing mode. Indentation guides are dotted vertical lines that appear within indentation whitespace at each level of indentation.

The default value is view.IV_NONE.

view.indic_alpha (table)

Table of fill color alpha values, ranging from 0 (transparent) to 255 (opaque), for indicator numbers from 1 to 32 whose styles are either INDIC_ROUNDBOX, INDIC_STRAIGHTBOX, or INDIC_DOTBOX. The default values are view.ALPHA_NOALPHA, for no alpha.

view.indic_fore (table)

Table of foreground colors, in “0xBBGGRR” format, for indicator numbers from 1 to 32. Changing an indicator’s foreground color resets that indicator’s hover foreground color.

view.indic_hover_fore (table)

Table of hover foreground colors, in “0xBBGGRR” format, for indicator numbers from 1 to 32. The default values are the respective indicator foreground colors.

view.indic_hover_style (table)

Table of hover styles for indicators numbers from 1 to 32. An indicator’s hover style drawn when either the cursor hovers over that indicator or the caret is within that indicator. The default values are the respective indicator styles.

view.indic_outline_alpha (table)

Table of outline color alpha values, ranging from 0 (transparent) to 255 (opaque), for indicator numbers from 1 to 32 whose styles are either INDIC_ROUNDBOX, INDIC_STRAIGHTBOX, or INDIC_DOTBOX. The default values are view.ALPHA_NOALPHA, for no alpha.

view.indic_style (table)

Table of styles for indicator numbers from 1 to 32.

Use _SCINTILLA.next_indic_number() for custom indicators. Changing an indicator’s style resets that indicator’s hover style.

view.indic_under (table)

Table of flags that indicate whether or not to draw indicators behind text instead of over the top of it for indicator numbers from 1 to 32. The default values are false.

view.line_visible (table, Read-only)

Table of flags per line number that indicate whether or not lines are visible for those line numbers.

view.lines_on_screen (number, Read-only)

The number of completely visible lines in the view. It is possible to have a partial line visible at the bottom of the view.

view.margin_back_n (table)

Table of background colors, in “0xBBGGRR” format, of margin numbers from 1 to view.margins (5 by default). Only affects margins of type view.MARGIN_COLOR.

view.margin_cursor_n (table)

Table of cursor types shown over margin numbers from 1 to view.margins (5 by default).

The default values are view.CURSORREVERSEARROW.

view.margin_left (number)

The pixel size of the left margin of the buffer text. The default value is 1.

view.margin_mask_n (table)

Table of bit-masks of markers whose symbols marker symbol margins can display for margin numbers from 1 to view.margins (5 by default). Bit-masks are 32-bit values whose bits correspond to the 32 available markers. The default values are 0, view.MASK_FOLDERS, 0, 0, and 0, for a line margin and logical marker margin.

view.margin_options (number)

A bit-mask of margin option settings.

The default value is view.MARGINOPTION_NONE.

view.margin_right (number)

The pixel size of the right margin of the buffer text. The default value is 1.

view.margin_sensitive_n (table)

Table of flags that indicate whether or not mouse clicks in margins emit MARGIN_CLICK events for margin numbers from 1 to view.margins (5 by default). The default values are false.

view.margin_type_n (table)

Table of margin types for margin numbers from 1 to view.margins (5 by default).

The default value for the first margin is view.MARGIN_NUMBER, followed by view.MARGIN_SYMBOL for the rest.

view.margin_width_n (table)

Table of pixel margin widths for margin numbers from 1 to view.margins (5 by default).

view.margins (number)

The number of margins. The default value is 5.

view.marker_alpha (table, Write-only)

Table of alpha values, ranging from 0 (transparent) to 255 (opaque), of markers drawn in the text area (not the margin) for markers numbers from 1 to 32. The default values are view.ALPHA_NOALPHA, for no alpha.

view.marker_back (table, Write-only)

Table of background colors, in “0xBBGGRR” format, of marker numbers from 1 to 32.

view.marker_back_selected (table, Write-only)

Table of background colors, in “0xBBGGRR” format, of markers whose folding blocks are selected for marker numbers from 1 to 32.

view.marker_fore (table, Write-only)

Table of foreground colors, in “0xBBGGRR” format, of marker numbers from 1 to 32.

view.mouse_dwell_time (number)

The number of milliseconds the mouse must idle before generating a DWELL_START event. A time of view.TIME_FOREVER will never generate one.

view.mouse_selection_rectangular_switch (bool)

Whether or not pressing view.rectangular_selection_modifier when selecting text normally with the mouse turns on rectangular selection. The default value is false.

view.property (table)

Map of key-value string pairs used by lexers.

view.property_expanded (table, Read-only)

Map of key-value string pairs used by lexers with $() and %() variable replacement performed in values.

view.property_int (table, Read-only)

Map of key-value pairs used by lexers with values interpreted as numbers, or 0 if not found.

view.rectangular_selection_modifier (number)

The modifier key used in combination with a mouse drag in order to create a rectangular selection.

The default value is view.MOD_CTRL.

view.representation (table)

The alternative string representations of characters. Representations are displayed in the same way control characters are. Use the empty string for the ‘\0’ character when assigning its representation. Characters are strings, not numeric codes. Call view.clear_representation() to remove a representation.

view.rgba_image_height (number)

The height of the RGBA image to be defined using view.marker_define_rgba_image().

view.rgba_image_scale (number)

The scale factor in percent of the RGBA image to be defined using view.marker_define_rgba_image(). This is useful on macOS with a retina display where each display unit is 2 pixels: use a factor of 200 so that each image pixel is displayed using a screen pixel. The default scale, 100, will stretch each image pixel to cover 4 screen pixels on a retina display.

view.rgba_image_width (number)

The width of the RGBA image to be defined using view.marker_define_rgba_image() and view.register_rgba_image().

view.scroll_width (number)

The horizontal scrolling pixel width. For performance, the view does not measure the display width of the buffer to determine the properties of the horizontal scroll bar, but uses an assumed width instead. To ensure the width of the currently visible lines can be scrolled use view.scroll_width_tracking. The default value is 2000.

view.scroll_width_tracking (bool)

Continuously update the horizontal scrolling width to match the maximum width of a displayed line beyond view.scroll_width. The default value is false.

view.sel_alpha (number)

The selection’s alpha value, ranging from 0 (transparent) to 255 (opaque). The default value is view.ALPHA_NOALPHA, for no alpha.

view.sel_eol_filled (bool)

Extend the selection to the view’s right margin. The default value is false.

view.size (number)

The split resizer’s pixel position if the view is a split one.

view.style_back (table)

Table of background colors, in “0xBBGGRR” format, of text for style numbers from 1 to 256.

view.style_bold (table)

Table of flags that indicate whether or not text is bold for style numbers from 1 to 256. The default values are false.

view.style_case (table)

Table of letter case modes of text for style numbers from 1 to 256.

The default values are view.CASE_MIXED.

view.style_changeable (table)

Table of flags that indicate whether or not text is changeable for style numbers from 1 to 256. The default values are true. Read-only styles do not allow the caret into the range of text.

view.style_eol_filled (table)

Table of flags that indicate whether or not the background colors of styles whose characters occur last on lines extend all the way to the view’s right margin for style numbers from 1 to 256. The default values are false.

view.style_font (table)

Table of string font names of text for style numbers from 1 to 256.

view.style_fore (table)

Table of foreground colors, in “0xBBGGRR” format, of text for style numbers from 1 to 256.

view.style_italic (table)

Table of flags that indicate whether or not text is italic for style numbers from 1 to 256. The default values are false.

view.style_size (table)

Table of font sizes of text for style numbers from 1 to 256.

view.style_underline (table)

Table of flags that indicate whether or not text is underlined for style numbers from 1 to 256. The default values are false.

view.style_visible (table)

Table of flags that indicate whether or not text is visible for style numbers from 1 to 256. The default values are true.

view.tab_draw_mode (number)

The draw mode of visible tabs.

The default value is view.TD_LONGARROW.

view.v_scroll_bar (bool)

Display the vertical scroll bar. The default value is true.

view.view_eol (bool)

Display end of line characters. The default value is false.

view.view_ws (number)

The whitespace visibility mode.

The default value is view.WS_INVISIBLE.

view.whitespace_size (number)

The pixel size of the dots that represent space characters when whitespace is visible. The default value is 1.

view.wrap_indent_mode (number)

The wrapped line indent mode.

The default value is view.WRAPINDENT_FIXED.

view.wrap_mode (number)

Long line wrap mode.

The default value is view.WRAP_NONE.

view.wrap_start_indent (number)

The number of spaces of indentation to display wrapped lines with if view.wrap_indent_mode is view.WRAPINDENT_FIXED. The default value is 0.

view.wrap_visual_flags (number)

The wrapped line visual flag display mode.

The default value is view.WRAPVISUALFLAG_NONE.

view.wrap_visual_flags_location (number)

The wrapped line visual flag location.

The default value is view.WRAPVISUALFLAGLOC_DEFAULT.

view.x_offset (number)

The horizontal scroll pixel position. A value of 0 is the normal position with the first text column visible at the left of the view.

view.zoom (number)

The number of points to add to the size of all fonts. Negative values are allowed, down to -10. The default value is 0.

Functions defined by view

view.brace_bad_light(view, pos)

Highlights the character at position pos as an unmatched brace character using the 'style.bracebad' style. Removes highlighting when pos is -1.

Parameters:

view.brace_bad_light_indicator(view, use_indicator, indicator)

Highlights unmatched brace characters with indicator number indicator, in the range of 1 to 32, instead of the view.STYLE_BRACEBAD style if use_indicator is true.

Parameters:

view.brace_highlight(view, pos1, pos2)

Highlights the characters at positions pos1 and pos2 as matching braces using the 'style.bracelight' style. If indent guides are enabled, locates the column with buffer.column and sets view.highlight_guide in order to highlight the indent guide.

Parameters:

view.brace_highlight_indicator(view, use_indicator, indicator)

Highlights matching brace characters with indicator number indicator, in the range of 1 to 32, instead of the view.STYLE_BRACELIGHT style if use_indicator is true.

Parameters:

view.call_tip_active(view)

Returns whether or not a call tip is visible.

Parameters:

Return:

view.call_tip_cancel(view)

Removes the displayed call tip from view.

Parameters:

view.call_tip_pos_start(view)

Returns a call tip’s display position.

Parameters:

Return:

view.call_tip_set_hlt(view, start_pos, end_pos)

Highlights a call tip’s text between positions start_pos to end_pos with the color view.call_tip_fore_hlt.

Parameters:

view.call_tip_show(view, pos, text)

Displays a call tip at position pos with string text as the call tip’s contents. Any “\001” or “\002” bytes in text are replaced by clickable up or down arrow visuals, respectively. These may be used to indicate that a symbol has more than one call tip, for example.

Parameters:

view.clear_registered_images(view)

Clears all images registered using view.register_image() and view.register_rgba_image().

Parameters:

view.clear_representation(view, char)

Removes the alternate string representation for character char.

Parameters:

view.contracted_fold_next(view, line)

Returns the line number of the next contracted fold point starting from line number line, or -1 if none exists.

Parameters:

Return:

view.doc_line_from_visible(view, display_line)

Returns the actual line number of displayed line number display_line, taking wrapped, annotated, and hidden lines into account. If display_line is less than or equal to 1, returns 1. If display_line is greater than the number of displayed lines, returns buffer.line_count.

Parameters:

Return:

view.ensure_visible(view, line)

Ensures line number line is visible by expanding any fold points hiding it.

Parameters:

view.ensure_visible_enforce_policy(view, line)

Ensures line number line is visible by expanding any fold points hiding it based on the vertical caret policy previously defined in view.set_visible_policy().

Parameters:

view.fold_all(view, action)

Contracts, expands, or toggles all fold points, depending on action. When toggling, the state of the first fold point determines whether to expand or contract.

Parameters:

view.fold_children(view, line, action)

Contracts, expands, or toggles the fold point on line number line, as well as all of its children, depending on action.

Parameters:

view.fold_line(view, line, action)

Contracts, expands, or toggles the fold point on line number line, depending on action.

Parameters:

view.get_default_fold_display_text(view)

Returns the default fold display text.

Parameters:

view.goto_buffer(view, buffer)

Switches to buffer buffer or the buffer buffer number of buffers relative to the current one. Emits BUFFER_BEFORE_SWITCH and BUFFER_AFTER_SWITCH events.

Parameters:

See also:

view.hide_lines(view, start_line, end_line)

Hides the range of lines between line numbers start_line to end_line. This has no effect on fold levels or fold flags and the first line cannot be hidden.

Parameters:

view.line_scroll(view, columns, lines)

Scrolls the buffer right columns columns and down lines lines. Negative values are allowed.

Parameters:

view.line_scroll_down(view)

Scrolls the buffer down one line, keeping the caret visible.

Parameters:

view.line_scroll_up(view)

Scrolls the buffer up one line, keeping the caret visible.

Parameters:

view.marker_define(view, marker, symbol)

Assigns marker symbol symbol to marker number marker, in the range of 1 to 32. symbol is shown in marker symbol margins next to lines marked with marker.

Parameters:

See also:

view.marker_define_pixmap(view, marker, pixmap)

Associates marker number marker, in the range of 1 to 32, with XPM image pixmap. The view.MARK_PIXMAP marker symbol must be assigned to marker. pixmap is shown in marker symbol margins next to lines marked with marker.

Parameters:

view.marker_define_rgba_image(view, marker, pixels)

Associates marker number marker, in the range of 1 to 32, with RGBA image pixels. The dimensions for pixels (view.rgba_image_width and view.rgba_image_height) must have already been defined. pixels is a sequence of 4 byte pixel values (red, blue, green, and alpha) defining the image line by line starting at the top-left pixel. The view.MARK_RGBAIMAGE marker symbol must be assigned to marker. pixels is shown in symbol margins next to lines marked with marker.

Parameters:

view.marker_enable_highlight(view, enabled)

Highlights the margin fold markers for the current fold block if enabled is true.

Parameters:

view.marker_symbol_defined(view, marker)

Returns the symbol assigned to marker number marker, in the range of 1 to 32, used in view.marker_define(), view.marker_define_pixmap(), or view.marker_define_rgba_image().

Parameters:

Return:

view.multi_edge_add_line(view, column, color)

Adds a new vertical line at column number column with color color, in “0xBBGGRR” format.

Parameters:

view.multi_edge_clear_all(view)

Clears all vertical lines created by view:multi_edge_add_line().

Parameters:

view.register_image(view, type, xpm_data)

Registers XPM image xpm_data to type number type for use in autocompletion and user lists.

Parameters:

view.register_rgba_image(view, type, pixels)

Registers RGBA image pixels to type number type for use in autocompletion and user lists. The dimensions for pixels (view.rgba_image_width and view.rgba_image_height) must have already been defined. pixels is a sequence of 4 byte pixel values (red, blue, green, and alpha) defining the image line by line starting at the top-left pixel.

Parameters:

view.scroll_caret(view)

Scrolls the caret into view based on the policies previously defined in view.set_x_caret_policy() and view.set_y_caret_policy().

Parameters:

See also:

view.scroll_range(view, secondary_pos, primary_pos)

Scrolls into view the range of text between positions primary_pos and secondary_pos, with priority given to primary_pos. Similar to view.scroll_caret(), but with primary_pos instead of buffer.current_pos. This is useful for scrolling search results into view.

Parameters:

view.scroll_to_end(view)

Scrolls to the end of the buffer without moving the caret.

Parameters:

view.scroll_to_start(view)

Scrolls to the beginning of the buffer without moving the caret.

Parameters:

view.set_default_fold_display_text(view, text)

Sets the default fold display text to string text.

Parameters:

See also:

view.set_fold_margin_color(view, use_setting, color)

Overrides the fold margin’s default color with color color, in “0xBBGGRR” format, if use_setting is true.

Parameters:

view.set_fold_margin_hi_color(view, use_setting, color)

Overrides the fold margin’s default highlight color with color color, in “0xBBGGRR” format, if use_setting is true.

Parameters:

view.set_sel_back(view, use_setting, color)

Overrides the selection’s default background color with color color, in “0xBBGGRR” format, if use_setting is true. Overwrites any existing view.additional_sel_back color.

Parameters:

view.set_sel_fore(view, use_setting, color)

Overrides the selection’s default foreground color with color color, in “0xBBGGRR” format, if use_setting is true. Overwrites any existing view.additional_sel_fore color.

Parameters:

view.set_theme(view, name, env)

Sets the view’s color theme to be string name, with the contents of table env available as global variables. User themes override Textadept’s default themes when they have the same name. If name contains slashes, it is assumed to be an absolute path to a theme instead of a theme name.

Parameters:

Usage:

See also:

view.set_visible_policy(view, policy, y)

Defines scrolling policy bit-mask policy as the policy for keeping the caret y number of lines away from the vertical margins as view.ensure_visible_enforce_policy() redisplays hidden or folded lines. It is similar in operation to view.set_y_caret_policy().

Parameters:

view.set_whitespace_back(view, use_setting, color)

Overrides the background color of whitespace with color color, in “0xBBGGRR” format, if use_setting is true.

Parameters:

view.set_whitespace_fore(view, use_setting, color)

Overrides the foreground color of whitespace with color color, in “0xBBGGRR” format, if use_setting is true.

Parameters:

view.set_x_caret_policy(view, policy, x)

Defines scrolling policy bit-mask policy as the policy for keeping the caret x number of pixels away from the horizontal margins.

Parameters:

view.set_y_caret_policy(view, policy, y)

Defines scrolling policy bit-mask policy as the policy for keeping the caret y number of lines away from the vertical margins.

Parameters:

view.show_lines(view, start_line, end_line)

Shows the range of lines between line numbers start_line to end_line. This has no effect on fold levels or fold flags and the first line cannot be hidden.

Parameters:

view.split(view, vertical)

Splits the view into top and bottom views (unless vertical is true), focuses the new view, and returns both the old and new views. If vertical is false, splits the view vertically into left and right views. Emits a VIEW_NEW event.

Parameters:

Return:

See also:

view.style_clear_all(view)

Reverts all styles to having the same properties as view.STYLE_DEFAULT.

Parameters:

view.style_reset_default(view)

Resets view.STYLE_DEFAULT to its initial state.

Parameters:

view.text_height(view, line)

Returns the pixel height of line number line.

Parameters:

Return:

view.text_width(view, style_num, text)

Returns the pixel width string text would have when styled with style number style_num, in the range of 1 to 256.

Parameters:

Return:

view.toggle_fold(view, line)

Toggles the fold point on line number line between expanded (where all of its child lines are displayed) and contracted (where all of its child lines are hidden).

Parameters:

See also:

view.toggle_fold_show_text(view, line, text)

Toggles a fold point on line number line between expanded (where all of its child lines are displayed) and contracted (where all of its child lines are hidden), and shows string text next to that line. text is drawn with style number view.STYLE_FOLDDISPLAYTEXT.

Parameters:

view.unsplit(view)

Unsplits the view if possible, returning true on success.

Parameters:

Return:

view.vertical_center_caret(view)

Centers current line in the view.

Parameters:

view.visible_from_doc_line(view, line)

Returns the displayed line number of actual line number line, taking wrapped, annotated, and hidden lines into account, or -1 if line is outside the range of lines in the buffer. Lines can occupy more than one display line if they wrap.

Parameters:

Return:

view.wrap_count(view, line)

Returns the number of wrapped lines needed to fully display line number line.

Parameters:

Return:

view.zoom_in(view)

Increases the size of all fonts by one point, up to 20.

Parameters:

view.zoom_out(view)

Decreases the size of all fonts by one point, down to -10.

Parameters:

Tables defined by view

view.buffer

The buffer the view currently contains. (Read-only)