path: root/modules/lua/api

ANNOTATION_BOXED _SCINTILLA.constants.ANNOTATION_BOXED\n2
ANNOTATION_HIDDEN _SCINTILLA.constants.ANNOTATION_HIDDEN\n0
ANNOTATION_STANDARD _SCINTILLA.constants.ANNOTATION_STANDARD\n1
APPLEEVENT_ODOC events.APPLEEVENT_ODOC\nCalled when Mac OSX tells Textadept to open a document.\n  * `uri`: The URI to open encoded in UTF-8.
AUTOINDENT _M.textadept.editing.AUTOINDENT (bool)\nMatch the indentation level of the previous line when pressing the Enter\nkey.\nThe default value is `true`.
AUTOPAIR _M.textadept.editing.AUTOPAIR (bool)\nOpening `(`, `[`, `[`, `"`, or `'` characters are automatically closed.\nThe default value is `true`.
AUTO_C_CHAR_DELETED events.AUTO_C_CHAR_DELETED\nCalled when the user deleted a character while the autocompletion list was\nactive.
AUTO_C_RELEASE events.AUTO_C_RELEASE\nCalled when the user has cancelled the autocompletion list.
AUTO_C_SELECTION events.AUTO_C_SELECTION\nCalled when the user has selected an item in an autocompletion list and\nbefore the selection is inserted.\nAutomatic insertion can be cancelled by calling\n`buffer:auto_c_cancel()` before returning from the event handler.\nArguments:\n  * `text`: The text of the selection.\n  * `position`: The start position of the word being completed.
BUFFER_AFTER_SWITCH events.BUFFER_AFTER_SWITCH\nCalled right after a buffer is switched to.
BUFFER_BEFORE_SWITCH events.BUFFER_BEFORE_SWITCH\nCalled right before another buffer is switched to.
BUFFER_DELETED events.BUFFER_DELETED\nCalled after a buffer was deleted.
BUFFER_NEW events.BUFFER_NEW\nCalled when a new buffer is created.
C lpeg.C(patt)\nCreates a simple capture, which captures the substring of the subject that\nmatches patt. The captured value is a string. If patt has other captures,\ntheir values are returned after this one.
CALL_TIP_CLICK events.CALL_TIP_CLICK\nCalled when the user clicks on a calltip.\nArguments:\n  * `position`: Set to 1 if the click is in an up arrow, 2 if in a down\n    arrow, and 0 if elsewhere.
CARETSTYLE_BLOCK _SCINTILLA.constants.CARETSTYLE_BLOCK\n2
CARETSTYLE_INVISIBLE _SCINTILLA.constants.CARETSTYLE_INVISIBLE\n0
CARETSTYLE_LINE _SCINTILLA.constants.CARETSTYLE_LINE\n1
CARET_EVEN _SCINTILLA.constants.CARET_EVEN\n8
CARET_JUMPS _SCINTILLA.constants.CARET_JUMPS\n16
CARET_SLOP _SCINTILLA.constants.CARET_SLOP\n1
CARET_STRICT _SCINTILLA.constants.CARET_STRICT\n4
CHAR_ADDED events.CHAR_ADDED\nCalled when an ordinary text character is added to the buffer.\nArguments:\n  * `ch`: The text character byte.
CLASS lexer.CLASS\nToken type for class tokens.
CLEAR keys.CLEAR (string)\nThe string representing the key sequence that clears the current keychain.\nThe default value is `'esc'` (Escape).
COMMAND_ENTRY_COMMAND events.COMMAND_ENTRY_COMMAND\nCalled when a command is entered into the Command Entry.\nArguments:\n  * `command`: The command text.
COMMAND_ENTRY_KEYPRESS events.COMMAND_ENTRY_KEYPRESS\nCalled when a key is pressed in the Command Entry.\nArguments:\n  * `code`: The key code.\n  * `shift`: The Shift key is held down.\n  * `ctrl`: The Control/Command key is held down.\n  * `alt`: The Alt/option key is held down.\n  * `meta`: The Control key on Mac OSX is held down.
COMMENT lexer.COMMENT\nToken type for comment tokens.
COMPILE_OUTPUT events.COMPILE_OUTPUT\nCalled after a compile command is executed.\nWhen connecting to this event (typically from a language-specific module),\nconnect with an index of `1` and return `true` if the event was handled and\nyou want to override the default handler that prints the output to a new\nview.\nArguments:\n  * `lexer`: The lexer language.\n  * `output`: The output from the command.
CONSTANT lexer.CONSTANT\nToken type for constant tokens.
Carg lpeg.Carg(n)\nCreates an argument capture. This pattern matches the empty string and\nproduces the value given as the nth extra argument given in the call to\nlpeg.match.
Cb lpeg.Cb(name)\nCreates a back capture. This pattern matches the empty string and produces\nthe values produced by the most recent group capture named name.\n\nMost recent means the last complete outermost group capture with the given\nname. A Complete capture means that the entire pattern corresponding to the\ncapture has matched. An Outermost capture means that the capture is not\ninside another complete capture.
Cc lpeg.Cc([value, ...])\nCreates a constant capture. This pattern matches the empty string and\nproduces all given values as its captured values.
Cf lpeg.Cf(patt, func)\nCreates a fold capture. If patt produces a list of captures C1 C2 ... Cn,\nthis capture will produce the value func(...func(func(C1, C2), C3)..., Cn),\nthat is, it will fold (or accumulate, or reduce) the captures from patt using\nfunction func.\n\nThis capture assumes that patt should produce at least one capture with at\nleast one value (of any type), which becomes the initial value of an\naccumulator. (If you need a specific initial value, you may prefix a constant\ncapture to patt.) For each subsequent capture LPeg calls func with this\naccumulator as the first argument and all values produced by the capture as\nextra arguments; the value returned by this call becomes the new value for\nthe accumulator. The final value of the accumulator becomes the captured\nvalue.\n\nAs an example, the following pattern matches a list of numbers separated by\ncommas and returns their addition:\n\n  -- matches a numeral and captures its value\n  number = lpeg.R"09"^1 / tonumber\n  -- matches a list of numbers, captures their values\n  list = number * ("," * number)^0\n  -- auxiliary function to add two numbers\n  function add (acc, newvalue) return acc + newvalue end\n  -- folds the list of numbers adding them\n  sum = lpeg.Cf(list, add)\n  -- example of use\n  print(sum:match("10,30,43"))   --> 83
Cg lpeg.Cg(patt [, name])\nCreates a group capture. It groups all values returned by patt into a single\ncapture. The group may be anonymous (if no name is given) or named with the\ngiven name.\n\nAn anonymous group serves to join values from several captures into a single\ncapture. A named group has a different behavior. In most situations, a named\ngroup returns no values at all. Its values are only relevant for a following\nback capture or when used inside a table capture.
Cmt lpeg.Cmt(patt, function)\nCreates a match-time capture. Unlike all other captures, this one is\nevaluated immediately when a match occurs. It forces the immediate evaluation\nof all its nested captures and then calls function.\n\nThe given function gets as arguments the entire subject, the current position\n(after the match of patt), plus any capture values produced by patt.\n\nThe first value returned by function defines how the match happens. If the\ncall returns a number, the match succeeds and the returned number becomes the\nnew current position. (Assuming a subject s and current position i, the\nreturned number must be in the range [i, len(s) + 1].) If the call returns\ntrue, the match succeeds without consuming any input. (So, to return true is\nequivalent to return i.) If the call returns false, nil, or no value, the\nmatch fails.\n\nAny extra values returned by the function become the values produced by the\ncapture.
Cp lpeg.Cp()\nCreates a position capture. It matches the empty string and captures the\nposition in the subject where the match occurs. The captured value is a\nnumber.
Cs lpeg.Cs(patt)\nCreates a substitution capture, which captures the substring of the subject\nthat matches patt, with substitutions. For any capture inside patt with a\nvalue, the substring that matched the capture is replaced by the capture\nvalue (which should be a string). The final captured value is the string\nresulting from all replacements.
Ct lpeg.Ct(patt)\nCreates a table capture. This capture creates a table and puts all values\nfrom all anonymous captures made by patt inside this table in successive\ninteger keys, starting at 1. Moreover, for each named capture group created\nby patt, the first value of the group is put into the table with the group\nname as its key. The captured value is only the table.
DEFAULT lexer.DEFAULT\nToken type for default tokens.
DEFAULT_DEPTH _M.textadept.snapopen.DEFAULT_DEPTH (number)\nMaximum directory depth to search. The default value is `4`.
DEFAULT_SESSION _M.textadept.session.DEFAULT_SESSION (string)\nThe path to the default session file.
DOUBLE_CLICK events.DOUBLE_CLICK\nCalled when the mouse button is double-clicked.\nArguments:\n  * `position`: The text position of the double click.\n  * `line`: The line of the double click.\n  * `modifiers`: The key modifiers held down. It is a combination of zero\n    or more of `_SCINTILLA.constants.SCMOD_ALT`,\n    `_SCINTILLA.constants.SCMOD_CTRL`,\n    `_SCINTILLA.constants.SCMOD_SHIFT`, and\n    `_SCINTILLA.constants.SCMOD_META`.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
DWELL_END events.DWELL_END\nCalled after a `DWELL_START` and the mouse is moved or other activity such\nas key press indicates the dwell is over.\nArguments:\n  * `position`: The nearest position in the document to the position where\n    the mouse pointer was lingering.\n  * `x`: Where the pointer lingered.\n  * `y`: Where the pointer lingered.
DWELL_START events.DWELL_START\nCalled when the user keeps the mouse in one position for the dwell period\n(see `_SCINTILLA.constants.SCI_SETMOUSEDWELLTIME`).\nArguments:\n  * `position`: The nearest position in the document to the position where\n    the mouse pointer was lingering.\n  * `x`: Where the pointer lingered.\n  * `y`: Where the pointer lingered.
EDGE_BACKGROUND _SCINTILLA.constants.EDGE_BACKGROUND\n2
EDGE_LINE _SCINTILLA.constants.EDGE_LINE\n1
EDGE_NONE _SCINTILLA.constants.EDGE_NONE\n0
ERROR events.ERROR\nCalled when an error occurs.\nArguments:\n  * `text`: The error text.
ERROR lexer.ERROR\nToken type for error tokens.
FIELDS _M.textadept.adeptsense.FIELDS (string)\nXPM image for Adeptsense fields.
FILE_AFTER_SAVE events.FILE_AFTER_SAVE\nCalled right after a file is saved to disk.\nArguments:\n  * `filename`: The filename encoded in UTF-8.
FILE_BEFORE_SAVE events.FILE_BEFORE_SAVE\nCalled right before a file is saved to disk.\nArguments:\n  * `filename`: The filename encoded in UTF-8.
FILE_OPENED events.FILE_OPENED\nCalled when a file is opened in a new buffer.\nArguments:\n  * `filename`: The filename encoded in UTF-8.
FILE_SAVED_AS events.FILE_SAVED_AS\nCalled when a file is saved under a different filename.\nArguments:\n  * `filename`: The filename encoded in UTF-8.
FILTER _M.textadept.snapopen.FILTER (table)\nDefault file and directory filters.
FIND events.FIND\nCalled when finding text via the Find dialog box.\nArguments:\n  * `text`: The text to search for.\n  * `next`: Search forward.
FUNCTION lexer.FUNCTION\nToken type for function toeksn.
FUNCTIONS _M.textadept.adeptsense.FUNCTIONS (string)\nXPM image for Adeptsense functions.
HIGHLIGHT_BRACES _M.textadept.editing.HIGHLIGHT_BRACES (bool)\nHighlight matching `()[]{}` characters.\nThe default value is `true`.
HOTSPOT_CLICK events.HOTSPOT_CLICK\nCalled when the user clicks on text that is in a style with the hotspot\nattribute set.\nArguments:\n  * `position`: The text position of the click.\n  * `modifiers`: The key modifiers held down. It is a combination of zero\n    or more of `_SCINTILLA.constants.SCMOD_ALT`,\n    `_SCINTILLA.constants.SCMOD_CTRL`,\n    `_SCINTILLA.constants.SCMOD_SHIFT`, and\n    `_SCINTILLA.constants.SCMOD_META`.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
HOTSPOT_DOUBLE_CLICK events.HOTSPOT_DOUBLE_CLICK\nCalled when the user double clicks on text that is in a style with the\nhotspot attribute set.\nArguments:\n  * `position`: The text position of the double click.\n  * `modifiers`: The key modifiers held down. It is a combination of zero\n    or more of `_SCINTILLA.constants.SCMOD_ALT`,\n    `_SCINTILLA.constants.SCMOD_CTRL`,\n    `_SCINTILLA.constants.SCMOD_SHIFT`, and\n    `_SCINTILLA.constants.SCMOD_META`.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
HOTSPOT_RELEASE_CLICK events.HOTSPOT_RELEASE_CLICK\nCalled when the user releases the mouse on text that is in a style with the\nhotspot attribute set.\nArguments:\n  * `position`: The text position of the release.
IDENTIFIER lexer.IDENTIFIER\nToken type for identifier tokens.
INDIC0_MASK _SCINTILLA.constants.INDIC0_MASK\n32
INDIC1_MASK _SCINTILLA.constants.INDIC1_MASK\n64
INDIC2_MASK _SCINTILLA.constants.INDIC2_MASK\n128
INDICATOR_CLICK events.INDICATOR_CLICK\nCalled when the user clicks the mouse on text that has an indicator.\nArguments:\n  * `position`: The text position of the click.\n  * `modifiers`: The key modifiers held down. It is a combination of zero\n    or more of `_SCINTILLA.constants.SCMOD_ALT`,\n    `_SCINTILLA.constants.SCMOD_CTRL`,\n    `_SCINTILLA.constants.SCMOD_SHIFT`, and\n    `_SCINTILLA.constants.SCMOD_META`.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
INDICATOR_RELEASE events.INDICATOR_RELEASE\nCalled when the user releases the mouse on text that has an indicator.\nArguments:\n  * `position`: The text position of the release.
INDICS_MASK _SCINTILLA.constants.INDICS_MASK\n224
INDIC_BOX _SCINTILLA.constants.INDIC_BOX\n6
INDIC_CONTAINER _SCINTILLA.constants.INDIC_CONTAINER\n8
INDIC_DASH _SCINTILLA.constants.INDIC_DASH\n9
INDIC_DIAGONAL _SCINTILLA.constants.INDIC_DIAGONAL\n3
INDIC_DOTBOX _SCINTILLA.constants.INDIC_DOTBOX\n12
INDIC_DOTS _SCINTILLA.constants.INDIC_DOTS\n10
INDIC_HIDDEN _SCINTILLA.constants.INDIC_HIDDEN\n5
INDIC_HIGHLIGHT_ALPHA _M.textadept.editing.INDIC_HIGHLIGHT_ALPHA (number)\nThe alpha transparency value between `0` (transparent) and `255` (opaque)\nused for an indicator for a highlighted word.\nThe default value is `100`.
INDIC_HIGHLIGHT_BACK _M.textadept.editing.INDIC_HIGHLIGHT_BACK (number)\nThe color used for an indicator for a highlighted word in `0xBBGGRR`\nformat.
INDIC_MAX _SCINTILLA.constants.INDIC_MAX\n31
INDIC_PLAIN _SCINTILLA.constants.INDIC_PLAIN\n0
INDIC_ROUNDBOX _SCINTILLA.constants.INDIC_ROUNDBOX\n7
INDIC_SQUIGGLE _SCINTILLA.constants.INDIC_SQUIGGLE\n1
INDIC_SQUIGGLELOW _SCINTILLA.constants.INDIC_SQUIGGLELOW\n11
INDIC_STRAIGHTBOX _SCINTILLA.constants.INDIC_STRAIGHTBOX\n8
INDIC_STRIKE _SCINTILLA.constants.INDIC_STRIKE\n4
INDIC_TT _SCINTILLA.constants.INDIC_TT\n2
INVALID_POSITION _SCINTILLA.constants.INVALID_POSITION\n-1
KEYPRESS events.KEYPRESS\nCalled when a key is pressed.\nArguments:\n  * `code`: The key code.\n  * `shift`: The Shift key is held down.\n  * `ctrl`: The Control/Command key is held down.\n  * `alt`: The Alt/option key is held down.\n  * `meta`: The Control key on Mac OSX is held down.
KEYSYMS keys.KEYSYMS (table)\nLookup table for key codes higher than 255.\nIf a key code given to `keypress()` is higher than 255, this table is used to\nreturn a string representation of the key if it exists.
KEYWORD lexer.KEYWORD\nToken type for keyword tokens.
KEYWORDSET_MAX _SCINTILLA.constants.KEYWORDSET_MAX\n8
LABEL lexer.LABEL\nToken type for label tokens.
LANGUAGE_MODULE_LOADED events.LANGUAGE_MODULE_LOADED\nCalled when loading a language-specific module.\nThis is useful for overriding its key commands since they are not available\nwhen Textadept starts.\nArguments:\n  * `lang`: The language lexer name.
LANGUAGE_MODULE_PREFIX keys.LANGUAGE_MODULE_PREFIX (string)\nThe starting key command of the keychain reserved for language-specific\nmodules.\nThe default value is Ctrl/Cmd+L.
MARGIN_CLICK events.MARGIN_CLICK\nCalled when the mouse is clicked inside a margin.\nArguments:\n  * `margin`: The margin number that was clicked.\n  * `position`: The position of the start of the line in the buffer that\n    corresponds to the margin click.\n  * `modifiers`: The appropriate combination of\n    `_SCINTILLA.constants.SCI_SHIFT`, `_SCINTILLA.constants.SCI_CTRL`,\n    and `_SCINTILLA.constants.SCI_ALT` to indicate the keys that were\n    held down at the time of the margin click.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
MARKER_MAX _SCINTILLA.constants.MARKER_MAX\n31
MARK_BOOKMARK_COLOR _M.textadept.bookmarks.MARK_BOOKMARK_COLOR (number)\nThe color used for a bookmarked line in `0xBBGGRR` format.
MARK_HIGHLIGHT_BACK _M.textadept.editing.MARK_HIGHLIGHT_BACK (number)\nThe background color used for a line containing a highlighted word in\n`0xBBGGRR` format.
MAX _M.textadept.snapopen.MAX (number)\nMaximum number of files to list. The default value is `1000`.
MAX_RECENT_FILES _M.textadept.session.MAX_RECENT_FILES (number)\nThe maximum number of files from the recent files list to save to the\nsession.\nThe default value is `10`.
MENU_CLICKED events.MENU_CLICKED\nCalled when a menu item is selected.\nArguments:\n  * `menu_id`: The numeric ID of the menu item set in `gui.gtkmenu()`.
NUMBER lexer.NUMBER\nToken type for number tokens.
OPERATOR lexer.OPERATOR\nToken type for operator tokens.
OSX _G.OSX (bool)\nIf Textadept is running on Mac OSX, this flag is `true`.
P lpeg.P(value)\nConverts the given value into a proper pattern, according to the following\nrules:\n  * If the argument is a pattern, it is returned unmodified.\n  * If the argument is a string, it is translated to a pattern that matches\n    literally the string.\n  * If the argument is a non-negative number n, the result is a pattern that\n    matches exactly n characters.\n  * If the argument is a negative number -n, the result is a pattern that\n    succeeds only if the input string does not have n characters: lpeg.P(-n)\n    is equivalent to -lpeg.P(n) (see the unary minus operation).\n  * If the argument is a boolean, the result is a pattern that always\n    succeeds or always fails (according to the boolean value), without\n    consuming any input.\n  * If the argument is a table, it is interpreted as a grammar (see\n    Grammars).\n  * If the argument is a function, returns a pattern equivalent to a\n    match-time capture over the empty string.
PATHS _M.textadept.snapopen.PATHS (table)\nTable of default UTF-8 paths to search.
PREPROCESSOR lexer.PREPROCESSOR\nToken type for preprocessor tokens.
QUIT events.QUIT\nCalled when quitting Textadept.\nWhen connecting to this event, connect with an index of 1 or the handler\nwill be ignored.
R lpeg.R({range})\nReturns a pattern that matches any single character belonging to one of the\ngiven ranges. Each range is a string xy of length 2, representing all\ncharacters with code between the codes of x and y (both inclusive).\n\nAs an example, the pattern lpeg.R("09") matches any digit, and lpeg.R("az",\n"AZ") matches any ASCII letter.
REGEX lexer.REGEX\nToken type for regex tokens.
REPLACE events.REPLACE\nCalled to replace selected (found) text.\nArguments:\n  * `text`: The text to replace selected text with.
REPLACE_ALL events.REPLACE_ALL\nCalled to replace all occurances of found text.\nArguments:\n  * `find_text`: The text to search for.\n  * `repl_text`: The text to replace found text with.
RESETTING _G.RESETTING (bool)\nIf `reset()` has been called, this flag is `true` while the Lua\nstate is being re-initialized.
RESET_AFTER events.RESET_AFTER\nCalled after resetting the Lua state.\nThis is triggered by `reset()`.
RESET_BEFORE events.RESET_BEFORE\nCalled before resetting the Lua state.\nThis is triggered by `reset()`.
RUN_OUTPUT events.RUN_OUTPUT\nCalled after a run command is executed.\nWhen connecting to this event (typically from a language-specific module),\nconnect with an index of `1` and return `true` if the event was handled and\nyou want to override the default handler that prints the output to a new\nview.\nArguments:\n  * `lexer`: The lexer language.\n  * `output`: The output from the command.
S lpeg.S(string)\nReturns a pattern that matches any single character that appears in the given\nstring. (The S stands for Set.)\n\nAs an example, the pattern lpeg.S("+-*/") matches any arithmetic operator.\n\nNote that, if s is a character (that is, a string of length 1), then\nlpeg.P(s) is equivalent to lpeg.S(s) which is equivalent to lpeg.R(s..s).\nNote also that both lpeg.S("") and lpeg.R() are patterns that always fail.
SAVE_ON_QUIT _M.textadept.session.SAVE_ON_QUIT (bool)\nSave the session when quitting.\nThe default value is `true` and can be disabled by passing the command line\nswitch `-n` or `--nosession` to Textadept.
SAVE_POINT_LEFT events.SAVE_POINT_LEFT\nCalled when a save point is left.
SAVE_POINT_REACHED events.SAVE_POINT_REACHED\nCalled when a save point is entered.
SCEN_CHANGE _SCINTILLA.constants.SCEN_CHANGE\n768
SCEN_KILLFOCUS _SCINTILLA.constants.SCEN_KILLFOCUS\n256
SCEN_SETFOCUS _SCINTILLA.constants.SCEN_SETFOCUS\n512
SCFIND_MATCHCASE _SCINTILLA.constants.SCFIND_MATCHCASE\n4
SCFIND_POSIX _SCINTILLA.constants.SCFIND_POSIX\n4194304
SCFIND_REGEXP _SCINTILLA.constants.SCFIND_REGEXP\n2097152
SCFIND_WHOLEWORD _SCINTILLA.constants.SCFIND_WHOLEWORD\n2
SCFIND_WORDSTART _SCINTILLA.constants.SCFIND_WORDSTART\n1048576
SCI_ANNOTATIONGETLINES _SCINTILLA.constants.SCI_ANNOTATIONGETLINES\n2546
SCI_ANNOTATIONGETSTYLE _SCINTILLA.constants.SCI_ANNOTATIONGETSTYLE\n2543
SCI_ANNOTATIONGETSTYLEOFFSET _SCINTILLA.constants.SCI_ANNOTATIONGETSTYLEOFFSET\n2551
SCI_ANNOTATIONGETVISIBLE _SCINTILLA.constants.SCI_ANNOTATIONGETVISIBLE\n2549
SCI_ANNOTATIONSETSTYLE _SCINTILLA.constants.SCI_ANNOTATIONSETSTYLE\n2542
SCI_ANNOTATIONSETSTYLEOFFSET _SCINTILLA.constants.SCI_ANNOTATIONSETSTYLEOFFSET\n2550
SCI_ANNOTATIONSETVISIBLE _SCINTILLA.constants.SCI_ANNOTATIONSETVISIBLE\n2548
SCI_AUTOCGETAUTOHIDE _SCINTILLA.constants.SCI_AUTOCGETAUTOHIDE\n2119
SCI_AUTOCGETCANCELATSTART _SCINTILLA.constants.SCI_AUTOCGETCANCELATSTART\n2111
SCI_AUTOCGETCHOOSESINGLE _SCINTILLA.constants.SCI_AUTOCGETCHOOSESINGLE\n2114
SCI_AUTOCGETDROPRESTOFWORD _SCINTILLA.constants.SCI_AUTOCGETDROPRESTOFWORD\n2271
SCI_AUTOCGETIGNORECASE _SCINTILLA.constants.SCI_AUTOCGETIGNORECASE\n2116
SCI_AUTOCGETMAXHEIGHT _SCINTILLA.constants.SCI_AUTOCGETMAXHEIGHT\n2211
SCI_AUTOCGETMAXWIDTH _SCINTILLA.constants.SCI_AUTOCGETMAXWIDTH\n2209
SCI_AUTOCGETSEPARATOR _SCINTILLA.constants.SCI_AUTOCGETSEPARATOR\n2107
SCI_AUTOCGETTYPESEPARATOR _SCINTILLA.constants.SCI_AUTOCGETTYPESEPARATOR\n2285
SCI_AUTOCSETAUTOHIDE _SCINTILLA.constants.SCI_AUTOCSETAUTOHIDE\n2118
SCI_AUTOCSETCANCELATSTART _SCINTILLA.constants.SCI_AUTOCSETCANCELATSTART\n2110
SCI_AUTOCSETCHOOSESINGLE _SCINTILLA.constants.SCI_AUTOCSETCHOOSESINGLE\n2113
SCI_AUTOCSETDROPRESTOFWORD _SCINTILLA.constants.SCI_AUTOCSETDROPRESTOFWORD\n2270
SCI_AUTOCSETFILLUPS _SCINTILLA.constants.SCI_AUTOCSETFILLUPS\n2112
SCI_AUTOCSETIGNORECASE _SCINTILLA.constants.SCI_AUTOCSETIGNORECASE\n2115
SCI_AUTOCSETMAXHEIGHT _SCINTILLA.constants.SCI_AUTOCSETMAXHEIGHT\n2210
SCI_AUTOCSETMAXWIDTH _SCINTILLA.constants.SCI_AUTOCSETMAXWIDTH\n2208
SCI_AUTOCSETSEPARATOR _SCINTILLA.constants.SCI_AUTOCSETSEPARATOR\n2106
SCI_AUTOCSETTYPESEPARATOR _SCINTILLA.constants.SCI_AUTOCSETTYPESEPARATOR\n2286
SCI_CALLTIPSETBACK _SCINTILLA.constants.SCI_CALLTIPSETBACK\n2205
SCI_CALLTIPSETFORE _SCINTILLA.constants.SCI_CALLTIPSETFORE\n2206
SCI_CALLTIPSETFOREHLT _SCINTILLA.constants.SCI_CALLTIPSETFOREHLT\n2207
SCI_CALLTIPSETPOSITION _SCINTILLA.constants.SCI_CALLTIPSETPOSITION\n2213
SCI_CALLTIPUSESTYLE _SCINTILLA.constants.SCI_CALLTIPUSESTYLE\n2212
SCI_GETADDITIONALCARETFORE _SCINTILLA.constants.SCI_GETADDITIONALCARETFORE\n2605
SCI_GETADDITIONALCARETSBLINK _SCINTILLA.constants.SCI_GETADDITIONALCARETSBLINK\n2568
SCI_GETADDITIONALCARETSVISIBLE _SCINTILLA.constants.SCI_GETADDITIONALCARETSVISIBLE\n2609
SCI_GETADDITIONALSELALPHA _SCINTILLA.constants.SCI_GETADDITIONALSELALPHA\n2603
SCI_GETADDITIONALSELECTIONTYPING _SCINTILLA.constants.SCI_GETADDITIONALSELECTIONTYPING\n2566
SCI_GETALLLINESVISIBLE _SCINTILLA.constants.SCI_GETALLLINESVISIBLE\n2236
SCI_GETANCHOR _SCINTILLA.constants.SCI_GETANCHOR\n2009
SCI_GETBACKSPACEUNINDENTS _SCINTILLA.constants.SCI_GETBACKSPACEUNINDENTS\n2263
SCI_GETBUFFEREDDRAW _SCINTILLA.constants.SCI_GETBUFFEREDDRAW\n2034
SCI_GETCARETFORE _SCINTILLA.constants.SCI_GETCARETFORE\n2138
SCI_GETCARETLINEBACK _SCINTILLA.constants.SCI_GETCARETLINEBACK\n2097
SCI_GETCARETLINEBACKALPHA _SCINTILLA.constants.SCI_GETCARETLINEBACKALPHA\n2471
SCI_GETCARETLINEVISIBLE _SCINTILLA.constants.SCI_GETCARETLINEVISIBLE\n2095
SCI_GETCARETPERIOD _SCINTILLA.constants.SCI_GETCARETPERIOD\n2075
SCI_GETCARETSTICKY _SCINTILLA.constants.SCI_GETCARETSTICKY\n2457
SCI_GETCARETSTYLE _SCINTILLA.constants.SCI_GETCARETSTYLE\n2513
SCI_GETCARETWIDTH _SCINTILLA.constants.SCI_GETCARETWIDTH\n2189
SCI_GETCHARACTERPOINTER _SCINTILLA.constants.SCI_GETCHARACTERPOINTER\n2520
SCI_GETCHARAT _SCINTILLA.constants.SCI_GETCHARAT\n2007
SCI_GETCODEPAGE _SCINTILLA.constants.SCI_GETCODEPAGE\n2137
SCI_GETCOLUMN _SCINTILLA.constants.SCI_GETCOLUMN\n2129
SCI_GETCONTROLCHARSYMBOL _SCINTILLA.constants.SCI_GETCONTROLCHARSYMBOL\n2389
SCI_GETCURRENTPOS _SCINTILLA.constants.SCI_GETCURRENTPOS\n2008
SCI_GETCURSOR _SCINTILLA.constants.SCI_GETCURSOR\n2387
SCI_GETDIRECTFUNCTION _SCINTILLA.constants.SCI_GETDIRECTFUNCTION\n2184
SCI_GETDIRECTPOINTER _SCINTILLA.constants.SCI_GETDIRECTPOINTER\n2185
SCI_GETDOCPOINTER _SCINTILLA.constants.SCI_GETDOCPOINTER\n2357
SCI_GETEDGECOLOUR _SCINTILLA.constants.SCI_GETEDGECOLOUR\n2364
SCI_GETEDGECOLUMN _SCINTILLA.constants.SCI_GETEDGECOLUMN\n2360
SCI_GETEDGEMODE _SCINTILLA.constants.SCI_GETEDGEMODE\n2362
SCI_GETENDATLASTLINE _SCINTILLA.constants.SCI_GETENDATLASTLINE\n2278
SCI_GETENDSTYLED _SCINTILLA.constants.SCI_GETENDSTYLED\n2028
SCI_GETEOLMODE _SCINTILLA.constants.SCI_GETEOLMODE\n2030
SCI_GETEXTRAASCENT _SCINTILLA.constants.SCI_GETEXTRAASCENT\n2526
SCI_GETEXTRADESCENT _SCINTILLA.constants.SCI_GETEXTRADESCENT\n2528
SCI_GETFIRSTVISIBLELINE _SCINTILLA.constants.SCI_GETFIRSTVISIBLELINE\n2152
SCI_GETFOCUS _SCINTILLA.constants.SCI_GETFOCUS\n2381
SCI_GETFOLDEXPANDED _SCINTILLA.constants.SCI_GETFOLDEXPANDED\n2230
SCI_GETFOLDLEVEL _SCINTILLA.constants.SCI_GETFOLDLEVEL\n2223
SCI_GETFOLDPARENT _SCINTILLA.constants.SCI_GETFOLDPARENT\n2225
SCI_GETFONTQUALITY _SCINTILLA.constants.SCI_GETFONTQUALITY\n2612
SCI_GETHIGHLIGHTGUIDE _SCINTILLA.constants.SCI_GETHIGHLIGHTGUIDE\n2135
SCI_GETHOTSPOTACTIVEUNDERLINE _SCINTILLA.constants.SCI_GETHOTSPOTACTIVEUNDERLINE\n2496
SCI_GETHOTSPOTSINGLELINE _SCINTILLA.constants.SCI_GETHOTSPOTSINGLELINE\n2497
SCI_GETHSCROLLBAR _SCINTILLA.constants.SCI_GETHSCROLLBAR\n2131
SCI_GETIDENTIFIER _SCINTILLA.constants.SCI_GETIDENTIFIER\n2623
SCI_GETINDENT _SCINTILLA.constants.SCI_GETINDENT\n2123
SCI_GETINDENTATIONGUIDES _SCINTILLA.constants.SCI_GETINDENTATIONGUIDES\n2133
SCI_GETINDICATORCURRENT _SCINTILLA.constants.SCI_GETINDICATORCURRENT\n2501
SCI_GETINDICATORVALUE _SCINTILLA.constants.SCI_GETINDICATORVALUE\n2503
SCI_GETKEYSUNICODE _SCINTILLA.constants.SCI_GETKEYSUNICODE\n2522
SCI_GETLAYOUTCACHE _SCINTILLA.constants.SCI_GETLAYOUTCACHE\n2273
SCI_GETLENGTH _SCINTILLA.constants.SCI_GETLENGTH\n2006
SCI_GETLEXER _SCINTILLA.constants.SCI_GETLEXER\n4002
SCI_GETLINECOUNT _SCINTILLA.constants.SCI_GETLINECOUNT\n2154
SCI_GETLINEENDPOSITION _SCINTILLA.constants.SCI_GETLINEENDPOSITION\n2136
SCI_GETLINEINDENTATION _SCINTILLA.constants.SCI_GETLINEINDENTATION\n2127
SCI_GETLINEINDENTPOSITION _SCINTILLA.constants.SCI_GETLINEINDENTPOSITION\n2128
SCI_GETLINESTATE _SCINTILLA.constants.SCI_GETLINESTATE\n2093
SCI_GETLINEVISIBLE _SCINTILLA.constants.SCI_GETLINEVISIBLE\n2228
SCI_GETMAINSELECTION _SCINTILLA.constants.SCI_GETMAINSELECTION\n2575
SCI_GETMARGINCURSORN _SCINTILLA.constants.SCI_GETMARGINCURSORN\n2249
SCI_GETMARGINLEFT _SCINTILLA.constants.SCI_GETMARGINLEFT\n2156
SCI_GETMARGINMASKN _SCINTILLA.constants.SCI_GETMARGINMASKN\n2245
SCI_GETMARGINOPTIONS _SCINTILLA.constants.SCI_GETMARGINOPTIONS\n2557
SCI_GETMARGINRIGHT _SCINTILLA.constants.SCI_GETMARGINRIGHT\n2158
SCI_GETMARGINSENSITIVEN _SCINTILLA.constants.SCI_GETMARGINSENSITIVEN\n2247
SCI_GETMARGINTYPEN _SCINTILLA.constants.SCI_GETMARGINTYPEN\n2241
SCI_GETMARGINWIDTHN _SCINTILLA.constants.SCI_GETMARGINWIDTHN\n2243
SCI_GETMAXLINESTATE _SCINTILLA.constants.SCI_GETMAXLINESTATE\n2094
SCI_GETMODEVENTMASK _SCINTILLA.constants.SCI_GETMODEVENTMASK\n2378
SCI_GETMODIFY _SCINTILLA.constants.SCI_GETMODIFY\n2159
SCI_GETMOUSEDOWNCAPTURES _SCINTILLA.constants.SCI_GETMOUSEDOWNCAPTURES\n2385
SCI_GETMOUSEDWELLTIME _SCINTILLA.constants.SCI_GETMOUSEDWELLTIME\n2265
SCI_GETMULTIPASTE _SCINTILLA.constants.SCI_GETMULTIPASTE\n2615
SCI_GETMULTIPLESELECTION _SCINTILLA.constants.SCI_GETMULTIPLESELECTION\n2564
SCI_GETOVERTYPE _SCINTILLA.constants.SCI_GETOVERTYPE\n2187
SCI_GETPASTECONVERTENDINGS _SCINTILLA.constants.SCI_GETPASTECONVERTENDINGS\n2468
SCI_GETPOSITIONCACHE _SCINTILLA.constants.SCI_GETPOSITIONCACHE\n2515
SCI_GETPRINTCOLOURMODE _SCINTILLA.constants.SCI_GETPRINTCOLOURMODE\n2149
SCI_GETPRINTMAGNIFICATION _SCINTILLA.constants.SCI_GETPRINTMAGNIFICATION\n2147
SCI_GETPRINTWRAPMODE _SCINTILLA.constants.SCI_GETPRINTWRAPMODE\n2407
SCI_GETPROPERTYINT _SCINTILLA.constants.SCI_GETPROPERTYINT\n4010
SCI_GETREADONLY _SCINTILLA.constants.SCI_GETREADONLY\n2140
SCI_GETRECTANGULARSELECTIONANCHOR _SCINTILLA.constants.SCI_GETRECTANGULARSELECTIONANCHOR\n2591
SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE _SCINTILLA.constants.SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE\n2595
SCI_GETRECTANGULARSELECTIONCARET _SCINTILLA.constants.SCI_GETRECTANGULARSELECTIONCARET\n2589
SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE _SCINTILLA.constants.SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE\n2593
SCI_GETRECTANGULARSELECTIONMODIFIER _SCINTILLA.constants.SCI_GETRECTANGULARSELECTIONMODIFIER\n2599
SCI_GETSCROLLWIDTH _SCINTILLA.constants.SCI_GETSCROLLWIDTH\n2275
SCI_GETSCROLLWIDTHTRACKING _SCINTILLA.constants.SCI_GETSCROLLWIDTHTRACKING\n2517
SCI_GETSEARCHFLAGS _SCINTILLA.constants.SCI_GETSEARCHFLAGS\n2199
SCI_GETSELALPHA _SCINTILLA.constants.SCI_GETSELALPHA\n2477
SCI_GETSELECTIONEND _SCINTILLA.constants.SCI_GETSELECTIONEND\n2145
SCI_GETSELECTIONMODE _SCINTILLA.constants.SCI_GETSELECTIONMODE\n2423
SCI_GETSELECTIONNANCHOR _SCINTILLA.constants.SCI_GETSELECTIONNANCHOR\n2579
SCI_GETSELECTIONNANCHORVIRTUALSPACE _SCINTILLA.constants.SCI_GETSELECTIONNANCHORVIRTUALSPACE\n2583
SCI_GETSELECTIONNCARET _SCINTILLA.constants.SCI_GETSELECTIONNCARET\n2577
SCI_GETSELECTIONNCARETVIRTUALSPACE _SCINTILLA.constants.SCI_GETSELECTIONNCARETVIRTUALSPACE\n2581
SCI_GETSELECTIONNEND _SCINTILLA.constants.SCI_GETSELECTIONNEND\n2587
SCI_GETSELECTIONNSTART _SCINTILLA.constants.SCI_GETSELECTIONNSTART\n2585
SCI_GETSELECTIONS _SCINTILLA.constants.SCI_GETSELECTIONS\n2570
SCI_GETSELECTIONSTART _SCINTILLA.constants.SCI_GETSELECTIONSTART\n2143
SCI_GETSELEOLFILLED _SCINTILLA.constants.SCI_GETSELEOLFILLED\n2479
SCI_GETSTATUS _SCINTILLA.constants.SCI_GETSTATUS\n2383
SCI_GETSTYLEAT _SCINTILLA.constants.SCI_GETSTYLEAT\n2010
SCI_GETSTYLEBITS _SCINTILLA.constants.SCI_GETSTYLEBITS\n2091
SCI_GETSTYLEBITSNEEDED _SCINTILLA.constants.SCI_GETSTYLEBITSNEEDED\n4011
SCI_GETTABINDENTS _SCINTILLA.constants.SCI_GETTABINDENTS\n2261
SCI_GETTABWIDTH _SCINTILLA.constants.SCI_GETTABWIDTH\n2121
SCI_GETTARGETEND _SCINTILLA.constants.SCI_GETTARGETEND\n2193
SCI_GETTARGETSTART _SCINTILLA.constants.SCI_GETTARGETSTART\n2191
SCI_GETTECHNOLOGY _SCINTILLA.constants.SCI_GETTECHNOLOGY\n2631
SCI_GETTEXTLENGTH _SCINTILLA.constants.SCI_GETTEXTLENGTH\n2183
SCI_GETTWOPHASEDRAW _SCINTILLA.constants.SCI_GETTWOPHASEDRAW\n2283
SCI_GETUNDOCOLLECTION _SCINTILLA.constants.SCI_GETUNDOCOLLECTION\n2019
SCI_GETUSETABS _SCINTILLA.constants.SCI_GETUSETABS\n2125
SCI_GETVIEWEOL _SCINTILLA.constants.SCI_GETVIEWEOL\n2355
SCI_GETVIEWWS _SCINTILLA.constants.SCI_GETVIEWWS\n2020
SCI_GETVIRTUALSPACEOPTIONS _SCINTILLA.constants.SCI_GETVIRTUALSPACEOPTIONS\n2597
SCI_GETVSCROLLBAR _SCINTILLA.constants.SCI_GETVSCROLLBAR\n2281
SCI_GETWHITESPACESIZE _SCINTILLA.constants.SCI_GETWHITESPACESIZE\n2087
SCI_GETWRAPINDENTMODE _SCINTILLA.constants.SCI_GETWRAPINDENTMODE\n2473
SCI_GETWRAPMODE _SCINTILLA.constants.SCI_GETWRAPMODE\n2269
SCI_GETWRAPSTARTINDENT _SCINTILLA.constants.SCI_GETWRAPSTARTINDENT\n2465
SCI_GETWRAPVISUALFLAGS _SCINTILLA.constants.SCI_GETWRAPVISUALFLAGS\n2461
SCI_GETWRAPVISUALFLAGSLOCATION _SCINTILLA.constants.SCI_GETWRAPVISUALFLAGSLOCATION\n2463
SCI_GETXOFFSET _SCINTILLA.constants.SCI_GETXOFFSET\n2398
SCI_GETZOOM _SCINTILLA.constants.SCI_GETZOOM\n2374
SCI_INDICGETALPHA _SCINTILLA.constants.SCI_INDICGETALPHA\n2524
SCI_INDICGETFORE _SCINTILLA.constants.SCI_INDICGETFORE\n2083
SCI_INDICGETOUTLINEALPHA _SCINTILLA.constants.SCI_INDICGETOUTLINEALPHA\n2559
SCI_INDICGETSTYLE _SCINTILLA.constants.SCI_INDICGETSTYLE\n2081
SCI_INDICGETUNDER _SCINTILLA.constants.SCI_INDICGETUNDER\n2511
SCI_INDICSETALPHA _SCINTILLA.constants.SCI_INDICSETALPHA\n2523
SCI_INDICSETFORE _SCINTILLA.constants.SCI_INDICSETFORE\n2082
SCI_INDICSETOUTLINEALPHA _SCINTILLA.constants.SCI_INDICSETOUTLINEALPHA\n2558
SCI_INDICSETSTYLE _SCINTILLA.constants.SCI_INDICSETSTYLE\n2080
SCI_INDICSETUNDER _SCINTILLA.constants.SCI_INDICSETUNDER\n2510
SCI_LEXER_START _SCINTILLA.constants.SCI_LEXER_START\n4000
SCI_LINESONSCREEN _SCINTILLA.constants.SCI_LINESONSCREEN\n2370
SCI_MARGINGETSTYLE _SCINTILLA.constants.SCI_MARGINGETSTYLE\n2533
SCI_MARGINGETSTYLEOFFSET _SCINTILLA.constants.SCI_MARGINGETSTYLEOFFSET\n2538
SCI_MARGINSETSTYLE _SCINTILLA.constants.SCI_MARGINSETSTYLE\n2532
SCI_MARGINSETSTYLEOFFSET _SCINTILLA.constants.SCI_MARGINSETSTYLEOFFSET\n2537
SCI_OPTIONAL_START _SCINTILLA.constants.SCI_OPTIONAL_START\n3000
SCI_RGBAIMAGESETHEIGHT _SCINTILLA.constants.SCI_RGBAIMAGESETHEIGHT\n2625
SCI_RGBAIMAGESETWIDTH _SCINTILLA.constants.SCI_RGBAIMAGESETWIDTH\n2624
SCI_SELECTIONISRECTANGLE _SCINTILLA.constants.SCI_SELECTIONISRECTANGLE\n2372
SCI_SETADDITIONALCARETFORE _SCINTILLA.constants.SCI_SETADDITIONALCARETFORE\n2604
SCI_SETADDITIONALCARETSBLINK _SCINTILLA.constants.SCI_SETADDITIONALCARETSBLINK\n2567
SCI_SETADDITIONALCARETSVISIBLE _SCINTILLA.constants.SCI_SETADDITIONALCARETSVISIBLE\n2608
SCI_SETADDITIONALSELALPHA _SCINTILLA.constants.SCI_SETADDITIONALSELALPHA\n2602
SCI_SETADDITIONALSELBACK _SCINTILLA.constants.SCI_SETADDITIONALSELBACK\n2601
SCI_SETADDITIONALSELECTIONTYPING _SCINTILLA.constants.SCI_SETADDITIONALSELECTIONTYPING\n2565
SCI_SETADDITIONALSELFORE _SCINTILLA.constants.SCI_SETADDITIONALSELFORE\n2600
SCI_SETANCHOR _SCINTILLA.constants.SCI_SETANCHOR\n2026
SCI_SETBACKSPACEUNINDENTS _SCINTILLA.constants.SCI_SETBACKSPACEUNINDENTS\n2262
SCI_SETBUFFEREDDRAW _SCINTILLA.constants.SCI_SETBUFFEREDDRAW\n2035
SCI_SETCARETFORE _SCINTILLA.constants.SCI_SETCARETFORE\n2069
SCI_SETCARETLINEBACK _SCINTILLA.constants.SCI_SETCARETLINEBACK\n2098
SCI_SETCARETLINEBACKALPHA _SCINTILLA.constants.SCI_SETCARETLINEBACKALPHA\n2470
SCI_SETCARETLINEVISIBLE _SCINTILLA.constants.SCI_SETCARETLINEVISIBLE\n2096
SCI_SETCARETPERIOD _SCINTILLA.constants.SCI_SETCARETPERIOD\n2076
SCI_SETCARETSTICKY _SCINTILLA.constants.SCI_SETCARETSTICKY\n2458
SCI_SETCARETSTYLE _SCINTILLA.constants.SCI_SETCARETSTYLE\n2512
SCI_SETCARETWIDTH _SCINTILLA.constants.SCI_SETCARETWIDTH\n2188
SCI_SETCODEPAGE _SCINTILLA.constants.SCI_SETCODEPAGE\n2037
SCI_SETCONTROLCHARSYMBOL _SCINTILLA.constants.SCI_SETCONTROLCHARSYMBOL\n2388
SCI_SETCURRENTPOS _SCINTILLA.constants.SCI_SETCURRENTPOS\n2141
SCI_SETCURSOR _SCINTILLA.constants.SCI_SETCURSOR\n2386
SCI_SETDOCPOINTER _SCINTILLA.constants.SCI_SETDOCPOINTER\n2358
SCI_SETEDGECOLOUR _SCINTILLA.constants.SCI_SETEDGECOLOUR\n2365
SCI_SETEDGECOLUMN _SCINTILLA.constants.SCI_SETEDGECOLUMN\n2361
SCI_SETEDGEMODE _SCINTILLA.constants.SCI_SETEDGEMODE\n2363
SCI_SETENDATLASTLINE _SCINTILLA.constants.SCI_SETENDATLASTLINE\n2277
SCI_SETEOLMODE _SCINTILLA.constants.SCI_SETEOLMODE\n2031
SCI_SETEXTRAASCENT _SCINTILLA.constants.SCI_SETEXTRAASCENT\n2525
SCI_SETEXTRADESCENT _SCINTILLA.constants.SCI_SETEXTRADESCENT\n2527
SCI_SETFIRSTVISIBLELINE _SCINTILLA.constants.SCI_SETFIRSTVISIBLELINE\n2613
SCI_SETFOCUS _SCINTILLA.constants.SCI_SETFOCUS\n2380
SCI_SETFOLDEXPANDED _SCINTILLA.constants.SCI_SETFOLDEXPANDED\n2229
SCI_SETFOLDLEVEL _SCINTILLA.constants.SCI_SETFOLDLEVEL\n2222
SCI_SETFONTQUALITY _SCINTILLA.constants.SCI_SETFONTQUALITY\n2611
SCI_SETHIGHLIGHTGUIDE _SCINTILLA.constants.SCI_SETHIGHLIGHTGUIDE\n2134
SCI_SETHOTSPOTACTIVEUNDERLINE _SCINTILLA.constants.SCI_SETHOTSPOTACTIVEUNDERLINE\n2412
SCI_SETHOTSPOTSINGLELINE _SCINTILLA.constants.SCI_SETHOTSPOTSINGLELINE\n2421
SCI_SETHSCROLLBAR _SCINTILLA.constants.SCI_SETHSCROLLBAR\n2130
SCI_SETIDENTIFIER _SCINTILLA.constants.SCI_SETIDENTIFIER\n2622
SCI_SETINDENT _SCINTILLA.constants.SCI_SETINDENT\n2122
SCI_SETINDENTATIONGUIDES _SCINTILLA.constants.SCI_SETINDENTATIONGUIDES\n2132
SCI_SETINDICATORCURRENT _SCINTILLA.constants.SCI_SETINDICATORCURRENT\n2500
SCI_SETINDICATORVALUE _SCINTILLA.constants.SCI_SETINDICATORVALUE\n2502
SCI_SETKEYSUNICODE _SCINTILLA.constants.SCI_SETKEYSUNICODE\n2521
SCI_SETKEYWORDS _SCINTILLA.constants.SCI_SETKEYWORDS\n4005
SCI_SETLAYOUTCACHE _SCINTILLA.constants.SCI_SETLAYOUTCACHE\n2272
SCI_SETLEXER _SCINTILLA.constants.SCI_SETLEXER\n4001
SCI_SETLINEINDENTATION _SCINTILLA.constants.SCI_SETLINEINDENTATION\n2126
SCI_SETLINESTATE _SCINTILLA.constants.SCI_SETLINESTATE\n2092
SCI_SETMAINSELECTION _SCINTILLA.constants.SCI_SETMAINSELECTION\n2574
SCI_SETMARGINCURSORN _SCINTILLA.constants.SCI_SETMARGINCURSORN\n2248
SCI_SETMARGINLEFT _SCINTILLA.constants.SCI_SETMARGINLEFT\n2155
SCI_SETMARGINMASKN _SCINTILLA.constants.SCI_SETMARGINMASKN\n2244
SCI_SETMARGINOPTIONS _SCINTILLA.constants.SCI_SETMARGINOPTIONS\n2539
SCI_SETMARGINRIGHT _SCINTILLA.constants.SCI_SETMARGINRIGHT\n2157
SCI_SETMARGINSENSITIVEN _SCINTILLA.constants.SCI_SETMARGINSENSITIVEN\n2246
SCI_SETMARGINTYPEN _SCINTILLA.constants.SCI_SETMARGINTYPEN\n2240
SCI_SETMARGINWIDTHN _SCINTILLA.constants.SCI_SETMARGINWIDTHN\n2242
SCI_SETMODEVENTMASK _SCINTILLA.constants.SCI_SETMODEVENTMASK\n2359
SCI_SETMOUSEDOWNCAPTURES _SCINTILLA.constants.SCI_SETMOUSEDOWNCAPTURES\n2384
SCI_SETMOUSEDWELLTIME _SCINTILLA.constants.SCI_SETMOUSEDWELLTIME\n2264
SCI_SETMULTIPASTE _SCINTILLA.constants.SCI_SETMULTIPASTE\n2614
SCI_SETMULTIPLESELECTION _SCINTILLA.constants.SCI_SETMULTIPLESELECTION\n2563
SCI_SETOVERTYPE _SCINTILLA.constants.SCI_SETOVERTYPE\n2186
SCI_SETPASTECONVERTENDINGS _SCINTILLA.constants.SCI_SETPASTECONVERTENDINGS\n2467
SCI_SETPOSITIONCACHE _SCINTILLA.constants.SCI_SETPOSITIONCACHE\n2514
SCI_SETPRINTCOLOURMODE _SCINTILLA.constants.SCI_SETPRINTCOLOURMODE\n2148
SCI_SETPRINTMAGNIFICATION _SCINTILLA.constants.SCI_SETPRINTMAGNIFICATION\n2146
SCI_SETPRINTWRAPMODE _SCINTILLA.constants.SCI_SETPRINTWRAPMODE\n2406
SCI_SETPROPERTY _SCINTILLA.constants.SCI_SETPROPERTY\n4004
SCI_SETREADONLY _SCINTILLA.constants.SCI_SETREADONLY\n2171
SCI_SETRECTANGULARSELECTIONANCHOR _SCINTILLA.constants.SCI_SETRECTANGULARSELECTIONANCHOR\n2590
SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE _SCINTILLA.constants.SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE\n2594
SCI_SETRECTANGULARSELECTIONCARET _SCINTILLA.constants.SCI_SETRECTANGULARSELECTIONCARET\n2588
SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE _SCINTILLA.constants.SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE\n2592
SCI_SETRECTANGULARSELECTIONMODIFIER _SCINTILLA.constants.SCI_SETRECTANGULARSELECTIONMODIFIER\n2598
SCI_SETSCROLLWIDTH _SCINTILLA.constants.SCI_SETSCROLLWIDTH\n2274
SCI_SETSCROLLWIDTHTRACKING _SCINTILLA.constants.SCI_SETSCROLLWIDTHTRACKING\n2516
SCI_SETSEARCHFLAGS _SCINTILLA.constants.SCI_SETSEARCHFLAGS\n2198
SCI_SETSELALPHA _SCINTILLA.constants.SCI_SETSELALPHA\n2478
SCI_SETSELECTIONEND _SCINTILLA.constants.SCI_SETSELECTIONEND\n2144
SCI_SETSELECTIONMODE _SCINTILLA.constants.SCI_SETSELECTIONMODE\n2422
SCI_SETSELECTIONNANCHOR _SCINTILLA.constants.SCI_SETSELECTIONNANCHOR\n2578
SCI_SETSELECTIONNANCHORVIRTUALSPACE _SCINTILLA.constants.SCI_SETSELECTIONNANCHORVIRTUALSPACE\n2582
SCI_SETSELECTIONNCARET _SCINTILLA.constants.SCI_SETSELECTIONNCARET\n2576
SCI_SETSELECTIONNCARETVIRTUALSPACE _SCINTILLA.constants.SCI_SETSELECTIONNCARETVIRTUALSPACE\n2580
SCI_SETSELECTIONNEND _SCINTILLA.constants.SCI_SETSELECTIONNEND\n2586
SCI_SETSELECTIONNSTART _SCINTILLA.constants.SCI_SETSELECTIONNSTART\n2584
SCI_SETSELECTIONSTART _SCINTILLA.constants.SCI_SETSELECTIONSTART\n2142
SCI_SETSELEOLFILLED _SCINTILLA.constants.SCI_SETSELEOLFILLED\n2480
SCI_SETSTATUS _SCINTILLA.constants.SCI_SETSTATUS\n2382
SCI_SETSTYLEBITS _SCINTILLA.constants.SCI_SETSTYLEBITS\n2090
SCI_SETTABINDENTS _SCINTILLA.constants.SCI_SETTABINDENTS\n2260
SCI_SETTABWIDTH _SCINTILLA.constants.SCI_SETTABWIDTH\n2036
SCI_SETTARGETEND _SCINTILLA.constants.SCI_SETTARGETEND\n2192
SCI_SETTARGETSTART _SCINTILLA.constants.SCI_SETTARGETSTART\n2190
SCI_SETTECHNOLOGY _SCINTILLA.constants.SCI_SETTECHNOLOGY\n2630
SCI_SETTWOPHASEDRAW _SCINTILLA.constants.SCI_SETTWOPHASEDRAW\n2284
SCI_SETUNDOCOLLECTION _SCINTILLA.constants.SCI_SETUNDOCOLLECTION\n2012
SCI_SETUSETABS _SCINTILLA.constants.SCI_SETUSETABS\n2124
SCI_SETVIEWEOL _SCINTILLA.constants.SCI_SETVIEWEOL\n2356
SCI_SETVIEWWS _SCINTILLA.constants.SCI_SETVIEWWS\n2021
SCI_SETVIRTUALSPACEOPTIONS _SCINTILLA.constants.SCI_SETVIRTUALSPACEOPTIONS\n2596
SCI_SETVSCROLLBAR _SCINTILLA.constants.SCI_SETVSCROLLBAR\n2280
SCI_SETWHITESPACECHARS _SCINTILLA.constants.SCI_SETWHITESPACECHARS\n2443
SCI_SETWHITESPACESIZE _SCINTILLA.constants.SCI_SETWHITESPACESIZE\n2086
SCI_SETWORDCHARS _SCINTILLA.constants.SCI_SETWORDCHARS\n2077
SCI_SETWRAPINDENTMODE _SCINTILLA.constants.SCI_SETWRAPINDENTMODE\n2472
SCI_SETWRAPMODE _SCINTILLA.constants.SCI_SETWRAPMODE\n2268
SCI_SETWRAPSTARTINDENT _SCINTILLA.constants.SCI_SETWRAPSTARTINDENT\n2464
SCI_SETWRAPVISUALFLAGS _SCINTILLA.constants.SCI_SETWRAPVISUALFLAGS\n2460
SCI_SETWRAPVISUALFLAGSLOCATION _SCINTILLA.constants.SCI_SETWRAPVISUALFLAGSLOCATION\n2462
SCI_SETXOFFSET _SCINTILLA.constants.SCI_SETXOFFSET\n2397
SCI_SETZOOM _SCINTILLA.constants.SCI_SETZOOM\n2373
SCI_START _SCINTILLA.constants.SCI_START\n2000
SCI_STYLEGETBACK _SCINTILLA.constants.SCI_STYLEGETBACK\n2482
SCI_STYLEGETBOLD _SCINTILLA.constants.SCI_STYLEGETBOLD\n2483
SCI_STYLEGETCASE _SCINTILLA.constants.SCI_STYLEGETCASE\n2489
SCI_STYLEGETCHANGEABLE _SCINTILLA.constants.SCI_STYLEGETCHANGEABLE\n2492
SCI_STYLEGETCHARACTERSET _SCINTILLA.constants.SCI_STYLEGETCHARACTERSET\n2490
SCI_STYLEGETEOLFILLED _SCINTILLA.constants.SCI_STYLEGETEOLFILLED\n2487
SCI_STYLEGETFORE _SCINTILLA.constants.SCI_STYLEGETFORE\n2481
SCI_STYLEGETHOTSPOT _SCINTILLA.constants.SCI_STYLEGETHOTSPOT\n2493
SCI_STYLEGETITALIC _SCINTILLA.constants.SCI_STYLEGETITALIC\n2484
SCI_STYLEGETSIZE _SCINTILLA.constants.SCI_STYLEGETSIZE\n2485
SCI_STYLEGETSIZEFRACTIONAL _SCINTILLA.constants.SCI_STYLEGETSIZEFRACTIONAL\n2062
SCI_STYLEGETUNDERLINE _SCINTILLA.constants.SCI_STYLEGETUNDERLINE\n2488
SCI_STYLEGETVISIBLE _SCINTILLA.constants.SCI_STYLEGETVISIBLE\n2491
SCI_STYLEGETWEIGHT _SCINTILLA.constants.SCI_STYLEGETWEIGHT\n2064
SCI_STYLESETBACK _SCINTILLA.constants.SCI_STYLESETBACK\n2052
SCI_STYLESETBOLD _SCINTILLA.constants.SCI_STYLESETBOLD\n2053
SCI_STYLESETCASE _SCINTILLA.constants.SCI_STYLESETCASE\n2060
SCI_STYLESETCHANGEABLE _SCINTILLA.constants.SCI_STYLESETCHANGEABLE\n2099
SCI_STYLESETCHARACTERSET _SCINTILLA.constants.SCI_STYLESETCHARACTERSET\n2066
SCI_STYLESETEOLFILLED _SCINTILLA.constants.SCI_STYLESETEOLFILLED\n2057
SCI_STYLESETFONT _SCINTILLA.constants.SCI_STYLESETFONT\n2056
SCI_STYLESETFORE _SCINTILLA.constants.SCI_STYLESETFORE\n2051
SCI_STYLESETHOTSPOT _SCINTILLA.constants.SCI_STYLESETHOTSPOT\n2409
SCI_STYLESETITALIC _SCINTILLA.constants.SCI_STYLESETITALIC\n2054
SCI_STYLESETSIZE _SCINTILLA.constants.SCI_STYLESETSIZE\n2055
SCI_STYLESETSIZEFRACTIONAL _SCINTILLA.constants.SCI_STYLESETSIZEFRACTIONAL\n2061
SCI_STYLESETUNDERLINE _SCINTILLA.constants.SCI_STYLESETUNDERLINE\n2059
SCI_STYLESETVISIBLE _SCINTILLA.constants.SCI_STYLESETVISIBLE\n2074
SCI_STYLESETWEIGHT _SCINTILLA.constants.SCI_STYLESETWEIGHT\n2063
SCK_ADD _SCINTILLA.constants.SCK_ADD\n310
SCK_BACK _SCINTILLA.constants.SCK_BACK\n8
SCK_DELETE _SCINTILLA.constants.SCK_DELETE\n308
SCK_DIVIDE _SCINTILLA.constants.SCK_DIVIDE\n312
SCK_DOWN _SCINTILLA.constants.SCK_DOWN\n300
SCK_END _SCINTILLA.constants.SCK_END\n305
SCK_ESCAPE _SCINTILLA.constants.SCK_ESCAPE\n7
SCK_HOME _SCINTILLA.constants.SCK_HOME\n304
SCK_INSERT _SCINTILLA.constants.SCK_INSERT\n309
SCK_LEFT _SCINTILLA.constants.SCK_LEFT\n302
SCK_MENU _SCINTILLA.constants.SCK_MENU\n315
SCK_NEXT _SCINTILLA.constants.SCK_NEXT\n307
SCK_PRIOR _SCINTILLA.constants.SCK_PRIOR\n306
SCK_RETURN _SCINTILLA.constants.SCK_RETURN\n13
SCK_RIGHT _SCINTILLA.constants.SCK_RIGHT\n303
SCK_RWIN _SCINTILLA.constants.SCK_RWIN\n314
SCK_SUBTRACT _SCINTILLA.constants.SCK_SUBTRACT\n311
SCK_TAB _SCINTILLA.constants.SCK_TAB\n9
SCK_UP _SCINTILLA.constants.SCK_UP\n301
SCK_WIN _SCINTILLA.constants.SCK_WIN\n313
SCLEX_AUTOMATIC _SCINTILLA.constants.SCLEX_AUTOMATIC\n1000
SCLEX_CONTAINER _SCINTILLA.constants.SCLEX_CONTAINER\n0
SCLEX_LPEG _SCINTILLA.constants.SCLEX_LPEG\n999
SCMOD_ALT _SCINTILLA.constants.SCMOD_ALT\n4
SCMOD_CTRL _SCINTILLA.constants.SCMOD_CTRL\n2
SCMOD_META _SCINTILLA.constants.SCMOD_META\n16
SCMOD_NORM _SCINTILLA.constants.SCMOD_NORM\n0
SCMOD_SHIFT _SCINTILLA.constants.SCMOD_SHIFT\n1
SCMOD_SUPER _SCINTILLA.constants.SCMOD_SUPER\n8
SCN_AUTOCCANCELLED _SCINTILLA.constants.SCN_AUTOCCANCELLED\n2026
SCN_AUTOCCHARDELETED _SCINTILLA.constants.SCN_AUTOCCHARDELETED\n2027
SCN_AUTOCSELECTION _SCINTILLA.constants.SCN_AUTOCSELECTION\n2022
SCN_CALLTIPCLICK _SCINTILLA.constants.SCN_CALLTIPCLICK\n2021
SCN_CHARADDED _SCINTILLA.constants.SCN_CHARADDED\n2001
SCN_DOUBLECLICK _SCINTILLA.constants.SCN_DOUBLECLICK\n2006
SCN_DWELLEND _SCINTILLA.constants.SCN_DWELLEND\n2017
SCN_DWELLSTART _SCINTILLA.constants.SCN_DWELLSTART\n2016
SCN_HOTSPOTCLICK _SCINTILLA.constants.SCN_HOTSPOTCLICK\n2019
SCN_HOTSPOTDOUBLECLICK _SCINTILLA.constants.SCN_HOTSPOTDOUBLECLICK\n2020
SCN_HOTSPOTRELEASECLICK _SCINTILLA.constants.SCN_HOTSPOTRELEASECLICK\n2028
SCN_INDICATORCLICK _SCINTILLA.constants.SCN_INDICATORCLICK\n2023
SCN_INDICATORRELEASE _SCINTILLA.constants.SCN_INDICATORRELEASE\n2024
SCN_KEY _SCINTILLA.constants.SCN_KEY\n2005
SCN_MACRORECORD _SCINTILLA.constants.SCN_MACRORECORD\n2009
SCN_MARGINCLICK _SCINTILLA.constants.SCN_MARGINCLICK\n2010
SCN_MODIFIED _SCINTILLA.constants.SCN_MODIFIED\n2008
SCN_MODIFYATTEMPTRO _SCINTILLA.constants.SCN_MODIFYATTEMPTRO\n2004
SCN_NEEDSHOWN _SCINTILLA.constants.SCN_NEEDSHOWN\n2011
SCN_PAINTED _SCINTILLA.constants.SCN_PAINTED\n2013
SCN_SAVEPOINTLEFT _SCINTILLA.constants.SCN_SAVEPOINTLEFT\n2003
SCN_SAVEPOINTREACHED _SCINTILLA.constants.SCN_SAVEPOINTREACHED\n2002
SCN_STYLENEEDED _SCINTILLA.constants.SCN_STYLENEEDED\n2000
SCN_UPDATEUI _SCINTILLA.constants.SCN_UPDATEUI\n2007
SCN_URIDROPPED _SCINTILLA.constants.SCN_URIDROPPED\n2015
SCN_USERLISTSELECTION _SCINTILLA.constants.SCN_USERLISTSELECTION\n2014
SCN_ZOOM _SCINTILLA.constants.SCN_ZOOM\n2018
SCVS_NONE _SCINTILLA.constants.SCVS_NONE\n0
SCVS_RECTANGULARSELECTION _SCINTILLA.constants.SCVS_RECTANGULARSELECTION\n1
SCVS_USERACCESSIBLE _SCINTILLA.constants.SCVS_USERACCESSIBLE\n2
SCWS_INVISIBLE _SCINTILLA.constants.SCWS_INVISIBLE\n0
SCWS_VISIBLEAFTERINDENT _SCINTILLA.constants.SCWS_VISIBLEAFTERINDENT\n2
SCWS_VISIBLEALWAYS _SCINTILLA.constants.SCWS_VISIBLEALWAYS\n1
SC_ALPHA_NOALPHA _SCINTILLA.constants.SC_ALPHA_NOALPHA\n256
SC_ALPHA_OPAQUE _SCINTILLA.constants.SC_ALPHA_OPAQUE\n255
SC_ALPHA_TRANSPARENT _SCINTILLA.constants.SC_ALPHA_TRANSPARENT\n0
SC_CACHE_CARET _SCINTILLA.constants.SC_CACHE_CARET\n1
SC_CACHE_DOCUMENT _SCINTILLA.constants.SC_CACHE_DOCUMENT\n3
SC_CACHE_NONE _SCINTILLA.constants.SC_CACHE_NONE\n0
SC_CACHE_PAGE _SCINTILLA.constants.SC_CACHE_PAGE\n2
SC_CARETSTICKY_OFF _SCINTILLA.constants.SC_CARETSTICKY_OFF\n0
SC_CARETSTICKY_ON _SCINTILLA.constants.SC_CARETSTICKY_ON\n1
SC_CARETSTICKY_WHITESPACE _SCINTILLA.constants.SC_CARETSTICKY_WHITESPACE\n2
SC_CASE_LOWER _SCINTILLA.constants.SC_CASE_LOWER\n2
SC_CASE_MIXED _SCINTILLA.constants.SC_CASE_MIXED\n0
SC_CASE_UPPER _SCINTILLA.constants.SC_CASE_UPPER\n1
SC_CHARSET_8859_15 _SCINTILLA.constants.SC_CHARSET_8859_15\n1000
SC_CHARSET_ANSI _SCINTILLA.constants.SC_CHARSET_ANSI\n0
SC_CHARSET_ARABIC _SCINTILLA.constants.SC_CHARSET_ARABIC\n178
SC_CHARSET_BALTIC _SCINTILLA.constants.SC_CHARSET_BALTIC\n186
SC_CHARSET_CHINESEBIG5 _SCINTILLA.constants.SC_CHARSET_CHINESEBIG5\n136
SC_CHARSET_CYRILLIC _SCINTILLA.constants.SC_CHARSET_CYRILLIC\n1251
SC_CHARSET_DEFAULT _SCINTILLA.constants.SC_CHARSET_DEFAULT\n1
SC_CHARSET_EASTEUROPE _SCINTILLA.constants.SC_CHARSET_EASTEUROPE\n238
SC_CHARSET_GB2312 _SCINTILLA.constants.SC_CHARSET_GB2312\n134
SC_CHARSET_GREEK _SCINTILLA.constants.SC_CHARSET_GREEK\n161
SC_CHARSET_HANGUL _SCINTILLA.constants.SC_CHARSET_HANGUL\n129
SC_CHARSET_HEBREW _SCINTILLA.constants.SC_CHARSET_HEBREW\n177
SC_CHARSET_JOHAB _SCINTILLA.constants.SC_CHARSET_JOHAB\n130
SC_CHARSET_MAC _SCINTILLA.constants.SC_CHARSET_MAC\n77
SC_CHARSET_OEM _SCINTILLA.constants.SC_CHARSET_OEM\n255
SC_CHARSET_RUSSIAN _SCINTILLA.constants.SC_CHARSET_RUSSIAN\n204
SC_CHARSET_SHIFTJIS _SCINTILLA.constants.SC_CHARSET_SHIFTJIS\n128
SC_CHARSET_SYMBOL _SCINTILLA.constants.SC_CHARSET_SYMBOL\n2
SC_CHARSET_THAI _SCINTILLA.constants.SC_CHARSET_THAI\n222
SC_CHARSET_TURKISH _SCINTILLA.constants.SC_CHARSET_TURKISH\n162
SC_CHARSET_VIETNAMESE _SCINTILLA.constants.SC_CHARSET_VIETNAMESE\n163
SC_CP_UTF8 _SCINTILLA.constants.SC_CP_UTF8\n65001
SC_CURSORARROW _SCINTILLA.constants.SC_CURSORARROW\n2
SC_CURSORNORMAL _SCINTILLA.constants.SC_CURSORNORMAL\n-1
SC_CURSORREVERSEARROW _SCINTILLA.constants.SC_CURSORREVERSEARROW\n7
SC_CURSORWAIT _SCINTILLA.constants.SC_CURSORWAIT\n4
SC_EFF_QUALITY_ANTIALIASED _SCINTILLA.constants.SC_EFF_QUALITY_ANTIALIASED\n2
SC_EFF_QUALITY_DEFAULT _SCINTILLA.constants.SC_EFF_QUALITY_DEFAULT\n0
SC_EFF_QUALITY_LCD_OPTIMIZED _SCINTILLA.constants.SC_EFF_QUALITY_LCD_OPTIMIZED\n3
SC_EFF_QUALITY_MASK _SCINTILLA.constants.SC_EFF_QUALITY_MASK\n15
SC_EFF_QUALITY_NON_ANTIALIASED _SCINTILLA.constants.SC_EFF_QUALITY_NON_ANTIALIASED\n1
SC_EOL_CR _SCINTILLA.constants.SC_EOL_CR\n1
SC_EOL_CRLF _SCINTILLA.constants.SC_EOL_CRLF\n0
SC_EOL_LF _SCINTILLA.constants.SC_EOL_LF\n2
SC_FOLDFLAG_LEVELNUMBERS _SCINTILLA.constants.SC_FOLDFLAG_LEVELNUMBERS\n64
SC_FOLDFLAG_LINEAFTER_CONTRACTED _SCINTILLA.constants.SC_FOLDFLAG_LINEAFTER_CONTRACTED\n16
SC_FOLDFLAG_LINEAFTER_EXPANDED _SCINTILLA.constants.SC_FOLDFLAG_LINEAFTER_EXPANDED\n8
SC_FOLDFLAG_LINEBEFORE_CONTRACTED _SCINTILLA.constants.SC_FOLDFLAG_LINEBEFORE_CONTRACTED\n4
SC_FOLDFLAG_LINEBEFORE_EXPANDED _SCINTILLA.constants.SC_FOLDFLAG_LINEBEFORE_EXPANDED\n2
SC_FOLDLEVELBASE _SCINTILLA.constants.SC_FOLDLEVELBASE\n1024
SC_FOLDLEVELBASE lexer.SC_FOLDLEVELBASE\nThe initial (root) fold level.
SC_FOLDLEVELHEADERFLAG _SCINTILLA.constants.SC_FOLDLEVELHEADERFLAG\n8192
SC_FOLDLEVELHEADERFLAG lexer.SC_FOLDLEVELHEADERFLAG\nFlag indicating the line is fold point.
SC_FOLDLEVELNUMBERMASK _SCINTILLA.constants.SC_FOLDLEVELNUMBERMASK\n4095
SC_FOLDLEVELNUMBERMASK lexer.SC_FOLDLEVELNUMBERMASK\nFlag used with `SCI_GETFOLDLEVEL(line)` to get the fold level of a line.
SC_FOLDLEVELWHITEFLAG _SCINTILLA.constants.SC_FOLDLEVELWHITEFLAG\n4096
SC_FOLDLEVELWHITEFLAG lexer.SC_FOLDLEVELWHITEFLAG\nFlag indicating that the line is blank.
SC_FONT_SIZE_MULTIPLIER _SCINTILLA.constants.SC_FONT_SIZE_MULTIPLIER\n100
SC_IV_LOOKBOTH _SCINTILLA.constants.SC_IV_LOOKBOTH\n3
SC_IV_LOOKFORWARD _SCINTILLA.constants.SC_IV_LOOKFORWARD\n2
SC_IV_NONE _SCINTILLA.constants.SC_IV_NONE\n0
SC_IV_REAL _SCINTILLA.constants.SC_IV_REAL\n1
SC_LASTSTEPINUNDOREDO _SCINTILLA.constants.SC_LASTSTEPINUNDOREDO\n256
SC_MARGINOPTION_NONE _SCINTILLA.constants.SC_MARGINOPTION_NONE\n0
SC_MARGINOPTION_SUBLINESELECT _SCINTILLA.constants.SC_MARGINOPTION_SUBLINESELECT\n1
SC_MARGIN_BACK _SCINTILLA.constants.SC_MARGIN_BACK\n2
SC_MARGIN_FORE _SCINTILLA.constants.SC_MARGIN_FORE\n3
SC_MARGIN_NUMBER _SCINTILLA.constants.SC_MARGIN_NUMBER\n1
SC_MARGIN_RTEXT _SCINTILLA.constants.SC_MARGIN_RTEXT\n5
SC_MARGIN_SYMBOL _SCINTILLA.constants.SC_MARGIN_SYMBOL\n0
SC_MARGIN_TEXT _SCINTILLA.constants.SC_MARGIN_TEXT\n4
SC_MARKNUM_FOLDER _SCINTILLA.constants.SC_MARKNUM_FOLDER\n30
SC_MARKNUM_FOLDEREND _SCINTILLA.constants.SC_MARKNUM_FOLDEREND\n25
SC_MARKNUM_FOLDERMIDTAIL _SCINTILLA.constants.SC_MARKNUM_FOLDERMIDTAIL\n27
SC_MARKNUM_FOLDEROPEN _SCINTILLA.constants.SC_MARKNUM_FOLDEROPEN\n31
SC_MARKNUM_FOLDEROPENMID _SCINTILLA.constants.SC_MARKNUM_FOLDEROPENMID\n26
SC_MARKNUM_FOLDERSUB _SCINTILLA.constants.SC_MARKNUM_FOLDERSUB\n29
SC_MARKNUM_FOLDERTAIL _SCINTILLA.constants.SC_MARKNUM_FOLDERTAIL\n28
SC_MARK_ARROW _SCINTILLA.constants.SC_MARK_ARROW\n2
SC_MARK_ARROWDOWN _SCINTILLA.constants.SC_MARK_ARROWDOWN\n6
SC_MARK_ARROWS _SCINTILLA.constants.SC_MARK_ARROWS\n24
SC_MARK_AVAILABLE _SCINTILLA.constants.SC_MARK_AVAILABLE\n28
SC_MARK_BACKGROUND _SCINTILLA.constants.SC_MARK_BACKGROUND\n22
SC_MARK_BOXMINUS _SCINTILLA.constants.SC_MARK_BOXMINUS\n14
SC_MARK_BOXMINUSCONNECTED _SCINTILLA.constants.SC_MARK_BOXMINUSCONNECTED\n15
SC_MARK_BOXPLUS _SCINTILLA.constants.SC_MARK_BOXPLUS\n12
SC_MARK_BOXPLUSCONNECTED _SCINTILLA.constants.SC_MARK_BOXPLUSCONNECTED\n13
SC_MARK_CHARACTER _SCINTILLA.constants.SC_MARK_CHARACTER\n10000
SC_MARK_CIRCLE _SCINTILLA.constants.SC_MARK_CIRCLE\n0
SC_MARK_CIRCLEMINUS _SCINTILLA.constants.SC_MARK_CIRCLEMINUS\n20
SC_MARK_CIRCLEMINUSCONNECTED _SCINTILLA.constants.SC_MARK_CIRCLEMINUSCONNECTED\n21
SC_MARK_CIRCLEPLUS _SCINTILLA.constants.SC_MARK_CIRCLEPLUS\n18
SC_MARK_CIRCLEPLUSCONNECTED _SCINTILLA.constants.SC_MARK_CIRCLEPLUSCONNECTED\n19
SC_MARK_DOTDOTDOT _SCINTILLA.constants.SC_MARK_DOTDOTDOT\n23
SC_MARK_EMPTY _SCINTILLA.constants.SC_MARK_EMPTY\n5
SC_MARK_FULLRECT _SCINTILLA.constants.SC_MARK_FULLRECT\n26
SC_MARK_LCORNER _SCINTILLA.constants.SC_MARK_LCORNER\n10
SC_MARK_LCORNERCURVE _SCINTILLA.constants.SC_MARK_LCORNERCURVE\n16
SC_MARK_LEFTRECT _SCINTILLA.constants.SC_MARK_LEFTRECT\n27
SC_MARK_MINUS _SCINTILLA.constants.SC_MARK_MINUS\n7
SC_MARK_PIXMAP _SCINTILLA.constants.SC_MARK_PIXMAP\n25
SC_MARK_PLUS _SCINTILLA.constants.SC_MARK_PLUS\n8
SC_MARK_RGBAIMAGE _SCINTILLA.constants.SC_MARK_RGBAIMAGE\n30
SC_MARK_ROUNDRECT _SCINTILLA.constants.SC_MARK_ROUNDRECT\n1
SC_MARK_SHORTARROW _SCINTILLA.constants.SC_MARK_SHORTARROW\n4
SC_MARK_SMALLRECT _SCINTILLA.constants.SC_MARK_SMALLRECT\n3
SC_MARK_TCORNER _SCINTILLA.constants.SC_MARK_TCORNER\n11
SC_MARK_TCORNERCURVE _SCINTILLA.constants.SC_MARK_TCORNERCURVE\n17
SC_MARK_UNDERLINE _SCINTILLA.constants.SC_MARK_UNDERLINE\n29
SC_MARK_VLINE _SCINTILLA.constants.SC_MARK_VLINE\n9
SC_MASK_FOLDERS _SCINTILLA.constants.SC_MASK_FOLDERS\n-33554432
SC_MODEVENTMASKALL _SCINTILLA.constants.SC_MODEVENTMASKALL\n1048575
SC_MOD_BEFOREDELETE _SCINTILLA.constants.SC_MOD_BEFOREDELETE\n2048
SC_MOD_BEFOREINSERT _SCINTILLA.constants.SC_MOD_BEFOREINSERT\n1024
SC_MOD_CHANGEANNOTATION _SCINTILLA.constants.SC_MOD_CHANGEANNOTATION\n131072
SC_MOD_CHANGEFOLD _SCINTILLA.constants.SC_MOD_CHANGEFOLD\n8
SC_MOD_CHANGEINDICATOR _SCINTILLA.constants.SC_MOD_CHANGEINDICATOR\n16384
SC_MOD_CHANGELINESTATE _SCINTILLA.constants.SC_MOD_CHANGELINESTATE\n32768
SC_MOD_CHANGEMARGIN _SCINTILLA.constants.SC_MOD_CHANGEMARGIN\n65536
SC_MOD_CHANGEMARKER _SCINTILLA.constants.SC_MOD_CHANGEMARKER\n512
SC_MOD_CHANGESTYLE _SCINTILLA.constants.SC_MOD_CHANGESTYLE\n4
SC_MOD_CONTAINER _SCINTILLA.constants.SC_MOD_CONTAINER\n262144
SC_MOD_DELETETEXT _SCINTILLA.constants.SC_MOD_DELETETEXT\n2
SC_MOD_INSERTTEXT _SCINTILLA.constants.SC_MOD_INSERTTEXT\n1
SC_MOD_LEXERSTATE _SCINTILLA.constants.SC_MOD_LEXERSTATE\n524288
SC_MULTILINEUNDOREDO _SCINTILLA.constants.SC_MULTILINEUNDOREDO\n4096
SC_MULTIPASTE_EACH _SCINTILLA.constants.SC_MULTIPASTE_EACH\n1
SC_MULTIPASTE_ONCE _SCINTILLA.constants.SC_MULTIPASTE_ONCE\n0
SC_MULTISTEPUNDOREDO _SCINTILLA.constants.SC_MULTISTEPUNDOREDO\n128
SC_PERFORMED_REDO _SCINTILLA.constants.SC_PERFORMED_REDO\n64
SC_PERFORMED_UNDO _SCINTILLA.constants.SC_PERFORMED_UNDO\n32
SC_PERFORMED_USER _SCINTILLA.constants.SC_PERFORMED_USER\n16
SC_PRINT_BLACKONWHITE _SCINTILLA.constants.SC_PRINT_BLACKONWHITE\n2
SC_PRINT_COLOURONWHITE _SCINTILLA.constants.SC_PRINT_COLOURONWHITE\n3
SC_PRINT_COLOURONWHITEDEFAULTBG _SCINTILLA.constants.SC_PRINT_COLOURONWHITEDEFAULTBG\n4
SC_PRINT_INVERTLIGHT _SCINTILLA.constants.SC_PRINT_INVERTLIGHT\n1
SC_PRINT_NORMAL _SCINTILLA.constants.SC_PRINT_NORMAL\n0
SC_SEL_LINES _SCINTILLA.constants.SC_SEL_LINES\n2
SC_SEL_RECTANGLE _SCINTILLA.constants.SC_SEL_RECTANGLE\n1
SC_SEL_STREAM _SCINTILLA.constants.SC_SEL_STREAM\n0
SC_SEL_THIN _SCINTILLA.constants.SC_SEL_THIN\n3
SC_STARTACTION _SCINTILLA.constants.SC_STARTACTION\n8192
SC_STATUS_BADALLOC _SCINTILLA.constants.SC_STATUS_BADALLOC\n2
SC_STATUS_FAILURE _SCINTILLA.constants.SC_STATUS_FAILURE\n1
SC_STATUS_OK _SCINTILLA.constants.SC_STATUS_OK\n0
SC_TECHNOLOGY_DEFAULT _SCINTILLA.constants.SC_TECHNOLOGY_DEFAULT\n0
SC_TECHNOLOGY_DIRECTWRITE _SCINTILLA.constants.SC_TECHNOLOGY_DIRECTWRITE\n1
SC_TIME_FOREVER _SCINTILLA.constants.SC_TIME_FOREVER\n10000000
SC_TYPE_BOOLEAN _SCINTILLA.constants.SC_TYPE_BOOLEAN\n0
SC_TYPE_INTEGER _SCINTILLA.constants.SC_TYPE_INTEGER\n1
SC_TYPE_STRING _SCINTILLA.constants.SC_TYPE_STRING\n2
SC_UPDATE_CONTENT _SCINTILLA.constants.SC_UPDATE_CONTENT\n1
SC_UPDATE_H_SCROLL _SCINTILLA.constants.SC_UPDATE_H_SCROLL\n8
SC_UPDATE_SELECTION _SCINTILLA.constants.SC_UPDATE_SELECTION\n2
SC_UPDATE_V_SCROLL _SCINTILLA.constants.SC_UPDATE_V_SCROLL\n4
SC_WEIGHT_BOLD _SCINTILLA.constants.SC_WEIGHT_BOLD\n700
SC_WEIGHT_NORMAL _SCINTILLA.constants.SC_WEIGHT_NORMAL\n400
SC_WEIGHT_SEMIBOLD _SCINTILLA.constants.SC_WEIGHT_SEMIBOLD\n600
SC_WRAPINDENT_FIXED _SCINTILLA.constants.SC_WRAPINDENT_FIXED\n0
SC_WRAPINDENT_INDENT _SCINTILLA.constants.SC_WRAPINDENT_INDENT\n2
SC_WRAPINDENT_SAME _SCINTILLA.constants.SC_WRAPINDENT_SAME\n1
SC_WRAPVISUALFLAGLOC_DEFAULT _SCINTILLA.constants.SC_WRAPVISUALFLAGLOC_DEFAULT\n0
SC_WRAPVISUALFLAGLOC_END_BY_TEXT _SCINTILLA.constants.SC_WRAPVISUALFLAGLOC_END_BY_TEXT\n1
SC_WRAPVISUALFLAGLOC_START_BY_TEXT _SCINTILLA.constants.SC_WRAPVISUALFLAGLOC_START_BY_TEXT\n2
SC_WRAPVISUALFLAG_END _SCINTILLA.constants.SC_WRAPVISUALFLAG_END\n1
SC_WRAPVISUALFLAG_NONE _SCINTILLA.constants.SC_WRAPVISUALFLAG_NONE\n0
SC_WRAPVISUALFLAG_START _SCINTILLA.constants.SC_WRAPVISUALFLAG_START\n2
SC_WRAP_CHAR _SCINTILLA.constants.SC_WRAP_CHAR\n2
SC_WRAP_NONE _SCINTILLA.constants.SC_WRAP_NONE\n0
SC_WRAP_WORD _SCINTILLA.constants.SC_WRAP_WORD\n1
STRING lexer.STRING\nToken type for string tokens.
STRIP_WHITESPACE_ON_SAVE _M.textadept.editing.STRIP_WHITESPACE_ON_SAVE (bool)\nStrip trailing whitespace on file save.\nThe default value is `true`.
STYLE_BRACEBAD _SCINTILLA.constants.STYLE_BRACEBAD\n35
STYLE_BRACELIGHT _SCINTILLA.constants.STYLE_BRACELIGHT\n34
STYLE_CALLTIP _SCINTILLA.constants.STYLE_CALLTIP\n38
STYLE_CONTROLCHAR _SCINTILLA.constants.STYLE_CONTROLCHAR\n36
STYLE_DEFAULT _SCINTILLA.constants.STYLE_DEFAULT\n32
STYLE_INDENTGUIDE _SCINTILLA.constants.STYLE_INDENTGUIDE\n37
STYLE_LASTPREDEFINED _SCINTILLA.constants.STYLE_LASTPREDEFINED\n39
STYLE_LINENUMBER _SCINTILLA.constants.STYLE_LINENUMBER\n33
STYLE_MAX _SCINTILLA.constants.STYLE_MAX\n255
TYPE lexer.TYPE\nToken type for type tokens.
UNDO_MAY_COALESCE _SCINTILLA.constants.UNDO_MAY_COALESCE\n1
UPDATE_UI events.UPDATE_UI\nCalled when either the text or styling of the buffer has changed or the\nselection range has changed.
URI_DROPPED events.URI_DROPPED\nCalled when the user has dragged a URI such as a file name onto the view.\nArguments:\n  * `text`: The URI text encoded in UTF-8.
USER_LIST_SELECTION events.USER_LIST_SELECTION\nCalled when the user has selected an item in a user list.\nArguments:\n  * `list_type`: This is set to the list_type parameter from the\n    `buffer:user_list_show()` call that initiated the list.\n  * `text`: The text of the selection.\n  * `position`: The position the list was displayed at.
V lpeg.V(v)\nThis operation creates a non-terminal (a variable) for a grammar. The created\nnon-terminal refers to the rule indexed by v in the enclosing grammar. (See\nGrammars for details.)
VARIABLE lexer.VARIABLE\nToken type for variable tokens.
VIEW_AFTER_SWITCH events.VIEW_AFTER_SWITCH\nCalled right after another view is switched to.
VIEW_BEFORE_SWITCH events.VIEW_BEFORE_SWITCH\nCalled right before another view is switched to.
VIEW_NEW events.VIEW_NEW\nCalled when a new view is created.
VISIBLE_SLOP _SCINTILLA.constants.VISIBLE_SLOP\n1
VISIBLE_STRICT _SCINTILLA.constants.VISIBLE_STRICT\n4
WHITESPACE lexer.WHITESPACE\nToken type for whitespace tokens.
WIN32 _G.WIN32 (bool)\nIf Textadept is running on Windows, this flag is `true`.
_BUFFERS _G._BUFFERS (table)\nTable of all open buffers in Textadept.\nNumeric keys have buffer values and buffer keys have their associated numeric\nkeys.
_CHARSET _G._CHARSET (string)\nThe character set encoding of the filesystem.\nThis is used in File I/O.
_EMBEDDEDRULES lexer._EMBEDDEDRULES (table)\nSet of rules for an embedded lexer.\nFor a parent lexer name, contains child's `start_rule`, `token_rule`, and\n`end_rule` patterns.
_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)\nPath to the directory containing Textadept.
_L _G._L (module)\nTable of all messages used by Textadept for localization.
_LEXERPATH _G._LEXERPATH (string)\nPaths to lexers, formatted like\n`package.path`.
_M _G._M (module)\nA table of loaded modules.
_NIL _L._NIL (string)\nString returned when no localization for a given message exists.
_RELEASE _G._RELEASE (string)\nThe Textadept release version.
_RULES lexer._RULES (table)\nList of rule names with associated LPeg patterns for a specific lexer.\nIt is accessible to other lexers for embedded lexer applications.
_SCINTILLA _G._SCINTILLA (module)\nScintilla constants, functions, and properties.\nDo not modify anything in this module. Doing so will result in instability.
_USERHOME _G._USERHOME (string)\nPath to the user's `~/.textadept/`.
_VERSION _G._VERSION (string)\nA global variable (not a function) that holds a string containing the\ncurrent interpreter version. The current contents of this variable is\n"`Lua 5.2`".
_VIEWS _G._VIEWS (table)\nTable of all views in Textadept.\nNumeric keys have view values and view keys have their associated numeric\nkeys.
_cancel_current _M.textadept.snippets._cancel_current()\nCancels the active snippet, reverting to the state before its activation, and\nrestores the previously running snippet (if any).
_insert _M.textadept.snippets._insert(text)\nInserts a snippet.\n@param text Optional snippet text. If none is specified, the snippet text\n  is determined from the trigger and lexer.\n@return `false` if no snippet was expanded; `true` otherwise.
_previous _M.textadept.snippets._previous()\nGoes back to the previous placeholder, reverting any changes from the current\none.\n@return `false` if no snippet is active; `nil` otherwise.
_print gui._print(buffer_type, ...)\nHelper function for printing messages to buffers.\nSplits the view and opens a new buffer for printing messages. If the message\nbuffer is already open and a view is currently showing it, the message is\nprinted to that view. Otherwise the view is split, goes to the open message\nbuffer, and prints to it.\n@param buffer_type String type of message buffer.\n@param ... Message strings.\n@usage gui._print(_L['[Error Buffer]'], error_message)\n@usage gui._print(_L['[Message Buffer]'], message)
_select _M.textadept.snippets._select()\nPrompts the user to select a snippet to insert from a filtered list dialog.\nGlobal snippets and snippets in the current lexer are shown.
abs math.abs(x)\nReturns the absolute value of `x`.
acos math.acos(x)\nReturns the arc cosine of `x` (in radians).
add _M.textadept.bookmarks.add()\nAdds a bookmark to the current line.
add_selection buffer.add_selection(buffer, caret, anchor)\nAdd a selection from anchor to caret as the main selection.\nRetainings all other selections as additional selections. Since there is\nalways at least one selection, to set a list of selections, the first\nselection should be added with `buffer:set_selection()` and later selections\nadded with this function.\n@param buffer The global buffer.\n@param caret The caret.\n@param anchor The anchor.
add_text buffer.add_text(buffer, text)\nAdd text to the document at current position.\nThe current position is set at the end of the inserted text, but it is not\nscrolled into view.\n@param buffer The global buffer.\n@param text The text to add.
add_trigger _M.textadept.adeptsense.add_trigger(sense, c, only_fields, only_functions)\nSets the trigger for autocompletion.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param c The character(s) that triggers the autocompletion. You can have up\n  to two characters.\n@param only_fields If `true`, this trigger only completes fields. The default\n  value is `false`.\n@param only_functions If `true`, this trigger only completes functions.\n  The default value is `false`.\n@usage sense:add_trigger('.')\n@usage sense:add_trigger(':', false, true) -- only functions\n@usage sense:add_trigger('->')
additional_caret_fore buffer.additional_caret_fore (number)\nThe foreground color of additional carets in `0xBBGGRR` format.
additional_carets_blink buffer.additional_carets_blink (bool)\nWhether additional carets will blink.
additional_carets_visible buffer.additional_carets_visible (bool)\nWhether additional carets are visible.
additional_sel_alpha buffer.additional_sel_alpha (number)\nThe alpha of additional selections. Alpha ranges from `0` (transparent) to\n`255` (opaque) or `256` for no alpha.
additional_sel_back buffer.additional_sel_back (number)\nThe background color of additional selections in `0xBBGGRR` format.\n`buffer:set_sel_back(true, ...)` must have been called previously for this\nto have an effect.
additional_sel_fore buffer.additional_sel_fore (number)\nThe foreground color of additional selections in `0xBBGGRR` format.\n`buffer:set_sel_fore(true, ...)` must have been called previously for this\nto have an effect.
additional_selection_typing buffer.additional_selection_typing (bool)\nWhether typing can be performed into multiple selections.
adeptsense _M.textadept.adeptsense (module)\nLanguage autocompletion support for the textadept module.
allocate buffer.allocate(buffer, bytes)\nEnlarge the document to a particular size of text bytes.\nThe document will not be made smaller than its current contents.\n@param buffer The global buffer.
alnum lexer.alnum\nMatches any alphanumeric character (`A-Z`, `a-z`, `0-9`).
alpha lexer.alpha\nMatches any alphabetic character (`A-Z`, `a-z`).
always_show_globals _M.textadept.adeptsense.always_show_globals (bool)\nInclude globals in the list of completions offered.\nGlobals are classes, functions, and fields that do not belong to another\nclass. They are contained in `completions['']`. The default value is\n`true`.
anchor buffer.anchor (number)\nThe position of the opposite end of the selection to the caret.
annotation_clear_all buffer.annotation_clear_all(buffer)\nClear the annotations from all lines.\n@param buffer The global buffer.
annotation_get_text buffer.annotation_get_text(buffer, line)\nGet the annotation text for a line.\n@param buffer The global buffer.\n@param line The line number.\n@return string
annotation_lines buffer.annotation_lines (table, Read-only)\nTable of the number of annotation lines for lines starting from zero.
annotation_set_text buffer.annotation_set_text(buffer, line, text)\nSet the annotation text for a line.\n@param buffer The global buffer.\n@param line The line number.\n@param text The text.
annotation_style buffer.annotation_style (table)\nTable of style numbers for annotations for lines starting at zero.
annotation_style_offset buffer.annotation_style_offset (number)\nThe start of the range of style numbers used for annotations.\nAnnotation styles may be completely separated from standard text styles by\nsetting a style offset. For example, setting this to `512` would allow the\nannotation styles to be numbered from `512` upto `767` so they do not\noverlap styles set by lexers (or margins if margins offset is `256`). Each\nstyle number set with `buffer.annotation_style` has the offset added before\nlooking up the style.
annotation_visible buffer.annotation_visible (number)\nThe visibility of annotations.\n\n* `_SCINTILLA.constants.ANNOTATION_HIDDEN` (0)\n  Annotations are not displayed.\n* `_SCINTILLA.constants.ANNOTATION_STANDARD` (1)\n  Annotations are drawn left justified with no adornment.\n* `_SCINTILLA.constants.ANNOTATION_BOXED` (2)\n  Annotations are indented to match the text and are surrounded by a box.
any lexer.any\nMatches any single character.
api_files _M.textadept.adeptsense.api_files (table)\nContains a list of api files used by `show_apidoc()`.\nEach line in the api file contains a symbol name (not the full symbol)\nfollowed by a space character and then the symbol's documentation. Since\nthere may be many duplicate symbol names, it is recommended to put the full\nsymbol and arguments, if any, on the first line. (e.g. `Class.function(arg1,\narg2, ...)`). This allows the correct documentation to be shown based on the\ncurrent context. In the documentation, newlines are represented with `\\n`. A\n`\` before `\\n` escapes the newline.
append_text buffer.append_text(buffer, text)\nAppend a string to the end of the document without changing the selection.\nThe current selection is not changed and the new text is not scrolled into\nview.\n@param buffer The global buffer.\n@param text The text.
arg _G.arg (table)\nCommand line parameters.
args _G.args (module)\nProcesses command line arguments for Textadept.
arshift bit32.arshift(x, disp)\nReturns the number `x` shifted `disp` bits to the right. The number `disp`\nmay be any representable integer. Negative displacements shift to the left.\n\nThis shift operation is what is called arithmetic shift. Vacant bits on the\nleft are filled with copies of the higher bit of `x`; vacant bits on the\nright are filled with zeros. In particular, displacements with absolute\nvalues higher than 31 result in zero or `0xFFFFFFFF` (all original bits are\nshifted out).
ascii lexer.ascii\nMatches any ASCII character (`0`..`127`).
asin math.asin(x)\nReturns the arc sine of `x` (in radians).
assert _G.assert(v [, message])\nIssues an error when the value of its argument `v` is false (i.e.,\nnil or false); otherwise, returns all its arguments. `message` is an error\nmessage; when absent, it defaults to "assertion failed!"
atan math.atan(x)\nReturns the arc tangent of `x` (in radians).
atan2 math.atan2(y, x)\nReturns the arc tangent of `y/x` (in radians), but uses the signs\nof both parameters to find the quadrant of the result. (It also handles\ncorrectly the case of `x` being zero.)
attributes lfs.attributes(filepath [, aname])\nReturns a table with the file attributes corresponding to filepath (or nil\nfollowed by an error message in case of error). If the second optional\nargument is given, then only the value of the named attribute is returned\n(this use is equivalent to lfs.attributes(filepath).aname, but the table is\nnot created and only one attribute is retrieved from the O.S.). The\nattributes are described as follows; attribute mode is a string, all the\nothers are numbers, and the time related attributes use the same time\nreference of os.time:\n  dev: on Unix systems, this represents the device that the inode resides on.\n       On Windows systems, represents the drive number of the disk containing\n       the file\n  ino: on Unix systems, this represents the inode number. On Windows systems\n       this has no meaning\n  mode: string representing the associated protection mode (the values could\n        be file, directory, link, socket, named pipe, char device, block\n        device or other)\n  nlink: number of hard links to the file\n  uid: user-id of owner (Unix only, always 0 on Windows)\n  gid: group-id of owner (Unix only, always 0 on Windows)\n  rdev: on Unix systems, represents the device type, for special file inodes.\n        On Windows systems represents the same as dev\n  access: time of last access\n  modification: time of last data modification\n  change: time of last file status change\n  size: file size, in bytes\n  blocks: block allocated for file; (Unix only)\n  blksize: optimal file system I/O blocksize; (Unix only)\n\nThis function uses stat internally thus if the given filepath is a symbolic\nlink, it is followed (if it points to another link the chain is followed\nrecursively) and the information is about the file it refers to. To obtain\ninformation about the link itself, see function lfs.symlinkattributes.
auto_c_active buffer.auto_c_active(buffer)\nIs there an auto-completion list visible?\n@return bool
auto_c_auto_hide buffer.auto_c_auto_hide (bool)\nWhether or not autocompletion is hidden automatically when nothing matches.\nBy default, the list is cancelled if there are no viable matches (the user\nhas typed characters that no longer match a list entry).
auto_c_cancel buffer.auto_c_cancel(buffer)\nRemove the auto-completion list from the screen.\nA set of characters that will cancel autocompletion can be specified with\n`buffer:auto_c_stops()`.\n@param buffer The global buffer.
auto_c_cancel_at_start buffer.auto_c_cancel_at_start (bool)\nWhether auto-completion is cancelled by backspacing to a position before\nwhere the box was created.\nIf `false`, the list is not cancelled until the caret moves before the\nfirst character of the word being completed. If `true`, cancel if the user\nbackspaces to a position before where it was created.
auto_c_choose_single buffer.auto_c_choose_single (bool)\nWhether a single item auto-completion list automatically choose the item.\nThe default is to display the list even if there is only a single item.
auto_c_complete buffer.auto_c_complete(buffer)\nUser has selected an item so remove the list and insert the selection.\nThis has the same effect as the tab key.\n@param buffer The global buffer.
auto_c_drop_rest_of_word buffer.auto_c_drop_rest_of_word (bool)\nWhether or not autocompletion deletes any word characters after the\ninserted text upon completion.\nThe default is `false`.
auto_c_fill_ups buffer.auto_c_fill_ups (string, Write-only)\nA set of characters that when typed will cause the autocompletion to choose\nthe selected item.\nBy default, no fillup characters are set.
auto_c_get_current buffer.auto_c_get_current(buffer)\nGet currently selected item position in the auto-completion list.\n@param buffer The global buffer.\n@return number
auto_c_get_current_text buffer.auto_c_get_current_text(buffer)\nGet currently selected item text in the auto-completion list.\n@param buffer The global buffer.\n@return string
auto_c_ignore_case buffer.auto_c_ignore_case (bool)\nWhether case is significant when performing auto-completion searches.\nBy default, matching of characters to list members is case sensitive.
auto_c_max_height buffer.auto_c_max_height (number)\nThe maximum height, in rows, of auto-completion and user lists.\nThe default is 5 rows.
auto_c_max_width buffer.auto_c_max_width (number)\nThe maximum width, in characters, of auto-completion and user lists.\nSet to `0` to autosize to fit longest item, which is the default.
auto_c_pos_start buffer.auto_c_pos_start(buffer)\nRetrieve the position of the caret when the auto-completion list was\ndisplayed.\n@param buffer The global buffer.\n@return number
auto_c_select buffer.auto_c_select(buffer, string)\nSelect the item in the auto-completion list that starts with a string.\nBy default, comparisons are case sensitive, but this can change with\n`buffer.auto_c_ignore_case`.\n@param buffer The global buffer.
auto_c_separator buffer.auto_c_separator (number)\nThe auto-completion list separator character byte.\nThe default is the space character.
auto_c_show buffer.auto_c_show(buffer, len_entered, item_list)\nDisplay an auto-completion list.\n@param len_entered The number of characters before the caret used to provide\n  the context.\n@param item_list List of words separated by separator characters (initially\n  spaces). The list of words should be in sorted order.
auto_c_stops buffer.auto_c_stops(buffer, chars)\nDefine a set of characters that when typed cancel the auto-completion list.\n@param buffer The global buffer.\n@param chars String list of characters. This list is empty by default.
auto_c_type_separator buffer.auto_c_type_separator (number)\nThe auto-completion list type-separator character byte.\nThe default is `'?'`. Autocompletion list items may display an image as\nwell as text. Each image is first registered with an integer type. Then\nthis integer is included in the text of the list separated by a `?` from\nthe text.
autocomplete_word _M.textadept.editing.autocomplete_word(word_chars, default_words)\nPops up an autocompletion list for the current word based on other words in\nthe document.\n@param word_chars String of chars considered to be part of words.\n@param default_words Optional list of words considered to be in the document,\n  even if they are not. Words may contain registered images.\n@return `true` if there were completions to show; `false` otherwise.
back_space_un_indents buffer.back_space_un_indents (bool)\nWhether a backspace pressed when caret is within indentation unindents.
back_tab buffer.back_tab(buffer)\nDedent the selected lines.\n@param buffer The global buffer.
band bit32.band(...)\nReturns the bitwise "and" of its operands.
begin_undo_action buffer.begin_undo_action(buffer)\nStart a sequence of actions that is undone and redone as a unit.\nMay be nested.\n@param buffer The global buffer.
bit32 _G.bit32 (module)\nLua bit32 module.
block_comment _M.textadept.editing.block_comment(comment)\nBlock comments or uncomments code with a given comment string.\nIf none is specified, uses the `comment_string` table.\n@param comment The comment string inserted or removed from the beginning of\n  each line in the selection.\n@see comment_string
bnot bit32.bnot(x)\nReturns the bitwise negation of `x`. For any integer `x`, the following\nidentity holds:\n\n  assert(bit32.bnot(x) == (-1 - x) % 2^32)
boms io.boms (table)\nList of byte-order marks (BOMs).
bookmarks _M.textadept.bookmarks (module)\nBookmarks for the textadept module.
bor bit32.bor(...)\nReturns the bitwise "or" of its operands.
brace_bad_light buffer.brace_bad_light(buffer, pos)\nHighlight the character at a position indicating there is no matching brace.\n@param buffer The global buffer.\n@param pos The position or -1 to remove the highlight.
brace_bad_light_indicator buffer.brace_bad_light_indicator(buffer, use_indicator, indic_num)\nUse specified indicator to highlight non matching brace instead of changing\nits style.\n@param buffer The global buffer.\n@param use_indicator Use an indicator.\n@param indic_num The indicator number.
brace_highlight buffer.brace_highlight(buffer, pos1, pos2)\nHighlight the characters at two positions.\nIf indent guides are enabled, the indent that corresponds with the brace can\nbe highlighted by locating the column with `buffer.column` and highlight the\nindent with `buffer.highlight_guide`.\n@param buffer The global buffer.\n@param pos1 The first position.\n@param pos2 The second position.
brace_highlight_indicator buffer.brace_highlight_indicator(buffer, use_indicator, indic_num)\nUse specified indicator to highlight matching braces instead of changing\ntheir style.\n@param buffer The global buffer.\n@param use_indicator Use an indicator.\n@param indic_num The indicator number.
brace_match buffer.brace_match(buffer, pos)\nFind the position of a matching brace or `-1` if no match.\nThe brace characters handled are `(`, `)`, `[`, `]`, `{`, `}`, `<`, and `>`.\nThe search is forwards from an opening brace and backwards from a closing\nbrace. A match only occurs if the style of the matching brace is the same as\nthe starting brace or the matching brace is beyond the end of styling. Nested\nbraces are handled correctly.\n@param buffer The global buffer.\n@param pos The position.\n@return number.
braces _M.textadept.editing.braces (table)\nHighlighted brace characters.\nKeys are lexer language names and values are tables of characters that count\nas brace characters. This table can be populated by language-specific\nmodules. The defaults are '(', ')', '[', ']', '{', and '}'.\n@see HIGHLIGHT_BRACES
btest bit32.btest(...)\nReturns a boolean signaling whether the bitwise "and" of its operands is\ndifferent from zero.
buffer _G.buffer (module)\nThe current buffer in the current view.\nIt also represents the structure of any buffer table in `_G._BUFFER`.
buffer view.buffer (table)\nThe buffer this view contains. (Read-only)
buffered_draw buffer.buffered_draw (bool)\nWhether drawing is buffered.\nIf drawing is buffered then each line of text is drawn into a bitmap buffer\nbefore drawing it to the screen to avoid flicker. The default is for\ndrawing to be buffered. first or directly onto the screen.
byte string.byte(s [, i [, j]])\nReturns the internal numerical codes of the characters `s[i]`, `s[i+1]`,\n..., `s[j]`. The default value for `i` is 1; the default value for `j`\nis `i`. These indices are corrected following the same rules of function\n`string.sub`.\n\nNumerical codes are not necessarily portable across platforms.
call_tip_active buffer.call_tip_active(buffer)\nIs there an active call tip?\n@param buffer The global buffer.\n@return bool
call_tip_back buffer.call_tip_back (number, Write-only)\nThe background color for the call tip in `0xBBGGRR` format.
call_tip_cancel buffer.call_tip_cancel(buffer)\nRemove the call tip from the screen.\nCall tips are also removed if any keyboard commands that are not compatible\nwith editing the argument list of a function are used.\n@param buffer The global buffer.
call_tip_fore buffer.call_tip_fore (number, Write-only)\nThe foreground color for the call tip in `0xBBGGRR` format.
call_tip_fore_hlt buffer.call_tip_fore_hlt (number, Write-only)\nThe foreground color for the highlighted part of the call tip in `0xBBGGRR`\nformat.
call_tip_pos_start buffer.call_tip_pos_start(buffer)\nRetrieve the position where the caret was before displaying the call tip.\n@param buffer The global buffer.\n@return number
call_tip_position buffer.call_tip_position (boolean)\nThe position of calltip, above or below text.\nBy default the calltip is displayed below the text. Setting to `true` will\ndisplay it above the text.
call_tip_set_hlt buffer.call_tip_set_hlt(buffer, start_pos, end_pos)\nHighlights a segment of a call tip.\n@param buffer The global buffer.\n@param start_pos The start position.\n@param end_pos The end position.
call_tip_show buffer.call_tip_show(buffer, pos, text)\nShow a call tip containing a definition near position pos.\nThe call tip text is aligned to start 1 line below this character unless up\nand/or down arrows have been included in the call tip text in which case the\ntip is aligned to the right-hand edge of the rightmost arrow. The assumption\nis that the text starts with something like `"\001 1 of 3 \002"`.\n@param buffer The global buffer.\n@param pos The position.\n@param text The text.
call_tip_use_style buffer.call_tip_use_style (number)\nEnable use of `_SCINTILLA.constants.STYLE_CALLTIP` and set call tip tab\nsize in pixels.\nIf the tab size is less than `1`, Tab characters are not treated specially.
can_paste buffer.can_paste(buffer)\nWill a paste succeed?\n@param buffer The global buffer.\n@return bool
can_redo buffer.can_redo(buffer)\nAre there any redoable actions in the undo history?\n@param buffer The global buffer.\n@return bool
can_undo buffer.can_undo(buffer)\nAre there any undoable actions in the undo history?\n@param buffer The global buffer.\n@return bool
cancel buffer.cancel(buffer)\nCancel any modes such as call tip or auto-completion list display.\n@param buffer The global buffer.
caret_fore buffer.caret_fore (number)\nThe foreground color of the caret in `0xBBGGRR` format.
caret_line_back buffer.caret_line_back (number)\nThe color of the background of the line containing the caret in `0xBBGGRR`\nformat.
caret_line_back_alpha buffer.caret_line_back_alpha (number)\nThe background alpha of the caret line.\nAlpha ranges from `0` (transparent) to `255` (opaque) or `256` for no\nalpha.
caret_line_visible buffer.caret_line_visible (bool)\nWhether the background of the line containing the caret is in a different\ncolor.
caret_period buffer.caret_period (number)\nThe time in milliseconds that the caret is on and off.\nSetting the period to `0` stops the caret blinking. The default value is\n500 milliseconds.
caret_sticky buffer.caret_sticky (number)\nThe caret preferred x position changing when the user types.\n\n* `_SCINTILLA.constants.SC_CARETSTICKY_OFF` (0)\n  All text changes (and all caret position changes) will remember the\n  caret's new horizontal position when moving to different lines.\n  This is the default.\n* `_SCINTILLA.constants.SC_CARETSTICKY_ON` (1)\n  The only thing which will cause the editor to remember the horizontal\n  caret position is moving the caret with mouse or keyboard (left/right\n  arrow keys, home/end keys, etc).\n* `_SCINTILLA.constants.SC_CARETSTICKY_WHITESPACE` (2)\n  The caret acts like sticky off except under one special case; when space\n  or tab characters are inserted. (Including pasting *only space/tabs* --\n  undo, redo, etc. do not exhibit this behavior.)
caret_style buffer.caret_style (number)\nThe style of the caret to be drawn.\n\n* `_SCINTILLA.constants.CARETSTYLE_INVISIBLE` (0)\n  Not draw the caret at all.\n* `_SCINTILLA.constants.CARETSTYLE_LINE` (1)\n  A line caret. This is the default value.\n* `_SCINTILLA.constants.CARETSTYLE_BLOCK` (2)\n  A block caret.
caret_width buffer.caret_width (number)\nThe width of the insert mode caret in pixels.\nCan be `0`, `1`, `2` or `3` pixels. The default width is 1 pixel. This\nsetting only affects the width of the cursor when the cursor style is set\nto line caret mode, it does not affect the width for a block caret.
ceil math.ceil(x)\nReturns the smallest integer larger than or equal to `x`.
change_lexer_state buffer.change_lexer_state(buffer, start_pos, end_pos)\nIndicate that the internal state of a lexer has changed over a range and\ntherefore there may be a need to redraw.\n@param buffer The global buffer.\n@param start_pos The start position.\n@param end_pos The end position.
char string.char(···)\nReceives zero or more integers. Returns a string with length equal to\nthe number of arguments, in which each character has the internal numerical\ncode equal to its corresponding argument.\n\nNumerical codes are not necessarily portable across platforms.
char_at buffer.char_at (table, Read-only)\nTable of character bytes at positions in the document starting at zero.
char_left buffer.char_left(buffer)\nMove caret left one character.\n@param buffer The global buffer.
char_left_extend buffer.char_left_extend(buffer)\nMove caret left one character extending selection to new caret position.\n@param buffer The global buffer.
char_left_rect_extend buffer.char_left_rect_extend(buffer)\nMove caret left one character, extending rectangular selection to new caret\nposition.\n@param buffer The global buffer.
char_matches _M.textadept.editing.char_matches (table)\nAuto-matched characters.\nUsed for auto-matching parentheses, brackets, braces, quotes, etc. Keys are\nlexer language names and values are tables of character match pairs. This\ntable can be populated by language-specific modules. The defaults are '()',\n'[]', '{}', '''', and '""'.\n@see AUTOPAIR
char_position_from_point buffer.char_position_from_point(buffer, x, y)\nFind the position of a character from a point within the window.\n@param buffer The global buffer.\n@return number
char_position_from_point_close buffer.char_position_from_point_close(buffer, x, y)\nFind the position of a character from a point within the window.\nReturn `-1` if not close to text.\n@param buffer The global buffer.\n@return number
char_right buffer.char_right(buffer)\nMove caret right one character.\n@param buffer The global buffer.
char_right_extend buffer.char_right_extend(buffer)\nMove caret right one character extending selection to new caret position.\n@param buffer The global buffer.
char_right_rect_extend buffer.char_right_rect_extend(buffer)\nMove caret right one character, extending rectangular selection to new caret\nposition.\n@param buffer The global buffer.
chdir lfs.chdir(path)\nChanges the current working directory to the given path.\n\nReturns true in case of success or nil plus an error string.
check_global buffer.check_global(buffer)\nChecks whether the given buffer is the global one.\nIf not, throws an error indicating so. It is necessary to call this at the\ntop of all buffer functions to avoid unexpected behavior since most buffer\nfunctions operate on `_G.buffer`, which is not necessarily the given one.\n@param buffer The buffer to check.
choose_caret_x buffer.choose_caret_x(buffer)\nSet the last x chosen value to be the caret x position.\nThe view remembers the x value of the last position horizontally moved to\nexplicitly by the user and this value is then used when moving vertically\nsuch as by using the up and down keys. This function sets the current x\nposition of the caret as the remembered value.\n@param buffer The global buffer.
class_definition _M.textadept.adeptsense.syntax.class_definition (table)\nA Lua pattern representing the language's class\n  definition syntax. The first capture returned must be the class name. A\n  second, optional capture contains the class' superclass (if any). If no\n  completions are found for the class name, completions for the superclass\n  are shown (if any). Completions will not be shown for both a class and\n  superclass unless defined in a previously loaded ctags file. Also, multiple\n  superclasses cannot be recognized by this pattern; use a ctags file\n  instead. The default value is `'class%s+([%w_]+)'`.
clear _M.textadept.adeptsense.clear(sense)\nClears an Adeptsense.\nThis is necessary for loading a new ctags file or completions from a\ndifferent project.\n@param sense The Adeptsense returned by `adeptsense.new()`.
clear _M.textadept.bookmarks.clear()\nClears all bookmarks in the current buffer.
clear buffer.clear(buffer)\nClear the selection.\n@param buffer The global buffer.
clear_all buffer.clear_all(buffer)\nDelete all text in the document.\n@param buffer The global buffer.
clear_all_cmd_keys buffer.clear_all_cmd_keys(buffer)\nDrop all key mappings.\n@param buffer The global buffer.
clear_document_style buffer.clear_document_style(buffer)\nSet all style bytes to `0`, remove all folding information.\n@param buffer The global buffer.
clear_registered_images buffer.clear_registered_images(buffer)\nClear all the registered XPM images.\n@param buffer The global buffer.
clear_selections buffer.clear_selections(buffer)\nClear selections to a single empty stream selection.\n@param buffer The global buffer.
clipboard_text gui.clipboard_text (string, Read-only)\nThe text on the clipboard.
clock os.clock()\nReturns an approximation of the amount in seconds of CPU time used by\nthe program.
close buffer.close(buffer)\nCloses the current buffer.\n@param buffer The global buffer.\nIf the buffer is dirty, the user is prompted to continue. The buffer is not\nsaved automatically. It must be done manually.
close file:close()\nCloses `file`. Note that files are automatically closed when their\nhandles are garbage collected, but that takes an unpredictable amount of\ntime to happen.\n\nWhen closing a file handle created with `io.popen`, `file:close` returns the\nsame values returned by `os.execute`.
close io.close([file])\nEquivalent to `file:close()`. Without a `file`, closes the default\noutput file.
close_all io.close_all()\nCloses all open buffers.\nIf any buffer is dirty, the user is prompted to continue. No buffers are\nsaved automatically. They must be saved manually.\n@usage io.close_all()\n@return `true` if user did not cancel.
cntrl lexer.cntrl\nMatches any control character (`0`..`31`).
code_page buffer.code_page (number)\nThe code page used to interpret the bytes of the document as characters.\nThe `_SCINTILLA.constants.SC_CP_UTF8` value can be used to enter Unicode\nmode.
collectgarbage _G.collectgarbage([opt [, arg]])\nThis function is a generic interface to the garbage collector. It\nperforms different functions according to its first argument, `opt`:\n  "collect": performs a full garbage-collection cycle. This is the default\n             option.\n  "stop": stops automatic execution of the garbage collector.\n  "restart": restarts automatic execution of the garbage collector.\n  "count": returns the total memory in use by Lua (in Kbytes) and a second\n           value with the total memory in bytes modulo 1024. The first value\n           has a fractional part, so the following equality is always true:\n\n             k, b = collectgarbage("count")\n             assert(k*1024 == math.floor(k)*1024 + b)\n\n           (The second result is useful when Lua is compiled with a non\n           floating-point type for numbers.)\n  "step": performs a garbage-collection step. The step "size" is controlled\n          by `arg` (larger values mean more steps) in a non-specified way. If\n          you want to control the step size you must experimentally tune the\n          value of `arg`. Returns true if the step finished a collection\n          cycle.\n  "setpause": sets `arg` as the new value for the *pause* of the collector\n              (see §2.5). Returns the previous value for *pause*.\n  "setstepmul": sets `arg` as the new value for the *step multiplier*\n                of the collector (see §2.5). Returns the previous value for\n                *step*.\n  "isrunning": returns a boolean that tells whether the collector is running\n               (i.e., not stopped).\n  "generational": changes the collector to generational mode. This is an\n                  experimental feature (see §2.5).\n  "incremental": changes the collector to incremental mode. This is the\n                 default mode.
color lexer.color(r, g, b)\nCreates a Scintilla color.\n@param r The string red component of the hexadecimal color.\n@param g The string green component of the color.\n@param b The string blue component of the color.\n@usage local red = color('FF', '00', '00')
colors lexer.colors (table)\nTable of common colors for a theme.\nThis table should be redefined in each theme.
colourise buffer.colourise(buffer, start_pos, end_pos)\nColorise a segment of the document using the current lexing language.\n@param buffer The global buffer.\n@param start_pos The start position.\n@param end_pos The end position or `-1` to style from `start_pos` to the end\n  of the document.
column buffer.column (table, Read-only)\nTable of column numbers, taking tab widths into account, for positions\nstarting from zero.
command_entry gui.command_entry (module)\nTextadept's Command entry.
comment_string _M.textadept.editing.comment_string (table)\nComment strings for various lexer languages.\nUsed by the `block_comment()` function. Keys are lexer language names and\nvalues are the line comment delimiters for the language. This table is\ntypically populated by language-specific modules.\n@see block_comment
compile _M.textadept.run.compile()\nCompiles the file as specified by its extension in the `compile_command`\ntable.\n@see compile_command
compile_command _M.textadept.run.compile_command (table)\nFile extensions and their associated 'compile' actions.\nEach key is a file extension whose value is a either a command line string to\nexecute or a function returning one.\nThis table is typically populated by language-specific modules.
complete _M.textadept.adeptsense.complete(sense, only_fields, only_functions)\nShows an autocompletion list for the symbol behind the caret.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param only_fields If `true`, returns list of only fields. The default value\n  is `false`.\n@param only_functions If `true`, returns list of only functions. The default\n  value is `false`.\n@return `true` on success or `false`.\n@see get_symbol\n@see get_completions
complete_symbol _M.textadept.adeptsense.complete_symbol()\nCompletes the symbol at the current position based on the current lexer's\nAdeptsense.\nThis should be called by key commands and menus instead of `complete()`.
completions _M.textadept.adeptsense.completions (table)\nContains lists of possible completions for known symbols.\nEach symbol key has a table value that contains a list of field completions\nwith a `fields` key and a list of functions completions with a `functions`\nkey. This table is normally populated by `load_ctags()`, but can also be set\nby the user.
concat table.concat(list [, sep [, i [, j]]])\nGiven a list where all elements are strings or numbers, returns\n`list[i]..sep..list[i+1] ··· sep..list[j]`. The default value for `sep` is\nthe empty string, the default for `i` is 1, and the default for `j` is\n`#list`. If `i` is greater than `j`, returns the empty string.
config package.config (string)\nA string describing some compile-time configurations for packages. This\nstring is a sequence of lines:\n  The first line is the directory separator string. Default is '`\`' for\n  Windows and '`/`' for all other systems.\n  The second line is the character that separates templates in a path.\n  Default is '`;`'.\n  The third line is the string that marks the substitution points in a\n  template. Default is '`?`'.\n  The fourth line is a string that, in a path in Windows, is replaced by\n  the executable's directory. Default is '`!`'.\n  The fifth line is a mark to ignore all text before it when building the\n  `luaopen_` function name. Default is '`-`'.
connect events.connect(event, f, index)\nAdds a handler function to an event.\n@param event The string event name. It is arbitrary and need not be defined\n  anywhere.\n@param f The Lua function to add.\n@param index Optional index to insert the handler into.\n@return Index of handler.\n@see disconnect
constants _SCINTILLA.constants (table)\nScintilla constants.
context_menu _M.textadept.menu.context_menu (table)\nContains the default right-click context menu.
context_menu gui.context_menu\nA GTK menu defining the editor's context menu.
contracted_fold_next buffer.contracted_fold_next(buffer, line_start)\nFind the next line at or after line_start that is a contracted fold header\nline.\nReturn `-1` when no more lines.\n@param buffer The global buffer.\n@param line_start The start line number.\n@return number
control_char_symbol buffer.control_char_symbol (number)\nThe way control characters are displayed.\nIf less than `32`, keep the rounded rectangle as ASCII mnemonics.\nOtherwise, use the given character byte. The default value is `0`.
control_structure_patterns _M.lua.control_structure_patterns (table)\nPatterns for auto 'end' completion for control structures.\n@see try_to_autocomplete_end
control_structure_patterns _M.ruby.control_structure_patterns (table)\nPatterns for auto 'end' completion for control structures.\n@see try_to_autocomplete_end
convert_eo_ls buffer.convert_eo_ls(buffer, mode)\nConverts all line endings in the document to one mode.\n@param buffer The global buffer.\n@param mode The line ending mode. Valid values are:\n  `_SCINTILLA.constants.SC_EOL_CRLF` (0),\n  `_SCINTILLA.constants.SC_EOL_CR (1)`, or\n  `_SCINTILLA.constants.SC_EOL_LF (2)`.
convert_indentation _M.textadept.editing.convert_indentation()\nConverts indentation between tabs and spaces.
copy buffer.copy(buffer)\nCopy the selection to the clipboard.\n@param buffer The buffer
copy_allow_line buffer.copy_allow_line(buffer)\nCopy the selection, if selection empty copy the line with the caret.\n@param buffer The global buffer.
copy_range buffer.copy_range(buffer, start_pos, end_pos)\nCopy a range of text to the clipboard. Positions are clipped into the\ndocument.\n@param buffer The global buffer.\n@param start_pos The start position.\n@param end_pos The end position.
copy_text buffer.copy_text(buffer, text)\nCopy argument text to the clipboard.\n@param buffer The global buffer.\n@param text The text.
coroutine _G.coroutine (module)\nLua coroutine module.
cos math.cos(x)\nReturns the cosine of `x` (assumed to be in radians).
cosh math.cosh(x)\nReturns the hyperbolic cosine of `x`.
count_characters buffer.count_characters(buffer, start_pos, end_pos)\nCount characters between two positions.\n@return number
cpath package.cpath (string)\nThe path used by `require` to search for a C loader.\nLua initializes the C path `package.cpath` in the same way it initializes\nthe Lua path `package.path`, using the environment variable `LUA_CPATH_5_2`\nor the environment variable `LUA_CPATH` or a default path defined in\n`luaconf.h`.
cpp _G.keys.cpp (table)\nContainer for C/C++-specific key commands.
cpp _G.snippets.cpp (table)\nContainer for C/C++-specific snippets.
cpp _M.cpp (module)\nThe cpp module.\nIt provides utilities for editing C/C++ code.\nUser tags are loaded from `_USERHOME/modules/cpp/tags` and user apis are\nloaded from `_USERHOME/modules/cpp/api`.
create coroutine.create(f)\nCreates a new coroutine, with body `f`. `f` must be a Lua\nfunction. Returns this new coroutine, an object with type `"thread"`.
css _G.keys.css (table)\nContainer for CSS-specific key commands.
css _G.snippets.css (table)\nContainer for CSS-specific snippets.
css _M.css (module)\nThe css module.\nIt provides utilities for editing CSS code.\nUser tags are loaded from _USERHOME/modules/css/tags and user apis are loaded\nfrom _USERHOME/modules/css/api.
ctags_kinds _M.textadept.adeptsense.ctags_kinds (table)\nContains a map of ctags kinds to Adeptsense kinds.\nRecognized kinds are `'functions'`, `'fields'`, and `'classes'`. Classes are\nquite simply containers for functions and fields so Lua modules would count\nas classes. Any other kinds will be passed to `handle_ctag()` for\nuser-defined handling.\n@see handle_ctag
current_pos buffer.current_pos (number)\nThe position of the caret.\nWhen setting, the caret is not scrolled into view.
currentdir lfs.currentdir()\nReturns a string with the current working directory or nil plus an error\nstring.
cursor buffer.cursor (number)\nThe cursor type.\n\n* `_SCINTILLA.constants.SC_CURSORNORMAL` (-1)\n  The normal cursor is displayed.\n* `_SCINTILLA.constants.SC_CURSORWAIT` (4)\n  The wait cursor is displayed when the mouse is over the view.
cut buffer.cut(buffer)\nCut the selection to the clipboard.\n@param buffer The global buffer.
date os.date([format [, time]])\nReturns a string or a table containing date and time, formatted according\nto the given string `format`.\n\nIf the `time` argument is present, this is the time to be formatted\n(see the `os.time` function for a description of this value). Otherwise,\n`date` formats the current time.\n\nIf `format` starts with '`!`', then the date is formatted in Coordinated\nUniversal Time. After this optional character, if `format` is the string\n"`*t`", then `date` returns a table with the following fields: `year` (four\ndigits), `month` (1-12), `day` (1-31), `hour` (0-23), `min` (0-59), `sec`\n(0-61), `wday` (weekday, Sunday is 1), `yday` (day of the year), and `isdst`\n(daylight saving flag, a boolean). This last field may be absent if the\ninformation is not available.\n\nIf `format` is not "`*t`", then `date` returns the date as a string,\nformatted according to the same rules as the C function `strftime`.\n\nWhen called without arguments, `date` returns a reasonable date and time\nrepresentation that depends on the host system and on the current locale\n(that is, `os.date()` is equivalent to `os.date("%c")`).\n\nOn some systems, this function may be not thread safe.
debug _G.debug (module)\nLua debug module.
debug debug.debug()\nEnters an interactive mode with the user, running each string that\nthe user enters. Using simple commands and other debug facilities,\nthe user can inspect global and local variables, change their values,\nevaluate expressions, and so on. A line containing only the word `cont`\nfinishes this function, so that the caller continues its execution.\n\nNote that commands for `debug.debug` are not lexically nested within any\nfunction and so have no direct access to local variables.
dec_num lexer.dec_num\nMatches a decimal number.
deg math.deg(x)\nReturns the angle `x` (given in radians) in degrees.
del_line_left buffer.del_line_left(buffer)\nDelete back from the current position to the start of the line.\n@param buffer The global buffer.
del_line_right buffer.del_line_right(buffer)\nDelete forwards from the current position to the end of the line.\n@param buffer The global buffer.
del_word_left buffer.del_word_left(buffer)\nDelete the word to the left of the caret.\n@param buffer The global buffer.
del_word_right buffer.del_word_right(buffer)\nDelete the word to the right of the caret.\n@param buffer The global buffer.
del_word_right_end buffer.del_word_right_end(buffer)\nDelete the word to the right of the caret, but not the trailing non-word\ncharacters.\n@param buffer The global buffer.
delete buffer.delete(buffer)\nDeletes the current buffer.\nWARNING: this function should NOT be called via scripts. Use `buffer:close()`\ninstead, which prompts for confirmation if necessary. Generates a\n`BUFFER_DELETED` event.\n@param buffer The global buffer.
delete_back buffer.delete_back(buffer)\nDelete the selection or if no selection, the character before the caret.\n@param buffer The global buffer.
delete_back_not_line buffer.delete_back_not_line(buffer)\nDelete the selection or if no selection, the character before the caret.\nWill not delete the character before at the start of a line.
delimited_range lexer.delimited_range(chars, escape, end_optional, balanced, forbidden)\nCreates an LPeg pattern that matches a range of characters delimitted by a\nspecific character(s).\nThis can be used to match a string, parenthesis, etc.\n@param chars The character(s) that bound the matched range.\n@param escape Optional escape character. This parameter may be omitted, nil,\n  or the empty string.\n@param end_optional Optional flag indicating whether or not an ending\n  delimiter is optional or not. If true, the range begun by the start\n  delimiter matches until an end delimiter or the end of the input is\n  reached.\n@param balanced Optional flag indicating whether or not a balanced range is\n  matched, like `%b` in Lua's `string.find`. This flag only applies if\n  `chars` consists of two different characters (e.g. '()').\n@param forbidden Optional string of characters forbidden in a delimited\n  range. Each character is part of the set.\n@usage local sq_str_noescapes = delimited_range("'")\n@usage local sq_str_escapes = delimited_range("'", '\\', true)\n@usage local unbalanced_parens = delimited_range('()', '\\', true)\n@usage local balanced_parens = delimited_range('()', '\\', true, true)
dialog gui.dialog(kind, ...)\nDisplays a gcocoadialog of a specified type with the given string arguments.\nEach argument is like a string in Lua's `arg` table. Tables of strings are\nallowed as arguments and are expanded in place. This is useful for\nfilteredlist dialogs with many items.\n@param kind The kind of gcocoadialog.\n@param ... Parameters to the gcocoadialog.\n@return string gcocoadialog result.
difftime os.difftime(t2, t1)\nReturns the number of seconds from time `t1` to time `t2`. In POSIX,\nWindows, and some other systems, this value is exactly `t2`*-*`t1`.
digit lexer.digit\nMatches any digit (`0-9`).
dir lfs.dir(path)\nLua iterator over the entries of a given directory. Each time the iterator is\ncalled with dir_obj it returns a directory entry's name as a string, or nil\nif there are no more entries. You can also iterate by calling dir_obj:next(),\nand explicitly close the directory before the iteration finished with\ndir_obj:close(). Raises an error if path is not a directory.
direct_function buffer.direct_function (number, Read-only)\nA pointer to a function that processes messages for this view.
direct_pointer buffer.direct_pointer (number, Read-only)\nA pointer value to use as the first argument when calling the function\nreturned by direct_function.
dirty buffer.dirty (bool)\nFlag indicating whether or not the buffer has been modified since it was\nlast saved.
disconnect events.disconnect(event, index)\nDisconnects a handler function from an event.\n@param event The string event name.\n@param index Index of the handler (returned by `events.connect()`).\n@see connect
doc_line_from_visible buffer.doc_line_from_visible(buffer)\nFind the document line of a display line taking hidden lines into account.\n@param buffer The global buffer.\n@return number
docstatusbar_text gui.docstatusbar_text (string, Write-only)\nThe text displayed by the doc statusbar.
document_end buffer.document_end(buffer)\nMove caret to last position in document.\n@param buffer The global buffer.
document_end_extend buffer.document_end_extend(buffer)\nMove caret to last position in document extending selection to new caret\nposition.\n@param buffer The global buffer.
document_start buffer.document_start(buffer)\nMove caret to first position in document.\n@param buffer The global buffer.
document_start_extend buffer.document_start_extend(buffer)\nMove caret to first position in document extending selection to new caret\nposition.\n@param buffer The global buffer.
dofile _G.dofile([filename])\nOpens the named file and executes its contents as a Lua chunk. When\ncalled without arguments,\n`dofile` executes the contents of the standard input (`stdin`). Returns\nall values returned by the chunk. In case of errors, `dofile` propagates\nthe error to its caller (that is, `dofile` does not run in protected mode).
dump string.dump(function)\nReturns a string containing a binary representation of the given\nfunction, so that a later `load` on this string returns a copy of the\nfunction (but with new upvalues).
edge_colour buffer.edge_colour (number)\nThe color used in edge indication in `0xBBGGRR` format.
edge_column buffer.edge_column (number)\nThe column number which text should be kept within.
edge_mode buffer.edge_mode (number)\nThe edge highlight mode.\n\n* `_SCINTILLA.constants.EDGE_NONE` (0)\n  Long lines are not marked. This is the default state.\n* `_SCINTILLA.constants.EDGE_LINE` (1)\n  A vertical line is drawn at the column number set by\n  `buffer.edge_column`.\n* `_SCINTILLA.constants.EDGE_BACKGROUND` (2)\n  The background color of characters after the column limit is changed to\n  the color set by `buffer.edge_colour`.
edit_toggle_overtype buffer.edit_toggle_overtype(buffer)\nSwitch from insert to overtype mode or the reverse.\n@param buffer The global buffer.
editing _M.textadept.editing (module)\nEditing commands for the textadept module.
embed_lexer lexer.embed_lexer(parent, child, start_rule, end_rule)\nEmbeds a child lexer language in a parent one.\n@param parent The parent lexer.\n@param child The child lexer.\n@param start_rule The token that signals the beginning of the embedded\n  lexer.\n@param end_rule The token that signals the end of the embedded lexer.\n@usage embed_lexer(M, css, css_start_rule, css_end_rule)\n@usage embed_lexer(html, M, php_start_rule, php_end_rule)\n@usage embed_lexer(html, ruby, ruby_start_rule, rule_end_rule)
emit events.emit(event, ...)\nCalls all handlers for the given event in sequence (effectively "generating"\nthe event).\nIf `true` or `false` is explicitly returned by any handler, the event is not\npropagated any further; iteration ceases.\n@param event The string event name.\n@param ... Arguments passed to the handler.\n@return `true` or `false` if any handler explicitly returned such; nil\n  otherwise.
empty_undo_buffer buffer.empty_undo_buffer(buffer)\nDelete the undo history.\nIt also sets the save point to the start of the undo buffer, so the document\nwill appear to be unmodified.\n@param buffer The global buffer.
enclose _M.textadept.editing.enclose(left, right)\nEncloses text within a given pair of strings.\nIf text is selected, it is enclosed. Otherwise, the previous word is\nenclosed.\n@param left The left part of the enclosure.\n@param right The right part of the enclosure.
encoded_from_utf8 buffer.encoded_from_utf8(buffer, string)\nTranslates a UTF8 string into the document encoding.\nReturn the length of the result in bytes. On error return `0`.\n@param buffer The global buffer.\n@param string The string.\n@return number
encoding buffer.encoding (string or nil)\nThe encoding of the file on the hard disk.\nIt will be `nil` if the file is a binary file.
encoding_bom buffer.encoding_bom (string)\nThe byte-order mark of the file encoding (if any).
end_at_last_line buffer.end_at_last_line (bool)\nWhether the maximum scroll position has the last line at the bottom of the\nview.\nIf `false`, allows scrolling one page below the last line. The default\nvalue is `true`.
end_styled buffer.end_styled (number, Read-only)\nThe position of the last correctly styled character.
end_undo_action buffer.end_undo_action(buffer)\nEnd a sequence of actions that is undone and redone as a unit.\n@param buffer The global buffer.
ensure_visible buffer.ensure_visible(buffer, line)\nEnsure a particular line is visible by expanding any header line hiding it.\n@param buffer The global buffer.\n@param line The line number.
ensure_visible_enforce_policy buffer.ensure_visible_enforce_policy(buffer, line)\nEnsure a particular line is visible by expanding any header line hiding it.\nUse the currently set visibility policy to determine which range to display.\n@param buffer The global buffer.\n@param line The line number.
entry_text gui.command_entry.entry_text (string)\nThe text in the entry.
eol_mode buffer.eol_mode (number)\nThe current end of line mode.\n\n* `_SCINTILLA.constants.SC_EOL_CRLF` (0)\n  `CRLF`.\n* `_SCINTILLA.constants.SC_EOL_CR` (1)\n  `CR`.\n* `_SCINTILLA.constants.SC_EOL_LF` (2)\n  `LF`.
error _G.error(message [, level])\nTerminates the last protected function called and returns `message`\nas the error message. Function `error` never returns.\n\nUsually, `error` adds some information about the error position at the\nbeginning of the message, if the message is a string. The `level` argument\nspecifies how to get the error position. With level 1 (the default), the\nerror position is where the `error` function was called. Level 2 points the\nerror to where the function that called `error` was called; and so on.\nPassing a level 0 avoids the addition of error position information to the\nmessage.
error_detail _M.textadept.run.error_detail (table)\nA table of error string details.\nEach entry is a table with the following fields:\n\n  + `pattern`: The Lua pattern that matches a specific error string.\n  + `filename`: The index of the Lua capture that contains the filename the\n    error occured in.\n  + `line`: The index of the Lua capture that contains the line number the\n    error occured on.\n  + `message`: [Optional] The index of the Lua capture that contains the\n    error's message. A call tip will be displayed if a message was captured.\n\nWhen an error message is double-clicked, the user is taken to the point of\nerror.\nThis table is usually populated by language-specific modules.
events _G.events (module)\nTextadept's core event structure and handlers.
execute _M.textadept.run.execute(command, lexer)\nExecutes the command line parameter and prints the output to Textadept.\n@param command The command line string.\n  It can have the following macros:\n    + `%(filepath)`: The full path of the current file.\n    + `%(filedir)`: The current file's directory path.\n    + `%(filename)`: The name of the file including extension.\n    + `%(filename_noext)`: The name of the file excluding extension.\n@param lexer The current lexer.
execute os.execute([command])\nThis function is equivalent to the C function `system`. It passes\n`command` to be executed by an operating system shell. Its first result is\n`true` if the command terminated successfully, or `nil` otherwise. After this\nfirst result the function returns a string and a number, as follows:\n  "exit": the command terminated normally; the following number is the exit\n          status of the command.\n  "signal": the command was terminated by a signal; the following number is\n            the signal that terminated the command.\n\nWhen called without a `command`, `os.execute` returns a boolean that is true\nif a shell is available.
exit os.exit([code [, close]])\nCalls the C function `exit` to terminate the host program. If `code` is\n`true`, the returned status is `EXIT_SUCCESS`; if `code` is `false`, the\nreturned status is `EXIT_FAILURE`; if `code` is a number, the returned status\nis this number. The default value for `code` is `true`.\n\nIf the optional second argument `close` is true, closes the Lua state before\nexiting.
exp math.exp(x)\nReturns the value *e^x*.
extend lexer.extend\nMatches any ASCII extended character (`0`..`255`).
extensions _M.textadept.mime_types.extensions (table)\nFile extensions with their associated lexers.
extra_ascent buffer.extra_ascent (number)\nThe extra ascent, the maximum that any style extends above the baseline,\nadded to each line.
extra_descent buffer.extra_descent (number)\nThe extra descent, the maximum that any style extends below the baseline,\nadded to each line.
extract bit32.extract(n, field [, width])\nReturns the unsigned number formed by the bits `field` to `field + width - 1`\nfrom `n`. Bits are numbered from 0 (least significant) to 31 (most\nsignificant). All accessed bits must be in the range [0, 31].\n\nThe default for `width` is 1.
filename buffer.filename (string)\nThe absolute path to the file associated with this buffer.\nIt is encoded in UTF-8. Use `string.iconv()` for\ncharset conversions.
filter_through _M.textadept.filter_through (module)\nFilter-Through for the textadept module.
filter_through _M.textadept.filter_through.filter_through()\nPrompts for a Linux, Mac OSX, or Windows shell command to filter text\nthrough.\nThe standard input (stdin) for shell commands is determined as follows:\n\n1. If text is selected and spans multiple lines, all text on the lines\ncontaining the selection is used. However, if the end of the selection is at\nthe beginning of a line, only the EOL (end of line) characters from the\nprevious line are included as input. 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\nThe input text is replaced with the standard output (stdout) of the command.
filteredlist gui.filteredlist(title, columns, items, int_return, ...)\nShortcut function for `gui.dialog('filtered_list', ...)` with 'Ok' and\n'Cancel' buttons.\n@param title The title for the filteredlist dialog.\n@param columns A column name or list of column names.\n@param items An item or list of items.\n@param int_return If `true`, returns the integer index of the selected item\n  in the filteredlist. The default value is `false`, which returns the string\n  item. Not compatible with a `'--select-multiple'` filteredlist.\n@param ... Additional parameters to pass to `gui.dialog()`.\n@usage gui.filteredlist('Title', 'Foo', { 'Bar', 'Baz' })\n@usage gui.filteredlist('Title', { 'Foo', 'Bar' }, { 'a', 'b', 'c', 'd' },\n                        false, '--output-column', '2')\n@return Either a string or integer on success; `nil` otherwise.
find gui.find (module)\nTextadept's integrated find/replace dialog.
find string.find(s, pattern [, init [, plain]])\nLooks for the first match of `pattern` in the string `s`. If it finds a\nmatch, then `find` returns the indices of `s` where this occurrence starts\nand ends; otherwise, it returns nil. A third, optional numerical argument\n`init` specifies where to start the search; its default value is 1 and\ncan 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_column buffer.find_column(buffer, line, column)\nFind the position of a column on a line taking into account tabs and\nmulti-byte characters.\nIf beyond end of line, return line end position.\n@param buffer The global buffer.\n@param line The line number.\n@param column The column number.
find_entry_text gui.find.find_entry_text (string)\nThe text in the find entry.
find_in_files gui.find.find_in_files(utf8_dir)\nPerforms a find in files with the given directory.\nUse the `gui.find` fields to set the text to find and option flags.\n@param utf8_dir UTF-8 encoded directory name. If none is provided, the user\n  is prompted for one.
find_incremental gui.find.find_incremental()\nBegins an incremental find using the Lua command entry.\nLua command functionality will be unavailable until the search is finished\n(pressing 'Escape' by default).
find_label_text gui.find.find_label_text (string, Write-only)\nThe text of the 'Find' label.\nThis is primarily used for localization.
find_next gui.find.find_next()\nMimicks a press of the 'Find Next' button in the Find box.
find_next_button_text gui.find.find_next_button_text (string, Write-only)\nThe text of the 'Find Next' button.\nThis is primarily used for localization.
find_prev gui.find.find_prev()\nMimicks a press of the 'Find Prev' button in the Find box.
find_prev_button_text gui.find.find_prev_button_text (string, Write-only)\nThe text of the 'Find Prev' button.\nThis is primarily used for localization.
first_visible_line buffer.first_visible_line (number)\nThe display line at the top of the display.
float lexer.float\nMatches a floating point number.
floor math.floor(x)\nReturns the largest integer smaller than or equal to `x`.
flush file:flush()\nSaves any written data to `file`.
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.
focus buffer.focus (bool)\nThe internal focus flag.
focus gui.command_entry.focus()\nFocuses the command entry.
focus gui.find.focus()\nDisplays and focuses the find/replace dialog.
fold lexer.fold(text, start_pos, start_line, start_level)\nFolds the given text.\nCalled by LexLPeg.cxx; do not call from Lua.\nIf the current lexer has no _fold function, folding by indentation is\nperformed if the 'fold.by.indentation' property is set.\n@param text The document text to fold.\n@param start_pos The position in the document text starts at.\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_expanded buffer.fold_expanded (bool)\nExpanded state of a header line.
fold_level buffer.fold_level (table)\nTable of fold levels for lines starting from zero.\nFold levels encodes an integer level along with flags indicating whether\nthe line is a header and whether it is effectively white space.\n\n* `_SCINTILLA.constants.SC_FOLDLEVELBASE` (0x400)\n  Initial fold level.\n* `_SCINTILLA.constants.SC_FOLDLEVELWHITEFLAG` (0x1000)\n  Indicates that the line is blank.\n* `_SCINTILLA.constants.SC_FOLDLEVELHEADERFLAG` (0x2000)\n  Indicates that the line is a header (fold point).
fold_line_comments lexer.fold_line_comments(prefix)\nReturns a fold function that folds consecutive line comments.\nThis function should be used inside the lexer's `_foldsymbols` table.\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_parent buffer.fold_parent (table, Read-only)\nTable of parent line numbers for child lines starting from zero.\n`-1` means no line was found.
font_quality buffer.font_quality (number)\n(Windows only)\n  The quality level for text.\n\n  * `_SCINTILLA.constants.SC_EFF_QUALITY_DEFAULt` (0).\n  * `_SCINTILLA.constants.SC_EFF_QUALITY_NON_ANTIALIASED` (1).\n  * `_SCINTILLA.constants.SC_EFF_QUALITY_ANTIALIASED` (2).\n  * `_SCINTILLA.constants.SC_EFF_QUALITY_LCD_OPTIMIZED` (3).
form_feed buffer.form_feed(buffer)\nInsert a Form Feed character.\n@param buffer The global buffer.
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 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`. The `q` option\nformats a string between double quotes, using escape sequences when necessary\nto ensure that it can safely be read back by the Lua interpreter. For\ninstance, 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` also\nexpect a number, but the range of that number may be limited by the\nunderlying C implementation. For options `o`, `u`, `X`, and `x`, the number\ncannot be negative. Option `q` expects a string; option `s` expects a string\nwithout embedded zeros. If the argument to option `s` is not a string, it is\nconverted to one following the same rules of `tostring`.
frexp math.frexp(x)\nReturns `m` and `e` such that 'x = m2^e', `e` is an integer and the\nabsolute value of `m` is in the range *[0.5, 1)* (or zero when `x` is zero).
functions _SCINTILLA.functions (table)\nScintilla functions.
get_apidoc _M.textadept.adeptsense.get_apidoc(sense, symbol)\nReturns a list of apidocs for the given symbol.\nIf there are multiple apidocs, the index of one to display is the value of\nthe `pos` key in the returned list.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param symbol The symbol to get apidocs for.\n@return apidoc_list or `nil`
get_class _M.textadept.adeptsense.get_class(sense, symbol)\nReturns the class name for a given symbol.\nIf the symbol is `sense.syntax.self` and a class definition using the\n`sense.syntax.class_definition` keyword is found, that class is returned.\nOtherwise the buffer is searched backwards for a type declaration of the\nsymbol according to the patterns in `sense.syntax.type_declarations`.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param symbol The symbol to get the class of.\n@return class or `nil`\n@see syntax
get_completions _M.textadept.adeptsense.get_completions(sense, symbol, only_fields, only_functions)\nReturns a list of completions for the given symbol.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param symbol The symbol to get completions for.\n@param only_fields If `true`, returns list of only fields. The default value\n  is `false`.\n@param only_functions If `true`, returns list of only functions. The default\n  value is `false`.\n@return completion_list or `nil`
get_cur_line buffer.get_cur_line(buffer)\nRetrieve the text of the line containing the caret.\nAlso returns the index of the caret on the line.\n@param buffer The global buffer.\n@return string, number
get_fold_level lexer.get_fold_level(line_number)\nReturns the fold level for a given line.\nThis level already has `SC_FOLDLEVELBASE` added to it, so you do not need to\nadd it yourself.\n@param line_number The line number to get the fold level of.
get_hotspot_active_back buffer.get_hotspot_active_back(buffer)\nGet the back color for active hotspots in 0xBBGGRR format.\n@param buffer The global buffer.\n@return number
get_hotspot_active_fore buffer.get_hotspot_active_fore(buffer)\nGet the fore color for active hotspots.\n@param buffer The global buffer.\n@return number
get_indent_amount lexer.get_indent_amount(line)\nReturns the indent amount of text for a given line.\n@param line The line number to get the indent amount of.
get_last_child buffer.get_last_child(buffer, header_line, level)\nFind the last child line of a header line.\n@param buffer The global buffer.\n@param header_line The line number of a header line.\n@param level The level or `-1` for the level of header_line.
get_lexer buffer.get_lexer(buffer, current)\nReplacement for `buffer.get_lexer_language(buffer)`.\n@param buffer The global buffer.\n@param current Whether to get the lexer at the current caret position in\n  multi-language lexers. The default is `false` and returns the parent lexer.
get_lexer_language buffer.get_lexer_language(buffer)\nRetrieve the name of the lexer.\n@param buffer The global buffer.
get_line buffer.get_line(buffer, line)\nRetrieve the contents of a line.\nAlso returns the length of the line.\n@param buffer The global buffer.\n@param line The line number.\n@return string, number
get_line_sel_end_position buffer.get_line_sel_end_position(buffer, line)\nRetrieve the position of the end of the selection at the given line (`-1` if\nno selection on this line).\n@param buffer The global buffer.\n@param line The line number.
get_line_sel_start_position buffer.get_line_sel_start_position(buffer, line)\nRetrieve the position of the start of the selection at the given line (`-1`\nif no selection on this line).\n@param buffer The global buffer.\n@param line The line number.
get_property buffer.get_property(buffer, key)\nRetrieve a `property` value previously set with `buffer.property`.\n@param buffer The global buffer.\n@param key Keyword.\n@return string
get_property lexer.get_property(key, default)\nReturns an integer property value for a given key.\n@param key The property key.\n@param default Optional integer value to return if key is not set.
get_property_expanded buffer.get_property_expanded(buffer, key)\nRetrieve a `property` value previously set with `buffer.property`, with `$()`\nvariable replacement on returned buffer.\n@param buffer The global buffer.\n@param key Keyword.\n@return string
get_sel_text buffer.get_sel_text(buffer)\nRetrieve the selected text.\nAlso returns the length of the text.\n@param buffer The global buffer.\n@return string, number
get_split_table gui.get_split_table()\nGets the current split view structure.\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  indicating if the split is vertical or not; and `size` is the integer\n  position of the split resizer.
get_style_at lexer.get_style_at(pos)\nReturns the string style name and style number at a given position.\n@param pos The position to get the style for.
get_style_name buffer.get_style_name(buffer, style_num)\nReturns the name of the style associated with a style number.\n@param buffer The global buffer.\n@param style_num A style number from `0` to `255`.\n@see buffer.style_at
get_symbol _M.textadept.adeptsense.get_symbol(sense)\nReturns a full symbol (if any) and current symbol part (if any) behind the\ncaret.\nFor example: `buffer.cur` would return `'buffer'` and `'cur'`.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@return symbol or `''`\n@return part or `''`
get_tag buffer.get_tag(buffer, tag_num)\nRetrieve the value of a tag from a regular expression search.\n@param buffer The global buffer.\n@param tag_num The tag number.\n@return string
get_text buffer.get_text(buffer)\nRetrieve all the text in the document.\nAlso returns number of characters retrieved.\n@param buffer The global buffer.
getenv os.getenv(varname)\nReturns the value of the process environment variable `varname`, or\nnil if the variable is not defined.
gethook debug.gethook([thread])\nReturns the current hook settings of the thread, as three values: the\ncurrent hook function, the current hook mask, and the current hook count\n(as set by the `debug.sethook` function).
getinfo debug.getinfo([thread, ] f [, what])\nReturns a table with information about a function. You can give the\nfunction directly or you can give a number as the value of `f`, which means\nthe function running at level `f` of the call stack of the given thread:\nlevel 0 is the current function (`getinfo` itself); level 1 is the function\nthat called `getinfo` and so on. If `f` is a number larger than the number of\nactive functions, then `getinfo` returns nil.\n\nThe returned table can contain all the fields returned by `lua_getinfo`,\nwith the string `what` describing which fields to fill in. The default for\n`what` is to get all information available, except the table of valid\nlines. If present, the option '`f`' adds a field named `func` with\nthe function itself. If present, the option '`L`' adds a field named\n`activelines` with the table of valid lines.\n\nFor instance, the expression `debug.getinfo(1,"n").name` returns a table\nwith a name for the current function, if a reasonable name can be found,\nand the expression `debug.getinfo(print)` returns a table with all available\ninformation about the `print` function.
getlocal debug.getlocal([thread, ] f, local)\nThis function returns the name and the value of the local variable with index\n`local` of the function at level `f` of the stack. This function accesses not\nonly explicit local variables, but also parameters, temporaries, etc.\n\nThe first parameter or local variable has index 1, and so on, until the last\nactive variable. Negative indices refer to vararg parameters; -1 is the first\nvararg parameter. The function returns nil if there is no variable with the\ngiven index, and raises an error when called with a level out of range. (You\ncan call `debug.getinfo` to check whether the level is valid.)\n\nVariable names starting with '`(`' (open parentheses) represent internal\nvariables (loop control variables, temporaries, varargs, and C function\nlocals).\n\nThe parameter `f` may also be a function. In that case, `getlocal` returns\nonly the name of function parameters.
getmetatable _G.getmetatable(object)\nIf `object` does not have a metatable, returns nil. Otherwise, if the\nobject's metatable has a `"__metatable"` field, returns the associated\nvalue. Otherwise, returns the metatable of the given object.
getmetatable debug.getmetatable(value)\nReturns the metatable of the given `value` or nil if it does not have\na metatable.
getregistry debug.getregistry()\nReturns the registry table (see §4.5).
getupvalue debug.getupvalue(f, up)\nThis function returns the name and the value of the upvalue with index\n`up` of the function `f`. The function returns nil if there is no upvalue\nwith the given index.
getuservalue debug.getuservalue(u)\nReturns the Lua value associated to `u`. If `u` is not a userdata, returns\nnil.
gmatch string.gmatch(s, pattern)\nReturns an iterator function that, each time it is called, returns the\nnext captures from `pattern` over the string `s`. If `pattern` specifies no\ncaptures, then the whole match is produced in each call.\n\nAs an example, the following loop will iterate over all the words from string\n`s`, printing one per line:\n\n  s = "hello world from Lua"\n  for w in string.gmatch(s, "%a+") do\n    print(w)\n  end\n\nThe next example collects all pairs `key=value` from the given string into a\ntable:\n\n  t = {}\n  s = "from=world, to=Lua"\n  for k, v in string.gmatch(s, "(%w+)=(%w+)") do\n    t[k] = v\n  end\n\nFor this function, a caret '`^`' at the start of a pattern does not work as\nan anchor, as this would prevent the iteration.
goto_bookmark _M.textadept.bookmarks.goto_bookmark()\nGoes to selected bookmark from a filtered list.
goto_buffer view:goto_buffer(n, relative)\nGoes to the specified buffer in the indexed view.\nGenerates `BUFFER_BEFORE_SWITCH` and `BUFFER_AFTER_SWITCH` events.\n@param n A relative or absolute buffer index. An absolute index of `-1` goes\n  to the last buffer.\n@param relative Flag indicating if `n` is a relative index or not. The\n  default value is `false`.
goto_ctag _M.textadept.adeptsense.goto_ctag(sense, k, title)\nDisplays a filteredlist of all known symbols of the given kind (classes,\nfunctions, fields, etc.) and jumps to the source of the selected one.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param k The ctag character kind (e.g. `'f'` for a Lua function).\n@param title The title for the filteredlist dialog.
goto_error _M.textadept.run.goto_error(pos, line_num)\nWhen the user double-clicks an error message, go to the line in the file\nthe error occured at and display a calltip with the error message.\n@param pos The position of the caret.\n@param line_num The line double-clicked.\n@see error_detail
goto_file gui.goto_file(filename, split, preferred_view, sloppy)\nGoes to the buffer with the given filename.\nIf the desired buffer is open in a view, goes to that view. Otherwise, opens\nthe buffer in either the `preferred_view` if given, the first view that is\nnot the current one, a split view if `split` is `true`, or the current view.\n@param filename The filename of the buffer to go to.\n@param split If there is only one view, split it and open the buffer in the\n  other view.\n@param preferred_view When multiple views exist and the desired buffer is not\n  open in any of them, open it in this one.\n@param sloppy Flag indicating whether or not to not match `filename` to\n  `buffer.filename` exactly. When `true`, matches `filename` to only the last\n  part of `buffer.filename` This is useful for run and compile commands which\n  output relative filenames and paths instead of full ones and it is likely\n  that the file in question is already open. The default value is `false`.
goto_file_in_list gui.find.goto_file_in_list(next)\nGoes to the next or previous file found relative to the file\non the current line.\n@param next Flag indicating whether or not to go to the next file.
goto_line _M.textadept.editing.goto_line(line)\nGoes to the requested line.\n@param line Optional line number to go to. If `nil`, the user is prompted for\n  one.
goto_line buffer.goto_line(buffer, line)\nSet caret to start of a line and ensure it is visible.\n@param buffer The global buffer.\n@param line The line number.
goto_next _M.textadept.bookmarks.goto_next()\nGoes to the next bookmark in the current buffer.
goto_pos buffer.goto_pos(buffer, pos)\nSet caret to a position and ensure it is visible.\nThe anchor position is set the same as the current position.\n@param buffer The global buffer.\n@param pos The position.
goto_prev _M.textadept.bookmarks.goto_prev()\nGoes to the previous bookmark in the current buffer.
goto_required _M.lua.goto_required()\nDetermines the Lua file being 'require'd, searches through package.path for\nthat file, and opens it in Textadept.
goto_required _M.php.goto_required()\nDetermines the PHP file being 'require'd or 'include'd, and opens it in\nTextadept.
goto_required _M.ruby.goto_required()\nDetermine the Ruby file being 'require'd, and search through the RUBYPATH\nfor that file and open it in Textadept.
goto_view gui.goto_view(n, relative)\nGoes to the specified view.\nGenerates `VIEW_BEFORE_SWITCH` and `VIEW_AFTER_SWITCH` events.\n@param n A relative or absolute view index.\n@param relative Flag indicating if n is a relative index or not. The default\n  value is `false`.
grab_focus buffer.grab_focus(buffer)\nSet the focus to this view.\n@param buffer The global buffer.
graph lexer.graph\nMatches any graphical character (`!` to `~`).
grow_selection _M.textadept.editing.grow_selection(amount)\nGrows the selection by a character amount on either end.\n@param amount The amount to grow the selection on either end.
gsub string.gsub(s, pattern, repl [, n])\nReturns a copy of `s` in which all (or the first `n`, if given)\noccurrences of the `pattern` have been replaced by a replacement string\nspecified by `repl`, which can be a string, a table, or a function. `gsub`\nalso returns, as its second value, the total number of matches that occurred.\nThe name `gsub` comes from "Global SUBstitution".\n\nIf `repl` is a string, then its value is used for replacement. The character\n`%` works as an escape character: any sequence in `repl` of the form `%d`,\nwith `d` between 1 and 9, stands for the value of the `d`-th captured\nsubstring (see below). The sequence `%0` stands for the whole match. The\nsequence `%%` stands for a single `%`.\n\nIf `repl` is a table, then the table is queried for every match, using\nthe first capture as the key; if the pattern specifies no captures, then\nthe whole match is used as the key.\nIf `repl` is a function, then this function is called every time a match\noccurs, with all captured substrings passed as arguments, in order; if\nthe pattern specifies no captures, then the whole match is passed as a\nsole argument.\n\nIf the value returned by the table query or by the function call is a\nstring or a number, then it is used as the replacement string; otherwise,\nif it is false or nil, then there is no replacement (that is, the original\nmatch is kept in the string).\n\nHere are some examples:\n\n  x = string.gsub("hello world", "(%w+)", "%1 %1")\n  --> x="hello hello world world"\n  x = string.gsub("hello world", "%w+", "%0 %0", 1)\n  --> x="hello hello world"\n  x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")\n  --> x="world hello Lua from"\n  x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)\n  --> x="home = /home/roberto, user = roberto"\n  x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)\n        return load(s)()\n      end)\n  --> x="4+5 = 9"\n  local t = {name="lua", version="5.2"}\n  x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)\n  --> x="lua-5.2.tar.gz"
gtkmenu gui.gtkmenu(menu_table)\nCreates a GTK menu, returning the userdata.\n@param menu_table A table defining the menu. It is an ordered list of tables\n  with a string menu item, integer menu ID, and optional keycode and modifier\n  mask. The latter two are used to display key shortcuts in the menu. The\n  string menu item is handled as follows:\n    `'gtk-*'` - a stock menu item is created based on the GTK stock-id.\n    `'separator'` - a menu separator item is created.\n    Otherwise a regular menu item with a mnemonic is created.\n  Submenus are just nested menu-structure tables. Their title text is defined\n  with a `title` key.\n@see keys.get_gdk_key
gui _G.gui (module)\nThe core gui table.
h_scroll_bar buffer.h_scroll_bar (bool)\nWhether the horizontal scroll bar is visible.\nSet to `false` to never see it and `true` to enable it again. The default\nstate is to display it when needed.
handle_clear _M.textadept.adeptsense.handle_clear(sense)\nCalled when clearing an Adeptsense.\nThis function should be replaced with your own if you have any persistant\nobjects that need to be deleted.\n@param sense The Adeptsense returned by `adeptsense.new()`.
handle_ctag _M.textadept.adeptsense.handle_ctag(sense, tag_name, file_name, ex_cmd, ext_fields)\nCalled by `load_ctags()` when a ctag kind is not recognized.\nThis method should be replaced with your own that is specific to the\nlanguage.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param tag_name The tag name.\n@param file_name The name of the file the tag belongs to.\n@param ex_cmd The `ex_cmd` returned by ctags.\n@param ext_fields The `ext_fields` returned by ctags.
handlers events.handlers (table)\nA table of event names and a table of functions connected to them.
hex_num lexer.hex_num\nMatches a hexadecimal number.
hide_lines buffer.hide_lines(buffer, start_line, end_line)\nMake a range of lines invisible.\nThis has no effect on fold levels or fold flags. `start_line` can not be\nhidden.\n@param buffer The global buffer.\n@param start_line The start line.\n@param end_line The end line.
hide_selection buffer.hide_selection(buffer, normal)\nDraw the selection in normal style or with selection highlighted.\n@param buffer The global buffer.\n@param normal Draw normal selection.
highlight_guide buffer.highlight_guide (number)\nThe highlighted indentation guide column.\nSet to `0` to cancel this highlight.
highlight_word _M.textadept.editing.highlight_word()\nHighlights all occurances of the word under the caret and adds markers to the\nlines they are on.
home buffer.home(buffer)\nMove caret to first position on line.\n@param buffer The global buffer.
home_display buffer.home_display(buffer)\nMove caret to first position on display line.\n@param buffer The global buffer.
home_display_extend buffer.home_display_extend(buffer)\nMove caret to first position on display line extending selection to new caret\nposition.\n@param buffer The global buffer.
home_extend buffer.home_extend(buffer)\nMove caret to first position on line extending selection to new caret\nposition.\n@param buffer The global buffer.
home_rect_extend buffer.home_rect_extend(buffer)\nMove caret to first position on line, extending rectangular selection to new\ncaret position.\n@param buffer The global buffer.
home_wrap buffer.home_wrap(buffer)\nMove caret to the start of the display line when word-wrap is enabled.\nIf already there, go to the start of the document line.\n@param buffer The global buffer.
home_wrap_extend buffer.home_wrap_extend(buffer)\nLike `buffer:home_wrap()` but extending selection to new caret position.\n@param buffer The global buffer.
hotspot_active_underline buffer.hotspot_active_underline (bool)\nWhether active hotspots are underlined.
hotspot_single_line buffer.hotspot_single_line (bool)\nWhether hotspots are limited to single line so hotspots on two lines do not\nmerge.
huge math.huge (number)\nThe value `HUGE_VAL`, a value larger than or equal to any other numerical\nvalue.
hypertext _G.keys.hypertext (table)\nContainer for HTML-specific key commands.
hypertext _G.snippets.hypertext (table)\nContainer for HTML-specific snippets.
hypertext _M.hypertext (module)\nThe hypertext module.\nIt provides utilities for editing HTML code.\nUser tags are loaded from _USERHOME/modules/hypertext/tags and user apis are\nloaded from _USERHOME/modules/hypertext/api.
iconv string.iconv(text, to, from)\nConverts a string from one character set to another using iconv.\nValid character sets are ones GLib's `g_convert()` accepts, typically GNU\niconv's character sets.\n@param text The text to convert.\n@param to The character set to convert to.\n@param from The character set to convert from.
in_files gui.find.in_files (bool)\nSearch for the text in a list of files.
in_files_label_text gui.find.in_files_label_text (string, Write-only)\nThe text of the 'In files' label.\nThis is primarily used for localization.
indent buffer.indent (number)\nIhe number of spaces used for one level of indentation.\nFor a width of `0`, the indent size is the same as the tab size.
indentation_guides buffer.indentation_guides (number)\nIndentation guides appearance.\nIndentation guides are dotted vertical lines that appear within indentation\nwhite space every indent size columns.\n\n* `_SCINTILLA.constants.SC_IV_NONE` (0)\n  No indentation guides are shown.\n* `_SCINTILLA.constants.SC_IV_REAL` (1)\n  Indentation guides are shown inside real indentation white space.\n* `_SCINTILLA.constants.SC_IV_LOOKFORWARD` (2)\n  Indentation guides are shown beyond the actual indentation up to the\n  level of the next non-empty line.\n  If the previous non-empty line was a fold header then indentation guides\n  are shown for one more level of indent than that line. This setting is\n  good for Python.\n* `_SCINTILLA.constants.SC_IV_LOOKBOTH` (3)\n  Indentation guides are shown beyond the actual indentation up to the\n  level of the next non-empty line or previous non-empty line whichever is\n  the greater.\n  This setting is good for most languages.
indic_alpha buffer.indic_alpha (table)\nTable of alpha transparency values ranging from `0` (transparent) to `255`\n(opaque) or `256` (no alpha) for indicators from `0` to `31`.\nUsed for drawing the fill color of the `INDIC_ROUNDBOX` and\n`INDIC_STRAIGHTBOX` rectangle.
indic_fore buffer.indic_fore (table)\nTable of foreground colors in `0xBBGGRR` format for indicators from `0` to\n`31`.
indic_outline_alpha buffer.indic_outline_alpha (table)\nTable of alpha transparency values ranging from `0` (transparent) to `255`\n(opaque) or `256` (no alpha) for indicators from `0` to `31`.\nUsed for drawing the outline color of the `INDIC_ROUNDBOX` and\n`INDIC_STRAIGHTBOX` rectangle.
indic_style buffer.indic_style (table)\nTable of styles for indicators from `0` to `31`.\n\n* `_SCINTILLA.constants.INDIC_PLAIN` (0)\n  Underlined with a single, straight line.\n* `_SCINTILLA.constants.INDIC_SQUIGGLE` (1)\n  A squiggly underline. Requires 3 pixels of descender space.\n* `_SCINTILLA.constants.INDIC_TT` (2)\n  A line of small T shapes.\n* `_SCINTILLA.constants.INDIC_DIAGONAL` (3)\n  Diagonal hatching.\n* `_SCINTILLA.constants.INDIC_STRIKE` (4)\n  Strike out.\n* `_SCINTILLA.constants.INDIC_HIDDEN` (5)\n  An indicator with no visual effect.\n* `_SCINTILLA.constants.INDIC_BOX` (6)\n  A rectangle around the text.\n* `_SCINTILLA.constants.INDIC_ROUNDBOX` (7)\n  A rectangle with rounded corners around the text using translucent\n  drawing with the interior usually more transparent than the border. Use\n  `buffer.indic_alpha` and `buffer.indic_outline_alpha` to control the\n  alpha transparency values. The default alpha values are `30` for fill\n  color and `50` for outline color.\n* `_SCINTILLA.constants.INDIC_STRAIGHTBOX` (8)\n  A rectangle around the text using translucent drawing with the interior\n  usually more transparent than the border.\n  You can use `buffer.indic_alpha` and `buffer.indic_outline_alpha` to\n  control the alpha transparency values. The default alpha values are `30`\n  for fill color and `50` for outline color.\n* `_SCINTILLA.constants.INDIC_DASH` (9)\n  A dashed underline.\n* `_SCINTILLA.constants.INDIC_DOTS` (10)\n  A dotted underline.\n* `_SCINTILLA.constants.INDIC_SQUIGGLELOW` (11)\n  Similar to `INDIC_SQUIGGLE` but only using 2 vertical pixels so will fit\n  under small fonts.\n* `_SCINTILLA.constants.INDIC_DOTBOX` (12)\n  A dotted rectangle around the text using translucent drawing.\n  Translucency alternates between the alpha and outline alpha settings with\n  the top-left pixel using the alpha setting. `buffer.indic_alpha` and\n  `buffer.indic_outline_alpha` control the alpha transparency values.\n  The default values are `30` for alpha and `50` for outline alpha. To\n  avoid excessive memory allocation the maximum width of a dotted box is\n  4000 pixels.\n* Use `_SCINTILLA.next_indic_number()` for custom indicators.
indic_under buffer.indic_under (table)\nTable of booleans for drawing under text or over (default) for indicators\nfrom `0` to `31`.
indicator_all_on_for buffer.indicator_all_on_for(buffer, pos)\nRetrieve a bitmap value representing which indicators are non-zero at a\nposition.\nBit 0 is set if indicator 0 is present, bit 1 for indicator 1 and so on.\n@param buffer The global buffer.\n@param pos The position.\n@return number
indicator_clear_range buffer.indicator_clear_range(buffer, pos, clear_length)\nTurn a indicator off over a range.\n@param buffer The global buffer.\n@param pos The start position.\n@param clear_length The length.
indicator_current buffer.indicator_current (number)\nThe indicator in the range of `0` to `31` used for\n`buffer:indicator_fill_range()` and `buffer:indicator_clear_range()`.
indicator_end buffer.indicator_end(buffer, indicator, pos)\nFind the position where a particular indicator ends.\n@param buffer The global buffer.\n@param indicator An indicator number in the range of `0` to `31`.\n@param pos The position of the indicator.
indicator_fill_range buffer.indicator_fill_range(buffer, pos, fill_length)\nTurn a indicator on over a range.\nThis function fills with the current indicator value.\n@param buffer The global buffer.\n@param pos the start position.\n@param fill_length The length.
indicator_start buffer.indicator_start(buffer, indicator, pos)\nFind the position where a particular indicator starts.\n@param buffer The global buffer.\n@param indicator An indicator number in the range of `0` to `31`.\n@param pos The position of the indicator.
indicator_value buffer.indicator_value (number)\nThe indicator value used for `buffer:indicator_fill_range()`.\nCurrently all values are drawn the same.
indicator_value_at buffer.indicator_value_at(buffer, indicator, pos)\nRetrieve the value of a particular indicator at a position.\nCurrently all values are drawn the same.\n@param buffer The global buffer.\n@param indicator The indicator number in the range of `0` to `31`.\n@param pos The position.\n@return number
inherited_classes _M.textadept.adeptsense.inherited_classes (table)\nContains a map of classes and a list of their inherited classes.
input io.input([file])\nWhen called with a file name, it opens the named file (in text mode),\nand sets its handle as the default input file. When called with a file\nhandle, it simply sets this file handle as the default input file. When\ncalled without parameters, it returns the current default input file.\n\nIn case of errors this function raises the error, instead of returning an\nerror code.
insert table.insert(list, [pos, ] value)\nInserts element `value` at position `pos` in `list`, shifting up the elements\n`list[pos], list[pos+1], ···, list[#list]`. The default value for `pos` is\n`#list+1`, so that a call `table.insert(t,x)` inserts `x` at the end of list\n`t`.
insert_text buffer.insert_text(buffer, pos, text)\nInsert string at a position.\nIf the current position is after the insertion point then it is moved along\nwith its surrounding text but no scrolling is performed.\n@param buffer The global buffer.\n@param pos The position to insert text at or `-1` for the current position.\n@param text The text to insert.
integer lexer.integer\nMatches a decimal, hexadecimal, or octal number.
io _G.io (module)\nLua io module.
ipairs _G.ipairs(t)\nIf `t` has a metamethod `__ipairs`, calls it with `t` as argument and returns\nthe first three results from the call.\n\nOtherwise, returns three values: an iterator function, the table `t`, and 0,\nso that the construction\n\n  for i,v in ipairs(t) do *body* end\n\nwill iterate over the pairs (`1,t[1]`), (`2,t[2]`), ..., up to the\nfirst integer key absent from the table.
java _G.keys.java (table)\nContainer for Java-specific key commands.
java _G.snippets.java (table)\nContainer for Java-specific snippets.
java _M.java (module)\nThe java module.\nIt provides utilities for editing Java code.\nUser tags are loaded from _USERHOME/modules/java/tags and user apis are\nloaded from _USERHOME/modules/java/api.
join_lines _M.textadept.editing.join_lines()\nJoins the currently selected lines.\nIf no lines are selected, joins the current line with the line below.
keys _G.keys (module)\nManages key commands in Textadept.
keys _M.textadept.keys (module)\nDefines key commands for Textadept.\nThis set of key commands is pretty standard among other text editors.\nThis module, should be `require`d last, but before `_M.textadept.menu`.
keys_unicode buffer.keys_unicode (bool)\nInterpret keyboard input as Unicode.
layout_cache buffer.layout_cache (number)\nThe degree of caching of layout information.\n\n* `_SCINTILLA.constants.SC_CACHE_NONE` (0)\n  No lines are cached.\n* `_SCINTILLA.constants.SC_CACHE_CARET` (1)\n  The line containing the text caret.\n  This is the default.\n* `_SCINTILLA.constants.SC_CACHE_PAGE` (2)\n  Visible lines plus the line containing the caret.\n* `_SCINTILLA.constants.SC_CACHE_DOCUMENT` (3)\n  All lines in the document.
ldexp math.ldexp(m, e)\nReturns 'm2^e' (`e` should be an integer).
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.
length buffer.length (number, Read-only)\nThe number of bytes in the document.
lex lexer.lex(text, init_style)\nLexes the given text.\nCalled by LexLPeg.cxx; do not call from Lua.\nIf the 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 text The text to lex.\n@param init_style The current style. Multilang lexers use this to determine\n  which language to start lexing in.
lexer _G.lexer (module)\nPerforms lexing of Scintilla documents.
lexer buffer.lexer (number)\nThe lexing language of the document.
lexers _M.textadept.mime_types.lexers (table)\nList of detected lexers.\nLexers are read from `lexers/` and `~/.textadept/lexers/`.
lfs _G.lfs (module)\nLua lfs module.
line_copy buffer.line_copy(buffer)\nCopy the line containing the caret.\n@param buffer The global buffer.
line_count buffer.line_count (number, Read-only)\nThe number of lines in the document.\nThere is always at least one.
line_cut buffer.line_cut(buffer)\nCut the line containing the caret.\n@param buffer The global buffer.
line_delete buffer.line_delete(buffer)\nDelete the line containing the caret.\n@param buffer The global buffer.
line_down buffer.line_down(buffer)\nMove caret down one line.\n@param buffer The global buffer.
line_down_extend buffer.line_down_extend(buffer)\nMove caret down one line extending selection to new caret position.\n@param buffer The global buffer.
line_down_rect_extend buffer.line_down_rect_extend(buffer)\nMove caret down one line, extending rectangular selection to new caret\nposition.\n@param buffer The global buffer.
line_duplicate buffer.line_duplicate(buffer)\nDuplicate the current line.\n@param buffer The global buffer.
line_end buffer.line_end(buffer)\nMove caret to last position on line.\n@param buffer The global buffer.
line_end_display buffer.line_end_display(buffer)\nMove caret to last position on display line.\n@param buffer The global buffer.
line_end_display_extend buffer.line_end_display_extend(buffer)\nMove caret to last position on display line extending selection to new caret\nposition.\n@param buffer The global buffer.
line_end_extend buffer.line_end_extend(buffer)\nMove caret to last position on line extending selection to new caret\nposition.\n@param buffer The global buffer.
line_end_position buffer.line_end_position (table, Read-only)\nTable of positions after the last visible characters on a line for lines\nstarting from zero.
line_end_rect_extend buffer.line_end_rect_extend(buffer)\nMove caret to last position on line, extending rectangular selection to new\ncaret position.\n@param buffer The global buffer.
line_end_wrap buffer.line_end_wrap(buffer)\nMove caret to the end of the display line when word-wrap is enabled.\nIf already there, go to the end of the document line.\n@param buffer The global buffer.
line_end_wrap_extend buffer.line_end_wrap_extend(buffer)\nLike `buffer:line_end_wrap()` but extending selection to new caret position.\n@param buffer The global buffer.
line_from_position buffer.line_from_position(buffer, pos)\nRetrieve the line containing a position.\n@param buffer The global buffer.\n@param pos The position.\n@return number
line_indent_position buffer.line_indent_position (table, Read-only)\nTable of positions before the first non indentation character on a line for\nlines starting from zero.
line_indentation buffer.line_indentation (table)\nTable of line indentation amounts for lines starting from zero.\nThe indentation is measured in character columns, which correspond to the\nwidth of space characters.
line_length buffer.line_length(buffer, line)\nReturns how many characters are on a line, including end of line characters.\nTo get the length of the line not including any end of line characters, use\n`buffer.line_end_position[line] - buffer:position_from_line(line)`.\n@param buffer The global buffer.\n@param line The line number.\n@return number
line_scroll buffer.line_scroll(buffer, columns, lines)\nScroll horizontally and vertically.\n@param buffer The global buffer.\n@param columns The number of columns to scroll horizontally.\n@param lines The number of lines to scroll vertically.
line_scroll_down buffer.line_scroll_down(buffer)\nScroll the document down, keeping the caret visible.\n@param buffer The global buffer.
line_scroll_up buffer.line_scroll_up(buffer)\nScroll the document up, keeping the caret visible.\n@param buffer The global buffer.
line_state buffer.line_state (table)\nTable of extra styling information for lines starting from zero.\nAs well as the 8 bits of lexical state stored for each character there is\nalso an integer stored for each line. This can be used for longer lived\nparse states.
line_transpose buffer.line_transpose(buffer)\nSwitch the current line with the previous.\n@param buffer The global buffer.
line_up buffer.line_up(buffer)\nMove caret up one line.\n@param buffer The global buffer.
line_up_extend buffer.line_up_extend(buffer)\nMove caret up one line extending selection to new caret position.\n@param buffer The global buffer.
line_up_rect_extend buffer.line_up_rect_extend(buffer)\nMove caret up one line, extending rectangular selection to new caret\nposition.\n@param buffer The global buffer.
line_visible buffer.line_visible (bool, Read-only)\nIs a line visible?
lines file:lines(···)\nReturns an iterator function that, each time it is called, reads the file\naccording to the given formats. When no format is given, uses "*l" as a\ndefault. As an example, the construction\n\n  for c in file:lines(1) do <em>body</em> end\n\nwill iterate over all characters of the file, starting at the current\nposition. Unlike `io.lines`, this function does not close the file when the\nloop ends.\n\nIn case of errors this function raises the error, instead of returning an\nerror code.
lines io.lines([filename ···])\nOpens the given file name in read mode and returns an iterator function that\nworks like `file:lines(···)` over the opened file. When the iterator function\ndetects -- the end of file, it returns nil (to finish the loop) and\nautomatically closes the file.\n\nThe call `io.lines()` (with no file name) is equivalent to\n`io.input():lines()`; that is, it iterates over the lines of the default\ninput file. In this case it does not close the file when the loop ends.\n\nIn case of errors this function raises the error, instead of returning an\nerror code.
lines_join buffer.lines_join(buffer)\nJoin the lines in the target.\nWhere this would lead to no space between words, an extra space is inserted.\n@param buffer The global buffer.
lines_on_screen buffer.lines_on_screen (number, Read-only)\nThe number of lines completely visible.
lines_split buffer.lines_split(buffer, pixel_width)\nSplit the lines in the target into lines that are less wide than\n`pixel_width` where possible.\n@param buffer The global buffer.\n@param pixel_width The pixel width. When `0`, the width of the view is used.
lines_visible buffer.lines_visible (bool, Read-only)\nAre all lines visible?
load _G.load(ld [, source [, mode [, env]]])\nLoads a chunk.\n\nIf `ld` is a string, the chunk is this string. If `ld` is a function, `load`\ncalls it repeatedly to get the chunk pieces. Each call to `ld` must return a\nstring that concatenates with previous results. A return of an empty string,\nnil, or no value signals the end of the chunk.\n\nIf there are no syntactic errors, returns the compiled chunk as a function;\notherwise, returns <b>nil</b> plus the error message.\n\nIf the resulting function has upvalues, the first upvalue is set to the value\nof the global environment or to `env`, if that parameter is given. When\nloading main chunks, the first upvalue will be the `_ENV` variable\n(see §2.2).\n\n`source` is used as the source of the chunk for error messages and debug\ninformation (see §4.9). When absent, it defaults to `ld`, if `ld` is a\nstring, or to "`=(load)`" otherwise.\n\nThe string `mode` controls whether the chunk can be text or binary (that is,\na precompiled chunk). It may be the string "`b`" (only binary chunks), "`t`"\n(only text chunks), or "`bt`" (both binary and text). The default is "`bt`".
load _M.textadept.session.load(filename)\nLoads a Textadept session file.\nTextadept restores split views, opened buffers, cursor information, and\nproject manager details.\n@param filename The absolute path to the session file to load. The default\n  value is `DEFAULT_SESSION`.\n@usage _M.textadept.session.load(filename)\n@return `true` if the session file was opened and read; `false` otherwise.\n@see DEFAULT_SESSION
load lexer.load(lexer_name)\nInitializes the specified lexer.\n@param lexer_name The name of the lexing language.
load_ctags _M.textadept.adeptsense.load_ctags(sense, tag_file, nolocations)\nLoads the given ctags file for autocompletion.\nIt is recommended to pass `-n` to ctags in order to use line numbers instead\nof text patterns to locate tags. This will greatly reduce memory usage for a\nlarge number of symbols if `nolocations` is not `true`.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param tag_file The path of the ctags file to load.\n@param nolocations If `true`, does not store the locations of the tags for\n  use by `goto_ctag()`. The default value is `false`.
load_project _M.rails.load_project(utf8_dir)\nSets keys.al.o to snapopen a Rails project.\nIf not directory is provided, the user is prompted for one.\n@param utf8_dir The UTF-8 Rails project directory.
loaded package.loaded (table)\nA table used by `require` to control which modules are already loaded. When\nyou require a module `modname` and `package.loaded[modname]` is not false,\n`require` simply returns the value stored there.\nThis variable is only a reference to the real table; assignments to this\nvariable do not change the table used by `require`.
loadfile _G.loadfile([filename [, mode [, env]]])\nSimilar to `load`, but gets the chunk from file `filename` or from the\nstandard input, if no file name is given.
loadlib package.loadlib(libname, funcname)\nDynamically links the host program with the C library `libname`.\n\nIf `funcname` is "`*`", then it only links with the library, making the\nsymbols exported by the library available to other dynamically linked\nlibraries. Otherwise, it looks for a function `funcname` inside the library\nand returns this function as a C function. (So, `funcname` must follow the\nprototype `lua_CFunction`).\n\nThis is a low-level function. It completely bypasses the package and module\nsystem. Unlike `require`, it does not perform any path searching and does\nnot automatically adds extensions. `libname` must be the complete file name\nof the C library, including if necessary a path and an extension. `funcname`\nmust be the exact name exported by the C library (which may depend on the\nC compiler and linker used).\n\nThis function is not supported by Standard C. As such, it is only available\non some platforms (Windows, Linux, Mac OS X, Solaris, BSD, plus other Unix\nsystems that support the `dlfcn` standard).
locale lpeg.locale([table])\nReturns a table with patterns for matching some character classes according\nto the current locale. The table has fields named alnum, alpha, cntrl, digit,\ngraph, lower, print, punct, space, upper, and xdigit, each one containing a\ncorrespondent pattern. Each pattern matches any single character that belongs\nto its class.\n\nIf called with an argument table, then it creates those fields inside the\ngiven table and returns that table.
locations _M.textadept.adeptsense.locations (table)\nContains the locations of known symbols.\nThis table is populated by `load_ctags()`.
lock lfs.lock(filehandle, mode[, start[, length]])\nLocks a file or a part of it. This function works on open files; the file\nhandle should be specified as the first argument. The string mode could be\neither r (for a read/shared lock) or w (for a write/exclusive lock). The\noptional arguments start and length can be used to specify a starting point\nand its length; both should be numbers.\n\nReturns true if the operation was successful; in case of error, it returns\nnil plus an error string.
lock_dir lfs.lock_dir(path, [seconds_stale])\nCreates a lockfile (called lockfile.lfs) in path if it does not exist and\nreturns the lock. If the lock already exists checks it it's stale, using the\nsecond parameter (default for the second parameter is INT_MAX, which in\npractice means the lock will never be stale. To free the the lock call\nlock:free().\n\nIn case of any errors it returns nil and the error message. In particular,\nif the lock exists and is not stale it returns the "File exists" message.
log math.log(x [, base])\nReturns the logarithm of `x` in the given base. The default for `base` is 'e'\n(so that the function returns the natural logarithm of `x`).
lower lexer.lower\nMatches any lowercase character (`a-z`).
lower string.lower(s)\nReceives a string and returns a copy of this string with all uppercase\nletters changed to lowercase. All other characters are left unchanged. The\ndefinition of what an uppercase letter is depends on the current locale.
lower_case buffer.lower_case(buffer)\nTransform the selection to lower case.\n@param buffer The global buffer.
lpeg _G.lpeg (module)\nLua lpeg module.
lrotate bit32.lrotate(x, disp)\nReturns the number `x` rotated `disp` bits to the left. The number `disp` may\nbe any representable integer.\n\nFor any valid displacement, the following identity holds:\n\n  assert(bit32.lrotate(x, disp) == bit32.lrotate(x, disp % 32))\n\nIn particular, negative displacements rotate to the right.
lshift bit32.lshift(x, disp)\nReturns the number `x` shifted `disp` bits to the left. The number `disp` may\nbe any representable integer. Negative displacements shift to the right. In\nany direction, vacant bits are filled with zeros. In particular,\ndisplacements with absolute values higher than 31 result in zero (all bits\nare shifted out).\n\nFor positive displacements, the following equality holds:\n\n  assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
lua _G.keys.lua (table)\nContainer for Lua-specific key commands.
lua _G.snippets.lua (table)\nContainer for Lua-specific snippets.
lua _M.lua (module)\nThe lua module.\nIt provides utilities for editing Lua code.\nUser tags are loaded from `_USERHOME/modules/lua/tags` and user apis are\nloaded from `_USERHOME/modules/lua/api`.
lua gui.find.lua (bool)\nThe search text is interpreted as a Lua pattern.
lua_pattern_label_text gui.find.lua_pattern_label_text (string, Write-only)\nThe text of the 'Lua pattern' label.\nThis is primarily used for localization.
main_selection buffer.main_selection (number)\nThe main selection.\nThe main selection may be displayed in different colors or with a\ndifferently styled caret. Only an already existing selection can be made\nmain.
margin_cursor_n buffer.margin_cursor_n (table)\nTable of cursors shown for margins from zero to four.\nA reversed arrow cursor is normally shown over all margins.\n\n* `_SCINTILLA.constants.SC_CURSORARROW`\n  Normal arrow.\n* `_SCINTILLA.constants.SC_CURSORREVERSEARROW`\n  Reversed arrow.
margin_get_text buffer.margin_get_text(buffer, line)\nGet the text in the text margin for a line.\n@param buffer The global buffer.\n@param line The line number.\n@return string
margin_left buffer.margin_left (number)\nThe size in pixels of the left margin.\nThe default is to one pixel.
margin_mask_n buffer.margin_mask_n (table)\nTable of marker masks for margins from zero to four.\nA mask determines which markers are displayed in a margin.
margin_options buffer.margin_options (number)\nA bit mask of margin options.\n\n* `_SCINTILLA.constants.SC_MARGINOPTION_NONE` (0)\n  None (default).\n* `_SCINTILLA.constants.SC_MARGINOPTION_SUBLINESELECT` (1)\n  Controls how wrapped lines are selected when clicking on margin in front\n  of them.\n  If set, only sub line of wrapped line is selected, otherwise whole\n  wrapped line is selected.
margin_right buffer.margin_right (number)\nThe size in pixels of the right margin.\nThe default is to one pixel.
margin_sensitive_n buffer.margin_sensitive_n (table)\nTable of mouse click sensitivity booleans for margins from zero to four.\nA click in a sensitive margin emits a `margin_click` event. By default, all\nmargins are insensitive.
margin_set_text buffer.margin_set_text(buffer, line, text)\nSet the text in the text margin for a line.\n@param buffer The global buffer.\n@param line The line number.\n@param text The text.
margin_style buffer.margin_style (table)\nTable of style numbers for text margin lines starting from zero.
margin_style_offset buffer.margin_style_offset (number)\nThe start of the range of style numbers used for margin text.\nMargin styles may be completely separated from standard text styles by\nsetting a style offset. For example, setting this to `256` would allow the\nmargin styles to be numbered from `256` upto `511` so they do not overlap\nstyles set by lexers. Each style number set with `buffer.margin_style` has\nthe offset added before looking up the style.
margin_text_clear_all buffer.margin_text_clear_all(buffer)\nClear the margin text on all lines.\n@param buffer The global buffer.
margin_type_n buffer.margin_type_n (table)\nTable of margin types for margins from zero to four.\n\n* `_SCINTILLA.constants.SC_MARGIN_SYMBOL` (0)\n  A symbol margin.\n* `_SCINTILLA.constants.SC_MARGIN_NUMBER` (1)\n  A line number margin.\n* `_SCINTILLA.constants.SC_MARGIN_BACK` (2)\n  A symbol margin that sets its background color to match the default\n  text background color.\n* `_SCINTILLA.constants.SC_MARGIN_FORE` (3)\n  A symbol margin that sets its background color to match the default\n  text foreground color.\n* `_SCINTILLA.constants.SC_MARGIN_TEXT` (4)\n  A text margin.\n* `_SCINTILLA.constants.SC_MARGIN_RTEXT` (5)\n  A right justified text margin.
margin_width_n buffer.margin_width_n (table)\nTable of margin widths expressed in pixes for margins from zero to four.
marker_add buffer.marker_add(buffer, line, marker_num)\nAdd a marker to a line, returning an ID which can be used to find or delete\nthe marker.\nReturns `-1` if this fails (illegal line number, out of memory).\n@param buffer The global buffer.\n@param line The line number.\n@param marker_num A marker number in the range of `0` to `31`.\n@return number
marker_add_set buffer.marker_add_set(buffer, line, marker_mask)\nAdd a set of markers to a line.\n@param buffer The global buffer.\n@param line The line number.\n@param marker_mask A mask of markers to set. Set bit 0 to set marker 0, bit\n  1 for marker 1 and so on.
marker_define buffer.marker_define(buffer, marker_num, marker_symbol)\nSet the symbol used for a particular marker number.\n@param buffer The global buffer.\n@param marker_num A marker number in the range of `0` to `31`.\n@param marker_symbol A marker symbol: `_SCINTILLA.constants.SC_MARK_*`.\n@see _SCINTILLA.next_marker_number
marker_define_pixmap buffer.marker_define_pixmap(buffer, marker_num, pixmap)\nDefine a marker from a pixmap.\n@param buffer The global buffer.\n@param marker_num A marker number in the range of `0` to `31`.\n@param pixmap `NULL`-terminated pixmap data.
marker_define_rgba_image buffer.marker_define_rgba_image(buffer, marker_num, pixels)\nDefine a marker from RGBA data.\nIt has the width and height from `buffer.rgba_image_width` and\n`buffer.rgba_image_height`.\n@param buffer The global buffer.\n@param marker_num A marker number in the range of `0` to `31`.\n@param pixels A sequence of 4 byte pixel values starting with the pixels for\n  the top line, with the leftmost pixel first, then continuing with the\n  pixels for subsequent lines. There is no gap between lines for alignment\n  reasons. Each pixel consists of, in order, a red byte, a green byte, a blue\n  byte and an alpha byte. The colour bytes are not premultiplied by the alpha\n  value. That is, a fully red pixel that is 25% opaque will be `[FF, 00, 00,\n  3F]`.
marker_delete buffer.marker_delete(buffer, line, marker_num)\nDelete a marker from a line.\n@param buffer The global buffer.\n@param line The line number.\n@param marker_num A marker number in the range of `0` to `31` or `-1` to\n  delete all markers from the line.
marker_delete_all buffer.marker_delete_all(buffer, marker_num)\nDelete all markers with a particular number from all lines.\n@param buffer The global buffer.\n@param marker_num A marker number in the range of `0` to `31` or `-1` to\n  delete all markers from the line.
marker_delete_handle buffer.marker_delete_handle(buffer, handle)\nDelete a marker.\n@param buffer The global buffer.\n@param handle The identifier of a marker returned by `buffer:marker_add()`.
marker_enable_highlight buffer.marker_enable_highlight(buffer, enabled)\nEnable/disable highlight for current folding block (smallest one that\ncontains the caret)\n@param buffer The global buffer.
marker_get buffer.marker_get(buffer, line)\nGet a bit mask of all the markers set on a line.\nBit 0 is set if marker 0 is present, bit 1 for marker 1 and so on.\n@param buffer The global buffer.\n@param line The line number.\n@return number.
marker_line_from_handle buffer.marker_line_from_handle(buffer, handle)\nRetrieve the line number at which a particular marker is located.\nReturns `-1` if it not found.\n@param buffer The global buffer.\n@param handle The identifier of a marker returned by `buffer:marker_add()`.\n@return number
marker_next buffer.marker_next(buffer, start_line, marker_mask)\nFind the next line at or after start_line that includes a marker in mask.\nReturn `-1` when no more lines.\n@param buffer The global buffer.\n@param start_line The start line.\n@param marker_mask A mask of markers to find. Set bit 0 to find marker 0, bit\n  1 for marker 1 and so on.\n@return number
marker_previous buffer.marker_previous(buffer, start_line, marker_mask)\nFind the previous line before `start_line` that includes a marker in mask.\n@param buffer The global buffer.\n@param start_line The start line.\n@param marker_mask A mask of markers to find. Set bit 0 to find marker 0, bit\n  1 for marker 1 and so on.\n@return number
marker_set_alpha buffer.marker_set_alpha(buffer, marker_num, alpha)\nSet the alpha used for a marker that is drawn in the text area, not the\nmargin.\n@param buffer The global buffer.\n@param marker_num A marker number in the range of `0` to `31`.\n@param alpha An alpha value between `0` (transparent) and `255` (opaque), or\n  `256` for no alpha.
marker_set_back buffer.marker_set_back(buffer, marker_num, color)\nSet the background color used for a particular marker number.\n@param buffer The global buffer.\n@param marker_num A marker number in the range of `0` to `31`.\n@param color A color in `0xBBGGRR` format.
marker_set_back_selected buffer.marker_set_back_selected(buffer, marker_num, color)\nSet the background color used for a particular marker number when its\nfolding block is selected.\n@param buffer The global buffer.\n@param marker_num A marker number in the range of `0` to `31`.\n@param color A color in `0xBBGGRR` format. The default color is `#FF0000`.
marker_set_fore buffer.marker_set_fore(buffer, marker_num, color)\nSet the foreground color used for a particular marker number.\n@param buffer The global buffer.\n@param marker_num A marker number in the range of `0` to `31`.\n@param color A color in `0xBBGGRR` format.
marker_symbol_defined buffer.marker_symbol_defined(buffer, marker_num)\nReturn the symbol defined for marker_num with `buffer:marker_define()`.\n@param buffer The global buffer.\n@param marker_num A marker number in the range of `0` to `31`.\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 starts 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` in the string `s`. If it\nfinds 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 _M.textadept.editing.match_brace(select)\nGoes to a matching brace position, selecting the text inside if specified to.\n@param select If `true`, selects the text between matching braces.
match_case gui.find.match_case (bool)\nSearches are case-sensitive.
match_case_label_text gui.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.
max math.max(x, ···)\nReturns the maximum value among its arguments.
max_line_state buffer.max_line_state (number, Read-only)\nThe last line number that has line state.
menu _M.textadept.menu (module)\nProvides dynamic menus for Textadept.\nThis module should be `require`d last, after `_M.textadept.keys` since it\nlooks up defined key commands to show them in menus.
menubar _M.textadept.menu.menubar (table)\nContains the main menubar.
menubar gui.menubar (table)\nA table of GTK menus defining a menubar. (Write-only)
mime_types _M.textadept.mime_types (module)\nHandles file-specific settings.
min math.min(x, ···)\nReturns the minimum value among its arguments.
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 two numbers, the integral part of `x` and the fractional part of\n`x`.
modify buffer.modify (bool)\nWhether the document is different from when it was last saved.
mouse_down_captures buffer.mouse_down_captures (bool)\nWhether the mouse is captured when its button is pressed.
mouse_dwell_time buffer.mouse_dwell_time (number)\nThe time the mouse must sit still to generate a mouse dwell event.\nIf set to `_SCINTILLA.constants.SC_TIME_FOREVER`, the default, no dwell\nevents are generated.
move_caret_inside_view buffer.move_caret_inside_view(buffer)\nMove the caret inside current view if it is not there already.\nAny selection is lost.\n@param buffer The global buffer.
move_selected_lines_down buffer.move_selected_lines_down(buffer)\nMove the selected lines down one line, shifting the line below before the\nselection.\nThe selection will be automatically extended to the beginning of the\nselection's first line and the end of the seletion's last line. If nothing\nwas selected, the line the cursor is currently at will be selected.\n@param buffer The global buffer.
move_selected_lines_up buffer.move_selected_lines_up(buffer)\nMove the selected lines up one line, shifting the line above after the\nselection.\nThe selection will be automatically extended to the beginning of the\nselection's first line and the end of the seletion's last line. If nothing\nwas selected, the line the cursor is currently at will be selected.\n@param buffer The global buffer.
multi_paste buffer.multi_paste (bool)\nThe effect of pasting when there are multiple selections.\n\n* `_SCINTILLA.constants.SC_MULTIPASTE_ONCE` (0)\n  Pasted text can go into just the main selection (default).\n* `_SCINTILLA.constants.SC_MULTIPASTE_EACH` (1)\n  Pasted text can go into each selection.
multiple_selection buffer.multiple_selection (bool)\nWhether multiple selections can be made.\nWhen multiple selection is disabled, it is not possible to select multiple\nranges by holding down the Ctrl key while dragging with the mouse.
nested_pair lexer.nested_pair(start_chars, end_chars, end_optional)\nSimilar to `delimited_range()`, but allows for multi-character delimitters.\nThis is useful for lexers with tokens such as nested block comments. With\nsingle-character delimiters, this function is identical to\n`delimited_range(start_chars..end_chars, nil, end_optional, true)`.\n@param start_chars The string starting a nested sequence.\n@param end_chars The string ending a nested sequence.\n@param end_optional Optional flag indicating whether or not an ending\n  delimiter is optional or not. If true, the range begun by the start\n  delimiter matches until an end delimiter or the end of the input is\n  reached.\n@usage local nested_comment = l.nested_pair('/*', '*/', true)
new _M.textadept.adeptsense.new(lang)\nCreates a new Adeptsense for the given lexer language.\nOnly one sense can exist per language.\n@param lang The lexer language to create an Adeptsense for.\n@usage local lua_sense = _M.textadept.adeptsense.new('lua')\n@return adeptsense
new_buffer _G.new_buffer()\nCreates a new buffer.\nGenerates a `BUFFER_NEW` event.\n@return the new buffer.
new_line buffer.new_line(buffer)\nInsert a new line, may use a CRLF, CR or LF depending on EOL mode.\n@param buffer The global buffer.
newline lexer.newline\nMatches any newline 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.
next_indic_number _SCINTILLA.next_indic_number()\nReturns a unique indicator number.\nUse this function for custom indicators in order to prevent clashes with\nidentifiers of other custom indicators.\n@usage local indic_num = _SCINTILLA.next_indic_number()\n@see buffer.indic_style
next_marker_number _SCINTILLA.next_marker_number()\nReturns a unique marker number.\nUse this function for custom markers in order to prevent clashes with\nidentifiers of other custom markers.\n@usage local marknum = _SCINTILLA.next_marker_number()\n@see buffer.marker_define
next_user_list_type _SCINTILLA.next_user_list_type()\nReturns a unique user list type.\nUse this function for custom user lists in order to prevent clashes with\ntype identifiers of other custom user lists.\n@usage local list_type = _SCINTILLA.next_user_list_type()\n@see buffer.user_list_show
nonnewline lexer.nonnewline\nMatches any non-newline character.
nonnewline_esc lexer.nonnewline_esc\nMatches any non-newline character excluding newlines escaped with `\\`.
oct_num lexer.oct_num\nMatches an octal number.
open _M.textadept.snapopen.open(utf8_paths, filter, exclude_PATHS, exclude_FILTER, depth)\nQuickly open a file in set of directories.\n@param utf8_paths A UTF-8 string directory path or table of UTF-8 directory\n  paths to search.\n@param filter A filter for files and folders to exclude. The filter may be\n  a string or table. Each filter is a Lua pattern. Any files matching a\n  filter are excluded. Prefix a pattern with `!` to exclude any files that\n  do not match the filter. File extensions can be more efficiently excluded\n  by adding the extension text to a table assigned to an `extensions` key in\n  the filter table instead of using individual filters. Directories can be\n  excluded by adding filters to a table assigned to a `folders` key in the\n  filter table. All strings should be UTF-8 encoded.\n@param exclude_PATHS Flag indicating whether or not to exclude `PATHS` in the\n  search. The default value is `false`.\n@param exclude_FILTER Flag indicating whether or not to exclude `FILTER` from\n  `filter` in the search. If false, adds `FILTER` to the given `filter`.\n  The default value is `false`.\n@param depth Number of directories to recurse into for finding files.\n  The default value is `DEFAULT_DEPTH`.\n@usage _M.textadept.snapopen.open()\n@usage _M.textadept.snapopen.open(buffer.filename:match('^.+/'), nil, true)\n@usage _M.textadept.snapopen.open(nil, '!%.lua$')\n@usage _M.textadept.snapopen.open(nil, { folders = { '%.hg' } })
open io.open(filename [, mode])\nThis function opens a file, in the mode specified in the string `mode`. It\nreturns a new file handle, or, in case of errors, nil plus an error message.\n\nThe `mode` string can be any of the following:\n  "r": read mode (the default);\n  "w": write mode;\n  "a": append mode;\n  "r+": update mode, all previous data is preserved;\n  "w+": update mode, all previous data is erased;\n  "a+": append update mode, previous data is preserved, writing is only\n        allowed at the end of file.\n\nThe `mode` string can also have a '`b`' at the end, which is needed in\nsome systems to open the file in binary mode.
open_file io.open_file(utf8_filenames)\nOpens a list of files.\n@param utf8_filenames A `\\n` separated list of UTF-8-encoded filenames to\n  open. If `nil`, the user is prompted with a fileselect dialog.\n@usage io.open_file(utf8_encoded_filename)
open_recent_file io.open_recent_file()\nPrompts the user to open a recently opened file.\n@see recent_files
os _G.os (module)\nLua os module.
output io.output([file])\nSimilar to `io.input`, but operates over the default output file.
overtype buffer.overtype (bool)\nOvertype mode.
pack table.pack(···)\nReturns a new table with all parameters stored into keys 1, 2, etc. and with\na field "`n`" with the total number of parameters. Note that the resulting\ntable may not be a sequence.
package _G.package (module)\nLua package module.
page_down buffer.page_down(buffer)\nMove caret one page down.\n@param buffer The global buffer.
page_down_extend buffer.page_down_extend(buffer)\nMove caret one page down extending selection to new caret position.\n@param buffer The global buffer.
page_down_rect_extend buffer.page_down_rect_extend(buffer)\nMove caret one page down, extending rectangular selection to new caret\nposition.\n@param buffer The global buffer.
page_up buffer.page_up(buffer)\nMove caret one page up.\n@param buffer The global buffer.
page_up_extend buffer.page_up_extend(buffer)\nMove caret one page up extending selection to new caret position.\n@param buffer The global buffer.
page_up_rect_extend buffer.page_up_rect_extend(buffer)\nMove caret one page up, extending rectangular selection to new caret\nposition.\n@param buffer The global buffer.
pairs _G.pairs(t)\nIf `t` has a metamethod `__pairs`, calls it with `t` as argument and returns\nthe first three results from the call.\n\nOtherwise, returns three values: the `next` function, the table `t`, and nil,\nso that the construction\n\n  for k,v in pairs(t) do *body* end\n\nwill iterate over all key–value pairs of table `t`.\n\nSee function `next` for the caveats of modifying the table during its\ntraversal.
para_down buffer.para_down(buffer)\nMove caret one paragraph down (delimited by empty lines).\n@param buffer The global buffer.
para_down_extend buffer.para_down_extend(buffer)\nMove caret one paragraph down (delimited by empty lines) extending selection\nto new caret position.\n@param buffer The global buffer.
para_up buffer.para_up(buffer)\nMove caret one paragraph up (delimited by empty lines).\n@param buffer The global buffer.
para_up_extend buffer.para_up_extend(buffer)\nMove caret one paragraph up (delimited by empty lines) extending selection to\nnew caret position.\n@param buffer The global buffer.
paste buffer.paste(buffer)\nPaste the contents of the clipboard into the document replacing the\nselection.\n@param buffer The global buffer.
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_2` 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 _M.textadept.mime_types.patterns (table)\nFirst-line patterns and their associated lexers.
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.
php _G.keys.php (table)\nContainer for PHP-specific key commands.
php _G.snippets.php (table)\nContainer for PHP-specific snippets.
php _M.php (module)\nThe php module.\nIt provides utilities for editing PHP code.\nUser tags are loaded from _USERHOME/modules/php/tags and user apis are loaded\nfrom _USERHOME/modules/php/api.
pi math.pi (number)\nThe value of 'π'.
point_x_from_position buffer.point_x_from_position(buffer, pos)\nRetrieve the x value of the point in the window where a position is\ndisplayed.\n@param buffer The global buffer.\n@param pos The position.\n@return number
point_y_from_position buffer.point_y_from_position(buffer, pos)\nRetrieve the y value of the point in the window where a position is\ndisplayed.\n@param buffer The global buffer.\n@param pos The position.\n@return number
popen io.popen(prog [, mode])\nStarts program `prog` in a separated process and returns a file handle\nthat you can use to read data from this program (if `mode` is `"r"`,\nthe default) or to write data to this program (if `mode` is `"w"`).\n\nThis function is system dependent and is not available on all platforms.
position_after buffer.position_after(buffer, pos)\nGiven a valid document position, return the next position taking code page\ninto account. Maximum value returned is the last position in the document.\n@param buffer The global buffer.\n@param pos The position.
position_before buffer.position_before(buffer, pos)\nGiven a valid document position, return the previous position taking code\npage into account. Returns `0` if passed `0`.\n@param buffer The global buffer.\n@param pos The position.\n@return number
position_cache buffer.position_cache (number)\nThe number of entries in the position cache.\nThe position cache stores position information for short runs of text so\nthat their layout can be determined more quickly if the run recurs.
position_from_line buffer.position_from_line(buffer, line)\nRetrieve the position at the start of a line.\nIf line is greater than the lines in the document, returns `-1`.\n@param buffer The global buffer.\n@param line The line.\n@return number
position_from_point buffer.position_from_point(buffer, x, y)\nFind the position from a point within the window.\n@param buffer The global buffer.\n@return number
position_from_point_close buffer.position_from_point_close(buffer, x, y)\nReturns the position from a point within the window, but return `-1` if not\nclose to text.\n@param buffer The global buffer.\n@return number
pow math.pow(x, y)\nReturns *x^y*. (You can also use the expression `x^y` to compute this\nvalue.)
preload package.preload (table)\nA table to store loaders for specific modules (see `require`).\nThis variable is only a reference to the real table; assignments to this\nvariable do not change the table used by `require`.
prepare_for_save _M.textadept.editing.prepare_for_save()\nPrepares the buffer for saving to a file.\nStrips trailing whitespace off of every line if `STRIP_WHITESPACE_ON_SAVE` is\n`true`, ensures an ending newline, and converts non-consistent EOLs.\n@see STRIP_WHITESPACE_ON_SAVE
print _G.print(···)\nReceives any number of arguments and prints their values to `stdout`, using\nthe `tostring` function to convert each argument to a string. `print` is not\nintended for formatted output, but only as a quick way to show a value,\nfor instance for debugging. For complete control over the output, use\n`string.format` and `io.write`.
print gui.print(...)\nPrints messages to the Textadept message buffer.\nOpens a new buffer (if one has not already been opened) for printing\nmessages.\n@param ... Message strings.
print lexer.print\nMatches any printable character (space to `~`).
print_colour_mode buffer.print_colour_mode (number)\nThe print color mode.\n\n* `_SCINTILLA.constants.SC_PRINT_NORMAL` (0)\n  Print using the current screen colors.\n  This is the default.\n* `_SCINTILLA.constants.SC_PRINT_INVERTLIGHT` (1)\n  If you use a dark screen background this saves ink by inverting the light\n  value of all colors and printing on a white background.\n* `_SCINTILLA.constants.SC_PRINT_BLACKONWHITE` (2)\n  Print all text as black on a white background.\n* `_SCINTILLA.constants.SC_PRINT_COLOURONWHITE` (3)\n  Everything prints in its own color on a white background.\n* `_SCINTILLA.constants.SC_PRINT_COLOURONWHITEDEFAULTBG` (4)\n  Everything prints in its own color on a white background except that line\n  numbers use their own background color.
print_magnification buffer.print_magnification (number)\nThe print magnification added to the point size of each style for printing.
print_wrap_mode buffer.print_wrap_mode (number)\nPrinting line wrap mode.\n\n* `_SCINTILLA.constants.SC_WRAP_NONE` (0)\n  Each line of text generates one line of output and the line is truncated\n  if it is too long to fit into the print area.\n* `_SCINTILLA.constants.SC_WRAP_WORD` (1)\n  Wraps printed output so that all characters fit into the print rectangle.\n  Tries to wrap only between words as indicated by white space or style\n  changes although if a word is longer than a line, it will be wrapped\n  before the line end. This is the default.\n* `_SCINTILLA.constants.SC_WRAP_CHAR` (2).
private_lexer_call buffer.private_lexer_call(buffer, operation, data)\nFor private communication between an application and a known lexer.\n@param buffer The global buffer.\n@param operation An operation number.\n@param data Number data.
process args.process()\nProcesses command line arguments.\nAdd command line switches with `args.register()`. Any unrecognized arguments\nare treated as filepaths and opened.\nGenerates an `'arg_none'` event when no args are present.\n@see register
prompt_load _M.textadept.session.prompt_load()\nPrompts the user for a Textadept session to load.
prompt_save _M.textadept.session.prompt_save()\nPrompts the user to save the current Textadept session to a file.
properties _SCINTILLA.properties (table)\nScintilla properties.
property buffer.property (table, Write-only)\nTable of keyword:value string pairs used by a lexer for some optional\nfeatures.
property_int buffer.property_int (table, Read-only)\nInterprets `buffer.property[keyword]` as an integer if found or returns\n`0`.
punct lexer.punct\nMatches any punctuation character not alphanumeric (`!` to `/`, `:` to `@`,\n  `[` to `'`, `{` to `~`).
quit _G.quit()\nQuits Textadept.
rad math.rad(x)\nReturns the angle `x` (given in degrees) in radians.
rails _G.keys.rails (table)\nContainer for Rails-specific key commands.
rails _G.snippets.rails (table)\nContainer for Rails-specific snippets.
rails _M.rails (module)\nThe rails module.\nIt provides utilities for editing Ruby on Rails code.\nUser tags are loaded from _USERHOME/modules/rails/tags and user apis are\nloaded from _USERHOME/modules/rails/api.
random math.random([m [, n]])\nThis function is an interface to the simple pseudo-random generator\nfunction `rand` provided by Standard C. (No guarantees can be given for its\nstatistical properties.)\n\nWhen called without arguments, returns a uniform pseudo-random real\nnumber in the range [0,1). When called with an integer number `m`,\n`math.random` returns a uniform pseudo-random integer in the range [1, m].\nWhen called with two integer numbers `m` and `n`, `math.random` returns a\nuniform pseudo-random integer in the range [m, n].
randomseed math.randomseed(x)\nSets `x` as the "seed" for the pseudo-random generator: equal seeds\nproduce equal sequences of numbers.
rawequal _G.rawequal(v1, v2)\nChecks whether `v1` is equal to `v2`, without invoking any\nmetamethod. Returns a boolean.
rawget _G.rawget(table, index)\nGets the real value of `table[index]`, without invoking any\nmetamethod. `table` must be a table; `index` may be any value.
rawlen _G.rawlen(v)\nReturns the length of the object `v`,\nwhich must be a table or a string,\nwithout invoking any metamethod.\nReturns an integer number.
rawset _G.rawset(table, index, value)\nSets the real value of `table[index]` to `value`, without invoking any\nmetamethod. `table` must be a table, `index` any value different from nil and\nNaN, and `value` any Lua value.\n\nThis function returns `table`.
read file:read(···)\nReads the file `file`, according to the given formats, which specify\nwhat to read. For each format, the function returns a string (or a number)\nwith the characters read, or nil if it cannot read data with the specified\nformat. When called without formats, it uses a default format that reads\nthe next line (see below).\n\nThe available formats are\n  "*n": reads a number; this is the only format that returns a number\n        instead of a string.\n  "*a": reads the whole file, starting at the current position. On end of\n        file, it returns the empty string.\n  "*l": reads the next line skipping the end of line, returning nil on\n        end of file. This is the default format.\n  "*L": reads the next line keeping the end of line (if present), returning\n        nil on end of file.\n  *number*: reads a string with up to this number of bytes, returning nil on\n        end of file. If number is zero, it reads nothing and returns an empty\n        string, or nil on end of file.
read io.read(···)\nEquivalent to `io.input():read(···)`.
read_only buffer.read_only (bool)\nRead-only mode.
rebuild_command_tables _M.textadept.menu.rebuild_command_tables()\nRebuilds the tables used by `select_command()`.\nThis should be called every time `set_menubar()` is called.
recent_files io.recent_files (table)\nList of recently opened files.\nThe most recent are towards the top.
rectangular_selection_anchor buffer.rectangular_selection_anchor (number)\nThe position of the anchor of the rectangular selection.
rectangular_selection_anchor_virtual_space buffer.rectangular_selection_anchor_virtual_space (number)\nThe amount of virtual space for the anchor of the rectangular selection.
rectangular_selection_caret buffer.rectangular_selection_caret (number)\nThe position of the caret of the rectangular selection.
rectangular_selection_caret_virtual_space buffer.rectangular_selection_caret_virtual_space (number)\nThe amount of virtual space for the caret of the rectangular selection.
rectangular_selection_modifier buffer.rectangular_selection_modifier (number)\nThe modifier key used to indicate that a rectangular selection should be\ncreated when combined with a mouse drag.\n\n* `_SCINTILLA.constants.SCMOD_CTRL` (2)\n  Control key (default).\n* `_SCINTILLA.constants.SCMOD_ALT` (4)\n  Alt key.\n* `_SCINTILLA.constants.SCMOD_SUPER` (8)\n  Left Windows key on a Windows keyboard or the Command key on a Mac.
redo buffer.redo(buffer)\nRedoes the next action on the undo history.\n@param buffer The global buffer.
register args.register(switch1, switch2, narg, f, description)\nRegisters a command line switch.\n@param switch1 String switch (short version).\n@param switch2 String switch (long version).\n@param narg The number of expected parameters for the switch.\n@param f The Lua function to run when the switch is tripped.\n@param description Description of the switch.
register_image buffer.register_image(buffer, type, xpm_data)\nRegister an XPM image for use in autocompletion lists.\n@param buffer The global buffer.\n@param type Integer type to register the image with.\n@param xpm_data XPM data as is described for `buffer:marker_define_pixmap()`.
register_rgba_image buffer.register_rgba_image(buffer, type, pixels)\nRegister an RGBA image for use in autocompletion lists.\nIt has the width and height from `buffer.rgba_image_width` and\n`buffer.rgba_image_height`.\n@param buffer The global buffer.\n@param type Integer type to register the image with.\n@param pixels RGBA data as is described for\n  `buffer:marker_define_rgba_image()`.
reload buffer.reload(buffer)\nReloads the file in a given buffer.\n@param buffer The global buffer.
remove _M.textadept.bookmarks.remove()\nClears the bookmark at the current line.
remove os.remove(filename)\nDeletes the file (or empty directory, on POSIX systems) with the given name.\nIf this function fails, it returns nil, plus a string describing the error\nand the error code.
remove table.remove(list [, pos])\nRemoves from `list` the element at position `pos`, shifting down the elements\n`list[pos+1], list[pos+2], ···, list[#list]` and erasing element\n`list[#list]`. Returns the value of the removed element. The default value\nfor `pos` is `#list`, so that a call `table.remove(t)` removes the last\nelement of list `t`.
rename os.rename(oldname, newname)\nRenames file or directory named `oldname` to `newname`. If this function\nfails, it returns nil, plus a string describing the error and the error code.
rep string.rep(s, n [, sep])\nReturns a string that is the concatenation of `n` copies of the string `s`\nseparated by the string `sep`. The default value for `sep` is the empty\nstring (that is, no separator).
replace bit32.replace(n, v, field [, width])\nReturns a copy of `n` with the bits `field` to `field + width - 1` replaced\nby the value `v`. See `bit32.extract` for details about `field` and `width`.
replace gui.find.replace()\nMimicks a press of the 'Replace' button in the Find box.
replace_all gui.find.replace_all()\nMimicks a press of the 'Replace All' button in the Find box.
replace_all_button_text gui.find.replace_all_button_text (string, Write-only)\nThe text of the 'Replace All' button.\nThis is primarily used for localization.
replace_button_text gui.find.replace_button_text (string, Write-only)\nThe text of the 'Replace' button.\nThis is primarily used for localization.
replace_entry_text gui.find.replace_entry_text (string)\nThe text in the replace entry.
replace_label_text gui.find.replace_label_text (string, Write-only)\nThe text of the 'Replace' label.\nThis is primarily used for localization.
replace_sel buffer.replace_sel(buffer, text)\nReplace the selected text with the argument text.\nThe caret is positioned after the inserted text and the caret is scrolled\ninto view.\n@param buffer The global buffer.\n@param text The text.
replace_target buffer.replace_target(buffer, text)\nReplace the target text with the argument text.\nAfter replacement, the target range refers to the replacement text.\nReturns the length of the replacement text.\n@param buffer The global buffer.\n@param text The text (can contain NULs).\n@return number
replace_target_re buffer.replace_target_re(buffer, text)\nReplace the target text with the argument text after `\d` processing.\nLooks for `\d` where `d` is between `1` and `9` and replaces these with the\nstrings matched in the last search operation which were surrounded by `\(`\nand `\)`. Returns the length of the replacement text including any change\ncaused by processing the `\d` patterns.\n@param buffer The global buffer.\n@param text The text (can contain NULs).\n@return number
require _G.require(modname)\nLoads the given module. The function starts by looking into the\n`package.loaded` table to determine whether `modname` is already\nloaded. If it is, then `require` returns the value stored at\n`package.loaded[modname]`. Otherwise, it tries to find a *loader* for\nthe module.\n\nTo find a loader, `require` is guided by the `package.searchers` sequence. By\nchanging this sequence, we can change how `require` looks for a module. The\nfollowing explanation is based on the default configuration for\n`package.searchers`.\n\nFirst `require` queries `package.preload[modname]`. If it has a value,\nthis value (which should be a function) is the loader. Otherwise `require`\nsearches for a Lua loader using the path stored in `package.path`. If\nthat also fails, it searches for a C loader using the path stored in\n`package.cpath`. If that also fails, it tries an *all-in-one* loader (see\n`package.searchers`).\n\nOnce a loader is found, `require` calls the loader with two arguments:\n`modname` and an extra value dependent on how it got the loader. (If the\nloader came from a file, this extra value is the file name.) If the loader\nreturns any non-nil value, `require` assigns the returned value to\n`package.loaded[modname]`. If the loader does not return a non-nil value and\nhas not assigned any value to `package.loaded[modname]`, then `require`\nassigns <b>true</b> to this entry. In any case, `require` returns the final\nvalue of `package.loaded[modname]`.\n\nIf there is any error loading or running the module, or if it cannot find\nany loader for the module, then `require` raises an error.
reset _G.reset()\nResets the Lua state by reloading all init scripts.\nLanguage-specific modules for opened files are NOT reloaded. Re-opening the\nfiles that use them will reload those modules.\nThis function is useful for modifying init scripts (such as the user's\n`modules/textadept/keys.lua`) on the fly without having to restart Textadept.\n`_G.RESETTING` is set to `true` when re-initing the Lua State. Any scripts\nthat need to differentiate between startup and reset can utilize this\nvariable.\n@see RESETTING
resume coroutine.resume(co [, val1, ···])\nStarts or continues the execution of coroutine `co`. The first time\nyou resume a coroutine, it starts running its body. The values `val1`,\n... are passed as the arguments to the body function. If the coroutine\nhas yielded, `resume` restarts it; the values `val1`, ... are passed\nas the results from the yield.\n\nIf the coroutine runs without any errors, `resume` returns true plus any\nvalues passed to `yield` (if the coroutine yields) or any values returned\nby the body function (if the coroutine terminates). If there is any error,\n`resume` returns false plus the error message.
reverse string.reverse(s)\nReturns a string that is the string `s` reversed.
rgba_image_height buffer.rgba_image_height (number)\nThe height for future RGBA image data.
rgba_image_width buffer.rgba_image_width (number)\nThe width for future RGBA image data.
rhtml _G.keys.rhtml (table)\nContainer for RHTML-specific key commands.
rhtml _G.snippets.rhtml (table)\nContainer for RHTML-specific snippets.
rhtml _M.rhtml (module)\nThe RHTML module.\nIt provides utilities for editing RHTML.\nUser tags are loaded from _USERHOME/modules/rhtml/tags and user apis are\nloaded from _USERHOME/modules/rhtml/api.
rmdir lfs.rmdir(dirname)\nRemoves an existing directory. The argument is the name of the directory.\n\nReturns true if the operation was successful; in case of error, it returns\nnil plus an error string.
rotate_selection buffer.rotate_selection(buffer)\nSet the main selection to the next selection.\n@param buffer The global buffer.
rrotate bit32.rrotate(x, disp)\nReturns the number `x` rotated `disp` bits to the right. The number `disp`\nmay be any representable integer.\n\nFor any valid displacement, the following identity holds:\n\n  assert(bit32.rrotate(x, disp) == bit32.rrotate(x, disp % 32))\n\nIn particular, negative displacements rotate to the left.
rshift bit32.rshift(x, disp)\nReturns the number `x` shifted `disp` bits to the right. The number `disp`\nmay be any representable integer. Negative displacements shift to the left.\nIn any direction, vacant bits are filled with zeros. In particular,\ndisplacements with absolute values higher than 31 result in zero (all bits\nare shifted out).\n\nFor positive displacements, the following equality holds:\n\n  assert(bit32.rshift(b, disp) == math.floor(b % 2^32 / 2^disp))\n\nThis shift operation is what is called logical shift.
ruby _G.keys.ruby (table)\nContainer for Ruby-specific key commands.
ruby _G.snippets.ruby (table)\nContainer for Ruby-specific snippets.
ruby _M.ruby (module)\nThe ruby module.\nIt provides utilities for editing Ruby code.\nUser tags are loaded from _USERHOME/modules/ruby/tags and user apis are\nloaded from _USERHOME/modules/ruby/api.
run _M.textadept.run (module)\nModule for running/executing source files.\nTypically, language-specific modules populate the `compile_command`,\n`run_command`, and `error_detail` tables for a particular language's file\nextension.
run _M.textadept.run.run()\nRuns/executes the file as specified by its extension in the `run_command`\ntable.\n@see run_command
run_command _M.textadept.run.run_command (table)\nFile extensions and their associated 'go' actions.\nEach key is a file extension whose value is either a command line string to\nexecute or a function returning one.\nThis table is typically populated by language-specific modules.
running coroutine.running()\nReturns the running coroutine plus a boolean, true when the running coroutine\nis the main one.
save _M.textadept.session.save(filename)\nSaves a Textadept session to a file.\nSaves split views, opened buffers, cursor information, and project manager\ndetails.\n@param filename The absolute path to the session file to save. The default\n  value is either the current session file or `DEFAULT_SESSION`.\n@usage _M.textadept.session.save(filename)\n@see DEFAULT_SESSION
save buffer.save(buffer)\nSaves the current buffer to a file.\n@param buffer The global buffer.
save_all io.save_all()\nSaves all dirty buffers to their respective files.\n@usage io.save_all()
save_as buffer.save_as(buffer, utf8_filename)\nSaves the current buffer to a file different than its filename property.\n@param buffer The global buffer.\n@param utf8_filename The new filepath to save the buffer to. Must be UTF-8\n  encoded.
scroll_caret buffer.scroll_caret(buffer)\nEnsure the caret is visible.\n@param buffer The global buffer.
scroll_to_end buffer.scroll_to_end(buffer)\nScroll to end of document.\n@param buffer The global buffer.
scroll_to_start buffer.scroll_to_start(buffer)\nScroll to start of document.\n@param buffer The global buffer.
scroll_width buffer.scroll_width (number)\nThe document width assumed for scrolling.\nFor performance, the view does not measure the display width of the\ndocument to determine the properties of the horizontal scroll bar. Instead,\nan assumed width is used. The default value is `2000`. To ensure the width\nof the currently visible lines can be scrolled use\n`buffer.scroll_width_tracking`.
scroll_width_tracking buffer.scroll_width_tracking (bool)\nWhether the maximum width line displayed is used to set scroll width.
search_anchor buffer.search_anchor(buffer)\nSets the current caret position to be the search anchor.\nAlways call this before calling either of `buffer:search_next()` or\n`buffer:search_prev()`.\n@param buffer The global buffer.
search_flags buffer.search_flags (number)\nThe search flags used by `buffer:search_in_target()`.\n\n* `_SCINTILLA.constants.SCFIND_WHOLEWORD` (2)\n  A match only occurs with text that matches the case of the search string.\n* `_SCINTILLA.constants.SCFIND_MATCHCASE` (4)\n  A match only occurs if the characters before and after are not word\n  characters.\n* `_SCINTILLA.constants.SCFIND_WORDSTART` (0x00100000)\n  A match only occurs if the character before is not a word character.\n* `_SCINTILLA.constants.SCFIND_REGEXP` (0x00200000)\n  The search string should be interpreted as a regular expression.\n* `_SCINTILLA.constants.SCFIND_POSIX` (0x00400000)\n  Treat regular expression in a more POSIX compatible manner by\n  interpreting bare `(` and `)` for tagged sections rather than `\(` and\n  `\)`.
search_in_target buffer.search_in_target(buffer, text)\nSearch for a counted string in the target and set the target to the found\nrange.\nReturns length of range or `-1` for failure in which case target is not\nmoved.\n@param buffer The global buffer.\n@param text The text (can contain NULs).\n@return number
search_next buffer.search_next(buffer, flags, text)\nFind some text starting at the search anchor.\nThe return value is `-1` if nothing is found, otherwise the return value is\nthe start position of the matching text. The selection is updated to show the\nmatched text, but is not scrolled into view.\n@param buffer The global buffer.\n@param flags Search flags. See `buffer.search_flags`.\n@param text The text.\n@return number
search_prev buffer.search_prev(buffer, flags, text)\nFind some text starting at the search anchor and moving backwards.\nThe return value is `-1` if nothing is found, otherwise the return value is\nthe start position of the matching text. The selection is updated to show the\nmatched text, but is not scrolled into view.\n@param buffer The global buffer.\n@param flags Search flags. See `buffer.search_flags`.\n@param text The text.\n@return number
searchers package.searchers (table)\nA table used by `require` to control how to load modules.\nEach entry in this table is a *searcher function*. When looking for a\nmodule, `require` calls each of these searchers in ascending order, with\nthe module name (the argument given to `require`) as its sole parameter.\nThe function can return another function (the module *loader*) plus an\nextra value that will be passed to that loader, or a string explaining why\nit did not find that module (or nil if it has nothing to say).\nLua initializes this table with four functions.\nThe first searcher simply looks for a loader in the `package.preload`\ntable.\nThe second searcher looks for a loader as a Lua library, using the path\nstored at `package.path`. The search is done as described in function\n`package.searchpath`.\nThe third searcher looks for a loader as a C library, using the path given\nby the variable `package.cpath`. Again, the search is done as described in\nfunction `package.searchpath`. For instance, if the C path is the string\n  "./?.so;./?.dll;/usr/local/?/init.so"\nthe searcher for module `foo` will try to open the files `./foo.so`,\n`./foo.dll`, and `/usr/local/foo/init.so`, in that order. Once it finds\na C library, this searcher first uses a dynamic link facility to link the\napplication with the library. Then it tries to find a C function inside the\nlibrary to be used as the loader. The name of this C function is the string\n"`luaopen_`" concatenated with a copy of the module name where each dot\nis replaced by an underscore. Moreover, if the module name has a hyphen,\nits prefix up to (and including) the first hyphen is removed. For instance,\nif the module name is `a.v1-b.c`, the function name will be `luaopen_b_c`.\nThe fourth searcher tries an *all-in-one loader*. It searches the C\npath for a library for the root name of the given module. For instance,\nwhen requiring `a.b.c`, it will search for a C library for `a`. If found,\nit looks into it for an open function for the submodule; in our example,\nthat would be `luaopen_a_b_c`. With this facility, a package can pack\nseveral C submodules into one single library, with each submodule keeping\nits original open function.\nAll searchers except the first one (preload) return as the extra value the\nfile name where the module was found, as returned by `package.searchpath`.\nThe first searcher returns no extra value.
searchpath package.searchpath(name, path [, sep [, rep]])\nSearches for the given `name` in the given `path`.\n\nA path is a string containing a sequence of _templates_ separated by\nsemicolons. For each template, the function replaces each interrogation mark\n(if any) in the template with a copy of `name` wherein all occurrences of\n`sep` (a dot, by default) were replaced by `rep` (the system's directory\nseparator, by default), and then tries to open the resulting file name.\nFor instance, if the path is the string\n  "./?.lua;./?.lc;/usr/local/?/init.lua"\nthe search for the name `foo.a` will try to open the files `./foo/a.lua`,\n`./foo/a.lc`, and `/usr/local/foo/a/init.lua`, in that order.\nReturns the resulting name of the first file that it can open in read mode\n(after closing the file), or nil plus an error message if none succeeds.\n(This error message lists all file names it tried to open.)
seek file:seek([whence [, offset]])\nSets and gets the file position, measured from the beginning of the\nfile, to the position given by `offset` plus a base specified by the string\n`whence`, as follows:\n  "set": base is position 0 (beginning of the file);\n  "cur": base is current position;\n  "end": base is end of file;\n\nIn case of success, function `seek` returns the final file position,\nmeasured in bytes from the beginning of the file. If `seek` fails, it returns\nnil, plus a string describing the error.\n\nThe default value for `whence` is `"cur"`, and for `offset` is 0. Therefore,\nthe call `file:seek()` returns the current file position, without changing\nit; the call `file:seek("set")` sets the position to the beginning of the\nfile (and returns 0); and the call `file:seek("end")` sets the position\nto the end of the file, and returns its size.
sel_alpha buffer.sel_alpha (number)\nThe alpha of the selection, between `0` (transparent) and `255` (opaque),\nor `256` for no alpha.
sel_eol_filled buffer.sel_eol_filled (bool)\nThe selection end of line fill.\nThe selection can be drawn up to the right hand border by setting this\nproperty.
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)\nSelect all the text in the document.\nThe current position is not scrolled into view.\n@param buffer The global buffer.
select_command _M.textadept.menu.select_command()\nPrompts the user with a filteredlist to run menu commands.
select_enclosed _M.textadept.editing.select_enclosed(left, right)\nSelects text between a given pair of strings.\n@param left The left part of the enclosure.\n@param right The right part of the enclosure.
select_indented_block _M.textadept.editing.select_indented_block()\nSelects indented blocks intelligently.\nIf no block of text is selected, all text with the current level of\nindentation is selected. If a block of text is selected and the lines to the\ntop and bottom of it are one indentation level lower, they are added to the\nselection. In all other cases, the behavior is the same as if no text is\nselected.
select_lexer _M.textadept.mime_types.select_lexer()\nPrompts the user to select a lexer from a filtered list for the current\nbuffer.
select_line _M.textadept.editing.select_line()\nSelects the current line.
select_paragraph _M.textadept.editing.select_paragraph()\nSelects the current paragraph.\nParagraphs are delimited by two or more consecutive newlines.
select_theme gui.select_theme()\nPrompts the user to select an editor theme from a filtered list.
select_word _M.textadept.editing.select_word()\nSelects the current word under the caret.
selection_duplicate buffer.selection_duplicate(buffer)\nDuplicate the selection.\nIf selection empty duplicate the line containing the caret.\n@param buffer The global buffer.
selection_end buffer.selection_end (number)\nThe position that ends the selection - this becomes the current position.\nThis does not make the caret visible.
selection_is_rectangle buffer.selection_is_rectangle (bool, Read-only)\nIs the selection rectangular?\nThe alternative is the more common stream selection.
selection_mode buffer.selection_mode (number)\nThe mode of the current selection.\n\n* `_SCINTILLA.constants.SC_SEL_STREAM` (0)\n  Stream.\n* `_SCINTILLA.constants.SC_SEL_RECTANGLE` (1)\n  Rectangle.\n* `_SCINTILLA.constants.SC_SEL_LINES` (2)\n  Lines.\n* `_SCINTILLA.constants.SC_SEL_THIN` (3)\n  Thin rectangular.
selection_n_anchor buffer.selection_n_anchor (table)\nTable of anchor positions for existing selections starting from zero, the\nmain selection.
selection_n_anchor_virtual_space buffer.selection_n_anchor_virtual_space (table)\nTable of the amount of virtual space for anchors for existing selections\nstarting from zero, the main selection.
selection_n_caret buffer.selection_n_caret (table)\nTable of caret positions for existing selections starting from zero, the\nmain selection.
selection_n_caret_virtual_space buffer.selection_n_caret_virtual_space (table)\nTable of the amount of virtual space for carets for existing selections\nstarting from zero, the main selection.
selection_n_end buffer.selection_n_end (table)\nTable of positions that end selections for existing selections starting\nfrom zero, the main selection.
selection_n_start buffer.selection_n_start (table)\nTable of positions that start selections for existing selections starting\nfrom zero, the main selection.
selection_start buffer.selection_start (number)\nThe position that starts the selection - this becomes the anchor.\nThis does not make the caret visible.
selections buffer.selections (number, Read-only)\nThe number of selections currently active.
self _M.textadept.adeptsense.syntax.self (table)\nThe language's syntax-equivalent of `self`. Default is `'self'`.
sense _M.cpp.sense\nThe C/C++ Adeptsense.
sense _M.css.sense\n: The CSS Adeptsense.
sense _M.hypertext.sense\n: The HTML Adeptsense.
sense _M.java.sense\nThe Java Adeptsense.
sense _M.lua.sense\nThe Lua Adeptsense.
sense _M.php.sense\n: The PHP Adeptsense.
sense _M.rails.sense\n: The Rails Adeptsense.
sense _M.rhtml.sense\n: The RHTML Adeptsense.
sense _M.ruby.sense\n: The Ruby Adeptsense.
session _M.textadept.session (module)\nSession support for the textadept module.
set_buffer_properties _M.cpp.set_buffer_properties()\nSets default buffer properties for C/C++ files.
set_buffer_properties _M.css.set_buffer_properties()\nSets default buffer properties for CSS files.
set_buffer_properties _M.hypertext.set_buffer_properties()\nSets default buffer properties for HTML files.
set_buffer_properties _M.java.set_buffer_properties()\nSets default buffer properties for Java files.
set_buffer_properties _M.lua.set_buffer_properties()\nSets default buffer properties for Lua files.
set_buffer_properties _M.php.set_buffer_properties()\nSets default buffer properties for PHP files.
set_buffer_properties _M.ruby.set_buffer_properties()\nSets default buffer properties for Ruby files.
set_chars_default buffer.set_chars_default(buffer)\nReset the set of characters for whitespace and word characters to the\ndefaults.\nThis sets whitespace to space, tab and other characters with codes less than\n`0x20`, with word characters set to alphanumeric and `'_'`.\n@param buffer The global buffer.
set_contextmenu _M.textadept.menu.set_contextmenu(menu_table)\nSets `gui.context_menu` from the given menu table.\n@param menu_table The menu table to create the context menu from. Each table\n  entry is either a submenu or menu text and a function or action table.\n@see set_menubar
set_empty_selection buffer.set_empty_selection(buffer, pos)\nSet caret to a position, while removing any existing selection.\nThe caret is not scrolled into view.\n@param buffer The buffer\n@param pos The position to move to.
set_encoding buffer.set_encoding(buffer, encoding)\nSets the encoding for the buffer, converting its contents in the process.\n@param buffer The global buffer.\n@param encoding The encoding to set. Valid encodings are ones that GTK's\n  `g_convert()` function accepts (typically GNU iconv's encodings).\n@usage buffer.set_encoding(buffer, 'ASCII')
set_fold_flags buffer.set_fold_flags(buffer, flags)\nSet some style options for folding.\n@param buffer The global buffer.\n@param flags Mask of fold flags. Flags available are\n  `_SCINTILLA.constants.SC_FOLDFLAG_LINEBEFORE_EXPANDED` (2): Draw above if\n  expanded; `_SCINTILLA.constants.SC_FOLDFLAG_LINEBEFORE_CONTRACTED` (4):\n  Draw above if not expanded;\n  `_SCINTILLA.constants.SC_FOLDFLAG_LINEAFTER_EXPANDED` (8): Draw below if\n  expanded; `_SCINTILLA.constants.SC_FOLDFLAG_LINEAFTER_CONTRACTED` (16):\n  Draw below if not expanded
set_fold_margin_colour buffer.set_fold_margin_colour(buffer, use_setting, color)\nSet the colors used as a chequerboard pattern in the fold margin.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
set_fold_margin_hi_colour buffer.set_fold_margin_hi_colour(buffer, use_setting, color)\nSet the colors used as a checkerboard pattern in the fold margin.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
set_hotspot_active_back buffer.set_hotspot_active_back(buffer, use_setting, color)\nSet a back color for active hotspots.\n@param buffer The global buffer.\n@param use_setting Enable the color change.\n@param color A color in `0xBBGGRR` format.
set_hotspot_active_fore buffer.set_hotspot_active_fore(buffer, use_setting, color)\nSet a fore color for active hotspots.\n@param buffer The global buffer.\n@param use_setting Enable the color change.\n@param color A color in `0xBBGGRR` format.
set_length_for_encode buffer.set_length_for_encode(buffer, bytes)\nSet the length of the utf8 argument for calling `buffer:encoded_from_utf8()`.\n@param buffer The global buffer.\n@param bytes Bytes or `-1` for measuring to first NUL.
set_lexer buffer.set_lexer(buffer, lang)\nReplacement for `buffer.set_lexer_language(buffer)`.\nSets a `buffer._lexer` field so it can be restored without querying the\nmime-types tables. Also if the user manually sets the lexer, it should be\nrestored.\nLoads the language-specific module if it exists.\nThis function is added by `_M.textadept.mime_types`.\n@param buffer The global buffer.\n@param lang The string language to set.\n@usage buffer.set_lexer(buffer, 'language_name')
set_lexer_language buffer.set_lexer_language(buffer, language_name)\nSet the lexing language of the document based on string name.\n@param buffer The global buffer.\n@param language_name The language name.
set_menubar _M.textadept.menu.set_menubar(menubar)\nSets `gui.menubar` from the given table of menus.\n@param menubar The table of menus to create the menubar from. Each table\n  entry is another table that corresponds to a particular menu. A menu can\n  have a `title` key with string value. Each menu item is either a submenu\n  (another menu table) or a table consisting of two items: string menu text\n  and a function or action table just like in `keys`. The table can\n  optionally contain 2 more number values: a GDK keycode and modifier mask\n  for setting a menu accelerator. If the menu text is `'separator'`, a menu\n  separator is created and no action table is required.\n@see keys.get_gdk_key\n@see rebuild_command_tables
set_save_point buffer.set_save_point(buffer)\nRemember the current position in the undo history as the position at which\nthe document was saved.\n@param buffer The global buffer.
set_sel buffer.set_sel(buffer, start_pos, end_pos)\nSelect a range of text.\nThe caret is scrolled into view after this operation.\n@param buffer The global buffer.\n@param start_pos Start position. If negative, it means the end of the\n  document.\n@param end_pos End position. If negative, it means remove any selection (i.e.\n  set the `anchor` to the same position as `current_pos`).
set_sel_back buffer.set_sel_back(buffer, use_setting, color)\nSet the background color of the main and additional selections and whether to\nuse this setting.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
set_sel_fore buffer.set_sel_fore(buffer, use_setting, color)\nSet the foreground color of the main and additional selections and whether\nto use this setting.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
set_selection buffer.set_selection(buffer, caret, anchor)\nSet a simple selection from anchor to caret.\n@param buffer The global buffer.\n@param caret The caret.\n@param anchor The anchor.
set_styling buffer.set_styling(buffer, length, style)\nChange style from current styling position for length characters to a style\nand move the current styling position to after this newly styled segment.\n@param buffer The global buffer.\n@param length The length to style.\n@param style The style number to set.
set_text buffer.set_text(buffer, text)\nReplace the contents of the document with the argument text.\n@param buffer The global buffer.\n@param text The text.
set_theme gui.set_theme(name)\nSets the editor theme from the given name.\nThemes in `_USERHOME/themes/` are checked first, followed by `_HOME/themes/`.\nIf the name contains slashes ('/' on Linux and Mac OSX and '\' on Win32), it\nis assumed to be an absolute path so `_USERHOME` and `_HOME` are not checked.\nThrows an error if the theme is not found. Any errors in the theme are\nprinted to `io.stderr`.\n@param name The name or absolute path of a theme. If nil, sets the default\n  theme.
set_visible_policy buffer.set_visible_policy(buffer, visible_policy, visible_slop)\nSet the way the display area is determined when a particular line is to be\nmoved to by `buffer:goto_line()`, etc.\nIt is similar in operation to `buffer:set_y_caret_policy()`.\n@param buffer The global buffer.\n@param visible_policy A combination of `_SCINTILLA.constants.VISIBLE_SLOP`,\n  (0x01) and `_SCINTILLA.constants.VISIBLE_STRICT` (0x04).\n@param visible_slop The slop value.
set_whitespace_back buffer.set_whitespace_back(buffer, use_setting, color)\nSet the background color of all whitespace and whether to use this setting.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
set_whitespace_fore buffer.set_whitespace_fore(buffer, use_setting, color)\nSet the foreground color of all whitespace and whether to use this setting.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
set_x_caret_policy buffer.set_x_caret_policy(buffer, caret_policy, caret_slop)\nSet the way the caret is kept visible when going sideway.\nThe exclusion zone is given in pixels.\n@param buffer The global buffer.\n@param caret_policy A combination of `_SCINTILLA.constants.CARET_SLOP`\n  (0x01), `_SCINTILLA.constants.CARET_STRICT` (0x04),\n  `_SCINTILLA.constants.CARET_JUMPS` (0x10), and\n  `_SCINTILLA.constants.CARET_EVEN` (0x08).\n@param caret_slop A slop value.
set_y_caret_policy buffer.set_y_caret_policy(buffer, caret_policy, caret_slop)\nSet the way the line the caret is on is kept visible.\n@param buffer The global buffer.\n@param caret_policy A combination of `_SCINTILLA.constants.CARET_SLOP`\n  (0x01), `_SCINTILLA.constants.CARET_STRICT` (0x04),\n  `_SCINTILLA.constants.CARET_JUMPS` (0x10), and\n  `_SCINTILLA.constants.CARET_EVEN` (0x08).\n@param caret_slop A slop value.
sethook debug.sethook([thread, ] hook, mask [, count])\nSets the given function as a hook. The string `mask` and the number\n`count` describe when the hook will be called. The string mask may have\nthe following characters, with the given meaning:\n  "c": the hook is called every time Lua calls a function;\n  "r": the hook is called every time Lua returns from a function;\n  "l": the hook is called every time Lua enters a new line of code.\n\nWith a `count` different from zero, the hook is called after every `count`\ninstructions.\n\nWhen called without arguments, `debug.sethook` turns off the hook.\n\nWhen the hook is called, its first parameter is a string describing\nthe event that has triggered its call: `"call"` (or `"tail call"`),\n`"return"`, `"line"`, and `"count"`. For line events, the hook also gets the\nnew line number as its second parameter. Inside a hook, you can call\n`getinfo` with level 2 to get more information about the running function\n(level 0 is the `getinfo` function, and level 1 is the hook function).
setlocal debug.setlocal([thread, ] level, local, value)\nThis function assigns the value `value` to the local variable with\nindex `local` of the function at level `level` of the stack. The function\nreturns nil if there is no local variable with the given index, and raises\nan error when called with a `level` out of range. (You can call `getinfo`\nto check whether the level is valid.) Otherwise, it returns the name of\nthe local variable.\n\nSee `debug.getlocal` for more information about variable indices and names.
setlocale os.setlocale(locale [, category])\nSets the current locale of the program. `locale` is a system-dependent string\nspecifying a locale; `category` is an optional string describing which\ncategory to change: `"all"`, `"collate"`, `"ctype"`, `"monetary"`,\n`"numeric"`, or `"time"`; the default category is `"all"`. The function\nreturns the name of the new locale, or nil if the request cannot be honored.\n\nIf `locale` is the empty string, the current locale is set to an\nimplementation-defined native locale. If `locale` is the string "`C`",\nthe current locale is set to the standard C locale.\n\nWhen called with nil as the first argument, this function only returns\nthe name of the current locale for the given category.
setmaxstack lpeg.setmaxstack(max)\nSets the maximum size for the backtrack stack used by LPeg to track calls and\nchoices. Most well-written patterns need little backtrack levels and\ntherefore you seldom need to change this maximum; but a few useful patterns\nmay need more space. Before changing this maximum you should try to rewrite\nyour pattern to avoid the need for extra space.
setmetatable _G.setmetatable(table, metatable)\nSets the metatable for the given table. (You cannot change the metatable\nof other types from Lua, only from C.) If `metatable` is nil, removes the\nmetatable of the given table. If the original metatable has a `"__metatable"`\nfield, raises an error.\n\nThis function returns `table`.
setmetatable debug.setmetatable(value, table)\nSets the metatable for the given `value` to the given `table` (which\ncan be nil).
setmode lfs.setmode(file, mode)\nSets the writing mode for a file. The mode string can be either binary or\ntext. Returns the previous mode string for the file. This function is only\navailable in Windows, so you may want to make sure that lfs.setmode exists\nbefore using it.
setupvalue debug.setupvalue(f, up, value)\nThis function assigns the value `value` to the upvalue with index `up`\nof the function `f`. The function returns nil if there is no upvalue with the\ngiven index. Otherwise, it returns the name of the upvalue.
setuservalue debug.setuservalue(udata, value)\nSets the given `value` as the Lua value associated to the given `udata`.\n`value` must be a table or nil; `udata` must be a full userdata.\n\nReturns `udata`.
setvbuf file:setvbuf(mode [, size])\nSets the buffering mode for an output file. There are three available\nmodes:\n  "no": no buffering; the result of any output operation appears immediately.\n  "full": full buffering; output operation is performed only when the\n          buffer is full or when you explicitly `flush` the file (see\n          `io.flush`).\n  "line": line buffering; output is buffered until a newline is output or\n          there is any input from some special files (such as a terminal\n          device).\n\nFor the last two cases, `size` specifies the size of the buffer, in\nbytes. The default is an appropriate size.
shebangs _M.textadept.mime_types.shebangs (table)\nShebang words and their associated lexers.
show_apidoc _M.textadept.adeptsense.show_apidoc(sense)\nShows a calltip with API documentation for the symbol behind the caret.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@return `true` on success or `false`.\n@see get_symbol\n@see get_apidoc
show_documentation _M.textadept.adeptsense.show_documentation()\nShows API documentation for the symbol at the current position based on the\ncurrent lexer's Adeptsense.\nThis should be called by key commands and menus instead of `show_apidoc()`.
show_lines buffer.show_lines(buffer, start_line, end_line)\nMake a range of lines visible.\nThis has no effect on fold levels or fold flags. `start_line` can not be\nhidden.\n@param buffer The global buffer.\n@param start_line The start line.\n@param end_line The end line.
sin math.sin(x)\nReturns the sine of `x` (assumed to be in radians).
singular _M.rails.singular\n: A map of plural controller names to their singulars. Add\nkey-value pairs to this if singularize() is incorrectly\nconverting your plural controller name to its singular model name.
sinh math.sinh(x)\nReturns the hyperbolic sine of `x`.
size gui.size (table)\nThe size of the Textadept window (`{ width, height }`).
size view.size (number)\nThe position of the split resizer (if this view is part of a split view).
snapopen _M.textadept.snapopen (module)\nSnapopen for the textadept module.
snippets _G.snippets (table)\nProvides access to snippets from `_G`.
snippets _M.textadept.snippets (module)\nProvides Lua-style snippets for Textadept.
sort table.sort(list [, comp])\nSorts list elements in a given order, *in-place*, from `list[1]` to\n`list[#list]`. If `comp` is given, then it must be a function that receives\ntwo list elements and returns true when the first element must come before\nthe second in the final order (so that `not comp(list[i+1],list[i])` will be\ntrue after the sort). If `comp` is not given, then the standard Lua operator\n`<` is used instead.\n\nThe sort algorithm is not stable; that is, elements considered equal by the\ngiven order may have their relative positions changed by the sort.
space lexer.space\nMatches any whitespace character (`\t`, `\v`, `\f`, `\\n`, `\r`, space).
split view:split(vertical)\nSplits the indexed view vertically or horizontally and focuses the new view.\n@param vertical Flag indicating a vertical split. The default value is\n  `false` for horizontal.\n@return old view and new view tables.
sqrt math.sqrt(x)\nReturns the square root of `x`. (You can also use the expression `x^0.5`\nto compute this value.)
start_record buffer.start_record(buffer)\nStart notifying the container of all key presses and commands.\n@param buffer The global buffer.
start_styling buffer.start_styling(buffer, position, mask)\nSet the current styling position to pos and the styling mask to mask.\nThe styling mask can be used to protect some bits in each styling byte from\nmodification.\n@param buffer The global buffer.\n@param position The styling position.\n@param mask The bit mask of the style bytes that can be set.
starts_line lexer.starts_line(patt)\nCreates an LPeg pattern from a given pattern that matches the beginning of a\nline and returns it.\n@param patt The LPeg pattern to match at the beginning of a line.\n@usage local preproc = token(l.PREPROCESSOR, #P('#') * l.starts_line('#' *\n  l.nonnewline^0))
status buffer.status (number)\nThe error status.\n\n* `_SCINTILLA.constants.SC_STATUS_OK` (0)\n  No failures.\n* `_SCINTILLA.constants.SC_STATUS_FAILURE` (1)\n  Generic failure.\n* `_SCINTILLA.constants.SC_STATUS_BADALLOC` (2)\n  Memory is exhausted.
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.
statusbar_text gui.statusbar_text (string)\nThe text displayed by the statusbar.
stderr io.stderr (file)\nStandard error.
stdin io.stdin (file)\nStandard in.
stdout io.stdout (file)\nStandard out.
stop_record buffer.stop_record(buffer)\nStop notifying the container of all key presses and commands.\n@param buffer The global buffer.
string _G.string (module)\nLua string module.
stuttered_page_down buffer.stuttered_page_down(buffer)\nMove caret to bottom of page, or one page down if already at bottom of page.\n@param buffer The global buffer.
stuttered_page_down_extend buffer.stuttered_page_down_extend(buffer)\nMove caret to bottom of page, or one page down if already at bottom of page,\nextending selection to new caret position.\n@param buffer The global buffer.
stuttered_page_up buffer.stuttered_page_up(buffer)\nMove caret to top of page, or one page up if already at top of page.\n@param buffer The global buffer.
stuttered_page_up_extend buffer.stuttered_page_up_extend(buffer)\nMove caret to top of page, or one page up if already at top of page,\nextending selection to new caret position.\n@param buffer The global buffer.
style lexer.style(style_table)\nCreates a Scintilla style from a table of style properties.\n@param style_table A table of style properties.\nStyle properties available:\n    * font [string]\n    * size [integer]\n    * bold [boolean]\n    * italic [boolean]\n    * underline [boolean]\n    * fore [integer] (Use value returned by [`color()`](#color))\n    * back [integer] (Use value returned by [`color()`](#color))\n    * eolfilled [boolean]\n    * characterset [?]\n    * case [integer]\n    * visible [boolean]\n    * changeable [boolean]\n    * hotspot [boolean]\n@usage local bold_italic = style { bold = true, italic = true }\n@see color
style_at buffer.style_at (table, Read-only)\nTable of style bytes at positions in the document starting at zero.
style_back buffer.style_back (table)\nTable of background colors in `0xBBGGRR` format for styles from `0` to\n`255`.
style_bits buffer.style_bits (number)\nThe number of bits in style bytes used to hold the lexical state.
style_bits_needed buffer.style_bits_needed (number, Read-only)\nThe number of bits the current lexer needs for styling.
style_bold buffer.style_bold (table)\nTable of booleans for bold styles from `0` to `255`.
style_case buffer.style_case (table)\nTable of cases for styles from `0` to `255`.\n\n* `_SCINTILLA.constants.SC_CASE_MIXED` (0)\n  Normal, mixed case.\n* `_SCINTILLA.constants.SC_CASE_UPPER` (1)\n  Upper case.\n* `_SCINTILLA.constants.SC_CASE_LOWER` (2)\n  Lower case.
style_changeable buffer.style_changeable (table)\nTable of booleans for changeable styles from `0` to `255`.\nThe default setting is `true`.
style_character_set buffer.style_character_set (table)\nTable of character sets for styles from `0` to `255`.
style_class lexer.style_class\nStyle typically used for class definitions.
style_clear_all buffer.style_clear_all(buffer)\nClear all the styles and make equivalent to the global default style.\n@param buffer The global buffer.
style_comment lexer.style_comment\nStyle typically used for code comments.
style_constant lexer.style_constant\nStyle typically used for constants.
style_definition lexer.style_definition\nStyle typically used for definitions.
style_embedded lexer.style_embedded\nStyle typically used for embedded code.
style_eol_filled buffer.style_eol_filled (table)\nTable of booleans for end of line filled styles from `0` to `255`.
style_error lexer.style_error\nStyle typically used for erroneous syntax.
style_font buffer.style_font (table)\nTable of font faces for styles from `0` to `255`.
style_fore buffer.style_fore (table)\nTable of foreground colors in `0xBBGGRR` format for styles from `0` to\n`255`.
style_function lexer.style_function\nStyle typically used for function definitions.
style_get_font buffer.style_get_font(buffer, style_num)\nReturns the font name of a given style.\n@param buffer The global buffer.\n@param style_num The style number.\n@return string
style_hot_spot buffer.style_hot_spot (table)\nTable of boolean hotspot styles from `0` to `255`.
style_identifier lexer.style_identifier\nStyle typically used for identifier words.
style_italic buffer.style_italic (table)\nTable of booleans for italic styles from `0` to `255`.
style_keyword lexer.style_keyword\nStyle typically used for language keywords.
style_label lexer.style_label\nStyle typically used for labels.
style_nothing lexer.style_nothing\nStyle typically used for no styling.
style_number lexer.style_number\nStyle typically used for numbers.
style_operator lexer.style_operator\nStyle typically used for operators.
style_preproc lexer.style_preproc\nStyle typically used for preprocessor statements.
style_regex lexer.style_regex\nStyle typically used for regular expression strings.
style_reset_default buffer.style_reset_default(buffer)\nReset the default style to its state at startup.\n@param buffer The global buffer.
style_size buffer.style_size (table)\nTable of font sizes for styles from `0` to `255`.\nFont size is a whole number of points.
style_size_fractional buffer.style_size_fractional (table)\nTable of sizes of characters for styles from `0` to `255`.\nSize is in hundreths of a point and multiplied by 100 internally. For\nexample, a text size of 9.4 points is set with 940.
style_string lexer.style_string\nStyle typically used for strings.
style_tag lexer.style_tag\nStyle typically used for markup tags.
style_type lexer.style_type\nStyle typically used for static types.
style_underline buffer.style_underline (table)\nTable of booleans for underlined styles from `0` to `255`.
style_variable lexer.style_variable\nStyle typically used for variables.
style_visible buffer.style_visible (table)\nTable of booleans for visible styles from `0` to `255`.
style_weight buffer.style_weight (table)\nTable of character weights for styles from `0` to `255`.\nThe weight or boldness of a font can be set with a number between 1 and 999\nwith 1 being very light and 999 very heavy. While any value can be used,\nfonts often only support between 2 and 4 weights with three weights being\ncommon enough to use symbolic names:\n\n* `_SCINTILLA.constants.SC_WEIGHT_NORMAL` (400)\n  Normal.\n* `_SCINTILLA.constants.SC_WEIGHT_SEMIBOLD` (600)\n  Semi-bold.\n* `_SCINTILLA.constants.SC_WEIGHT_BOLD` (700)\n  Bold.
style_whitespace lexer.style_whitespace\nStyle typically used for whitespace.
sub string.sub(s, i [, j])\nReturns the substring of `s` that starts at `i` and continues until\n`j`; `i` and `j` can be negative. If `j` is absent, then it is assumed to\nbe equal to -1 (which is the same as the string length). In particular,\nthe call `string.sub(s,1,j)` returns a prefix of `s` with length `j`, and\n`string.sub(s, -i)` returns a suffix of `s` with length `i`.\n\nIf, after the translation of negative indices, `i` is less than 1, it is\ncorrected to 1. If `j` is greater than the string length, it is corrected to\nthat length. If, after these corrections, `i` is greater than `j`, the\nfunction returns the empty string.
swap_main_anchor_caret buffer.swap_main_anchor_caret(buffer)\nSwap that caret and anchor of the main selection.\n@param buffer The global buffer.
switch_buffer gui.switch_buffer()\nDisplays a dialog with a list of buffers to switch to and switches to the\nselected one, if any.
symbol_chars _M.textadept.adeptsense.syntax.symbol_chars (table)\nA Lua pattern of characters allowed in a symbol,\n  including member operators. The pattern should be a character set. The\n  default is `'[%w_%.]'`.
symlinkattributes lfs.symlinkattributes(filepath [, aname])\nIdentical to lfs.attributes except that it obtains information about the link\nitself (not the file it refers to). This function is not available in Windows\nso you may want to make sure that lfs.symlinkattributes exists before using\nit.
syntax _M.textadept.adeptsense.syntax (table)\nContains syntax-specific values for the language.\n@see get_class
tab buffer.tab(buffer)\nIf selection is empty or all on one line replace the selection with a tab\ncharacter, or if more than one line selected, indent the lines.\n@param buffer The global buffer.
tab_indents buffer.tab_indents (bool)\nWhether a tab pressed when caret is within indentation indents.
tab_width buffer.tab_width (number)\nThe visible size of a tab as a multiple of the width of a space character.\nThe default tab width is 8 characters.
table _G.table (module)\nLua table module.
tan math.tan(x)\nReturns the tangent of `x` (assumed to be in radians).
tanh math.tanh(x)\nReturns the hyperbolic tangent of `x`.
target_as_utf8 buffer.target_as_utf8(buffer)\nReturns the target converted to UTF8.\n@param buffer The global buffer.
target_end buffer.target_end (number)\nThe position that ends the target which is used for updating the document\nwithout affecting the scroll position.\nThe target is also set by a successful `buffer:search_in_target()`.
target_from_selection buffer.target_from_selection(buffer)\nMake the target range start and end be the same as the selection range start\nand end.\n@param buffer The global buffer.
target_start buffer.target_start (number)\nThe position that starts the target which is used for updating the document\nwithout affecting the scroll position.\nThe target is also set by a successful `buffer:search_in_target()`.
text_height buffer.text_height(buffer, line)\nRetrieve the height of a particular line of text in pixels.\n@param buffer The global buffer.\n@param line The line number.\n@return number
text_length buffer.text_length (number, Read-only)\nThe number of characters in the document.
text_range buffer.text_range(buffer, start_pos, end_pos)\nGets a range of text from the current buffer.\n@param buffer The global buffer.\n@param start_pos The beginning position of the range of text to get.\n@param end_pos The end position of the range of text to get.
text_width buffer.text_width(buffer, style_num, text)\nMeasure the pixel width of some text in a particular style.\nDoes not handle tab or control characters.\n@param buffer The global buffer.\n@param style_num The style number between `0` and `255`.\n@param text The text.\n@return number
textadept _M.textadept (module)\nThe textadept module.\nIt provides utilities for editing text in Textadept.
time os.time([table])\nReturns the current time when called without arguments, or a time\nrepresenting the date and time specified by the given table. This table\nmust have fields `year`, `month`, and `day`, and may have fields `hour`\n(default is 12), `min` (default is 0), `sec` (default is 0), and `isdst`\n(default is nil). For a description of these fields, see the `os.date`\nfunction.\n\nThe returned value is a number, whose meaning depends on your system. In\nPOSIX, Windows, and some other systems, this number counts the number of\nseconds since some given start time (the "epoch"). In other systems, the\nmeaning is not specified, and the number returned by `time` can be used only\nas an argument to `os.date` and `os.difftime`.
timeout _G.timeout(interval, f, ...)\nCalls a given function after an interval of time.\nTo repeatedly call the function, return true inside the function. A `nil` or\n`false` return value stops repetition.\n@param interval The interval in seconds to call the function after.\n@param f The function to call.\n@param ... Additional arguments to pass to `f`.
title gui.title (string)\nThe title of the Textadept window.
tmpfile io.tmpfile()\nReturns a handle for a temporary file. This file is opened in update\nmode and it is automatically removed when the program ends.
tmpname os.tmpname()\nReturns a string with a file name that can be used for a temporary\nfile. The file must be explicitly opened before its use and explicitly\nremoved when no longer needed.\n\nOn POSIX systems, this function also creates a file with that name, to avoid\nsecurity risks. (Someone else might create the file with wrong permissions in\nthe time between getting the name and creating the file.) You still have to\nopen the file to use it and to remove it (even if you do not use it).\n\nWhen possible, you may prefer to use `io.tmpfile`, which automatically\nremoves the file when the program ends.
toggle _M.textadept.bookmarks.toggle()\nToggles a bookmark on the current line.
toggle_block _M.ruby.toggle_block()\nToggles between { ... } and do ... end Ruby blocks.\nIf the caret is inside a { ... } single-line block, that block is converted\nto a multiple-line do .. end block. If the caret is on a line that contains\nsingle-line do ... end block, that block is converted to a single-line\n{ ... } block. If the caret is inside a multiple-line do ... end block, that\nblock is converted to a single-line { ... } block with all newlines replaced\nby a space. Indentation is important. The 'do' and 'end' keywords must be on\nlines with the same level of indentation to toggle correctly
toggle_caret_sticky buffer.toggle_caret_sticky(buffer)\nSwitch between sticky and non-sticky: meant to be bound to a key.\nSee `buffer.caret_sticky`.\n@param buffer The global buffer.
toggle_fold buffer.toggle_fold(buffer, line)\nSwitch a header line between expanded and contracted.\n@param buffer The global buffer.\n@param line The line number.
token lexer.token(name, patt)\nCreates an LPeg capture table index with the name and position of the token.\n@param name The name of token. If this name is not in `l.tokens` then you\n  will have to specify a style for it in `lexer._tokenstyles`.\n@param patt The LPeg pattern associated with the token.\n@usage local ws = token(l.WHITESPACE, l.space^1)\n@usage php_start_rule = token('php_tag', '<?' * ('php' * l.space)^-1)
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 (see §3.4.2), then `tonumber` returns this number; otherwise, it\nreturns nil.\n\nWhen called with `base`, then `e` should 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 reasonable\nformat. (For complete control of how numbers are converted, use\n`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.
traceback debug.traceback([thread, ] [message] [, level])\nIf `message` is present but is neither a string nor nil, this function\nreturns `message` without further processing. Otherwise, it returns a string\nwith a traceback of the call stack. An optional `message` string is appended\nat the beginning of the traceback. An optional `level` number tells at which\nlevel to start the traceback (default is 1, the function calling\n`traceback`).
transpose_chars _M.textadept.editing.transpose_chars()\nTransposes characters intelligently.\nIf the caret is at the end of a line, the two characters before the caret are\ntransposed. Otherwise, the characters to the left and right are.
try_encodings io.try_encodings (table)\nList of encodings to try to decode files as after UTF-8.
try_to_autocomplete_end _M.lua.try_to_autocomplete_end()\nTries to autocomplete Lua's 'end' keyword for control structures like 'if',\n'while', 'for', etc.\n@see control_structure_patterns
try_to_autocomplete_end _M.ruby.try_to_autocomplete_end()\nTries to autocomplete Ruby's 'end' keyword for control structures like 'if',\n'while', 'for', etc.\n@see control_structure_patterns
two_phase_draw buffer.two_phase_draw (bool)\nTwo phase drawing mode.\nWhen `true`, drawing is performed in two phases, first the background and\nthen the foreground. This avoids chopping off characters that overlap the\nnext run. The default is for drawing to be two phase.
type _G.type(v)\nReturns the type of its only argument, coded as a string. The possible\nresults of this function are "\n`nil`" (a string, not the value nil), "`number`", "`string`", "`boolean`",\n"`table`", "`function`", "`thread`", and "`userdata`".
type io.type(obj)\nChecks whether `obj` is a valid file handle. Returns the string `"file"`\nif `obj` is an open file handle, `"closed file"` if `obj` is a closed file\nhandle, or nil if `obj` is not a file handle.
type lpeg.type(value)\nIf the given value is a pattern, returns the string "pattern". Otherwise\nreturns nil.
type_assignments _M.textadept.adeptsense.syntax.type_assignments (table)\nA map of Lua patterns to class types for variable\n  assignments. This is typically used for dynamically typed languages. For\n  example, `sense.type_assignments['^"'] = 'string'`  would recognize string\n  assignments in Lua so the `foo` in `foo = "bar"` would be recognized as\n  type `string`. The class type value can contain pattern captures.
type_declarations _M.textadept.adeptsense.syntax.type_declarations (table)\nA list of Lua patterns used for determining the\n  class type of a symbol. The first capture returned must be the class name.\n  Use `%_` to match the symbol. The default value is `'(%u[%w_%.]+)%s+%_'`.
type_declarations_exclude _M.textadept.adeptsense.syntax.type_declarations_exclude (table)\nA table of types to exclude, even if they\n  match a type_declaration pattern. Each excluded type is a table key and has\n  a `true` boolean value. For example, `{ Foo = true }` excludes any type\n  whose name is `Foo`. The default value is `{}`.
undo buffer.undo(buffer)\nUndo one action in the undo history.\n@param buffer The global buffer.
undo_collection buffer.undo_collection (bool)\nWhether to collect undo information.\nWhen stopping collection, use `buffer:empty_undo_buffer()` to avoid the\nundo buffer being unsynchronized with the data in the buffer.
unlock lfs.unlock(filehandle[, start[, length]])\nUnlocks a file or a part of it. This function works on open files; the file\nhandle should be specified as the first argument. The optional arguments\nstart and length can be used to specify a starting point and its length; both\nshould be numbers.\n\nReturns true if the operation was successful; in case of error, it returns\nnil plus an error string.
unpack table.unpack(list [, i [, j]])\nReturns the elements from the given table. This function is equivalent to\n\n  return list[i], list[i+1], ···, list[j]\n\nBy default, `i` is 1 and `j` is `#list`.
unsplit view:unsplit()\nUnsplits the indexed view if possible.\n@return boolean if the view was unsplit or not.
upper lexer.upper\nMatches any uppercase character (`A-Z`).
upper string.upper(s)\nReceives a string and returns a copy of this string with all lowercase\nletters changed to uppercase. All other characters are left unchanged. The\ndefinition of what a lowercase letter is depends on the current locale.
upper_case buffer.upper_case(buffer)\nTransform the selection to upper case.\n@param buffer The global buffer.
upvalueid debug.upvalueid(f, n)\nReturns an unique identifier (as a light userdata) for the upvalue numbered\n`n` from the given function.\n\nThese unique identifiers allow a program to check whether different closures\nshare upvalues. Lua closures that share an upvalue (that is, that access a\nsame external local variable) will return identical ids for those upvalue\nindices.
upvaluejoin debug.upvaluejoin(f1, n1, f2, n2)\nMake the `n1`-th upvalue of the Lua closure `f1` refer to the `n2`-th upvalue\nof the Lua closure `f2`.
use_pop_up buffer.use_pop_up(buffer, allow_popup)\nSets whether a pop up menu is displayed automatically when the user presses\nthe wrong mouse button.\n@param buffer The global buffer.\n@param allow_popup Allow popup menu.
use_tabs buffer.use_tabs (bool)\nWhether tabs will be used in indentation.\nThe default is `true`. `false` will only use space characters.
user_dofile _G.user_dofile(filename)\nCalls `dofile()` on the given filename in the user's Textadept directory.\nErrors are printed to the Textadept message buffer.\n@param filename The name of the file (not path).\n@return `true` if successful; `false` otherwise.\n@see dofile
user_list_show buffer.user_list_show(buffer, list_type, item_list)\nDisplay a list of strings and send notification when user chooses one.\n@param buffer The global buffer.\n@param list_type A list identifier number greater than zero.\n@param item_list List of words separated by separator characters (initially\n  spaces).\n@see _SCINTILLA.next_user_list_type
v_scroll_bar buffer.v_scroll_bar (bool)\nWhether the vertical scroll bar is visible.\nSet to `false` to never see it and `true` to enable it again. The default\nstate is to display it when required.
vc_home buffer.vc_home(buffer)\nMove caret to before first visible character on line.\nIf already there move to first character on line.\n@param buffer The global buffer.
vc_home_extend buffer.vc_home_extend(buffer)\nLike `buffer:vc_home()` but extending selection to new caret position.\n@param buffer The global buffer.
vc_home_rect_extend buffer.vc_home_rect_extend(buffer)\nMove caret to before first visible character on line.\nIf already there move to first character on line. In either case, extend\nrectangular selection to new caret position.\n@param buffer The global buffer.
vc_home_wrap buffer.vc_home_wrap(buffer)\nMove caret to before first visible character on display line when word-wrap\nis enabled.\nIf already there, go to first character on display line.\n@param buffer The global buffer.
vc_home_wrap_extend buffer.vc_home_wrap_extend(buffer)\nLike `buffer:vc_home_wrap()` but extending selection to new caret position.\n@param buffer The global buffer.
version lpeg.version()\nReturns a string with the running version of LPeg.
vertical_centre_caret buffer.vertical_centre_caret(buffer)\nCenter current line in window.\n@param buffer The global buffer.
view _G.view (module)\nThe currently focused view.\nIt also represents the structure of any view table in `_G._VIEWS`.
view_eol buffer.view_eol (bool)\nWhether the end of line characters are visible.\nNormally, the end of line characters are hidden.
view_ws buffer.view_ws (number)\nThe visibility of white space characters.\n\n* `_SCINTILLA.constants.SCWS_INVISIBLE` (0)\n  The normal display mode with white space displayed as an empty background\n  color.\n* `_SCINTILLA.constants.SCWS_VISIBLEALWAYS` (1)\n  White space characters are drawn as dots and arrows.\n* `_SCINTILLA.constants.SCWS_VISIBLEAFTERINDENT` (2)\n  White space used for indentation is displayed normally but after the\n  first visible character, it is shown as dots and arrows.
virtual_space_options buffer.virtual_space_options (number)\nVirtual space options.\n\n* `_SCINTILLA.constants.SCVS_NONE` (0)\n  Disables all use of virtual space (default).\n* `_SCINTILLA.constants.SCVS_RECTANGULARSELECTION` (1)\n  Enabled only for rectangular selections.\n* `_SCINTILLA.constants.SCVS_USERACCESSIBLE` (2)\n  Enabled.
visible_from_doc_line buffer.visible_from_doc_line(buffer, line)\nFind the display line of a document line taking hidden lines into account.\nIf there is folding and line is outside the range of lines in the document,\nthe return value is `-1`.\n@param buffer The global buffer.\n@param line The line number.\n@return number
whitespace_chars buffer.whitespace_chars (string, Write-only)\nThe set of characters making up whitespace for when moving or selecting by\nword.\nUse after setting `buffer.word_chars`.
whitespace_size buffer.whitespace_size (number)\nThe size of the dots used to mark space characters.
whole_word gui.find.whole_word (bool)\nOnly whole-word matches are allowed in searches.
whole_word_label_text gui.find.whole_word_label_text (string, Write-only)\nThe text of the 'Whole word' label.\nThis is primarily used for localization.
word lexer.word\nMatches a typical word starting with a letter or underscore and then any\n  alphanumeric or underscore characters.
word_chars _M.textadept.adeptsense.syntax.word_chars (table)\nA Lua pattern of characters allowed in a word. The default\n  is `'%w_'`.
word_chars buffer.word_chars (string)\nThe set of characters making up words when moving or selecting by word.
word_end_position buffer.word_end_position(buffer, pos, only_word_chars)\nGet position of end of word.\n@param buffer The global buffer.\n@param pos The position.\n@param only_word_chars If `true`, stops searching at the first non-word\n  character in the search direction. Otherwise, the first character in the\n  search direction sets the type of the search as word or non-word and the\n  search stops at the first non-matching character. Searches are also\n  terminated by the start or end of the document.
word_left buffer.word_left(buffer)\nMove caret left one word.\n@param buffer The global buffer.
word_left_end buffer.word_left_end(buffer)\nMove caret left one word, position cursor at end of word.\n@param buffer The global buffer.
word_left_end_extend buffer.word_left_end_extend(buffer)\nMove caret left one word, position cursor at end of word, extending selection\nto new caret position.\n@param buffer The global buffer.
word_left_extend buffer.word_left_extend(buffer)\nMove caret left one word extending selection to new caret position.\n@param buffer The global buffer.
word_match lexer.word_match(words, word_chars, case_insensitive)\nCreates an LPeg pattern that matches a set of words.\n@param words A table of words.\n@param word_chars Optional string of additional characters considered to be\n  part of a word (default is `%w_`).\n@param case_insensitive Optional boolean flag indicating whether the word\n  match is case-insensitive.\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))
word_part_left buffer.word_part_left(buffer)\nMove to the previous change in capitalisation or underscores.\n@param buffer The global buffer.
word_part_left_extend buffer.word_part_left_extend(buffer)\nMove to the previous change in capitalisation or underscores extending\nselection to new caret position.\n@param buffer The global buffer.
word_part_right buffer.word_part_right(buffer)\nMove to the next change in capitalisation or underscores.\n@param buffer The global buffer.
word_part_right_extend buffer.word_part_right_extend(buffer)\nMove to the next change in capitalisation or underscores extending selection\nto new caret position.\n@param buffer The global buffer.
word_right buffer.word_right(buffer)\nMove caret right one word.\n@param buffer The global buffer.
word_right_end buffer.word_right_end(buffer)\nMove caret right one word, position cursor at end of word.\n@param buffer The global buffer.
word_right_end_extend buffer.word_right_end_extend(buffer)\nMove caret right one word, position cursor at end of word, extending\nselection to new caret position.\n@param buffer The global buffer.
word_right_extend buffer.word_right_extend(buffer)\nMove caret right one word extending selection to new caret position.\n@param buffer The global buffer.
word_start_position buffer.word_start_position(buffer, pos, only_word_chars)\nGet position of start of word.\n@param buffer The global buffer.\n@param pos The position.\n@param only_word_chars If `true`, stops searching at the first non-word\n  character in the search direction. Otherwise, the first character in the\n  search direction sets the type of the search as word or non-word and the\n  search stops at the first non-matching character. Searches are also\n  terminated by the start or end of the document.
wrap coroutine.wrap(f)\nCreates a new coroutine, with body `f`. `f` must be a Lua\nfunction. Returns a function that resumes the coroutine each time it is\ncalled. Any arguments passed to the function behave as the extra arguments to\n`resume`. Returns the same values returned by `resume`, except the first\nboolean. In case of error, propagates the error.
wrap_count buffer.wrap_count(buffer, line)\nReturns the number of display lines needed to wrap a document line.\n@param buffer The global buffer.\n@param line The line number.\n@return number
wrap_indent_mode buffer.wrap_indent_mode (number)\nHow wrapped sublines are placed.\nDefault is fixed.\n\n* `_SCINTILLA.constants.SC_WRAP_INDENT_FIXED` (0)\n  Wrapped sublines aligned to left of window plus amount set by\n  `buffer.wrap_start_indent`.\n* `_SCINTILLA.constants.SC_WRAP_INDENT_SAME` (1)\n  Wrapped sublines are aligned to first subline indent.\n* `_SCINTILLA.constants.SC_WRAP_INDENT_INDENT` (2)\n  Wrapped sublines are aligned to first subline indent plus one more level\n  of indentation.
wrap_mode buffer.wrap_mode (number)\nText word wrap mode.\n\n* `_SCINTILLA.constants.SC_WRAP_NONE` (0)\n  Disable line wrapping.\n* `_SCINTILLA.constants.SC_WRAP_WORD` (1)\n  Enable wrapping on word boundaries.\n* `_SCINTILLA.constants.SC_WRAP_CHAR` (2)\n  Enable wrapping between any characters.
wrap_start_indent buffer.wrap_start_indent (number)\nThe start indent for wrapped lines.
wrap_visual_flags buffer.wrap_visual_flags (number)\nThe display mode of visual flags for wrapped lines.\n\n* `_SCINTILLA.constants.SC_WRAPVISUALFLAG_NONE` (0)\n  No visual flags.\n* `_SCINTILLA.constants.SC_WRAPVISUALFLAG_END` (1)\n  Visual flag at end of subline of a wrapped line.\n* `_SCINTILLA.constants.SC_WRAPVISUALFLAG_START` (2)\n  Visual flag at begin of subline of a wrapped line.\n  Subline is indented by at least 1 to make room for the flag.
wrap_visual_flags_location buffer.wrap_visual_flags_location (number)\nThe location of visual flags for wrapped lines.\n\n* `_SCINTILLA.constants.SC_WRAPVISUALFLAGLOC_DEFAULT` (0)\n  Visual flags drawn near border.\n* `_SCINTILLA.constants.SC_WRAPVISUALFLAGLOC_END_BY_TEXT` (1)\n  Visual flag at end of subline drawn near text.\n* `_SCINTILLA.constants.SC_WRAPVISUALFLAGLOC_START_BY_TEXT` (2)\n  Visual flag at beginning of subline drawn near text.
write file:write(···)\nWrites the value of each of its arguments to `file`. The arguments must be\nstrings or numbers.\n\nIn case of success, this function returns `file`. Otherwise it returns nil\nplus a string describing the error.
write io.write(···)\nEquivalent to `io.output():write(···)`.
x_offset buffer.x_offset (number)\nThe horizontal scroll position.\nA value of `0` is the normal position with the first text column visible at\nthe left of the view.
xdigit lexer.xdigit\nMatches any hexadecimal digit (`0-9`, `A-F`, `a-f`).
xor bit32.xor(...)\nReturns the bitwise "exclusive or" of its operands.
xpcall _G.xpcall(f, msgh [, arg1, ···])\nThis function is similar to `pcall`, except that it sets a new message\nhandler `msgh`.
yield coroutine.yield(···)\nSuspends the execution of the calling coroutine. Any arguments to `yield` are\npassed as extra results to `resume`.
zoom buffer.zoom (number)\nThe number of points added to the size of all fonts.\nIt may be positive to magnify or negative to reduce.
zoom_in buffer.zoom_in(buffer)\nMagnify the displayed text by increasing the sizes by 1 point if the current\nzoom factor is less than 20 points.\n@param buffer The global buffer.
zoom_out buffer.zoom_out(buffer)\nMake the displayed text smaller by decreasing the sizes by 1 point if the\ncurrent zoom factor is greater than -10 points.\n@param buffer The global buffer.