diff options
| -rw-r--r-- | modules/lua/api | 54 | ||||
| -rw-r--r-- | modules/lua/tags | 26 |
2 files changed, 38 insertions, 42 deletions
diff --git a/modules/lua/api b/modules/lua/api index 875ccba6..02793758 100644 --- a/modules/lua/api +++ b/modules/lua/api @@ -137,7 +137,6 @@ KEYPRESS events.KEYPRESS (string)\nEmitted when pressing a key.\nIf any handler KEYSYMS keys.KEYSYMS (table)\nLookup table for string representations of key codes higher than 255.\nKey codes can be identified by temporarily uncommenting the `print()`\nstatements in *core/keys.lua*. KEYWORD lexer.KEYWORD (string)\nThe token name for keyword tokens. LABEL lexer.LABEL (string)\nThe token name for label tokens. -LEXERPATH lexer.LEXERPATH (string)\nThe path used to search for a lexer to load.\nIdentical in format to Lua's `package.path` string.\nThe default value is `package.path`. LEXER_LOADED events.LEXER_LOADED (string)\nEmitted after loading a language lexer.\nThis is useful for overriding a language module's key bindings or other\nproperties since the module is not loaded when Textadept starts.\nArguments:\n\n* *`lexer`*: The language lexer's name. LINUX _G.LINUX (bool)\nWhether or not Textadept is running on Linux. MARGINOPTION_NONE buffer.MARGINOPTION_NONE (number, Read-only)\n @@ -317,37 +316,32 @@ WS_INVISIBLE buffer.WS_INVISIBLE (number, Read-only)\n WS_VISIBLEAFTERINDENT buffer.WS_VISIBLEAFTERINDENT (number, Read-only)\n WS_VISIBLEALWAYS buffer.WS_VISIBLEALWAYS (number, Read-only)\n XPM_IMAGES textadept.editing.XPM_IMAGES (table)\nMap of image names to registered image numbers. +ZOOM events.ZOOM (string)\nEmitted after changing `buffer.zoom`.\nEmitted by `buffer.zoom_in()` and `buffer.zoom_out()`. _BUFFERS _G._BUFFERS (table)\nTable of all open buffers in Textadept.\nNumeric keys have buffer values and buffer keys have their associated numeric\nkeys.\n@see _G.buffer _CHARSET _G._CHARSET (string)\nThe filesystem's character encoding.\nThis is used when working with files. -_FOLDBYINDENTATION lexer.lexer._FOLDBYINDENTATION (table)\nDeclares the lexer does not define fold points and\n that fold points should be calculated based on changes in indentation. _G _G._G (module)\nLua _G module. _G _G._G (table)\nA global variable (not a function) that holds the global environment\n(see §2.2). Lua itself does not use this variable; changing its value does\nnot affect any environment, nor vice versa. _HOME _G._HOME (string)\nThe path to Textadept's home, or installation, directory. _L _G._L (module)\nMap of all messages used by Textadept to their localized form.\nIf the table does not contain the localized version of a given message, it\nreturns a string that starts with "No Localization:" via a metamethod. -_LEXBYLINE lexer.lexer._LEXBYLINE (table)\nIndicates the lexer can only process one whole line of text\n (instead of an arbitrary chunk of text) at a time.\n The default value is `false`. Line lexers cannot look ahead to subsequent\n lines. _M _G._M (module)\nA table of loaded Textadept language modules.\n\nLanguage modules are a special kind of module that Textadept automatically\nloads when editing source code in a particular programming language. The only\nthing "special" about them is they are named after a lexer. Otherwise they\nare plain Lua modules. The *~/.textadept/modules/* directory houses language\nmodules (along with other modules).\n\nA language module is designed to provide extra functionality for a single\nprogramming language. Some examples of what language modules can do:\n\n * Specify block comment syntax for lines of code\n * Define compile and run commands for source files\n * Set language-specific editor properties like indentation rules\n * Specify code autocompletion routines\n * Declare snippets\n * Define commands and key bindings for them\n * Add to the top-level menu or right-click editor context menu\n\nExamples of these features are described in the sections below. -_NAME lexer.lexer._NAME (table)\nThe string name of the lexer. _RELEASE _G._RELEASE (string)\nThe Textadept release version string. -_RULES lexer.lexer._RULES (table)\nA map of rule name keys with their associated LPeg pattern\n values for the lexer.\n This is constructed from the lexer's `_rules` table and accessible to other\n lexers for embedded lexer applications like modifying parent or child\n rules. _SCINTILLA _G._SCINTILLA (module)\nScintilla constants, functions, and properties.\nDo not modify anything in this module. Doing so will have unpredictable\nconsequences. _USERHOME _G._USERHOME (string)\nThe path to the user's *~/.textadept/* directory, where all preferences and\nuser-data is stored.\nOn Windows machines *~/* is the value of the "USERHOME" environment\nvariable (typically *C:\Users\username\\* or\n*C:\Documents and Settings\username\\*). On Linux, BSD, and Mac OSX\nmachines *~/* is the value of "$HOME" (typically */home/username/* and\n*/Users/username/* respectively). _VERSION _G._VERSION (string)\nA global variable (not a function) that holds a string containing the\nrunning Lua version. The current value of this variable is "`Lua 5.3`". _VIEWS _G._VIEWS (table)\nTable of all views in Textadept.\nNumeric keys have view values and view keys have their associated numeric\nkeys.\n@see _G.view _cancel_current textadept.snippets._cancel_current()\nCancels the active snippet, removing all inserted text.\nReturns `false` if no snippet is active.\n@return `false` if no snippet is active; `nil` otherwise. -_fold lexer.lexer._fold (table)\nIf this function exists in the lexer, it is called for folding\n the document instead of using `_foldsymbols` or indentation. -_foldsymbols lexer.lexer._foldsymbols (table)\nA table of recognized fold points for the lexer.\n Keys are token names with table values defining fold points. Those table\n values have string keys of keywords or characters that indicate a fold\n point whose values are integers. A value of `1` indicates a beginning fold\n point and a value of `-1` indicates an ending fold point. Values can also\n be functions that return `1`, `-1`, or `0` (indicating no fold point) for\n keys which need additional processing.\n There is also a required `_patterns` key whose value is a table containing\n Lua pattern strings that match all fold points (the string keys contained\n in token name table values). When the lexer encounters text that matches\n one of those patterns, the matched text is looked up in its token's table\n to determine whether or not it is a fold point.\n There is also an optional `_case_insensitive` option that indicates whether\n or not fold point keys are case-insensitive. If `true`, fold point keys\n should be in lower case. _insert textadept.snippets._insert(text)\nInserts snippet text *text* or the snippet assigned to the trigger word\nbehind the caret.\nOtherwise, if a snippet is active, goes to the active snippet's next\nplaceholder. Returns `false` if no action was taken.\n@param text Optional snippet text to insert. If `nil`, attempts to insert a\n new snippet based on the trigger, the word behind caret, and the current\n lexer.\n@return `false` if no action was taken; `nil` otherwise.\n@see buffer.word_chars -_lexer lexer.lexer._lexer (table)\nThe parent lexer object whose rules should be used. This field\n is only necessary to disambiguate a proxy lexer that loaded parent and\n child lexers for embedding and ended up having multiple parents loaded. _paths textadept.snippets._paths (table)\nList of directory paths to look for snippet files in.\nFilenames are of the form *lexer.trigger.ext* or *trigger.ext* (*.ext* is an\noptional, arbitrary file extension). If the global `snippets` table does not\ncontain a snippet for a given trigger, this table is consulted for a matching\nfilename, and the contents of that file is inserted as a snippet.\nNote: If a directory has multiple snippets with the same trigger, the snippet\nchosen for insertion is not defined and may not be constant. _previous textadept.snippets._previous()\nJumps back to the previous snippet placeholder, reverting any changes from\nthe current one.\nReturns `false` if no snippet is active.\n@return `false` if no snippet is active; `nil` otherwise. _print ui._print(buffer_type, ...)\nPrints the given string messages to the buffer of string type *buffer_type*.\nOpens a new buffer for printing messages to if necessary. If the message\nbuffer is already open in a view, the message is printed to that view.\nOtherwise the view is split (unless `ui.tabs` is `true`) and the message\nbuffer is displayed before being printed to.\n@param buffer_type String type of message buffer.\n@param ... Message strings.\n@usage ui._print(_L['[Message Buffer]'], message) -_rules lexer.lexer._rules (table)\nAn ordered list of rules for a lexer grammar.\n Each rule is a table containing an arbitrary rule name and the LPeg pattern\n associated with the rule. The order of rules is important, as rules are\n matched sequentially.\n Child lexers should not use this table to access and/or modify their\n parent's rules and vice-versa. Use the `_RULES` table instead. _select textadept.snippets._select()\nPrompts the user to select a snippet to insert from a list of global and\nlanguage-specific snippets. -_tokenstyles lexer.lexer._tokenstyles (table)\nA map of non-predefined token names to styles.\n Remember to use token names, not rule names. It is recommended to use\n predefined styles or color-agnostic styles derived from predefined styles\n to ensure compatibility with user color themes. abs math.abs(x)\nReturns the absolute value of `x`. (integer/float) abspath lfs.abspath(filename, prefix)\nReturns the absolute path to string *filename*.\n*prefix* or `lfs.currentdir()` is prepended to a relative filename. The\nreturned path is not guaranteed to exist.\n@param filename The relative or absolute path to a file.\n@param prefix Optional prefix path prepended to a relative filename.\n@return string absolute path acos math.acos(x)\nReturns the arc cosine of `x` (in radians). +add_fold_point lexer.add_fold_point(lexer, token_name, start_symbol, end_symbol)\nAdds to lexer *lexer* a fold point whose beginning and end tokens are string\n*token_name* tokens with string content *start_symbol* and *end_symbol*,\nrespectively.\nIn the event that *start_symbol* may or may not be a fold point depending on\ncontext, and that additional processing is required, *end_symbol* may be a\nfunction that ultimately returns `1` (indicating a beginning fold point),\n`-1` (indicating an ending fold point), or `0` (indicating no fold point).\nThat function is passed the following arguments:\n\n * `text`: The text being processed for fold points.\n * `pos`: The position in *text* of the beginning of the line currently\n being processed.\n * `line`: The text of the line currently being processed.\n * `s`: The position of *start_symbol* in *line*.\n * `symbol`: *start_symbol* itself.\n@param lexer The lexer to add a fold point to.\n@param token_name The token name of text that indicates a fold point.\n@param start_symbol The text that indicates the beginning of a fold point.\n@param end_symbol Either the text that indicates the end of a fold point, or\n a function that returns whether or not *start_symbol* is a beginning fold\n point (1), an ending fold point (-1), or not a fold point at all (0).\n@usage lex:add_fold_point(lexer.OPERATOR, '{', '}')\n@usage lex:add_fold_point(lexer.KEYWORD, 'if', 'end')\n@usage lex:add_fold_point(lexer.COMMENT, '#', lexer.fold_line_comments('#'))\n@usage lex:add_fold_point('custom', function(text, pos, line, s, symbol)\n ... end) +add_rule lexer.add_rule(lexer, id, rule)\nAdds pattern *rule* identified by string *id* to the ordered list of rules\nfor lexer *lexer*.\n@param lexer The lexer to add the given rule to.\n@param id The id associated with this rule. It does not have to be the same\n as the name passed to `token()`.\n@param rule The LPeg pattern of the rule.\n@see modify_rule add_selection buffer.add_selection(buffer, end_pos, start_pos)\nSelects the range of text between positions *start_pos* to *end_pos* as the\nmain selection, retaining all other selections as additional selections.\nSince an empty selection still counts as a selection, use\n`buffer.set_selection()` first when setting a list of selections.\n@param buffer A buffer.\n@param end_pos The caret position of the range of text to select in *buffer*.\n@param start_pos The anchor position of the range of text to select in\n *buffer*.\n@see set_selection +add_style lexer.add_style(lexer, token_name, style)\nAssociates string *token_name* in lexer *lexer* with Scintilla style string\n*style*.\nStyle strings are comma-separated property settings. Available property\nsettings are:\n\n * `font:name`: Font name.\n * `size:int`: Font size.\n * `bold` or `notbold`: Whether or not the font face is bold.\n * `weight:int`: Font weight (between 1 and 999).\n * `italics` or `notitalics`: Whether or not the font face is italic.\n * `underlined` or `notunderlined`: Whether or not the font face is\n underlined.\n * `fore:color`: Font face foreground color in "#RRGGBB" or 0xBBGGRR format.\n * `back:color`: Font face background color in "#RRGGBB" or 0xBBGGRR format.\n * `eolfilled` or `noteolfilled`: Whether or not the background color\n extends to the end of the line.\n * `case:char`: Font case ('u' for uppercase, 'l' for lowercase, and 'm' for\n mixed case).\n * `visible` or `notvisible`: Whether or not the text is visible.\n * `changeable` or `notchangeable`: Whether or not the text is changeable or\n read-only.\n\nProperty settings may also contain "$(property.name)" expansions for\nproperties defined in Scintilla, theme files, etc.\n@param lexer The lexer to add a style to.\n@param token_name The name of the token to associated with the style.\n@param style A style string for Scintilla.\n@usage lex:add_style('longstring', lexer.STYLE_STRING)\n@usage lex:add_style('deprecated_function', lexer.STYLE_FUNCTION..',italics')\n@usage lex:add_style('visible_ws',\n lexer.STYLE_WHITESPACE..',back:$(color.grey)') add_text buffer.add_text(buffer, text)\nAdds string *text* to the buffer at the caret position and moves the caret to\nthe end of the added text without scrolling it into view.\n@param buffer A buffer.\n@param text The text to add. additional_caret_fore buffer.additional_caret_fore (number)\nThe foreground color, in "0xBBGGRR" format, of additional carets. additional_carets_blink buffer.additional_carets_blink (bool)\nAllow additional carets to blink.\nThe default value is `true`. @@ -420,7 +414,7 @@ brace_bad_light buffer.brace_bad_light(buffer, pos)\nHighlights the character at brace_bad_light_indicator buffer.brace_bad_light_indicator(buffer, use_indicator, indicator)\nHighlights unmatched brace characters with indicator number *indicator*, in\nthe range of `0` to `31`, instead of the\n`buffer.STYLE_BRACEBAD` style if *use_indicator* is `true`.\n@param buffer A buffer.\n@param use_indicator Whether or not to use an indicator.\n@param indicator The indicator number to use. brace_highlight buffer.brace_highlight(buffer, pos1, pos2)\nHighlights the characters at positions *pos1* and *pos2* as matching braces\nusing the `'style.bracelight'` style.\nIf indent guides are enabled, locates the column with `buffer.column` and\nsets `buffer.highlight_guide` in order to highlight the indent guide.\n@param buffer A buffer.\n@param pos1 The first position in *buffer* to highlight.\n@param pos2 The second position in *buffer* to highlight. brace_highlight_indicator buffer.brace_highlight_indicator(buffer, use_indicator, indicator)\nHighlights matching brace characters with indicator number *indicator*, in\nthe range of `0` to `31`, instead of the\n`buffer.STYLE_BRACELIGHT` style if *use_indicator* is `true`.\n@param buffer A buffer.\n@param use_indicator Whether or not to use an indicator.\n@param indicator The indicator number to use. -brace_match buffer.brace_match(buffer, pos)\nReturns the position of the matching brace for the brace character at\nposition *pos*, taking nested braces into account, or `-1`.\nThe brace characters recognized are '(', ')', '[', ']', '{', '}', '<', and\n'>' and must have the same style.\n@param buffer A buffer.\n@param pos The position of the brace in *buffer* to match.\n@return number +brace_match buffer.brace_match(buffer, pos, max_re_style)\nReturns the position of the matching brace for the brace character at\nposition *pos*, taking nested braces into account, or `-1`.\nThe brace characters recognized are '(', ')', '[', ']', '{', '}', '<', and\n'>' and must have the same style.\n@param buffer A buffer.\n@param pos The position of the brace in *buffer* to match.\n@param max_re_style Must be `0`. Reserved for expansion.\n@return number brace_matches textadept.editing.brace_matches (table)\nTable of brace characters to highlight.\nThe ASCII values of brace characters are keys and are assigned non-`nil`\nvalues. The default brace characters are '(', ')', '[', ']', '{', and '}'. btest bit32.btest(...)\nReturns a boolean signaling whether the bitwise "and" of its operands is\ndifferent from zero.\n\nNew in Lua 5.2.\nDeprecated in Lua 5.3. buffer _G.buffer (module)\nA Textadept buffer object.\nConstants are documented in the fields they apply to.\nWhile you can work with individual buffer instances, it is really only useful\nto work with the global one.\nMany of these functions and fields are derived from the Scintilla editing\ncomponent, and additional information can be found on the Scintilla website:\nhttp://scintilla.org/ScintillaDoc.html @@ -533,7 +527,7 @@ delete buffer.delete(buffer)\nDeletes the buffer.\n**Do not call this function.* delete_back buffer.delete_back(buffer)\nDeletes the character behind the caret if no text is selected.\nOtherwise, deletes the selected text.\n@param buffer A buffer. delete_back_not_line buffer.delete_back_not_line(buffer)\nDeletes the character behind the caret unless either the caret is at the\nbeginning of a line or text is selected.\nIf text is selected, deletes it.\n@param buffer A buffer. delete_range buffer.delete_range(buffer, pos, length)\nDeletes the range of text from position *pos* to *pos* + *length*.\n@param buffer A buffer.\n@param pos The start position of the range of text in *buffer* to delete.\n@param length The number of characters in the range of text to delete. -delimited_range lexer.delimited_range(chars, single_line, no_escape, balanced)\nCreates and returns a pattern that matches a range of text bounded by\n*chars* characters.\nThis is a convenience function for matching more complicated delimited ranges\nlike strings with escape characters and balanced parentheses. *single_line*\nindicates whether or not the range must be on a single line, *no_escape*\nindicates whether or not to ignore '\' as an escape character, and *balanced*\nindicates whether or not to handle balanced ranges like parentheses and\nrequires *chars* to be composed of two characters.\n@param chars The character(s) that bound the matched range.\n@param single_line Optional flag indicating whether or not the range must be\n on a single line.\n@param no_escape Optional flag indicating whether or not the range end\n character may be escaped by a '\\' character.\n@param balanced Optional flag indicating whether or not to match a balanced\n range, like the "%b" Lua pattern. This flag only applies if *chars*\n consists of two different characters (e.g. "()").\n@usage local dq_str_escapes = l.delimited_range('"')\n@usage local dq_str_noescapes = l.delimited_range('"', false, true)\n@usage local unbalanced_parens = l.delimited_range('()')\n@usage local balanced_parens = l.delimited_range('()', false, false, true)\n@return pattern\n@see nested_pair +delimited_range lexer.delimited_range(chars, single_line, no_escape, balanced)\nCreates and returns a pattern that matches a range of text bounded by\n*chars* characters.\nThis is a convenience function for matching more complicated delimited ranges\nlike strings with escape characters and balanced parentheses. *single_line*\nindicates whether or not the range must be on a single line, *no_escape*\nindicates whether or not to ignore '\' as an escape character, and *balanced*\nindicates whether or not to handle balanced ranges like parentheses and\nrequires *chars* to be composed of two characters.\n@param chars The character(s) that bound the matched range.\n@param single_line Optional flag indicating whether or not the range must be\n on a single line.\n@param no_escape Optional flag indicating whether or not the range end\n character may be escaped by a '\\' character.\n@param balanced Optional flag indicating whether or not to match a balanced\n range, like the "%b" Lua pattern. This flag only applies if *chars*\n consists of two different characters (e.g. "()").\n@usage local dq_str_escapes = lexer.delimited_range('"')\n@usage local dq_str_noescapes = lexer.delimited_range('"', false, true)\n@usage local unbalanced_parens = lexer.delimited_range('()')\n@usage local balanced_parens = lexer.delimited_range('()', false, false,\n true)\n@return pattern\n@see nested_pair dialog ui.dialog(kind, ...)\nLow-level function for prompting the user with a gtdialog of kind *kind*\nwith the given string and table arguments, returning a formatted string of\nthe dialog's output.\nYou probably want to use the higher-level functions in the `ui.dialogs`\nmodule.\nTable arguments containing strings are allowed and expanded in place. This is\nuseful for filtered list dialogs with many items.\n@param kind The kind of gtdialog.\n@param ... Parameters to the gtdialog.\n@return string gtdialog result. dialogs ui.dialogs (module)\nProvides a set of interactive dialog prompts for user input. difftime os.difftime(t2, t1)\nReturns the difference, in seconds, from time `t1` to time `t2` (where the\ntimes are values returned by `os.time`). In POSIX, Windows, and some other\nsystems, this value is exactly `t2`*-*`t1`. @@ -556,7 +550,7 @@ edge_mode buffer.edge_mode (number)\nThe long line mark mode.\n\n* `buffer.EDGE_ edit_toggle_overtype buffer.edit_toggle_overtype(buffer)\nToggles `buffer.overtype`.\n@param buffer A buffer. editing textadept.editing (module)\nEditing features for Textadept. editing_keys ui.command_entry.editing_keys (table)\nA metatable with typical platform-specific key bindings for text entries.\nThis metatable may be used to add basic editing keys to command entry modes.\nIt is automatically added to command entry modes unless a metatable was\npreviously set. -embed_lexer lexer.embed_lexer(parent, child, start_rule, end_rule)\nEmbeds child lexer *child* in parent lexer *parent* using patterns\n*start_rule* and *end_rule*, which signal the beginning and end of the\nembedded lexer, respectively.\n@param parent The parent lexer.\n@param child The child lexer.\n@param start_rule The pattern that signals the beginning of the embedded\n lexer.\n@param end_rule The pattern that signals the end of the embedded lexer.\n@usage l.embed_lexer(M, css, css_start_rule, css_end_rule)\n@usage l.embed_lexer(html, M, php_start_rule, php_end_rule)\n@usage l.embed_lexer(html, ruby, ruby_start_rule, ruby_end_rule) +embed lexer.embed(lexer, child, start_rule, end_rule)\nEmbeds child lexer *child* in parent lexer *lexer* using patterns\n*start_rule* and *end_rule*, which signal the beginning and end of the\nembedded lexer, respectively.\n@param lexer The parent lexer.\n@param child The child lexer.\n@param start_rule The pattern that signals the beginning of the embedded\n lexer.\n@param end_rule The pattern that signals the end of the embedded lexer.\n@usage html:embed(css, css_start_rule, css_end_rule)\n@usage html:embed(lex, php_start_rule, php_end_rule) -- from php lexer emit events.emit(event, ...)\nSequentially calls all handler functions for event *event* with the given\narguments.\n*event* may be any arbitrary string and does not need to have been previously\ndefined. If any handler explicitly returns `true` or `false`, `emit()`\nreturns that value and ceases to call subsequent handlers. This is useful for\nstopping the propagation of an event like a keypress after it has been\nhandled.\n@param event The string event name.\n@param ... Arguments passed to the handler.\n@usage events.emit('my_event', 'my message')\n@return `true` or `false` if any handler explicitly returned such; `nil`\n otherwise. empty_undo_buffer buffer.empty_undo_buffer(buffer)\nDeletes the undo and redo history.\n@param buffer A buffer. enclose textadept.editing.enclose(left, right)\nEncloses the selected text or the current word within strings *left* and\n*right*, taking multiple selections into account.\n@param left The left part of the enclosure.\n@param right The right part of the enclosure. @@ -587,7 +581,7 @@ file_types textadept.file_types (module)\nHandles file type detection for Textad filename buffer.filename (string)\nThe absolute file path associated with the buffer. filesave ui.dialogs.filesave(options)\nPrompts the user with a file save dialog defined by dialog options table\n*options*, returning the string file chosen.\nIf the user canceled the dialog, returns `nil`.\n@param options Table of key-value option pairs for the dialog.\n\n * `title`: The dialog's title text.\n * `with_directory`: The initial filesystem directory to show.\n * `with_file`: The initially chosen filename. This option requires\n `with_directory` to be set.\n * `with_extension`: The list of extensions selectable files must have.\n * `no_create_directories`: Prevent the user from creating new directories.\n The default value is `false`.\n@return filename or nil fileselect ui.dialogs.fileselect(options)\nPrompts the user with a file selection dialog defined by dialog options\ntable *options*, returning the string file selected.\nIf *options*.`select_multiple` is `true`, returns the list of files selected.\nIf the user canceled the dialog, returns `nil`.\n@param options Table of key-value option pairs for the dialog.\n\n * `title`: The dialog's title text.\n * `with_directory`: The initial filesystem directory to show.\n * `with_file`: The initially selected filename. This option requires\n `with_directory` to be set.\n * `with_extension`: The list of extensions selectable files must have.\n * `select_multiple`: Allow the user to select multiple files. The default\n value is `false`.\n * `select_only_directories`: Only allow the user to select directories. The\n default value is `false`.\n@usage ui.dialogs.fileselect{title = 'Open C File', with_directory = _HOME,\n with_extension = {'c', 'h'}, select_multiple = true}\n@return filename, list of filenames, or nil -filter_through textadept.editing.filter_through(command)\nPasses the selected text or all buffer text to string shell command *command*\nas standard input (stdin) and replaces the input text with the command's\nstandard output (stdout).\nStandard input is as follows:\n\n1. If text is selected and spans multiple lines, all text on the lines that\nhave text selected is passed as stdin. However, if the end of the selection\nis at the beginning of a line, only the line ending delimiters from the\nprevious line are included. The rest of the line is excluded.\n2. If text is selected and spans a single line, only the selected text is\nused.\n3. If no text is selected, the entire buffer is used.\n@param command The Linux, BSD, Mac OSX, or Windows shell command to filter\n text through. +filter_through textadept.editing.filter_through(command)\nPasses the selected text or all buffer text to string shell command *command*\nas standard input (stdin) and replaces the input text with the command's\nstandard output (stdout). *command* may contain pipes.\nStandard input is as follows:\n\n1. If text is selected and spans multiple lines, all text on the lines that\nhave text selected is passed as stdin. However, if the end of the selection\nis at the beginning of a line, only the line ending delimiters from the\nprevious line are included. The rest of the line is excluded.\n2. If text is selected and spans a single line, only the selected text is\nused.\n3. If no text is selected, the entire buffer is used.\n@param command The Linux, BSD, Mac OSX, or Windows shell command to filter\n text through. May contain pipes. filteredlist ui.dialogs.filteredlist(options)\nPrompts the user with a filtered list item selection dialog defined by dialog\noptions table *options*, returning the selected button's index along with the\nindex or indices of the selected item or items (depending on whether or not\n*options*.`select_multiple` is `true`).\nIf *options*.`string_output` is `true`, returns the selected button's label\nalong with the text of the selected item or items.\nIf the dialog timed out, returns `0` or `"timeout"`. If the user canceled the\ndialog, returns `-1` or `"delete"`.\nSpaces in the filter text are treated as wildcards.\n@param options Table of key-value option pairs for the filtered list dialog.\n\n * `title`: The dialog's title text.\n * `informative_text`: The dialog's main message text.\n * `text`: The dialog's initial input text.\n * `columns`: The list of string column names for list rows.\n * `items`: The list of string items to show in the filtered list.\n * `button1`: The right-most button's label. The default value is\n `_L['_OK']`.\n * `button2`: The middle button's label.\n * `button3`: The left-most button's label. This option requires `button2`\n to be set.\n * `select_multiple`: Allow the user to select multiple items. The default\n value is `false`.\n * `search_column`: The column number to filter the input text against. The\n default value is `1`. This option requires `columns` to be set and\n contain at least *n* column names.\n * `output_column`: The column number to use for `string_output`. The\n default value is `1`. This option requires `columns` to be set and\n contain at least *n* column names.\n * `string_output`: Return the selected button's label (instead of its\n index) and the selected item's text (instead of its index). If no item\n was selected, returns the dialog's exit status (instead of its exit\n code). The default value is `false`.\n * `width`: The dialog's pixel width.\n * `height`: The dialog's pixel height.\n * `float`: Show the dialog on top of all desktop windows. The default value\n is `false`.\n * `timeout`: The integer number of seconds the dialog waits for the user to\n select a button before timing out. Dialogs do not time out by default.\n@usage ui.dialogs.filteredlist{title = 'Title', columns = {'Foo', 'Bar'},\n items = {'a', 'b', 'c', 'd'}}\n@return selected button or exit code, selected item or list of selected items find string.find(s, pattern [, init [, plain]])\nLooks for the first match of `pattern` (see §6.4.1) in the string `s`. If it\nfinds a match, then `find` returns the indices of `s` where this occurrence\nstarts and ends; otherwise, it returns nil. A third, optional numerical\nargument `init` specifies where to start the search; its default value is 1\nand can be negative. A value of true as a fourth, optional argument `plain`\nturns off the pattern matching facilities, so the function does a plain\n"find substring" operation, with no characters in `pattern` being considered\nmagic. Note that if `plain` is given, then `init` must be given as well.\n\nIf the pattern has captures, then in a successful match the captured values\nare also returned, after the two indices. find ui.find (module)\nTextadept's Find & Replace pane. @@ -611,7 +605,7 @@ flush io.flush()\nEquivalent to `io.output():flush()`. fmod math.fmod(x, y)\nReturns the remainder of the division of `x` by `y` that rounds the\nquotient towards zero. (integer/float) focus ui.command_entry.focus()\nOpens the command entry. focus ui.find.focus()\nDisplays and focuses the Find & Replace Pane. -fold lexer.fold(lexer, text, start_pos, start_line, start_level)\nDetermines fold points in a chunk of text *text* with lexer *lexer*.\n*text* starts at position *start_pos* on line number *start_line* with a\nbeginning fold level of *start_level* in the buffer. If *lexer* has a `_fold`\nfunction or a `_foldsymbols` table, that field is used to perform folding.\nOtherwise, if *lexer* has a `_FOLDBYINDENTATION` field set, or if a\n`fold.by.indentation` property is set, folding by indentation is done.\n@param lexer The lexer object to fold with.\n@param text The text in the buffer to fold.\n@param start_pos The position in the buffer *text* starts at, starting at\n zero.\n@param start_line The line number *text* starts on.\n@param start_level The fold level *text* starts on.\n@return table of fold levels. +fold lexer.fold(lexer, text, start_pos, start_line, start_level)\nDetermines fold points in a chunk of text *text* using lexer *lexer*,\nreturning a table of fold levels associated with line numbers.\n*text* starts at position *start_pos* on line number *start_line* with a\nbeginning fold level of *start_level* in the buffer.\n@param lexer The lexer to fold text with.\n@param text The text in the buffer to fold.\n@param start_pos The position in the buffer *text* starts at, starting at\n zero.\n@param start_line The line number *text* starts on.\n@param start_level The fold level *text* starts on.\n@return table of fold levels associated with line numbers. fold_all buffer.fold_all(buffer, action)\nContracts, expands, or toggles all fold points, depending on *action*.\nWhen toggling, the state of the first fold point determines whether to\nexpand or contract.\n@param buffer A buffer.\n@param action The fold action to perform. Valid values are:\n * `buffer.FOLDACTION_CONTRACT`\n * `buffer.FOLDACTION_EXPAND`\n * `buffer.FOLDACTION_TOGGLE` fold_children buffer.fold_children(buffer, line, action)\nContracts, expands, or toggles the fold point on line number *line*, as well\nas all of its children, depending on *action*.\n@param buffer A buffer.\n@param line The line number in *buffer* to set the fold states for.\n@param action The fold action to perform. Valid values are:\n * `buffer.FOLDACTION_CONTRACT`\n * `buffer.FOLDACTION_EXPAND`\n * `buffer.FOLDACTION_TOGGLE` fold_display_text_style buffer.fold_display_text_style (number)\nThe fold display text mode.\n\n* `buffer.FOLDDISPLAYTEXT_HIDDEN`\n Fold display text is not shown.\n* `buffer.FOLDDISPLAYTEXT_STANDARD`\n Fold display text is shown with no decoration.\n* `buffer.FOLDDISPLAYTEXT_BOXED`\n Fold display text is shown outlined with a box.\n\nThe default value is `buffer.FOLDDISPLAYTEXT_HIDDEN`. @@ -620,7 +614,7 @@ fold_flags buffer.fold_flags (number, Read-only)\nBit-mask of folding lines to d fold_level buffer.fold_level (table)\nTable of fold level bit-masks for line numbers starting from zero.\nFold level masks comprise of an integer level combined with any of the\nfollowing bit flags:\n\n* `buffer.FOLDLEVELBASE`\n The initial fold level.\n* `buffer.FOLDLEVELWHITEFLAG`\n The line is blank.\n* `buffer.FOLDLEVELHEADERFLAG`\n The line is a header, or fold point. fold_level lexer.fold_level (table, Read-only)\nTable of fold level bit-masks for line numbers starting from zero.\nFold level masks are composed of an integer level combined with any of the\nfollowing bits:\n\n* `lexer.FOLD_BASE`\n The initial fold level.\n* `lexer.FOLD_BLANK`\n The line is blank.\n* `lexer.FOLD_HEADER`\n The line is a header, or fold point. fold_line buffer.fold_line(buffer, line, action)\nContracts, expands, or toggles the fold point on line number *line*,\ndepending on *action*.\n@param buffer A buffer.\n@param line The line number in *buffer* to set the fold state for.\n@param action The fold action to perform. Valid values are:\n * `buffer.FOLDACTION_CONTRACT`\n * `buffer.FOLDACTION_EXPAND`\n * `buffer.FOLDACTION_TOGGLE` -fold_line_comments lexer.fold_line_comments(prefix)\nReturns a fold function (to be used within the lexer's `_foldsymbols` table)\nthat folds consecutive line comments that start with string *prefix*.\n@param prefix The prefix string defining a line comment.\n@usage [l.COMMENT] = {['--'] = l.fold_line_comments('--')}\n@usage [l.COMMENT] = {['//'] = l.fold_line_comments('//')} +fold_line_comments lexer.fold_line_comments(prefix)\nReturns a fold function (to be passed to `lexer.add_fold_point()`) that folds\nconsecutive line comments that start with string *prefix*.\n@param prefix The prefix string defining a line comment.\n@usage lex:add_fold_point(lexer.COMMENT, '--',\n lexer.fold_line_comments('--'))\n@usage lex:add_fold_point(lexer.COMMENT, '//',\n lexer.fold_line_comments('//')) fold_parent buffer.fold_parent (table, Read-only)\nTable of fold point line numbers for child line numbers starting from zero.\nA line number of `-1` means no line was found. fontselect ui.dialogs.fontselect(options)\nPrompts the user with a font selection dialog defined by dialog options\ntable *options*, returning the font selected (including style and size).\nIf the user canceled the dialog, returns `nil`.\n@param options Table of key-value option pairs for the option select dialog.\n\n * `title`: The dialog's title text.\n * `text`: The font preview text.\n * `font-name`: The initially selected font name.\n * `font-size`: The initially selected font size. The default value is `12`.\n * `font-style`: The initially selected font style. The available options\n are `"regular"`, `"bold"`, `"italic"`, and `"bold italic"`. The default\n value is `"regular"`.\n * `float`: Show the dialog on top of all desktop windows. The default value\n is `false`.\n@usage ui.dialogs.fontselect{title = 'Font', font_name = 'Monospace',\n font_size = 10}\n@return selected font, including style and size format string.format(formatstring, ···)\nReturns a formatted version of its variable number of arguments following the\ndescription given in its first argument (which must be a string). The format\nstring follows the same rules as the ISO C function `sprintf`. The only\ndifferences are that the options/modifiers `*`, `h`, `L`, `l`, `n`, and `p`\nare not supported and that there is an extra option, `q`.\n\nThe `q` option formats a string between double quotes, using escape sequences\nwhen necessary to ensure that it can safely be read back by the Lua\ninterpreter. For instance, the call\n\n string.format('%q', 'a string with "quotes" and \n new line')\n\nmay produce the string:\n\n "a string with \"quotes\" and \\n new line"\n\nOptions `A` and `a` (when available), `E`, `e`, `f`, `G`, and `g` all expect\na number as argument. Options `c`, `d`, `i`, `o`, `u`, `X`, and `x` expect an\ninteger. Option `q` expects a string. Option `s` expects a string; if its\nargument is not a string, it is converted to one following the same rules of\n`tostring`. If the option has any modifier (flags, width, length), the string\nargument should not contain zeros. @@ -633,6 +627,7 @@ get_line buffer.get_line(buffer, line)\nReturns the text on line number *line*, get_line_sel_end_position buffer.get_line_sel_end_position(buffer, line)\nReturns the position of the end of the selected text on line number *line*,\nor `-1` if *line* has no selection.\n@param buffer A buffer.\n@param line The line number in *buffer* to use. get_line_sel_start_position buffer.get_line_sel_start_position(buffer, line)\nReturns the position of the beginning of the selected text on line number\n*line*, or `-1` if *line* has no selection.\n@param buffer A buffer.\n@param line The line number in *buffer* to use. get_project_root io.get_project_root(path)\nReturns the root directory of the project that contains filesystem path\n*path*.\nIn order to be recognized, projects must be under version control. Recognized\nVCSes are Bazaar, Git, Mercurial, and SVN.\n@param path Optional filesystem path to a project or a file contained within\n a project. The default value is the buffer's filename or the current\n working directory.\n@return string root or nil +get_rule lexer.get_rule(lexer, id)\nReturns the rule identified by string *id*.\n@param lexer The lexer to fetch a rule from.\n@param id The id of the rule to fetch.\n@return pattern get_sel_text buffer.get_sel_text(buffer)\nReturns the selected text.\nMultiple selections are included in order with no delimiters. Rectangular\nselections are included from top to bottom with end of line characters.\nVirtual space is not included.\n@param buffer A buffer.\n@return string, number get_split_table ui.get_split_table()\nReturns a split table that contains Textadept's current split view structure.\nThis is primarily used in session saving.\n@return table of split views. Each split view entry is a table with 4\n fields: `1`, `2`, `vertical`, and `size`. `1` and `2` have values of either\n nested split view entries or the views themselves; `vertical` is a flag\n that indicates if the split is vertical or not; and `size` is the integer\n position of the split resizer. get_text buffer.get_text(buffer)\nReturns the buffer's text.\n@param buffer A buffer. @@ -713,14 +708,13 @@ keys _G.keys (module)\nManages key bindings in Textadept. keys _G.keys (table)\nMap of key bindings to commands, with language-specific key tables assigned\nto a lexer name key. keys textadept.keys (module)\nDefines key commands for Textadept.\nThis set of key commands is pretty standard among other text editors, at\nleast for basic editing commands and movements. kill spawn_proc:kill(signal)\nKills running process *spawn_proc*, or sends it Unix signal *signal*.\n@param signal Optional Unix signal to send to *spawn_proc*. The default value\n is 9 (`SIGKILL`), which kills the process. -last_char_includes lexer.last_char_includes(s)\nCreates and returns a pattern that verifies that string set *s* contains the\nfirst non-whitespace character behind the current match position.\n@param s String character set like one passed to `lpeg.S()`.\n@usage local regex = l.last_char_includes('+-*!%^&|=,([{') *\n l.delimited_range('/')\n@return pattern +last_char_includes lexer.last_char_includes(s)\nCreates and returns a pattern that verifies that string set *s* contains the\nfirst non-whitespace character behind the current match position.\n@param s String character set like one passed to `lpeg.S()`.\n@usage local regex = lexer.last_char_includes('+-*!%^&|=,([{') *\n lexer.delimited_range('/')\n@return pattern ldexp math.ldexp(m, e)\nReturns 'm2^e' (`e` should be an integer).\n\nDeprecated in Lua 5.3. len string.len(s)\nReceives a string and returns its length. The empty string `""` has\nlength 0. Embedded zeros are counted, so `"a\000bc\000"` has length 5. len utf8.len(s [, i [, j]])\nReturns the number of UTF-8 characters in string `s` that start between\npositions `i` and `j` (both inclusive). The default for `i` is 1 and for `j`\nis -1. If it finds any invalid byte sequence, returns a false value plus the\nposition of the first invalid byte.\n\nNew in Lua 5.3. length buffer.length (number, Read-only)\nThe number of bytes in the buffer. -lex lexer.lex(lexer, text, init_style)\nLexes a chunk of text *text* (that has an initial style number of\n*init_style*) with lexer *lexer*.\nIf *lexer* has a `_LEXBYLINE` flag set, the text is lexed one line at a time.\nOtherwise the text is lexed as a whole.\n@param lexer The lexer object to lex with.\n@param text The text in the buffer to lex.\n@param init_style The current style. Multiple-language lexers use this to\n determine which language to start lexing in.\n@return table of token names and positions. -lexer _G.lexer (module)\nLexes Scintilla documents with Lua and LPeg. -lexer lexer.lexer (table)\nIndividual fields for a lexer instance. +lex lexer.lex(lexer, text, init_style)\nLexes a chunk of text *text* (that has an initial style number of\n*init_style*) using lexer *lexer*, returning a table of token names and\npositions.\n@param lexer The lexer to lex text with.\n@param text The text in the buffer to lex.\n@param init_style The current style. Multiple-language lexers use this to\n determine which language to start lexing in.\n@return table of token names and positions. +lexer _G.lexer (module)\nLexes Scintilla documents and source code with Lua and LPeg. lexers textadept.file_types.lexers (table)\nList of available lexer names. lfs _G.lfs (module)\nLua lfs module. line_copy buffer.line_copy(buffer)\nCopies the current line to the clipboard.\n@param buffer A buffer. @@ -815,7 +809,6 @@ marker_previous buffer.marker_previous(buffer, line, marker_mask)\nReturns the l marker_symbol_defined buffer.marker_symbol_defined(buffer, marker)\nReturns the symbol assigned to marker number *marker*, in the range of `0` to\n`31`, used in `buffer.marker_define()`,\n`buffer.marker_define_pixmap()`, or `buffer.marker_define_rgba_image()`.\n@param buffer A buffer.\n@param marker The marker number in the range of `0` to `31` to get the symbol\n of.\n@return number match lpeg.match(pattern, subject [, init])\nThe matching function. It attempts to match the given pattern against the\nsubject string. If the match succeeds, returns the index in the subject of\nthe first character after the match, or the captured values (if the pattern\ncaptured any value).\n\nAn optional numeric argument `init` makes the match start at that position in\nthe subject string. As usual in Lua libraries, a negative value counts from\nthe end.\n\nUnlike typical pattern-matching functions, match works only in anchored mode;\nthat is, it tries to match the pattern with a prefix of the given subject\nstring (at position `init`), not with an arbitrary substring of the subject.\nSo, if we want to find a pattern anywhere in a string, we must either write a\nloop in Lua or write a pattern that matches anywhere. This second approach is\neasy and quite efficient; see examples. match string.match(s, pattern [, init])\nLooks for the first *match* of `pattern` (see §6.4.1) in the string `s`. If\nit finds one, then `match` returns the captures from the pattern; otherwise\nit returns nil. If `pattern` specifies no captures, then the whole match\nis returned. A third, optional numerical argument `init` specifies where\nto start the search; its default value is 1 and can be negative. -match_brace textadept.editing.match_brace(select)\nGoes to the current character's matching brace, selecting the text in between\nif *select* is `true`.\n@param select Optional flag indicating whether or not to select the text\n between matching braces. The default value is `false`. match_case ui.find.match_case (bool)\nMatch search text case sensitively.\nThe default value is `false`. match_case_label_text ui.find.match_case_label_text (string, Write-only)\nThe text of the "Match case" label.\nThis is primarily used for localization. math _G.math (module)\nLua math module. @@ -833,6 +826,7 @@ mininteger math.mininteger (number)\nAn integer with the minimum value for an in mkdir lfs.mkdir(dirname)\nCreates a new directory. The argument is the name of the new directory.\n\nReturns true if the operation was successful; in case of error, it returns\nnil plus an error string. modf math.modf(x)\nReturns the integral part of `x` and the fractional part of `x`. Its second\nresult is always a float. modify buffer.modify (bool)\nWhether or not the buffer has unsaved changes. +modify_rule lexer.modify_rule(lexer, id, rule)\nReplaces in lexer *lexer* the existing rule identified by string *id* with\npattern *rule*.\n@param lexer The lexer to modify.\n@param id The id associated with this rule.\n@param rule The LPeg pattern of the rule. module _G.module(name [, ···])\nCreates a module. If there is a table in `package.loaded[name]`, this table\nis the module. Otherwise, if there is a global table `t` with the given name,\nthis table is the module. Otherwise creates a new table `t` and sets it as\nthe value of the global `name` and the value of `package.loaded[name]`. This\nfunction also initializes `t._NAME` with the given name, `t._M` with the\nmodule (`t` itself), and `t._PACKAGE` with the package name (the full module\nname minus last component; see below). Finally, `module` sets `t` as the new\nenvironment of the current function and the new value of\n`package.loaded[name]`, so that `require` returns `t`. If `name` is a\ncompound name (that is, one with components separated by dots), `module`\ncreates (or reuses, if they already exist) tables for each component. For\ninstance, if `name` is `a.b.c`, then `module` stores the module table in\nfield `c` of field `b` of global `a`. This function can receive optional\n*options* after the module name, where each option is a function to be\napplied over the module.\n\nDeprecated in Lua 5.2. mouse_dwell_time buffer.mouse_dwell_time (number)\nThe number of milliseconds the mouse must idle before generating a\n`DWELL_START` event. A time of `buffer.TIME_FOREVER` will never generate\none. mouse_selection_rectangular_switch buffer.mouse_selection_rectangular_switch (bool)\nWhether or not pressing `buffer.rectangular_selection_modifier` when\nselecting text normally with the mouse turns on rectangular selection.\nThe default value is `false`. @@ -847,8 +841,9 @@ multi_paste buffer.multi_paste (number)\nThe multiple selection paste mode.\n\n* multiple_select_add_each buffer.multiple_select_add_each(buffer)\nAdds to the set of selections each occurrence of the main selection within\nthe target range.\nIf there is no selected text, the current word is used.\n@param buffer A buffer. multiple_select_add_next buffer.multiple_select_add_next(buffer)\nAdds to the set of selections the next occurrence of the main selection\nwithin the target range, makes that occurrence the new main selection, and\nscrolls it into view.\nIf there is no selected text, the current word is used.\n@param buffer A buffer. multiple_selection buffer.multiple_selection (bool)\nEnable multiple selection.\nThe default value is `false`. -nested_pair lexer.nested_pair(start_chars, end_chars)\nReturns a pattern that matches a balanced range of text that starts with\nstring *start_chars* and ends with string *end_chars*.\nWith single-character delimiters, this function is identical to\n`delimited_range(start_chars..end_chars, false, true, true)`.\n@param start_chars The string starting a nested sequence.\n@param end_chars The string ending a nested sequence.\n@usage local nested_comment = l.nested_pair('/*', '*/')\n@return pattern\n@see delimited_range +nested_pair lexer.nested_pair(start_chars, end_chars)\nReturns a pattern that matches a balanced range of text that starts with\nstring *start_chars* and ends with string *end_chars*.\nWith single-character delimiters, this function is identical to\n`delimited_range(start_chars..end_chars, false, true, true)`.\n@param start_chars The string starting a nested sequence.\n@param end_chars The string ending a nested sequence.\n@usage local nested_comment = lexer.nested_pair('/*', '*/')\n@return pattern\n@see delimited_range new buffer.new()\nCreates and returns a new buffer.\nEmits a `BUFFER_NEW` event.\n@return the new buffer.\n@see events.BUFFER_NEW +new lexer.new(name, opts)\nCreates a returns a new lexer with the given name.\n@param name The lexer's name.\n@param opts Table of lexer options. Options currently supported:\n * `lex_by_line`: Whether or not the lexer only processes whole lines of\n text (instead of arbitrary chunks of text) at a time.\n Line lexers cannot look ahead to subsequent lines.\n The default value is `false`.\n * `fold_by_indentation`: Whether or not the lexer does not define any fold\n points and that fold points should be calculated based on changes in line\n indentation.\n The default value is `false`.\n * `case_insensitive_fold_points`: Whether or not fold points added via\n `lexer.add_fold_point()` ignore case.\n The default value is `false`.\n * `inherit`: Lexer to inherit from.\n The default value is `nil`.\n@usage lexer.new('rhtml', {inherit = lexer.load('html')}) new_line buffer.new_line(buffer)\nTypes a new line at the caret position according to `buffer.eol_mode`.\n@param buffer A buffer. newline lexer.newline (pattern)\nA pattern that matches any set of end of line characters. next _G.next(table [, index])\nAllows a program to traverse all fields of a table. Its first argument is\na table and its second argument is an index in this table. `next` returns\nthe next index of the table and its associated value. When called with nil\nas its second argument, `next` returns an initial index and its associated\nvalue. When called with the last index, or with nil in an empty table, `next`\nreturns nil. If the second argument is absent, then it is interpreted as\nnil. In particular, you can use `next(t)` to check whether a table is empty.\n\nThe order in which the indices are enumerated is not specified, *even for\nnumeric indices*. (To traverse a table in numeric order, use a numerical\n`for`.)\n\nThe behavior of `next` is undefined if, during the traversal, you assign any\nvalue to a non-existent field in the table. You may however modify existing\nfields. In particular, you may clear existing fields. @@ -885,6 +880,9 @@ para_down_extend buffer.para_down_extend(buffer)\nMoves the caret down one parag para_up buffer.para_up(buffer)\nMoves the caret up one paragraph.\nParagraphs are surrounded by one or more blank lines.\n@param buffer A buffer. para_up_extend buffer.para_up_extend(buffer)\nMoves the caret up one paragraph, extending the selected text to the new\nposition.\nParagraphs are surrounded by one or more blank lines.\n@param buffer A buffer. paste buffer.paste(buffer)\nPastes the clipboard's contents into the buffer, replacing any selected text\naccording to `buffer.multi_paste`.\n@param buffer A buffer. +paste textadept.editing.paste()\nPastes the text from the clipboard, taking into account the buffer's\nindentation settings and the indentation of the current and preceding lines. +paste_reindents textadept.editing.paste_reindents (bool)\nReindent pasted text according to the buffer's indentation settings.\nThe default value is `true`. +path lexer.path (string)\nThe path used to search for a lexer to load.\nIdentical in format to Lua's `package.path` string.\nThe default value is `package.path`. path package.path (string)\nThe path used by `require` to search for a Lua loader.\nAt start-up, Lua initializes this variable with the value of the\nenvironment variable `LUA_PATH_5_3` or the environment variable `LUA_PATH`\nor with a default path defined in `luaconf.h`, if those environment\nvariables are not defined. Any "`;;`" in the value of the environment\nvariable is replaced by the default path. patterns textadept.file_types.patterns (table)\nMap of first-line patterns to their associated lexer names.\nEach pattern is matched against the first line in the file. pcall _G.pcall(f [, arg1, ···])\nCalls function `f` with the given arguments in *protected mode*. This\nmeans that any error inside `f` is not propagated; instead, `pcall` catches\nthe error and returns a status code. Its first result is the status code (a\nboolean), which is true if the call succeeds without errors. In such case,\n`pcall` also returns all results from the call, after this first result. In\ncase of any error, `pcall` returns false plus the error message. @@ -1003,7 +1001,7 @@ sel_eol_filled buffer.sel_eol_filled (bool)\nExtend the selection to the view's select _G.select(index, ···)\nIf `index` is a number, returns all arguments after argument number\n`index`; a negative number indexes from the end (-1 is the last argument).\nOtherwise, `index` must be the string `"#"`, and `select` returns the total\nnumber of extra arguments it received. select_all buffer.select_all(buffer)\nSelects all of the buffer's text without scrolling the view.\n@param buffer A buffer. select_command textadept.menu.select_command()\nPrompts the user to select a menu command to run. -select_enclosed textadept.editing.select_enclosed(left, right)\nSelects the text between strings *left* and *right* that enclose the caret.\nIf that range is already selected, toggles between selecting *left* and\n*right* as well.\n@param left The left part of the enclosure.\n@param right The right part of the enclosure. +select_enclosed textadept.editing.select_enclosed(left, right)\nSelects the text between strings *left* and *right* that enclose the caret.\nIf that range is already selected, toggles between selecting *left* and\n*right* as well.\nIf *left* and *right* are not provided, they are assumed to be one of the\ndelimiter pairs specified in `auto_pairs` and are inferred from the current\nposition or selection.\n@param left Optional left part of the enclosure.\n@param right Optional right part of the enclosure.\n@see auto_pairs select_lexer textadept.file_types.select_lexer()\nPrompts the user to select a lexer for the current buffer.\n@see buffer.set_lexer select_line textadept.editing.select_line()\nSelects the current line. select_paragraph textadept.editing.select_paragraph()\nSelects the current paragraph.\nParagraphs are surrounded by one or more blank lines. @@ -1036,7 +1034,7 @@ set_selection buffer.set_selection(buffer, end_pos, start_pos)\nSelects the rang set_styling buffer.set_styling(buffer, length, style)\nAssigns style number *style*, in the range from `0` to `255`, to the next\n*length* characters, starting from the current styling position, and\nincrements the styling position by *length*.\n`buffer:start_styling` should be called before `buffer:set_styling()`.\n@param buffer A buffer.\n@param length The number of characters to style.\n@param style The style number to set. set_target_range buffer.set_target_range(buffer, start_pos, end_pos)\nDefines the target range's beginning and end positions as *start_pos* and\n*end_pos*, respectively.\n@param buffer A buffer.\n@param start_pos The position of the beginning of the target range.\n@param end_pos The position of the end of the target range. set_text buffer.set_text(buffer, text)\nReplaces the buffer's text with string *text*.\n@param buffer A buffer.\n@param text The text to set. -set_theme ui.set_theme(name, props)\nSwitches the editor theme to string *name* and (optionally) assigns the\nproperties contained in table *props*.\nUser themes override Textadept's default themes when they have the same name.\nIf *name* contains slashes, it is assumed to be an absolute path to a theme\ninstead of a theme name.\n@param name The name or absolute path of a theme to set.\n@param props Optional table of theme property assignments that override the\n theme's defaults.\n@usage ui.set_theme('light', {font = 'Monospace', fontsize = 12}) +set_theme buffer.set_theme(name, props)\nDeclares the editor theme to be string *name* and (optionally) assigns the\nproperties contained in table *props*.\nUser themes override Textadept's default themes when they have the same name.\nIf *name* contains slashes, it is assumed to be an absolute path to a theme\ninstead of a theme name.\nNote: this function must be called on startup in order to be effective. Once\nset, it applies to all subsequent buffers, so additional calls are\nunnecessary.\n@param name The name or absolute path of a theme to set.\n@param props Optional table of theme property assignments that override the\n theme's defaults.\n@usage buffer.set_theme('light', {font = 'Monospace', fontsize = 12}) set_visible_policy buffer.set_visible_policy(buffer, policy, y)\nDefines scrolling policy bit-mask *policy* as the policy for keeping the\ncaret *y* number of lines away from the vertical margins as\n`buffer.ensure_visible_enforce_policy()` redisplays hidden or folded lines.\nIt is similar in operation to `buffer.set_y_caret_policy()`.\n@param buffer A buffer.\n@param policy The combination of `buffer.VISIBLE_SLOP` and\n `buffer.VISIBLE_STRICT` policy flags to set.\n@param y The number of lines from the vertical margins to keep the caret. set_whitespace_back buffer.set_whitespace_back(buffer, use_setting, color)\nOverrides the background color of whitespace with color *color*, in\n"0xBBGGRR" format, if *use_setting* is `true`.\n@param buffer A buffer.\n@param use_setting Whether or not to use *color*.\n@param color The color in "0xBBGGRR" format. set_whitespace_fore buffer.set_whitespace_fore(buffer, use_setting, color)\nOverrides the foreground color of whitespace with color *color*, in\n"0xBBGGRR" format, if *use_setting* is `true`.\n@param use_setting Whether or not to use *color*.\n@param color The color in "0xBBGGRR" format. @@ -1071,7 +1069,7 @@ sqrt math.sqrt(x)\nReturns the square root of `x`. (You can also use the express standard_dropdown ui.dialogs.standard_dropdown(options)\nPrompts the user with a drop-down item selection dialog defined by dialog\noptions table *options* and with localized "Ok" and "Cancel" buttons,\nreturning the selected button's index along with the selected item's index.\nIf *options*.`string_output` is `true`, returns the selected button's label\nalong with the selected item's text.\nIf the dialog closed due to *options*.`exit_onchange`, returns `4` along with\neither the selected item's index or its text. If the dialog timed out,\nreturns `0` or `"timeout"`. If the user canceled the dialog, returns `-1` or\n`"delete"`.\n@param options Table of key-value option pairs for the drop-down dialog.\n\n * `title`: The dialog's title text.\n * `text`: The dialog's main message text.\n * `items`: The list of string items to show in the drop-down.\n * `no_cancel`: Do not display the "Cancel" button. The default value is\n `false`.\n * `exit_onchange`: Close the dialog after selecting a new item. The default\n value is `false`.\n * `select`: The index of the initially selected list item. The default\n value is `1`.\n * `string_output`: Return the selected button's label (instead of its\n index) and the selected item's text (instead of its index). If no item\n was selected, returns the dialog's exit status (instead of its exit\n code). The default value is `false`.\n * `width`: The dialog's pixel width.\n * `height`: The dialog's pixel height.\n * `float`: Show the dialog on top of all desktop windows. The default value\n is `false`.\n * `timeout`: The integer number of seconds the dialog waits for the user to\n select a button before timing out. Dialogs do not time out by default.\n@return selected button or exit code, selected item standard_inputbox ui.dialogs.standard_inputbox(options)\nPrompts the user with an inputbox dialog defined by dialog options table\n*options* and with localized "Ok" and "Cancel" buttons, returning the\nselected button's index along with the user's input text (the latter as a\nstring or table, depending on the type of *options*.`informative_text`).\nIf *options*.`string_output` is `true`, returns the selected button's label\nalong with the user's input text.\nIf the dialog timed out, returns `0` or `"timeout"`. If the user canceled the\ndialog, returns `-1` or `"delete"`.\n@param options Table of key-value option pairs for the inputbox.\n\n * `title`: The dialog's title text.\n * `informative_text`: The dialog's main message text. If the value is a\n table, the first table value is the main message text and any subsequent\n values are used as the labels for multiple entry boxes. Providing a\n single label has no effect.\n * `text`: The dialog's initial input text. If the value is a table, the\n table values are used to populate the multiple entry boxes defined by\n `informative_text`.\n * `no_cancel`: Do not display the "Cancel" button. The default value is\n `false`.\n * `string_output`: Return the selected button's label (instead of its\n index) or the dialog's exit status instead of the button's index (instead\n of its exit code). The default value is `false`.\n * `width`: The dialog's pixel width.\n * `height`: The dialog's pixel height.\n * `float`: Show the dialog on top of all desktop windows. The default value\n is `false`.\n * `timeout`: The integer number of seconds the dialog waits for the user to\n select a button before timing out. Dialogs do not time out by default.\n@return selected button or exit code, input text start_styling buffer.start_styling(buffer, position, style_mask)\nBegins styling at position *position* with styling bit-mask *style_mask*.\n*style_mask* specifies which style bits can be set with\n`buffer.set_styling()`.\n@param buffer A buffer.\n@param position The position in *buffer* to start styling at.\n@param style_mask The bit mask of style bits that can be set when styling.\n@usage buffer:start_styling(0, 0xFF)\n@see set_styling -starts_line lexer.starts_line(patt)\nCreates and returns a pattern that matches pattern *patt* only at the\nbeginning of a line.\n@param patt The LPeg pattern to match on the beginning of a line.\n@usage local preproc = token(l.PREPROCESSOR, l.starts_line('#') *\n l.nonnewline^0)\n@return pattern +starts_line lexer.starts_line(patt)\nCreates and returns a pattern that matches pattern *patt* only at the\nbeginning of a line.\n@param patt The LPeg pattern to match on the beginning of a line.\n@usage local preproc = token(lexer.PREPROCESSOR, lexer.starts_line('#') *\n lexer.nonnewline^0)\n@return pattern status coroutine.status(co)\nReturns the status of coroutine `co`, as a string: `"running"`, if\nthe coroutine is running (that is, it called `status`); `"suspended"`, if\nthe coroutine is suspended in a call to `yield`, or if it has not started\nrunning yet; `"normal"` if the coroutine is active but not running (that\nis, it has resumed another coroutine); and `"dead"` if the coroutine has\nfinished its body function, or if it has stopped with an error. status spawn_proc:status()\nReturns the status of process *spawn_proc*, which is either "running" or\n"terminated".\n@return "running" or "terminated" statusbar_text ui.statusbar_text (string, Write-only)\nThe text displayed in the statusbar. @@ -1143,7 +1141,7 @@ toggle_caret_sticky buffer.toggle_caret_sticky(buffer)\nCycles between `buffer.c toggle_fold buffer.toggle_fold(buffer, line)\nToggles the fold point on line number *line* between expanded (where all of\nits child lines are displayed) and contracted (where all of its child lines\nare hidden).\n@param buffer A buffer.\n@param line The line number in *buffer* to toggle the fold on. toggle_fold_display_text buffer.toggle_fold_display_text(buffer, line, text)\nToggles a fold point on line number *line* between expanded (where all of\nits child lines are displayed) and contracted (where all of its child lines\nare hidden), and shows string *text* after the line.\n*text* is drawn with style number `buffer.STYLE_FOLDDISPLAYTEXT`.\n@param buffer A buffer.\n@param line The line number in *buffer* to toggle the fold on and display\n *text* after.\n@param text The text to display after the line. tointeger math.tointeger(x)\nIf the value `x` is convertible to an integer, returns that integer.\nOtherwise, returns nil.\n\nNew in Lua 5.3. -token lexer.token(name, patt)\nCreates and returns a token pattern with token name *name* and pattern\n*patt*.\nIf *name* is not a predefined token name, its style must be defined in the\nlexer's `_tokenstyles` table.\n@param name The name of token. If this name is not a predefined token name,\n then a style needs to be assiciated with it in the lexer's `_tokenstyles`\n table.\n@param patt The LPeg pattern associated with the token.\n@usage local ws = token(l.WHITESPACE, l.space^1)\n@usage local annotation = token('annotation', '@' * l.word)\n@return pattern +token lexer.token(name, patt)\nCreates and returns a token pattern with token name *name* and pattern\n*patt*.\nIf *name* is not a predefined token name, its style must be defined via\n`lexer.add_style()`.\n@param name The name of token. If this name is not a predefined token name,\n then a style needs to be assiciated with it via `lexer.add_style()`.\n@param patt The LPeg pattern associated with the token.\n@usage local ws = token(lexer.WHITESPACE, lexer.space^1)\n@usage local annotation = token('annotation', '@' * lexer.word)\n@return pattern tonumber _G.tonumber(e [, base])\nWhen called with no `base`, `tonumber` tries to convert its argument to a\nnumber. If the argument is already a number or a string convertible to a\nnumber, then `tonumber` returns this number; otherwise, it\nreturns nil.\n\nThe conversion of strings can result in integers or floats, according to the\nlexical conventions of Lua (see §3.1). (The string may have leading and\ntrailing spaces and a sign.)\n\nWhen called with `base`, then `e` must be a string to be interpreted as an\ninteger numeral in that base. The base may be any integer between 2 and 36,\ninclusive. In bases above 10, the letter '`A`' (in either upper or lower\ncase) represents 10, '`B`' represents 11, and so forth, with '`Z`'\nrepresenting 35. If the string `e` is not a valid numeral in the given base,\nthe function returns nil tostring _G.tostring(v)\nReceives a value of any type and converts it to a string in a human-readable\nformat. Floats always produce strings with some floating-point indication\n(either a decimal dot or an exponent). (For complete control of how numbers\nare converted, use `string.format`.)\n\nIf the metatable of `v` has a `__tostring` field, then `tostring` calls the\ncorresponding value with `v` as argument, and uses the result of the call as\nits result. touch lfs.touch(filepath [, atime [, mtime]])\nSet access and modification times of a file. This function is a bind to utime\nfunction. The first argument is the filename, the second argument (atime) is\nthe access time, and the third argument (mtime) is the modification time.\nBoth times are provided in seconds (which should be generated with Lua\nstandard function os.time). If the modification time is omitted, the access\ntime provided is used; if both times are omitted, the current time is used.\n\nReturns true if the operation was successful; in case of error, it returns\nnil plus an error string. @@ -1185,7 +1183,7 @@ view _G.view (module)\nA Textadept view object. view _G.view (table)\nThe current view. view_eol buffer.view_eol (bool)\nDisplay end of line characters.\nThe default value is `false`. view_ws buffer.view_ws (number)\nThe whitespace visibility mode.\n\n* `buffer.WS_INVISIBLE`\n Whitespace is invisible.\n* `buffer.WS_VISIBLEALWAYS`\n Display all space characters as dots and tab characters as arrows.\n* `buffer.WS_VISIBLEAFTERINDENT`\n Display only non-indentation spaces and tabs as dots and arrows.\n* `buffer.WS_VISIBLEONLYININDENT`\n Display only indentation spaces and tabs as dots and arrows.\n\nThe default value is `buffer.WS_INVISIBLE`. -virtual_space_options buffer.virtual_space_options (number)\nThe virtual space mode.\n\n* `buffer.VS_NONE`\n Disable virtual space.\n* `buffer.VS_RECTANGULARSELECTION`\n Enable virtual space only for rectangular selections.\n* `buffer.VS_USERACCESSIBLE`\n Enable virtual space.\n* `buffer.VS_NOWRAPLINESTART`\n Prevent the caret from wrapping to the previous line via\n `buffer:char_left()` and `buffer:char_left_extend()`. This option is not\n restricted to virtual space.\n\nWhen virtual space is enabled, the caret may move into the space past end\nof line characters.\nThe default value is `buffer.VS_NONE`. +virtual_space_options buffer.virtual_space_options (number)\nThe virtual space mode.\n\n* `buffer.VS_NONE`\n Disable virtual space.\n* `buffer.VS_RECTANGULARSELECTION`\n Enable virtual space only for rectangular selections.\n* `buffer.VS_USERACCESSIBLE`\n Enable virtual space.\n* `buffer.VS_NOWRAPLINESTART`\n Prevent the caret from wrapping to the previous line via\n `buffer:char_left()` and `buffer:char_left_extend()`. This option is not\n restricted to virtual space and should be added to any of the above\n options.\n\nWhen virtual space is enabled, the caret may move into the space past end\nof line characters.\nThe default value is `buffer.VS_NONE`. visible_from_doc_line buffer.visible_from_doc_line(buffer, line)\nReturns the displayed line number of actual line number *line*, taking hidden\nlines into account, or `-1` if *line* is outside the range of lines in the\nbuffer.\nLines can occupy more than one display line if they wrap.\n@param buffer A buffer.\n@param line The line number in *buffer* to use.\n@return number wait spawn_proc:wait()\nBlocks until process *spawn_proc* finishes. whitespace_chars buffer.whitespace_chars (string)\nThe string set of characters recognized as whitespace characters.\nSet this only after setting `buffer.word_chars`.\nThe default value is a string that contains all non-newline characters less\nthan ASCII value 33. @@ -1199,7 +1197,7 @@ word_left buffer.word_left(buffer)\nMoves the caret left one word.\n`buffer.word word_left_end buffer.word_left_end(buffer)\nMoves the caret left one word, positioning it at the end of the previous\nword.\n`buffer.word_chars` contains the set of characters that constitute words.\n@param buffer A buffer. word_left_end_extend buffer.word_left_end_extend(buffer)\nLike `buffer.word_left_end()`, but extends the selected text to the new\nposition.\n@param buffer A buffer. word_left_extend buffer.word_left_extend(buffer)\nMoves the caret left one word, extending the selected text to the new\nposition.\n`buffer.word_chars` contains the set of characters that constitute words.\n@param buffer A buffer. -word_match lexer.word_match(words, word_chars, case_insensitive)\nCreates and returns a pattern that matches any single word in list *words*.\nWords consist of alphanumeric and underscore characters, as well as the\ncharacters in string set *word_chars*. *case_insensitive* indicates whether\nor not to ignore case when matching words.\nThis is a convenience function for simplifying a set of ordered choice word\npatterns.\n@param words A table of words.\n@param word_chars Optional string of additional characters considered to be\n part of a word. By default, word characters are alphanumerics and\n underscores ("%w_" in Lua). This parameter may be `nil` or the empty string\n in order to indicate no additional word characters.\n@param case_insensitive Optional boolean flag indicating whether or not the\n word match is case-insensitive. The default is `false`.\n@usage local keyword = token(l.KEYWORD, word_match{'foo', 'bar', 'baz'})\n@usage local keyword = token(l.KEYWORD, word_match({'foo-bar', 'foo-baz',\n 'bar-foo', 'bar-baz', 'baz-foo', 'baz-bar'}, '-', true))\n@return pattern +word_match lexer.word_match(words, case_insensitive, word_chars)\nCreates and returns a pattern that matches any single word in string *words*.\n*case_insensitive* indicates whether or not to ignore case when matching\nwords.\nThis is a convenience function for simplifying a set of ordered choice word\npatterns.\nIf *words* is a multi-line string, it may contain Lua line comments (`--`)\nthat will ultimately be ignored.\n@param words A string list of words separated by spaces.\n@param case_insensitive Optional boolean flag indicating whether or not the\n word match is case-insensitive. The default value is `false`.\n@param word_chars Unused legacy parameter.\n@usage local keyword = token(lexer.KEYWORD, word_match[[foo bar baz]])\n@usage local keyword = token(lexer.KEYWORD, word_match([[foo-bar foo-baz\n bar-foo bar-baz baz-foo baz-bar]], true))\n@return pattern word_part_left buffer.word_part_left(buffer)\nMoves the caret to the previous part of the current word.\nWord parts are delimited by underscore characters or changes in\ncapitalization.\n`buffer.word_chars` contains the set of characters that constitute words.\n@param buffer A buffer. word_part_left_extend buffer.word_part_left_extend(buffer)\nMoves the caret to the previous part of the current word, extending the\nselected text to the new position.\nWord parts are delimited by underscore characters or changes in\ncapitalization.\n`buffer.word_chars` contains the set of characters that constitute words.\n@param buffer A buffer. word_part_right buffer.word_part_right(buffer)\nMoves the caret to the next part of the current word.\nWord parts are delimited by underscore characters or changes in\ncapitalization.\n`buffer.word_chars` contains the set of characters that constitute words.\n@param buffer A buffer. diff --git a/modules/lua/tags b/modules/lua/tags index 3d50f160..fe966991 100644 --- a/modules/lua/tags +++ b/modules/lua/tags @@ -137,7 +137,6 @@ KEYPRESS _ 0;" F class:events KEYSYMS _ 0;" t class:keys KEYWORD _ 0;" F class:lexer LABEL _ 0;" F class:lexer -LEXERPATH _ 0;" F class:lexer LEXER_LOADED _ 0;" F class:events LINUX _ 0;" F MARGINOPTION_NONE _ 0;" F class:buffer @@ -317,14 +316,13 @@ WS_INVISIBLE _ 0;" F class:buffer WS_VISIBLEAFTERINDENT _ 0;" F class:buffer WS_VISIBLEALWAYS _ 0;" F class:buffer XPM_IMAGES _ 0;" t class:textadept.editing +ZOOM _ 0;" F class:events _BUFFERS _ 0;" t _CHARSET _ 0;" F -_FOLDBYINDENTATION _ 0;" F class:lexer.lexer _G _ 0;" F _G _ 0;" m _HOME _ 0;" F _L _ 0;" m -_LEXBYLINE _ 0;" F class:lexer.lexer _M _ 0;" m _M.ansi_c _ 0;" m _M.css _ 0;" m @@ -334,28 +332,24 @@ _M.python _ 0;" m _M.rest _ 0;" m _M.ruby _ 0;" m _M.yaml _ 0;" m -_NAME _ 0;" F class:lexer.lexer _RELEASE _ 0;" F -_RULES _ 0;" F class:lexer.lexer _SCINTILLA _ 0;" m _USERHOME _ 0;" F _VERSION _ 0;" F _VIEWS _ 0;" t _cancel_current _ 0;" f class:textadept.snippets -_fold _ 0;" F class:lexer.lexer -_foldsymbols _ 0;" F class:lexer.lexer _insert _ 0;" f class:textadept.snippets -_lexer _ 0;" F class:lexer.lexer _paths _ 0;" t class:textadept.snippets _previous _ 0;" f class:textadept.snippets _print _ 0;" f class:ui -_rules _ 0;" F class:lexer.lexer _select _ 0;" f class:textadept.snippets -_tokenstyles _ 0;" F class:lexer.lexer abs _ 0;" f class:math abspath _ 0;" f class:lfs acos _ 0;" f class:math +add_fold_point _ 0;" f class:lexer +add_rule _ 0;" f class:lexer add_selection _ 0;" f class:buffer +add_style _ 0;" f class:lexer add_text _ 0;" f class:buffer additional_caret_fore _ 0;" F class:buffer additional_carets_blink _ 0;" F class:buffer @@ -564,7 +558,7 @@ edge_mode _ 0;" F class:buffer edit_toggle_overtype _ 0;" f class:buffer editing _ 0;" m class:textadept editing_keys _ 0;" t class:ui.command_entry -embed_lexer _ 0;" f class:lexer +embed _ 0;" f class:lexer emit _ 0;" f class:events empty_undo_buffer _ 0;" f class:buffer enclose _ 0;" f class:textadept.editing @@ -641,6 +635,7 @@ get_line _ 0;" f class:buffer get_line_sel_end_position _ 0;" f class:buffer get_line_sel_start_position _ 0;" f class:buffer get_project_root _ 0;" f class:io +get_rule _ 0;" f class:lexer get_sel_text _ 0;" f class:buffer get_split_table _ 0;" f class:ui get_text _ 0;" f class:buffer @@ -728,7 +723,6 @@ len _ 0;" f class:utf8 length _ 0;" F class:buffer lex _ 0;" f class:lexer lexer _ 0;" m -lexer _ 0;" t class:lexer lexers _ 0;" t class:textadept.file_types lfs _ 0;" m line_copy _ 0;" f class:buffer @@ -823,7 +817,6 @@ marker_previous _ 0;" f class:buffer marker_symbol_defined _ 0;" f class:buffer match _ 0;" f class:lpeg match _ 0;" f class:string -match_brace _ 0;" f class:textadept.editing match_case _ 0;" F class:ui.find match_case_label_text _ 0;" F class:ui.find math _ 0;" m @@ -841,6 +834,7 @@ mininteger _ 0;" F class:math mkdir _ 0;" f class:lfs modf _ 0;" f class:math modify _ 0;" F class:buffer +modify_rule _ 0;" f class:lexer module _ 0;" f mouse_dwell_time _ 0;" F class:buffer mouse_selection_rectangular_switch _ 0;" F class:buffer @@ -857,6 +851,7 @@ multiple_select_add_next _ 0;" f class:buffer multiple_selection _ 0;" F class:buffer nested_pair _ 0;" f class:lexer new _ 0;" f class:buffer +new _ 0;" f class:lexer new_line _ 0;" f class:buffer newline _ 0;" F class:lexer next _ 0;" f @@ -893,6 +888,9 @@ para_down_extend _ 0;" f class:buffer para_up _ 0;" f class:buffer para_up_extend _ 0;" f class:buffer paste _ 0;" f class:buffer +paste _ 0;" f class:textadept.editing +paste_reindents _ 0;" F class:textadept.editing +path _ 0;" F class:lexer path _ 0;" F class:package patterns _ 0;" t class:textadept.file_types pcall _ 0;" f @@ -1044,7 +1042,7 @@ set_selection _ 0;" f class:buffer set_styling _ 0;" f class:buffer set_target_range _ 0;" f class:buffer set_text _ 0;" f class:buffer -set_theme _ 0;" f class:ui +set_theme _ 0;" f class:buffer set_visible_policy _ 0;" f class:buffer set_whitespace_back _ 0;" f class:buffer set_whitespace_fore _ 0;" f class:buffer |