| 1 |
1 |
moose |
## First line may be used for shbang |
| 2 |
|
|
|
| 3 |
|
|
## This file defines the interface to Scintilla |
| 4 |
|
|
|
| 5 |
|
|
## Copyright 2000-2003 by Neil Hodgson <neilh@scintilla.org> |
| 6 |
|
|
## The License.txt file describes the conditions under which this software may be distributed. |
| 7 |
|
|
|
| 8 |
|
|
## A line starting with ## is a pure comment and should be stripped by readers. |
| 9 |
|
|
## A line starting with #! is for future shbang use |
| 10 |
|
|
## A line starting with # followed by a space is a documentation comment and refers |
| 11 |
|
|
## to the next feature definition. |
| 12 |
|
|
|
| 13 |
|
|
## Each feature is defined by a line starting with fun, get, set, val or evt. |
| 14 |
|
|
## cat -> start a category |
| 15 |
|
|
## fun -> a function |
| 16 |
|
|
## get -> a property get function |
| 17 |
|
|
## set -> a property set function |
| 18 |
|
|
## val -> definition of a constant |
| 19 |
|
|
## evt -> an event |
| 20 |
|
|
## enu -> associate an enumeration with a set of vals with a prefix |
| 21 |
|
|
## lex -> associate a lexer with the lexical classes it produces |
| 22 |
|
|
## |
| 23 |
|
|
## All other feature names should be ignored. They may be defined in the future. |
| 24 |
|
|
## A property may have a set function, a get function or both. Each will have |
| 25 |
|
|
## "Get" or "Set" in their names and the corresponding name will have the obvious switch. |
| 26 |
|
|
## A property may be subscripted, in which case the first parameter is the subscript. |
| 27 |
|
|
## fun, get, and set features have a strict syntax: |
| 28 |
|
|
## <featureType><ws><returnType><ws><name>[=<number](<param>,<param>) |
| 29 |
|
|
## where <ws> stands for white space. |
| 30 |
|
|
## param may be empty (null value) or is <paramType><ws><paramName>[=<value>] |
| 31 |
|
|
## Additional white space is allowed between elements. |
| 32 |
|
|
## The syntax for evt is <featureType><ws><returnType><ws><name>[=<number]([<param>[,<param>]*]) |
| 33 |
|
|
## Feature names that contain an underscore are defined by Windows, so in these |
| 34 |
|
|
## cases, using the Windows definition is preferred where available. |
| 35 |
|
|
## The feature numbers are stable so features will not be renumbered. |
| 36 |
|
|
## Features may be removed but they will go through a period of deprecation |
| 37 |
|
|
## before removal which is signalled by moving them into the Deprecated category. |
| 38 |
|
|
## |
| 39 |
|
|
## enu has the syntax enu<ws><enumeration>=<prefix>[<ws><prefix>]* where all the val |
| 40 |
|
|
## features in this file starting with a given <prefix> are considered part of the |
| 41 |
|
|
## enumeration. |
| 42 |
|
|
## |
| 43 |
|
|
## lex has the syntax lex<ws><name>=<lexerVal><ws><prefix>[<ws><prefix>]* |
| 44 |
|
|
## where name is a reasonably capitalised (Python, XML) identifier or UI name, |
| 45 |
|
|
## lexerVal is the val used to specify the lexer, and the list of prefixes is similar |
| 46 |
|
|
## to enu. The name may not be the same as that used within the lexer so the lexerVal |
| 47 |
|
|
## should be used to tie these entities together. |
| 48 |
|
|
|
| 49 |
|
|
## Types: |
| 50 |
|
|
## void |
| 51 |
|
|
## int |
| 52 |
|
|
## bool -> integer, 1=true, 0=false |
| 53 |
|
|
## position -> integer position in a document |
| 54 |
|
|
## colour -> colour integer containing red, green and blue bytes. |
| 55 |
|
|
## string -> pointer to const character |
| 56 |
|
|
## stringresult -> pointer to character, NULL-> return size of result |
| 57 |
|
|
## cells -> pointer to array of cells, each cell containing a style byte and character byte |
| 58 |
|
|
## textrange -> range of a min and a max position with an output string |
| 59 |
|
|
## findtext -> searchrange, text -> foundposition |
| 60 |
|
|
## keymod -> integer containing key in low half and modifiers in high half |
| 61 |
|
|
## formatrange |
| 62 |
|
|
## Types no longer used: |
| 63 |
|
|
## findtextex -> searchrange |
| 64 |
|
|
## charrange -> range of a min and a max position |
| 65 |
|
|
## charrangeresult -> like charrange, but output param |
| 66 |
|
|
## countedstring |
| 67 |
|
|
## point -> x,y |
| 68 |
|
|
## pointresult -> like point, but output param |
| 69 |
|
|
## rectangle -> left,top,right,bottom |
| 70 |
|
|
## Client code should ignore definitions containing types it does not understand, except |
| 71 |
|
|
## for possibly #defining the constants |
| 72 |
|
|
|
| 73 |
|
|
## Line numbers and positions start at 0. |
| 74 |
|
|
## String arguments may contain NUL ('\0') characters where the calls provide a length |
| 75 |
|
|
## argument and retrieve NUL characters. All retrieved strings except for those retrieved |
| 76 |
|
|
## by GetLine also have a NUL appended but client code should calculate the size that |
| 77 |
|
|
## will be returned rather than relying upon the NUL whenever possible. Allow for the |
| 78 |
|
|
## extra NUL character when allocating buffers. The size to allocate for a stringresult |
| 79 |
|
|
## can be determined by calling with a NULL (0) pointer. |
| 80 |
|
|
|
| 81 |
|
|
cat Basics |
| 82 |
|
|
|
| 83 |
|
|
################################################ |
| 84 |
|
|
## For Scintilla.h |
| 85 |
|
|
val INVALID_POSITION=-1 |
| 86 |
|
|
# Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages |
| 87 |
|
|
# as many EM_ messages can be used although that use is deprecated. |
| 88 |
|
|
val SCI_START=2000 |
| 89 |
|
|
val SCI_OPTIONAL_START=3000 |
| 90 |
|
|
val SCI_LEXER_START=4000 |
| 91 |
|
|
|
| 92 |
|
|
# Add text to the document at current position. |
| 93 |
|
|
fun void AddText=2001(int length, string text) |
| 94 |
|
|
|
| 95 |
|
|
# Add array of cells to document. |
| 96 |
|
|
fun void AddStyledText=2002(int length, cells c) |
| 97 |
|
|
|
| 98 |
|
|
# Insert string at a position. |
| 99 |
|
|
fun void InsertText=2003(position pos, string text) |
| 100 |
|
|
|
| 101 |
|
|
# Delete all text in the document. |
| 102 |
|
|
fun void ClearAll=2004(,) |
| 103 |
|
|
|
| 104 |
|
|
# Set all style bytes to 0, remove all folding information. |
| 105 |
|
|
fun void ClearDocumentStyle=2005(,) |
| 106 |
|
|
|
| 107 |
|
|
# Returns the number of characters in the document. |
| 108 |
|
|
get int GetLength=2006(,) |
| 109 |
|
|
|
| 110 |
|
|
# Returns the character byte at the position. |
| 111 |
|
|
get int GetCharAt=2007(position pos,) |
| 112 |
|
|
|
| 113 |
|
|
# Returns the position of the caret. |
| 114 |
|
|
get position GetCurrentPos=2008(,) |
| 115 |
|
|
|
| 116 |
|
|
# Returns the position of the opposite end of the selection to the caret. |
| 117 |
|
|
get position GetAnchor=2009(,) |
| 118 |
|
|
|
| 119 |
|
|
# Returns the style byte at the position. |
| 120 |
|
|
get int GetStyleAt=2010(position pos,) |
| 121 |
|
|
|
| 122 |
|
|
# Redoes the next action on the undo history. |
| 123 |
|
|
fun void Redo=2011(,) |
| 124 |
|
|
|
| 125 |
|
|
# Choose between collecting actions into the undo |
| 126 |
|
|
# history and discarding them. |
| 127 |
|
|
set void SetUndoCollection=2012(bool collectUndo,) |
| 128 |
|
|
|
| 129 |
|
|
# Select all the text in the document. |
| 130 |
|
|
fun void SelectAll=2013(,) |
| 131 |
|
|
|
| 132 |
|
|
# Remember the current position in the undo history as the position |
| 133 |
|
|
# at which the document was saved. |
| 134 |
|
|
fun void SetSavePoint=2014(,) |
| 135 |
|
|
|
| 136 |
|
|
# Retrieve a buffer of cells. |
| 137 |
|
|
# Returns the number of bytes in the buffer not including terminating NULs. |
| 138 |
|
|
fun int GetStyledText=2015(, textrange tr) |
| 139 |
|
|
|
| 140 |
|
|
# Are there any redoable actions in the undo history? |
| 141 |
|
|
fun bool CanRedo=2016(,) |
| 142 |
|
|
|
| 143 |
|
|
# Retrieve the line number at which a particular marker is located. |
| 144 |
|
|
fun int MarkerLineFromHandle=2017(int handle,) |
| 145 |
|
|
|
| 146 |
|
|
# Delete a marker. |
| 147 |
|
|
fun void MarkerDeleteHandle=2018(int handle,) |
| 148 |
|
|
|
| 149 |
|
|
# Is undo history being collected? |
| 150 |
|
|
get bool GetUndoCollection=2019(,) |
| 151 |
|
|
|
| 152 |
|
|
enu WhiteSpace=SCWS_ |
| 153 |
|
|
val SCWS_INVISIBLE=0 |
| 154 |
|
|
val SCWS_VISIBLEALWAYS=1 |
| 155 |
|
|
val SCWS_VISIBLEAFTERINDENT=2 |
| 156 |
|
|
|
| 157 |
|
|
# Are white space characters currently visible? |
| 158 |
|
|
# Returns one of SCWS_* constants. |
| 159 |
|
|
get int GetViewWS=2020(,) |
| 160 |
|
|
|
| 161 |
|
|
# Make white space characters invisible, always visible or visible outside indentation. |
| 162 |
|
|
set void SetViewWS=2021(int viewWS,) |
| 163 |
|
|
|
| 164 |
|
|
# Find the position from a point within the window. |
| 165 |
|
|
fun position PositionFromPoint=2022(int x, int y) |
| 166 |
|
|
|
| 167 |
|
|
# Find the position from a point within the window but return |
| 168 |
|
|
# INVALID_POSITION if not close to text. |
| 169 |
|
|
fun position PositionFromPointClose=2023(int x, int y) |
| 170 |
|
|
|
| 171 |
|
|
# Set caret to start of a line and ensure it is visible. |
| 172 |
|
|
fun void GotoLine=2024(int line,) |
| 173 |
|
|
|
| 174 |
|
|
# Set caret to a position and ensure it is visible. |
| 175 |
|
|
fun void GotoPos=2025(position pos,) |
| 176 |
|
|
|
| 177 |
|
|
# Set the selection anchor to a position. The anchor is the opposite |
| 178 |
|
|
# end of the selection from the caret. |
| 179 |
|
|
set void SetAnchor=2026(position posAnchor,) |
| 180 |
|
|
|
| 181 |
|
|
# Retrieve the text of the line containing the caret. |
| 182 |
|
|
# Returns the index of the caret on the line. |
| 183 |
|
|
fun int GetCurLine=2027(int length, stringresult text) |
| 184 |
|
|
|
| 185 |
|
|
# Retrieve the position of the last correctly styled character. |
| 186 |
|
|
get position GetEndStyled=2028(,) |
| 187 |
|
|
|
| 188 |
|
|
enu EndOfLine=SC_EOL_ |
| 189 |
|
|
val SC_EOL_CRLF=0 |
| 190 |
|
|
val SC_EOL_CR=1 |
| 191 |
|
|
val SC_EOL_LF=2 |
| 192 |
|
|
|
| 193 |
|
|
# Convert all line endings in the document to one mode. |
| 194 |
|
|
fun void ConvertEOLs=2029(int eolMode,) |
| 195 |
|
|
|
| 196 |
|
|
# Retrieve the current end of line mode - one of CRLF, CR, or LF. |
| 197 |
|
|
get int GetEOLMode=2030(,) |
| 198 |
|
|
|
| 199 |
|
|
# Set the current end of line mode. |
| 200 |
|
|
set void SetEOLMode=2031(int eolMode,) |
| 201 |
|
|
|
| 202 |
|
|
# Set the current styling position to pos and the styling mask to mask. |
| 203 |
|
|
# The styling mask can be used to protect some bits in each styling byte from modification. |
| 204 |
|
|
fun void StartStyling=2032(position pos, int mask) |
| 205 |
|
|
|
| 206 |
|
|
# Change style from current styling position for length characters to a style |
| 207 |
|
|
# and move the current styling position to after this newly styled segment. |
| 208 |
|
|
fun void SetStyling=2033(int length, int style) |
| 209 |
|
|
|
| 210 |
|
|
# Is drawing done first into a buffer or direct to the screen? |
| 211 |
|
|
get bool GetBufferedDraw=2034(,) |
| 212 |
|
|
|
| 213 |
|
|
# If drawing is buffered then each line of text is drawn into a bitmap buffer |
| 214 |
|
|
# before drawing it to the screen to avoid flicker. |
| 215 |
|
|
set void SetBufferedDraw=2035(bool buffered,) |
| 216 |
|
|
|
| 217 |
|
|
# Change the visible size of a tab to be a multiple of the width of a space character. |
| 218 |
|
|
set void SetTabWidth=2036(int tabWidth,) |
| 219 |
|
|
|
| 220 |
|
|
# Retrieve the visible size of a tab. |
| 221 |
|
|
get int GetTabWidth=2121(,) |
| 222 |
|
|
|
| 223 |
|
|
# The SC_CP_UTF8 value can be used to enter Unicode mode. |
| 224 |
|
|
# This is the same value as CP_UTF8 in Windows |
| 225 |
|
|
val SC_CP_UTF8=65001 |
| 226 |
|
|
|
| 227 |
|
|
# The SC_CP_DBCS value can be used to indicate a DBCS mode for GTK+. |
| 228 |
|
|
val SC_CP_DBCS=1 |
| 229 |
|
|
|
| 230 |
|
|
# Set the code page used to interpret the bytes of the document as characters. |
| 231 |
|
|
# The SC_CP_UTF8 value can be used to enter Unicode mode. |
| 232 |
|
|
set void SetCodePage=2037(int codePage,) |
| 233 |
|
|
|
| 234 |
|
|
# In palette mode, Scintilla uses the environment's palette calls to display |
| 235 |
|
|
# more colours. This may lead to ugly displays. |
| 236 |
|
|
set void SetUsePalette=2039(bool usePalette,) |
| 237 |
|
|
|
| 238 |
|
|
enu MarkerSymbol=SC_MARK_ |
| 239 |
|
|
val MARKER_MAX=31 |
| 240 |
|
|
val SC_MARK_CIRCLE=0 |
| 241 |
|
|
val SC_MARK_ROUNDRECT=1 |
| 242 |
|
|
val SC_MARK_ARROW=2 |
| 243 |
|
|
val SC_MARK_SMALLRECT=3 |
| 244 |
|
|
val SC_MARK_SHORTARROW=4 |
| 245 |
|
|
val SC_MARK_EMPTY=5 |
| 246 |
|
|
val SC_MARK_ARROWDOWN=6 |
| 247 |
|
|
val SC_MARK_MINUS=7 |
| 248 |
|
|
val SC_MARK_PLUS=8 |
| 249 |
|
|
|
| 250 |
|
|
# Shapes used for outlining column. |
| 251 |
|
|
val SC_MARK_VLINE=9 |
| 252 |
|
|
val SC_MARK_LCORNER=10 |
| 253 |
|
|
val SC_MARK_TCORNER=11 |
| 254 |
|
|
val SC_MARK_BOXPLUS=12 |
| 255 |
|
|
val SC_MARK_BOXPLUSCONNECTED=13 |
| 256 |
|
|
val SC_MARK_BOXMINUS=14 |
| 257 |
|
|
val SC_MARK_BOXMINUSCONNECTED=15 |
| 258 |
|
|
val SC_MARK_LCORNERCURVE=16 |
| 259 |
|
|
val SC_MARK_TCORNERCURVE=17 |
| 260 |
|
|
val SC_MARK_CIRCLEPLUS=18 |
| 261 |
|
|
val SC_MARK_CIRCLEPLUSCONNECTED=19 |
| 262 |
|
|
val SC_MARK_CIRCLEMINUS=20 |
| 263 |
|
|
val SC_MARK_CIRCLEMINUSCONNECTED=21 |
| 264 |
|
|
|
| 265 |
|
|
# Invisible mark that only sets the line background color. |
| 266 |
|
|
val SC_MARK_BACKGROUND=22 |
| 267 |
|
|
val SC_MARK_DOTDOTDOT=23 |
| 268 |
|
|
val SC_MARK_ARROWS=24 |
| 269 |
|
|
val SC_MARK_PIXMAP=25 |
| 270 |
|
|
val SC_MARK_FULLRECT=26 |
| 271 |
|
|
|
| 272 |
|
|
val SC_MARK_CHARACTER=10000 |
| 273 |
|
|
|
| 274 |
|
|
enu MarkerOutline=SC_MARKNUM_ |
| 275 |
|
|
# Markers used for outlining column. |
| 276 |
|
|
val SC_MARKNUM_FOLDEREND=25 |
| 277 |
|
|
val SC_MARKNUM_FOLDEROPENMID=26 |
| 278 |
|
|
val SC_MARKNUM_FOLDERMIDTAIL=27 |
| 279 |
|
|
val SC_MARKNUM_FOLDERTAIL=28 |
| 280 |
|
|
val SC_MARKNUM_FOLDERSUB=29 |
| 281 |
|
|
val SC_MARKNUM_FOLDER=30 |
| 282 |
|
|
val SC_MARKNUM_FOLDEROPEN=31 |
| 283 |
|
|
|
| 284 |
|
|
val SC_MASK_FOLDERS=0xFE000000 |
| 285 |
|
|
|
| 286 |
|
|
# Set the symbol used for a particular marker number. |
| 287 |
|
|
fun void MarkerDefine=2040(int markerNumber, int markerSymbol) |
| 288 |
|
|
|
| 289 |
|
|
# Set the foreground colour used for a particular marker number. |
| 290 |
|
|
fun void MarkerSetFore=2041(int markerNumber, colour fore) |
| 291 |
|
|
|
| 292 |
|
|
# Set the background colour used for a particular marker number. |
| 293 |
|
|
fun void MarkerSetBack=2042(int markerNumber, colour back) |
| 294 |
|
|
|
| 295 |
|
|
# Add a marker to a line, returning an ID which can be used to find or delete the marker. |
| 296 |
|
|
fun int MarkerAdd=2043(int line, int markerNumber) |
| 297 |
|
|
|
| 298 |
|
|
# Delete a marker from a line. |
| 299 |
|
|
fun void MarkerDelete=2044(int line, int markerNumber) |
| 300 |
|
|
|
| 301 |
|
|
# Delete all markers with a particular number from all lines. |
| 302 |
|
|
fun void MarkerDeleteAll=2045(int markerNumber,) |
| 303 |
|
|
|
| 304 |
|
|
# Get a bit mask of all the markers set on a line. |
| 305 |
|
|
fun int MarkerGet=2046(int line,) |
| 306 |
|
|
|
| 307 |
|
|
# Find the next line after lineStart that includes a marker in mask. |
| 308 |
|
|
fun int MarkerNext=2047(int lineStart, int markerMask) |
| 309 |
|
|
|
| 310 |
|
|
# Find the previous line before lineStart that includes a marker in mask. |
| 311 |
|
|
fun int MarkerPrevious=2048(int lineStart, int markerMask) |
| 312 |
|
|
|
| 313 |
|
|
# Define a marker from a pixmap. |
| 314 |
|
|
fun void MarkerDefinePixmap=2049(int markerNumber, string pixmap) |
| 315 |
|
|
|
| 316 |
|
|
enu MarginType=SC_MARGIN_ |
| 317 |
|
|
val SC_MARGIN_SYMBOL=0 |
| 318 |
|
|
val SC_MARGIN_NUMBER=1 |
| 319 |
|
|
|
| 320 |
|
|
# Set a margin to be either numeric or symbolic. |
| 321 |
|
|
set void SetMarginTypeN=2240(int margin, int marginType) |
| 322 |
|
|
|
| 323 |
|
|
# Retrieve the type of a margin. |
| 324 |
|
|
get int GetMarginTypeN=2241(int margin,) |
| 325 |
|
|
|
| 326 |
|
|
# Set the width of a margin to a width expressed in pixels. |
| 327 |
|
|
set void SetMarginWidthN=2242(int margin, int pixelWidth) |
| 328 |
|
|
|
| 329 |
|
|
# Retrieve the width of a margin in pixels. |
| 330 |
|
|
get int GetMarginWidthN=2243(int margin,) |
| 331 |
|
|
|
| 332 |
|
|
# Set a mask that determines which markers are displayed in a margin. |
| 333 |
|
|
set void SetMarginMaskN=2244(int margin, int mask) |
| 334 |
|
|
|
| 335 |
|
|
# Retrieve the marker mask of a margin. |
| 336 |
|
|
get int GetMarginMaskN=2245(int margin,) |
| 337 |
|
|
|
| 338 |
|
|
# Make a margin sensitive or insensitive to mouse clicks. |
| 339 |
|
|
set void SetMarginSensitiveN=2246(int margin, bool sensitive) |
| 340 |
|
|
|
| 341 |
|
|
# Retrieve the mouse click sensitivity of a margin. |
| 342 |
|
|
get bool GetMarginSensitiveN=2247(int margin,) |
| 343 |
|
|
|
| 344 |
|
|
# Styles in range 32..37 are predefined for parts of the UI and are not used as normal styles. |
| 345 |
|
|
# Styles 38 and 39 are for future use. |
| 346 |
|
|
enu StylesCommon=STYLE_ |
| 347 |
|
|
val STYLE_DEFAULT=32 |
| 348 |
|
|
val STYLE_LINENUMBER=33 |
| 349 |
|
|
val STYLE_BRACELIGHT=34 |
| 350 |
|
|
val STYLE_BRACEBAD=35 |
| 351 |
|
|
val STYLE_CONTROLCHAR=36 |
| 352 |
|
|
val STYLE_INDENTGUIDE=37 |
| 353 |
|
|
val STYLE_LASTPREDEFINED=39 |
| 354 |
|
|
val STYLE_MAX=127 |
| 355 |
|
|
|
| 356 |
|
|
# Character set identifiers are used in StyleSetCharacterSet. |
| 357 |
|
|
# The values are the same as the Windows *_CHARSET values. |
| 358 |
|
|
enu CharacterSet=SC_CHARSET_ |
| 359 |
|
|
val SC_CHARSET_ANSI=0 |
| 360 |
|
|
val SC_CHARSET_DEFAULT=1 |
| 361 |
|
|
val SC_CHARSET_BALTIC=186 |
| 362 |
|
|
val SC_CHARSET_CHINESEBIG5=136 |
| 363 |
|
|
val SC_CHARSET_EASTEUROPE=238 |
| 364 |
|
|
val SC_CHARSET_GB2312=134 |
| 365 |
|
|
val SC_CHARSET_GREEK=161 |
| 366 |
|
|
val SC_CHARSET_HANGUL=129 |
| 367 |
|
|
val SC_CHARSET_MAC=77 |
| 368 |
|
|
val SC_CHARSET_OEM=255 |
| 369 |
|
|
val SC_CHARSET_RUSSIAN=204 |
| 370 |
|
|
val SC_CHARSET_CYRILLIC=1251 |
| 371 |
|
|
val SC_CHARSET_SHIFTJIS=128 |
| 372 |
|
|
val SC_CHARSET_SYMBOL=2 |
| 373 |
|
|
val SC_CHARSET_TURKISH=162 |
| 374 |
|
|
val SC_CHARSET_JOHAB=130 |
| 375 |
|
|
val SC_CHARSET_HEBREW=177 |
| 376 |
|
|
val SC_CHARSET_ARABIC=178 |
| 377 |
|
|
val SC_CHARSET_VIETNAMESE=163 |
| 378 |
|
|
val SC_CHARSET_THAI=222 |
| 379 |
|
|
val SC_CHARSET_8859_15=1000 |
| 380 |
|
|
|
| 381 |
|
|
# Clear all the styles and make equivalent to the global default style. |
| 382 |
|
|
set void StyleClearAll=2050(,) |
| 383 |
|
|
|
| 384 |
|
|
# Set the foreground colour of a style. |
| 385 |
|
|
set void StyleSetFore=2051(int style, colour fore) |
| 386 |
|
|
|
| 387 |
|
|
# Set the background colour of a style. |
| 388 |
|
|
set void StyleSetBack=2052(int style, colour back) |
| 389 |
|
|
|
| 390 |
|
|
# Set a style to be bold or not. |
| 391 |
|
|
set void StyleSetBold=2053(int style, bool bold) |
| 392 |
|
|
|
| 393 |
|
|
# Set a style to be italic or not. |
| 394 |
|
|
set void StyleSetItalic=2054(int style, bool italic) |
| 395 |
|
|
|
| 396 |
|
|
# Set the size of characters of a style. |
| 397 |
|
|
set void StyleSetSize=2055(int style, int sizePoints) |
| 398 |
|
|
|
| 399 |
|
|
# Set the font of a style. |
| 400 |
|
|
set void StyleSetFont=2056(int style, string fontName) |
| 401 |
|
|
|
| 402 |
|
|
# Set a style to have its end of line filled or not. |
| 403 |
|
|
set void StyleSetEOLFilled=2057(int style, bool filled) |
| 404 |
|
|
|
| 405 |
|
|
# Reset the default style to its state at startup |
| 406 |
|
|
fun void StyleResetDefault=2058(,) |
| 407 |
|
|
|
| 408 |
|
|
# Set a style to be underlined or not. |
| 409 |
|
|
set void StyleSetUnderline=2059(int style, bool underline) |
| 410 |
|
|
|
| 411 |
|
|
enu CaseVisible=SC_CASE_ |
| 412 |
|
|
val SC_CASE_MIXED=0 |
| 413 |
|
|
val SC_CASE_UPPER=1 |
| 414 |
|
|
val SC_CASE_LOWER=2 |
| 415 |
|
|
# Set a style to be mixed case, or to force upper or lower case. |
| 416 |
|
|
set void StyleSetCase=2060(int style, int caseForce) |
| 417 |
|
|
|
| 418 |
|
|
# Set the character set of the font in a style. |
| 419 |
|
|
set void StyleSetCharacterSet=2066(int style, int characterSet) |
| 420 |
|
|
|
| 421 |
|
|
# Set a style to be a hotspot or not. |
| 422 |
|
|
set void StyleSetHotSpot=2409(int style, bool hotspot) |
| 423 |
|
|
|
| 424 |
|
|
# Set the foreground colour of the selection and whether to use this setting. |
| 425 |
|
|
fun void SetSelFore=2067(bool useSetting, colour fore) |
| 426 |
|
|
|
| 427 |
|
|
# Set the background colour of the selection and whether to use this setting. |
| 428 |
|
|
fun void SetSelBack=2068(bool useSetting, colour back) |
| 429 |
|
|
|
| 430 |
|
|
# Set the foreground colour of the caret. |
| 431 |
|
|
set void SetCaretFore=2069(colour fore,) |
| 432 |
|
|
|
| 433 |
|
|
# When key+modifier combination km is pressed perform msg. |
| 434 |
|
|
fun void AssignCmdKey=2070(keymod km, int msg) |
| 435 |
|
|
|
| 436 |
|
|
# When key+modifier combination km is pressed do nothing. |
| 437 |
|
|
fun void ClearCmdKey=2071(keymod km,) |
| 438 |
|
|
|
| 439 |
|
|
# Drop all key mappings. |
| 440 |
|
|
fun void ClearAllCmdKeys=2072(,) |
| 441 |
|
|
|
| 442 |
|
|
# Set the styles for a segment of the document. |
| 443 |
|
|
fun void SetStylingEx=2073(int length, string styles) |
| 444 |
|
|
|
| 445 |
|
|
# Set a style to be visible or not. |
| 446 |
|
|
set void StyleSetVisible=2074(int style, bool visible) |
| 447 |
|
|
|
| 448 |
|
|
# Get the time in milliseconds that the caret is on and off. |
| 449 |
|
|
get int GetCaretPeriod=2075(,) |
| 450 |
|
|
|
| 451 |
|
|
# Get the time in milliseconds that the caret is on and off. 0 = steady on. |
| 452 |
|
|
set void SetCaretPeriod=2076(int periodMilliseconds,) |
| 453 |
|
|
|
| 454 |
|
|
# Set the set of characters making up words for when moving or selecting by word. |
| 455 |
|
|
# First sets deaults like SetCharsDefault. |
| 456 |
|
|
set void SetWordChars=2077(, string characters) |
| 457 |
|
|
|
| 458 |
|
|
# Start a sequence of actions that is undone and redone as a unit. |
| 459 |
|
|
# May be nested. |
| 460 |
|
|
fun void BeginUndoAction=2078(,) |
| 461 |
|
|
|
| 462 |
|
|
# End a sequence of actions that is undone and redone as a unit. |
| 463 |
|
|
fun void EndUndoAction=2079(,) |
| 464 |
|
|
|
| 465 |
|
|
enu IndicatorStyle=INDIC_ |
| 466 |
|
|
val INDIC_MAX=7 |
| 467 |
|
|
val INDIC_PLAIN=0 |
| 468 |
|
|
val INDIC_SQUIGGLE=1 |
| 469 |
|
|
val INDIC_TT=2 |
| 470 |
|
|
val INDIC_DIAGONAL=3 |
| 471 |
|
|
val INDIC_STRIKE=4 |
| 472 |
|
|
val INDIC_HIDDEN=5 |
| 473 |
|
|
val INDIC_BOX=6 |
| 474 |
|
|
val INDIC0_MASK=0x20 |
| 475 |
|
|
val INDIC1_MASK=0x40 |
| 476 |
|
|
val INDIC2_MASK=0x80 |
| 477 |
|
|
val INDICS_MASK=0xE0 |
| 478 |
|
|
|
| 479 |
|
|
# Set an indicator to plain, squiggle or TT. |
| 480 |
|
|
set void IndicSetStyle=2080(int indic, int style) |
| 481 |
|
|
|
| 482 |
|
|
# Retrieve the style of an indicator. |
| 483 |
|
|
get int IndicGetStyle=2081(int indic,) |
| 484 |
|
|
|
| 485 |
|
|
# Set the foreground colour of an indicator. |
| 486 |
|
|
set void IndicSetFore=2082(int indic, colour fore) |
| 487 |
|
|
|
| 488 |
|
|
# Retrieve the foreground colour of an indicator. |
| 489 |
|
|
get colour IndicGetFore=2083(int indic,) |
| 490 |
|
|
|
| 491 |
|
|
# Set the foreground colour of all whitespace and whether to use this setting. |
| 492 |
|
|
fun void SetWhitespaceFore=2084(bool useSetting, colour fore) |
| 493 |
|
|
|
| 494 |
|
|
# Set the background colour of all whitespace and whether to use this setting. |
| 495 |
|
|
fun void SetWhitespaceBack=2085(bool useSetting, colour back) |
| 496 |
|
|
|
| 497 |
|
|
# Divide each styling byte into lexical class bits (default: 5) and indicator |
| 498 |
|
|
# bits (default: 3). If a lexer requires more than 32 lexical states, then this |
| 499 |
|
|
# is used to expand the possible states. |
| 500 |
|
|
set void SetStyleBits=2090(int bits,) |
| 501 |
|
|
|
| 502 |
|
|
# Retrieve number of bits in style bytes used to hold the lexical state. |
| 503 |
|
|
get int GetStyleBits=2091(,) |
| 504 |
|
|
|
| 505 |
|
|
# Used to hold extra styling information for each line. |
| 506 |
|
|
set void SetLineState=2092(int line, int state) |
| 507 |
|
|
|
| 508 |
|
|
# Retrieve the extra styling information for a line. |
| 509 |
|
|
get int GetLineState=2093(int line,) |
| 510 |
|
|
|
| 511 |
|
|
# Retrieve the last line number that has line state. |
| 512 |
|
|
get int GetMaxLineState=2094(,) |
| 513 |
|
|
|
| 514 |
|
|
# Is the background of the line containing the caret in a different colour? |
| 515 |
|
|
get bool GetCaretLineVisible=2095(,) |
| 516 |
|
|
|
| 517 |
|
|
# Display the background of the line containing the caret in a different colour. |
| 518 |
|
|
set void SetCaretLineVisible=2096(bool show,) |
| 519 |
|
|
|
| 520 |
|
|
# Get the colour of the background of the line containing the caret. |
| 521 |
|
|
get colour GetCaretLineBack=2097(,) |
| 522 |
|
|
|
| 523 |
|
|
# Set the colour of the background of the line containing the caret. |
| 524 |
|
|
set void SetCaretLineBack=2098(colour back,) |
| 525 |
|
|
|
| 526 |
|
|
# Set a style to be changeable or not (read only). |
| 527 |
|
|
# Experimental feature, currently buggy. |
| 528 |
|
|
set void StyleSetChangeable=2099(int style, bool changeable) |
| 529 |
|
|
|
| 530 |
|
|
# Display a auto-completion list. |
| 531 |
|
|
# The lenEntered parameter indicates how many characters before |
| 532 |
|
|
# the caret should be used to provide context. |
| 533 |
|
|
fun void AutoCShow=2100(int lenEntered, string itemList) |
| 534 |
|
|
|
| 535 |
|
|
# Remove the auto-completion list from the screen. |
| 536 |
|
|
fun void AutoCCancel=2101(,) |
| 537 |
|
|
|
| 538 |
|
|
# Is there an auto-completion list visible? |
| 539 |
|
|
fun bool AutoCActive=2102(,) |
| 540 |
|
|
|
| 541 |
|
|
# Retrieve the position of the caret when the auto-completion list was displayed. |
| 542 |
|
|
fun position AutoCPosStart=2103(,) |
| 543 |
|
|
|
| 544 |
|
|
# User has selected an item so remove the list and insert the selection. |
| 545 |
|
|
fun void AutoCComplete=2104(,) |
| 546 |
|
|
|
| 547 |
|
|
# Define a set of character that when typed cancel the auto-completion list. |
| 548 |
|
|
fun void AutoCStops=2105(, string characterSet) |
| 549 |
|
|
|
| 550 |
|
|
# Change the separator character in the string setting up an auto-completion list. |
| 551 |
|
|
# Default is space but can be changed if items contain space. |
| 552 |
|
|
set void AutoCSetSeparator=2106(int separatorCharacter,) |
| 553 |
|
|
|
| 554 |
|
|
# Retrieve the auto-completion list separator character. |
| 555 |
|
|
get int AutoCGetSeparator=2107(,) |
| 556 |
|
|
|
| 557 |
|
|
# Select the item in the auto-completion list that starts with a string. |
| 558 |
|
|
fun void AutoCSelect=2108(, string text) |
| 559 |
|
|
|
| 560 |
|
|
# Should the auto-completion list be cancelled if the user backspaces to a |
| 561 |
|
|
# position before where the box was created. |
| 562 |
|
|
set void AutoCSetCancelAtStart=2110(bool cancel,) |
| 563 |
|
|
|
| 564 |
|
|
# Retrieve whether auto-completion cancelled by backspacing before start. |
| 565 |
|
|
get bool AutoCGetCancelAtStart=2111(,) |
| 566 |
|
|
|
| 567 |
|
|
# Define a set of characters that when typed will cause the autocompletion to |
| 568 |
|
|
# choose the selected item. |
| 569 |
|
|
set void AutoCSetFillUps=2112(, string characterSet) |
| 570 |
|
|
|
| 571 |
|
|
# Should a single item auto-completion list automatically choose the item. |
| 572 |
|
|
set void AutoCSetChooseSingle=2113(bool chooseSingle,) |
| 573 |
|
|
|
| 574 |
|
|
# Retrieve whether a single item auto-completion list automatically choose the item. |
| 575 |
|
|
get bool AutoCGetChooseSingle=2114(,) |
| 576 |
|
|
|
| 577 |
|
|
# Set whether case is significant when performing auto-completion searches. |
| 578 |
|
|
set void AutoCSetIgnoreCase=2115(bool ignoreCase,) |
| 579 |
|
|
|
| 580 |
|
|
# Retrieve state of ignore case flag. |
| 581 |
|
|
get bool AutoCGetIgnoreCase=2116(,) |
| 582 |
|
|
|
| 583 |
|
|
# Display a list of strings and send notification when user chooses one. |
| 584 |
|
|
fun void UserListShow=2117(int listType, string itemList) |
| 585 |
|
|
|
| 586 |
|
|
# Set whether or not autocompletion is hidden automatically when nothing matches. |
| 587 |
|
|
set void AutoCSetAutoHide=2118(bool autoHide,) |
| 588 |
|
|
|
| 589 |
|
|
# Retrieve whether or not autocompletion is hidden automatically when nothing matches. |
| 590 |
|
|
get bool AutoCGetAutoHide=2119(,) |
| 591 |
|
|
|
| 592 |
|
|
# Set whether or not autocompletion deletes any word characters |
| 593 |
|
|
# after the inserted text upon completion. |
| 594 |
|
|
set void AutoCSetDropRestOfWord=2270(bool dropRestOfWord,) |
| 595 |
|
|
|
| 596 |
|
|
# Retrieve whether or not autocompletion deletes any word characters |
| 597 |
|
|
# after the inserted text upon completion. |
| 598 |
|
|
get bool AutoCGetDropRestOfWord=2271(,) |
| 599 |
|
|
|
| 600 |
|
|
# Register an XPM image for use in autocompletion lists. |
| 601 |
|
|
fun void RegisterImage=2405(int type, string xpmData) |
| 602 |
|
|
|
| 603 |
|
|
# Clear all the registered XPM images. |
| 604 |
|
|
fun void ClearRegisteredImages=2408(,) |
| 605 |
|
|
|
| 606 |
|
|
# Retrieve the auto-completion list type-separator character. |
| 607 |
|
|
get int AutoCGetTypeSeparator=2285(,) |
| 608 |
|
|
|
| 609 |
|
|
# Change the type-separator character in the string setting up an auto-completion list. |
| 610 |
|
|
# Default is '?' but can be changed if items contain '?'. |
| 611 |
|
|
set void AutoCSetTypeSeparator=2286(int separatorCharacter,) |
| 612 |
|
|
|
| 613 |
|
|
# Set the maximum width, in characters, of auto-completion and user lists. |
| 614 |
|
|
# Set to 0 to autosize to fit longest item, which is the default. |
| 615 |
|
|
set void AutoCSetMaxWidth=2208(int characterCount,) |
| 616 |
|
|
|
| 617 |
|
|
# Get the maximum width, in characters, of auto-completion and user lists. |
| 618 |
|
|
get int AutoCGetMaxWidth=2209(,) |
| 619 |
|
|
|
| 620 |
|
|
# Set the maximum height, in rows, of auto-completion and user lists. |
| 621 |
|
|
# The default is 5 rows. |
| 622 |
|
|
set void AutoCSetMaxHeight=2210(int rowCount,) |
| 623 |
|
|
|
| 624 |
|
|
# Set the maximum height, in rows, of auto-completion and user lists. |
| 625 |
|
|
get int AutoCGetMaxHeight=2211(,) |
| 626 |
|
|
|
| 627 |
|
|
# Set the number of spaces used for one level of indentation. |
| 628 |
|
|
set void SetIndent=2122(int indentSize,) |
| 629 |
|
|
|
| 630 |
|
|
# Retrieve indentation size. |
| 631 |
|
|
get int GetIndent=2123(,) |
| 632 |
|
|
|
| 633 |
|
|
# Indentation will only use space characters if useTabs is false, otherwise |
| 634 |
|
|
# it will use a combination of tabs and spaces. |
| 635 |
|
|
set void SetUseTabs=2124(bool useTabs,) |
| 636 |
|
|
|
| 637 |
|
|
# Retrieve whether tabs will be used in indentation. |
| 638 |
|
|
get bool GetUseTabs=2125(,) |
| 639 |
|
|
|
| 640 |
|
|
# Change the indentation of a line to a number of columns. |
| 641 |
|
|
set void SetLineIndentation=2126(int line, int indentSize) |
| 642 |
|
|
|
| 643 |
|
|
# Retrieve the number of columns that a line is indented. |
| 644 |
|
|
get int GetLineIndentation=2127(int line,) |
| 645 |
|
|
|
| 646 |
|
|
# Retrieve the position before the first non indentation character on a line. |
| 647 |
|
|
get position GetLineIndentPosition=2128(int line,) |
| 648 |
|
|
|
| 649 |
|
|
# Retrieve the column number of a position, taking tab width into account. |
| 650 |
|
|
get int GetColumn=2129(position pos,) |
| 651 |
|
|
|
| 652 |
|
|
# Show or hide the horizontal scroll bar. |
| 653 |
|
|
set void SetHScrollBar=2130(bool show,) |
| 654 |
|
|
|
| 655 |
|
|
# Is the horizontal scroll bar visible? |
| 656 |
|
|
get bool GetHScrollBar=2131(,) |
| 657 |
|
|
|
| 658 |
|
|
# Show or hide indentation guides. |
| 659 |
|
|
set void SetIndentationGuides=2132(bool show,) |
| 660 |
|
|
|
| 661 |
|
|
# Are the indentation guides visible? |
| 662 |
|
|
get bool GetIndentationGuides=2133(,) |
| 663 |
|
|
|
| 664 |
|
|
# Set the highlighted indentation guide column. |
| 665 |
|
|
# 0 = no highlighted guide. |
| 666 |
|
|
set void SetHighlightGuide=2134(int column,) |
| 667 |
|
|
|
| 668 |
|
|
# Get the highlighted indentation guide column. |
| 669 |
|
|
get int GetHighlightGuide=2135(,) |
| 670 |
|
|
|
| 671 |
|
|
# Get the position after the last visible characters on a line. |
| 672 |
|
|
get int GetLineEndPosition=2136(int line,) |
| 673 |
|
|
|
| 674 |
|
|
# Get the code page used to interpret the bytes of the document as characters. |
| 675 |
|
|
get int GetCodePage=2137(,) |
| 676 |
|
|
|
| 677 |
|
|
# Get the foreground colour of the caret. |
| 678 |
|
|
get colour GetCaretFore=2138(,) |
| 679 |
|
|
|
| 680 |
|
|
# In palette mode? |
| 681 |
|
|
get bool GetUsePalette=2139(,) |
| 682 |
|
|
|
| 683 |
|
|
# In read-only mode? |
| 684 |
|
|
get bool GetReadOnly=2140(,) |
| 685 |
|
|
|
| 686 |
|
|
# Sets the position of the caret. |
| 687 |
|
|
set void SetCurrentPos=2141(position pos,) |
| 688 |
|
|
|
| 689 |
|
|
# Sets the position that starts the selection - this becomes the anchor. |
| 690 |
|
|
set void SetSelectionStart=2142(position pos,) |
| 691 |
|
|
|
| 692 |
|
|
# Returns the position at the start of the selection. |
| 693 |
|
|
get position GetSelectionStart=2143(,) |
| 694 |
|
|
|
| 695 |
|
|
# Sets the position that ends the selection - this becomes the currentPosition. |
| 696 |
|
|
set void SetSelectionEnd=2144(position pos,) |
| 697 |
|
|
|
| 698 |
|
|
# Returns the position at the end of the selection. |
| 699 |
|
|
get position GetSelectionEnd=2145(,) |
| 700 |
|
|
|
| 701 |
|
|
# Sets the print magnification added to the point size of each style for printing. |
| 702 |
|
|
set void SetPrintMagnification=2146(int magnification,) |
| 703 |
|
|
|
| 704 |
|
|
# Returns the print magnification. |
| 705 |
|
|
get int GetPrintMagnification=2147(,) |
| 706 |
|
|
|
| 707 |
|
|
enu PrintOption=SC_PRINT_ |
| 708 |
|
|
# PrintColourMode - use same colours as screen. |
| 709 |
|
|
val SC_PRINT_NORMAL=0 |
| 710 |
|
|
# PrintColourMode - invert the light value of each style for printing. |
| 711 |
|
|
val SC_PRINT_INVERTLIGHT=1 |
| 712 |
|
|
# PrintColourMode - force black text on white background for printing. |
| 713 |
|
|
val SC_PRINT_BLACKONWHITE=2 |
| 714 |
|
|
# PrintColourMode - text stays coloured, but all background is forced to be white for printing. |
| 715 |
|
|
val SC_PRINT_COLOURONWHITE=3 |
| 716 |
|
|
# PrintColourMode - only the default-background is forced to be white for printing. |
| 717 |
|
|
val SC_PRINT_COLOURONWHITEDEFAULTBG=4 |
| 718 |
|
|
|
| 719 |
|
|
# Modify colours when printing for clearer printed text. |
| 720 |
|
|
set void SetPrintColourMode=2148(int mode,) |
| 721 |
|
|
|
| 722 |
|
|
# Returns the print colour mode. |
| 723 |
|
|
get int GetPrintColourMode=2149(,) |
| 724 |
|
|
|
| 725 |
|
|
enu FindOption=SCFIND_ |
| 726 |
|
|
val SCFIND_WHOLEWORD=2 |
| 727 |
|
|
val SCFIND_MATCHCASE=4 |
| 728 |
|
|
val SCFIND_WORDSTART=0x00100000 |
| 729 |
|
|
val SCFIND_REGEXP=0x00200000 |
| 730 |
|
|
val SCFIND_POSIX=0x00400000 |
| 731 |
|
|
|
| 732 |
|
|
# Find some text in the document. |
| 733 |
|
|
fun position FindText=2150(int flags, findtext ft) |
| 734 |
|
|
|
| 735 |
|
|
# On Windows, will draw the document into a display context such as a printer. |
| 736 |
|
|
fun position FormatRange=2151(bool draw, formatrange fr) |
| 737 |
|
|
|
| 738 |
|
|
# Retrieve the display line at the top of the display. |
| 739 |
|
|
get int GetFirstVisibleLine=2152(,) |
| 740 |
|
|
|
| 741 |
|
|
# Retrieve the contents of a line. |
| 742 |
|
|
# Returns the length of the line. |
| 743 |
|
|
fun int GetLine=2153(int line, stringresult text) |
| 744 |
|
|
|
| 745 |
|
|
# Returns the number of lines in the document. There is always at least one. |
| 746 |
|
|
get int GetLineCount=2154(,) |
| 747 |
|
|
|
| 748 |
|
|
# Sets the size in pixels of the left margin. |
| 749 |
|
|
set void SetMarginLeft=2155(, int pixelWidth) |
| 750 |
|
|
|
| 751 |
|
|
# Returns the size in pixels of the left margin. |
| 752 |
|
|
get int GetMarginLeft=2156(,) |
| 753 |
|
|
|
| 754 |
|
|
# Sets the size in pixels of the right margin. |
| 755 |
|
|
set void SetMarginRight=2157(, int pixelWidth) |
| 756 |
|
|
|
| 757 |
|
|
# Returns the size in pixels of the right margin. |
| 758 |
|
|
get int GetMarginRight=2158(,) |
| 759 |
|
|
|
| 760 |
|
|
# Is the document different from when it was last saved? |
| 761 |
|
|
get bool GetModify=2159(,) |
| 762 |
|
|
|
| 763 |
|
|
# Select a range of text. |
| 764 |
|
|
fun void SetSel=2160(position start, position end) |
| 765 |
|
|
|
| 766 |
|
|
# Retrieve the selected text. |
| 767 |
|
|
# Return the length of the text. |
| 768 |
|
|
fun int GetSelText=2161(, stringresult text) |
| 769 |
|
|
|
| 770 |
|
|
# Retrieve a range of text. |
| 771 |
|
|
# Return the length of the text. |
| 772 |
|
|
fun int GetTextRange=2162(, textrange tr) |
| 773 |
|
|
|
| 774 |
|
|
# Draw the selection in normal style or with selection highlighted. |
| 775 |
|
|
fun void HideSelection=2163(bool normal,) |
| 776 |
|
|
|
| 777 |
|
|
# Retrieve the x value of the point in the window where a position is displayed. |
| 778 |
|
|
fun int PointXFromPosition=2164(, position pos) |
| 779 |
|
|
|
| 780 |
|
|
# Retrieve the y value of the point in the window where a position is displayed. |
| 781 |
|
|
fun int PointYFromPosition=2165(, position pos) |
| 782 |
|
|
|
| 783 |
|
|
# Retrieve the line containing a position. |
| 784 |
|
|
fun int LineFromPosition=2166(position pos,) |
| 785 |
|
|
|
| 786 |
|
|
# Retrieve the position at the start of a line. |
| 787 |
|
|
fun position PositionFromLine=2167(int line,) |
| 788 |
|
|
|
| 789 |
|
|
# Scroll horizontally and vertically. |
| 790 |
|
|
fun void LineScroll=2168(int columns, int lines) |
| 791 |
|
|
|
| 792 |
|
|
# Ensure the caret is visible. |
| 793 |
|
|
fun void ScrollCaret=2169(,) |
| 794 |
|
|
|
| 795 |
|
|
# Replace the selected text with the argument text. |
| 796 |
|
|
fun void ReplaceSel=2170(, string text) |
| 797 |
|
|
|
| 798 |
|
|
# Set to read only or read write. |
| 799 |
|
|
set void SetReadOnly=2171(bool readOnly,) |
| 800 |
|
|
|
| 801 |
|
|
# Null operation. |
| 802 |
|
|
fun void Null=2172(,) |
| 803 |
|
|
|
| 804 |
|
|
# Will a paste succeed? |
| 805 |
|
|
fun bool CanPaste=2173(,) |
| 806 |
|
|
|
| 807 |
|
|
# Are there any undoable actions in the undo history? |
| 808 |
|
|
fun bool CanUndo=2174(,) |
| 809 |
|
|
|
| 810 |
|
|
# Delete the undo history. |
| 811 |
|
|
fun void EmptyUndoBuffer=2175(,) |
| 812 |
|
|
|
| 813 |
|
|
# Undo one action in the undo history. |
| 814 |
|
|
fun void Undo=2176(,) |
| 815 |
|
|
|
| 816 |
|
|
# Cut the selection to the clipboard. |
| 817 |
|
|
fun void Cut=2177(,) |
| 818 |
|
|
|
| 819 |
|
|
# Copy the selection to the clipboard. |
| 820 |
|
|
fun void Copy=2178(,) |
| 821 |
|
|
|
| 822 |
|
|
# Paste the contents of the clipboard into the document replacing the selection. |
| 823 |
|
|
fun void Paste=2179(,) |
| 824 |
|
|
|
| 825 |
|
|
# Clear the selection. |
| 826 |
|
|
fun void Clear=2180(,) |
| 827 |
|
|
|
| 828 |
|
|
# Replace the contents of the document with the argument text. |
| 829 |
|
|
fun void SetText=2181(, string text) |
| 830 |
|
|
|
| 831 |
|
|
# Retrieve all the text in the document. |
| 832 |
|
|
# Returns number of characters retrieved. |
| 833 |
|
|
fun int GetText=2182(int length, stringresult text) |
| 834 |
|
|
|
| 835 |
|
|
# Retrieve the number of characters in the document. |
| 836 |
|
|
get int GetTextLength=2183(,) |
| 837 |
|
|
|
| 838 |
|
|
# Retrieve a pointer to a function that processes messages for this Scintilla. |
| 839 |
|
|
get int GetDirectFunction=2184(,) |
| 840 |
|
|
|
| 841 |
|
|
# Retrieve a pointer value to use as the first argument when calling |
| 842 |
|
|
# the function returned by GetDirectFunction. |
| 843 |
|
|
get int GetDirectPointer=2185(,) |
| 844 |
|
|
|
| 845 |
|
|
# Set to overtype (true) or insert mode. |
| 846 |
|
|
set void SetOvertype=2186(bool overtype,) |
| 847 |
|
|
|
| 848 |
|
|
# Returns true if overtype mode is active otherwise false is returned. |
| 849 |
|
|
get bool GetOvertype=2187(,) |
| 850 |
|
|
|
| 851 |
|
|
# Set the width of the insert mode caret. |
| 852 |
|
|
set void SetCaretWidth=2188(int pixelWidth,) |
| 853 |
|
|
|
| 854 |
|
|
# Returns the width of the insert mode caret. |
| 855 |
|
|
get int GetCaretWidth=2189(,) |
| 856 |
|
|
|
| 857 |
|
|
# Sets the position that starts the target which is used for updating the |
| 858 |
|
|
# document without affecting the scroll position. |
| 859 |
|
|
set void SetTargetStart=2190(position pos,) |
| 860 |
|
|
|
| 861 |
|
|
# Get the position that starts the target. |
| 862 |
|
|
get position GetTargetStart=2191(,) |
| 863 |
|
|
|
| 864 |
|
|
# Sets the position that ends the target which is used for updating the |
| 865 |
|
|
# document without affecting the scroll position. |
| 866 |
|
|
set void SetTargetEnd=2192(position pos,) |
| 867 |
|
|
|
| 868 |
|
|
# Get the position that ends the target. |
| 869 |
|
|
get position GetTargetEnd=2193(,) |
| 870 |
|
|
|
| 871 |
|
|
# Replace the target text with the argument text. |
| 872 |
|
|
# Text is counted so it can contain NULs. |
| 873 |
|
|
# Returns the length of the replacement text. |
| 874 |
|
|
fun int ReplaceTarget=2194(int length, string text) |
| 875 |
|
|
|
| 876 |
|
|
# Replace the target text with the argument text after \d processing. |
| 877 |
|
|
# Text is counted so it can contain NULs. |
| 878 |
|
|
# Looks for \d where d is between 1 and 9 and replaces these with the strings |
| 879 |
|
|
# matched in the last search operation which were surrounded by \( and \). |
| 880 |
|
|
# Returns the length of the replacement text including any change |
| 881 |
|
|
# caused by processing the \d patterns. |
| 882 |
|
|
fun int ReplaceTargetRE=2195(int length, string text) |
| 883 |
|
|
|
| 884 |
|
|
# Search for a counted string in the target and set the target to the found |
| 885 |
|
|
# range. Text is counted so it can contain NULs. |
| 886 |
|
|
# Returns length of range or -1 for failure in which case target is not moved. |
| 887 |
|
|
fun int SearchInTarget=2197(int length, string text) |
| 888 |
|
|
|
| 889 |
|
|
# Set the search flags used by SearchInTarget. |
| 890 |
|
|
set void SetSearchFlags=2198(int flags,) |
| 891 |
|
|
|
| 892 |
|
|
# Get the search flags used by SearchInTarget. |
| 893 |
|
|
get int GetSearchFlags=2199(,) |
| 894 |
|
|
|
| 895 |
|
|
# Show a call tip containing a definition near position pos. |
| 896 |
|
|
fun void CallTipShow=2200(position pos, string definition) |
| 897 |
|
|
|
| 898 |
|
|
# Remove the call tip from the screen. |
| 899 |
|
|
fun void CallTipCancel=2201(,) |
| 900 |
|
|
|
| 901 |
|
|
# Is there an active call tip? |
| 902 |
|
|
fun bool CallTipActive=2202(,) |
| 903 |
|
|
|
| 904 |
|
|
# Retrieve the position where the caret was before displaying the call tip. |
| 905 |
|
|
fun position CallTipPosStart=2203(,) |
| 906 |
|
|
|
| 907 |
|
|
# Highlight a segment of the definition. |
| 908 |
|
|
fun void CallTipSetHlt=2204(int start, int end) |
| 909 |
|
|
|
| 910 |
|
|
# Set the background colour for the call tip. |
| 911 |
|
|
set void CallTipSetBack=2205(colour back,) |
| 912 |
|
|
|
| 913 |
|
|
# Set the foreground colour for the call tip. |
| 914 |
|
|
set void CallTipSetFore=2206(colour fore,) |
| 915 |
|
|
|
| 916 |
|
|
# Set the foreground colour for the highlighted part of the call tip. |
| 917 |
|
|
set void CallTipSetForeHlt=2207(colour fore,) |
| 918 |
|
|
|
| 919 |
|
|
# Find the display line of a document line taking hidden lines into account. |
| 920 |
|
|
fun int VisibleFromDocLine=2220(int line,) |
| 921 |
|
|
|
| 922 |
|
|
# Find the document line of a display line taking hidden lines into account. |
| 923 |
|
|
fun int DocLineFromVisible=2221(int lineDisplay,) |
| 924 |
|
|
|
| 925 |
|
|
# The number of display lines needed to wrap a document line |
| 926 |
|
|
fun int WrapCount=2235(int line,) |
| 927 |
|
|
|
| 928 |
|
|
enu FoldLevel=SC_FOLDLEVEL |
| 929 |
|
|
val SC_FOLDLEVELBASE=0x400 |
| 930 |
|
|
val SC_FOLDLEVELWHITEFLAG=0x1000 |
| 931 |
|
|
val SC_FOLDLEVELHEADERFLAG=0x2000 |
| 932 |
|
|
val SC_FOLDLEVELBOXHEADERFLAG=0x4000 |
| 933 |
|
|
val SC_FOLDLEVELBOXFOOTERFLAG=0x8000 |
| 934 |
|
|
val SC_FOLDLEVELCONTRACTED=0x10000 |
| 935 |
|
|
val SC_FOLDLEVELUNINDENT=0x20000 |
| 936 |
|
|
val SC_FOLDLEVELNUMBERMASK=0x0FFF |
| 937 |
|
|
|
| 938 |
|
|
# Set the fold level of a line. |
| 939 |
|
|
# This encodes an integer level along with flags indicating whether the |
| 940 |
|
|
# line is a header and whether it is effectively white space. |
| 941 |
|
|
set void SetFoldLevel=2222(int line, int level) |
| 942 |
|
|
|
| 943 |
|
|
# Retrieve the fold level of a line. |
| 944 |
|
|
get int GetFoldLevel=2223(int line,) |
| 945 |
|
|
|
| 946 |
|
|
# Find the last child line of a header line. |
| 947 |
|
|
get int GetLastChild=2224(int line, int level) |
| 948 |
|
|
|
| 949 |
|
|
# Find the parent line of a child line. |
| 950 |
|
|
get int GetFoldParent=2225(int line,) |
| 951 |
|
|
|
| 952 |
|
|
# Make a range of lines visible. |
| 953 |
|
|
fun void ShowLines=2226(int lineStart, int lineEnd) |
| 954 |
|
|
|
| 955 |
|
|
# Make a range of lines invisible. |
| 956 |
|
|
fun void HideLines=2227(int lineStart, int lineEnd) |
| 957 |
|
|
|
| 958 |
|
|
# Is a line visible? |
| 959 |
|
|
get bool GetLineVisible=2228(int line,) |
| 960 |
|
|
|
| 961 |
|
|
# Show the children of a header line. |
| 962 |
|
|
set void SetFoldExpanded=2229(int line, bool expanded) |
| 963 |
|
|
|
| 964 |
|
|
# Is a header line expanded? |
| 965 |
|
|
get bool GetFoldExpanded=2230(int line,) |
| 966 |
|
|
|
| 967 |
|
|
# Switch a header line between expanded and contracted. |
| 968 |
|
|
fun void ToggleFold=2231(int line,) |
| 969 |
|
|
|
| 970 |
|
|
# Ensure a particular line is visible by expanding any header line hiding it. |
| 971 |
|
|
fun void EnsureVisible=2232(int line,) |
| 972 |
|
|
|
| 973 |
|
|
enu FoldFlag=SC_FOLDFLAG_ |
| 974 |
|
|
val SC_FOLDFLAG_LINEBEFORE_EXPANDED=0x0002 |
| 975 |
|
|
val SC_FOLDFLAG_LINEBEFORE_CONTRACTED=0x0004 |
| 976 |
|
|
val SC_FOLDFLAG_LINEAFTER_EXPANDED=0x0008 |
| 977 |
|
|
val SC_FOLDFLAG_LINEAFTER_CONTRACTED=0x0010 |
| 978 |
|
|
val SC_FOLDFLAG_LEVELNUMBERS=0x0040 |
| 979 |
|
|
val SC_FOLDFLAG_BOX=0x0001 |
| 980 |
|
|
|
| 981 |
|
|
# Set some style options for folding. |
| 982 |
|
|
fun void SetFoldFlags=2233(int flags,) |
| 983 |
|
|
|
| 984 |
|
|
# Ensure a particular line is visible by expanding any header line hiding it. |
| 985 |
|
|
# Use the currently set visibility policy to determine which range to display. |
| 986 |
|
|
fun void EnsureVisibleEnforcePolicy=2234(int line,) |
| 987 |
|
|
|
| 988 |
|
|
# Sets whether a tab pressed when caret is within indentation indents. |
| 989 |
|
|
set void SetTabIndents=2260(bool tabIndents,) |
| 990 |
|
|
|
| 991 |
|
|
# Does a tab pressed when caret is within indentation indent? |
| 992 |
|
|
get bool GetTabIndents=2261(,) |
| 993 |
|
|
|
| 994 |
|
|
# Sets whether a backspace pressed when caret is within indentation unindents. |
| 995 |
|
|
set void SetBackSpaceUnIndents=2262(bool bsUnIndents,) |
| 996 |
|
|
|
| 997 |
|
|
# Does a backspace pressed when caret is within indentation unindent? |
| 998 |
|
|
get bool GetBackSpaceUnIndents=2263(,) |
| 999 |
|
|
|
| 1000 |
|
|
val SC_TIME_FOREVER=10000000 |
| 1001 |
|
|
|
| 1002 |
|
|
# Sets the time the mouse must sit still to generate a mouse dwell event. |
| 1003 |
|
|
set void SetMouseDwellTime=2264(int periodMilliseconds,) |
| 1004 |
|
|
|
| 1005 |
|
|
# Retrieve the time the mouse must sit still to generate a mouse dwell event. |
| 1006 |
|
|
get int GetMouseDwellTime=2265(,) |
| 1007 |
|
|
|
| 1008 |
|
|
# Get position of start of word. |
| 1009 |
|
|
fun int WordStartPosition=2266(position pos, bool onlyWordCharacters) |
| 1010 |
|
|
|
| 1011 |
|
|
# Get position of end of word. |
| 1012 |
|
|
fun int WordEndPosition=2267(position pos, bool onlyWordCharacters) |
| 1013 |
|
|
|
| 1014 |
|
|
enu Wrap=SC_WRAP_ |
| 1015 |
|
|
val SC_WRAP_NONE=0 |
| 1016 |
|
|
val SC_WRAP_WORD=1 |
| 1017 |
|
|
val SC_WRAP_CHAR=2 |
| 1018 |
|
|
|
| 1019 |
|
|
# Sets whether text is word wrapped. |
| 1020 |
|
|
set void SetWrapMode=2268(int mode,) |
| 1021 |
|
|
|
| 1022 |
|
|
# Retrieve whether text is word wrapped. |
| 1023 |
|
|
get int GetWrapMode=2269(,) |
| 1024 |
|
|
|
| 1025 |
|
|
enu WrapVisualFlag=SC_WRAPVISUALFLAG_ |
| 1026 |
|
|
val SC_WRAPVISUALFLAG_NONE=0x0000 |
| 1027 |
|
|
val SC_WRAPVISUALFLAG_END=0x0001 |
| 1028 |
|
|
val SC_WRAPVISUALFLAG_START=0x0002 |
| 1029 |
|
|
|
| 1030 |
|
|
# Set the display mode of visual flags for wrapped lines. |
| 1031 |
|
|
set void SetWrapVisualFlags=2460(int wrapVisualFlags,) |
| 1032 |
|
|
|
| 1033 |
|
|
# Retrive the display mode of visual flags for wrapped lines. |
| 1034 |
|
|
get int GetWrapVisualFlags=2461(,) |
| 1035 |
|
|
|
| 1036 |
|
|
enu WrapVisualLocation=SC_WRAPVISUALFLAGLOC_ |
| 1037 |
|
|
val SC_WRAPVISUALFLAGLOC_DEFAULT=0x0000 |
| 1038 |
|
|
val SC_WRAPVISUALFLAGLOC_END_BY_TEXT=0x0001 |
| 1039 |
|
|
val SC_WRAPVISUALFLAGLOC_START_BY_TEXT=0x0002 |
| 1040 |
|
|
|
| 1041 |
|
|
# Set the location of visual flags for wrapped lines. |
| 1042 |
|
|
set void SetWrapVisualFlagsLocation=2462(int wrapVisualFlagsLocation,) |
| 1043 |
|
|
|
| 1044 |
|
|
# Retrive the location of visual flags for wrapped lines. |
| 1045 |
|
|
get int GetWrapVisualFlagsLocation=2463(,) |
| 1046 |
|
|
|
| 1047 |
|
|
# Set the start indent for wrapped lines. |
| 1048 |
|
|
set void SetWrapStartIndent=2464(int indent,) |
| 1049 |
|
|
|
| 1050 |
|
|
# Retrive the start indent for wrapped lines. |
| 1051 |
|
|
get int GetWrapStartIndent=2465(,) |
| 1052 |
|
|
|
| 1053 |
|
|
enu LineCache=SC_CACHE_ |
| 1054 |
|
|
val SC_CACHE_NONE=0 |
| 1055 |
|
|
val SC_CACHE_CARET=1 |
| 1056 |
|
|
val SC_CACHE_PAGE=2 |
| 1057 |
|
|
val SC_CACHE_DOCUMENT=3 |
| 1058 |
|
|
|
| 1059 |
|
|
# Sets the degree of caching of layout information. |
| 1060 |
|
|
set void SetLayoutCache=2272(int mode,) |
| 1061 |
|
|
|
| 1062 |
|
|
# Retrieve the degree of caching of layout information. |
| 1063 |
|
|
get int GetLayoutCache=2273(,) |
| 1064 |
|
|
|
| 1065 |
|
|
# Sets the document width assumed for scrolling. |
| 1066 |
|
|
set void SetScrollWidth=2274(int pixelWidth,) |
| 1067 |
|
|
|
| 1068 |
|
|
# Retrieve the document width assumed for scrolling. |
| 1069 |
|
|
get int GetScrollWidth=2275(,) |
| 1070 |
|
|
|
| 1071 |
|
|
# Measure the pixel width of some text in a particular style. |
| 1072 |
|
|
# NUL terminated text argument. |
| 1073 |
|
|
# Does not handle tab or control characters. |
| 1074 |
|
|
fun int TextWidth=2276(int style, string text) |
| 1075 |
|
|
|
| 1076 |
|
|
# Sets the scroll range so that maximum scroll position has |
| 1077 |
|
|
# the last line at the bottom of the view (default). |
| 1078 |
|
|
# Setting this to false allows scrolling one page below the last line. |
| 1079 |
|
|
set void SetEndAtLastLine=2277(bool endAtLastLine,) |
| 1080 |
|
|
|
| 1081 |
|
|
# Retrieve whether the maximum scroll position has the last |
| 1082 |
|
|
# line at the bottom of the view. |
| 1083 |
|
|
get bool GetEndAtLastLine=2278(,) |
| 1084 |
|
|
|
| 1085 |
|
|
# Retrieve the height of a particular line of text in pixels. |
| 1086 |
|
|
fun int TextHeight=2279(int line,) |
| 1087 |
|
|
|
| 1088 |
|
|
# Show or hide the vertical scroll bar. |
| 1089 |
|
|
set void SetVScrollBar=2280(bool show,) |
| 1090 |
|
|
|
| 1091 |
|
|
# Is the vertical scroll bar visible? |
| 1092 |
|
|
get bool GetVScrollBar=2281(,) |
| 1093 |
|
|
|
| 1094 |
|
|
# Append a string to the end of the document without changing the selection. |
| 1095 |
|
|
fun void AppendText=2282(int length, string text) |
| 1096 |
|
|
|
| 1097 |
|
|
# Is drawing done in two phases with backgrounds drawn before faoregrounds? |
| 1098 |
|
|
get bool GetTwoPhaseDraw=2283(,) |
| 1099 |
|
|
|
| 1100 |
|
|
# In twoPhaseDraw mode, drawing is performed in two phases, first the background |
| 1101 |
|
|
# and then the foreground. This avoids chopping off characters that overlap the next run. |
| 1102 |
|
|
set void SetTwoPhaseDraw=2284(bool twoPhase,) |
| 1103 |
|
|
|
| 1104 |
|
|
# Make the target range start and end be the same as the selection range start and end. |
| 1105 |
|
|
fun void TargetFromSelection=2287(,) |
| 1106 |
|
|
|
| 1107 |
|
|
# Join the lines in the target. |
| 1108 |
|
|
fun void LinesJoin=2288(,) |
| 1109 |
|
|
|
| 1110 |
|
|
# Split the lines in the target into lines that are less wide than pixelWidth |
| 1111 |
|
|
# where possible. |
| 1112 |
|
|
fun void LinesSplit=2289(int pixelWidth,) |
| 1113 |
|
|
|
| 1114 |
|
|
# Set the colours used as a chequerboard pattern in the fold margin |
| 1115 |
|
|
fun void SetFoldMarginColour=2290(bool useSetting, colour back) |
| 1116 |
|
|
fun void SetFoldMarginHiColour=2291(bool useSetting, colour fore) |
| 1117 |
|
|
|
| 1118 |
|
|
## New messages go here |
| 1119 |
|
|
|
| 1120 |
|
|
## Start of key messages |
| 1121 |
|
|
# Move caret down one line. |
| 1122 |
|
|
fun void LineDown=2300(,) |
| 1123 |
|
|
|
| 1124 |
|
|
# Move caret down one line extending selection to new caret position. |
| 1125 |
|
|
fun void LineDownExtend=2301(,) |
| 1126 |
|
|
|
| 1127 |
|
|
# Move caret up one line. |
| 1128 |
|
|
fun void LineUp=2302(,) |
| 1129 |
|
|
|
| 1130 |
|
|
# Move caret up one line extending selection to new caret position. |
| 1131 |
|
|
fun void LineUpExtend=2303(,) |
| 1132 |
|
|
|
| 1133 |
|
|
# Move caret left one character. |
| 1134 |
|
|
fun void CharLeft=2304(,) |
| 1135 |
|
|
|
| 1136 |
|
|
# Move caret left one character extending selection to new caret position. |
| 1137 |
|
|
fun void CharLeftExtend=2305(,) |
| 1138 |
|
|
|
| 1139 |
|
|
# Move caret right one character. |
| 1140 |
|
|
fun void CharRight=2306(,) |
| 1141 |
|
|
|
| 1142 |
|
|
# Move caret right one character extending selection to new caret position. |
| 1143 |
|
|
fun void CharRightExtend=2307(,) |
| 1144 |
|
|
|
| 1145 |
|
|
# Move caret left one word. |
| 1146 |
|
|
fun void WordLeft=2308(,) |
| 1147 |
|
|
|
| 1148 |
|
|
# Move caret left one word extending selection to new caret position. |
| 1149 |
|
|
fun void WordLeftExtend=2309(,) |
| 1150 |
|
|
|
| 1151 |
|
|
# Move caret right one word. |
| 1152 |
|
|
fun void WordRight=2310(,) |
| 1153 |
|
|
|
| 1154 |
|
|
# Move caret right one word extending selection to new caret position. |
| 1155 |
|
|
fun void WordRightExtend=2311(,) |
| 1156 |
|
|
|
| 1157 |
|
|
# Move caret to first position on line. |
| 1158 |
|
|
fun void Home=2312(,) |
| 1159 |
|
|
|
| 1160 |
|
|
# Move caret to first position on line extending selection to new caret position. |
| 1161 |
|
|
fun void HomeExtend=2313(,) |
| 1162 |
|
|
|
| 1163 |
|
|
# Move caret to last position on line. |
| 1164 |
|
|
fun void LineEnd=2314(,) |
| 1165 |
|
|
|
| 1166 |
|
|
# Move caret to last position on line extending selection to new caret position. |
| 1167 |
|
|
fun void LineEndExtend=2315(,) |
| 1168 |
|
|
|
| 1169 |
|
|
# Move caret to first position in document. |
| 1170 |
|
|
fun void DocumentStart=2316(,) |
| 1171 |
|
|
|
| 1172 |
|
|
# Move caret to first position in document extending selection to new caret position. |
| 1173 |
|
|
fun void DocumentStartExtend=2317(,) |
| 1174 |
|
|
|
| 1175 |
|
|
# Move caret to last position in document. |
| 1176 |
|
|
fun void DocumentEnd=2318(,) |
| 1177 |
|
|
|
| 1178 |
|
|
# Move caret to last position in document extending selection to new caret position. |
| 1179 |
|
|
fun void DocumentEndExtend=2319(,) |
| 1180 |
|
|
|
| 1181 |
|
|
# Move caret one page up. |
| 1182 |
|
|
fun void PageUp=2320(,) |
| 1183 |
|
|
|
| 1184 |
|
|
# Move caret one page up extending selection to new caret position. |
| 1185 |
|
|
fun void PageUpExtend=2321(,) |
| 1186 |
|
|
|
| 1187 |
|
|
# Move caret one page down. |
| 1188 |
|
|
fun void PageDown=2322(,) |
| 1189 |
|
|
|
| 1190 |
|
|
# Move caret one page down extending selection to new caret position. |
| 1191 |
|
|
fun void PageDownExtend=2323(,) |
| 1192 |
|
|
|
| 1193 |
|
|
# Switch from insert to overtype mode or the reverse. |
| 1194 |
|
|
fun void EditToggleOvertype=2324(,) |
| 1195 |
|
|
|
| 1196 |
|
|
# Cancel any modes such as call tip or auto-completion list display. |
| 1197 |
|
|
fun void Cancel=2325(,) |
| 1198 |
|
|
|
| 1199 |
|
|
# Delete the selection or if no selection, the character before the caret. |
| 1200 |
|
|
fun void DeleteBack=2326(,) |
| 1201 |
|
|
|
| 1202 |
|
|
# If selection is empty or all on one line replace the selection with a tab character. |
| 1203 |
|
|
# If more than one line selected, indent the lines. |
| 1204 |
|
|
fun void Tab=2327(,) |
| 1205 |
|
|
|
| 1206 |
|
|
# Dedent the selected lines. |
| 1207 |
|
|
fun void BackTab=2328(,) |
| 1208 |
|
|
|
| 1209 |
|
|
# Insert a new line, may use a CRLF, CR or LF depending on EOL mode. |
| 1210 |
|
|
fun void NewLine=2329(,) |
| 1211 |
|
|
|
| 1212 |
|
|
# Insert a Form Feed character. |
| 1213 |
|
|
fun void FormFeed=2330(,) |
| 1214 |
|
|
|
| 1215 |
|
|
# Move caret to before first visible character on line. |
| 1216 |
|
|
# If already there move to first character on line. |
| 1217 |
|
|
fun void VCHome=2331(,) |
| 1218 |
|
|
|
| 1219 |
|
|
# Like VCHome but extending selection to new caret position. |
| 1220 |
|
|
fun void VCHomeExtend=2332(,) |
| 1221 |
|
|
|
| 1222 |
|
|
# Magnify the displayed text by increasing the sizes by 1 point. |
| 1223 |
|
|
fun void ZoomIn=2333(,) |
| 1224 |
|
|
|
| 1225 |
|
|
# Make the displayed text smaller by decreasing the sizes by 1 point. |
| 1226 |
|
|
fun void ZoomOut=2334(,) |
| 1227 |
|
|
|
| 1228 |
|
|
# Delete the word to the left of the caret. |
| 1229 |
|
|
fun void DelWordLeft=2335(,) |
| 1230 |
|
|
|
| 1231 |
|
|
# Delete the word to the right of the caret. |
| 1232 |
|
|
fun void DelWordRight=2336(,) |
| 1233 |
|
|
|
| 1234 |
|
|
# Cut the line containing the caret. |
| 1235 |
|
|
fun void LineCut=2337(,) |
| 1236 |
|
|
|
| 1237 |
|
|
# Delete the line containing the caret. |
| 1238 |
|
|
fun void LineDelete=2338(,) |
| 1239 |
|
|
|
| 1240 |
|
|
# Switch the current line with the previous. |
| 1241 |
|
|
fun void LineTranspose=2339(,) |
| 1242 |
|
|
|
| 1243 |
|
|
# Duplicate the current line. |
| 1244 |
|
|
fun void LineDuplicate=2404(,) |
| 1245 |
|
|
|
| 1246 |
|
|
# Transform the selection to lower case. |
| 1247 |
|
|
fun void LowerCase=2340(,) |
| 1248 |
|
|
|
| 1249 |
|
|
# Transform the selection to upper case. |
| 1250 |
|
|
fun void UpperCase=2341(,) |
| 1251 |
|
|
|
| 1252 |
|
|
# Scroll the document down, keeping the caret visible. |
| 1253 |
|
|
fun void LineScrollDown=2342(,) |
| 1254 |
|
|
|
| 1255 |
|
|
# Scroll the document up, keeping the caret visible. |
| 1256 |
|
|
fun void LineScrollUp=2343(,) |
| 1257 |
|
|
|
| 1258 |
|
|
# Delete the selection or if no selection, the character before the caret. |
| 1259 |
|
|
# Will not delete the character before at the start of a line. |
| 1260 |
|
|
fun void DeleteBackNotLine=2344(,) |
| 1261 |
|
|
|
| 1262 |
|
|
# Move caret to first position on display line. |
| 1263 |
|
|
fun void HomeDisplay=2345(,) |
| 1264 |
|
|
|
| 1265 |
|
|
# Move caret to first position on display line extending selection to |
| 1266 |
|
|
# new caret position. |
| 1267 |
|
|
fun void HomeDisplayExtend=2346(,) |
| 1268 |
|
|
|
| 1269 |
|
|
# Move caret to last position on display line. |
| 1270 |
|
|
fun void LineEndDisplay=2347(,) |
| 1271 |
|
|
|
| 1272 |
|
|
# Move caret to last position on display line extending selection to new |
| 1273 |
|
|
# caret position. |
| 1274 |
|
|
fun void LineEndDisplayExtend=2348(,) |
| 1275 |
|
|
|
| 1276 |
|
|
# These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)? |
| 1277 |
|
|
# except they behave differently when word-wrap is enabled: |
| 1278 |
|
|
# They go first to the start / end of the display line, like (Home|LineEnd)Display |
| 1279 |
|
|
# The difference is that, the cursor is already at the point, it goes on to the start |
| 1280 |
|
|
# or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?. |
| 1281 |
|
|
|
| 1282 |
|
|
fun void HomeWrap=2349(,) |
| 1283 |
|
|
fun void HomeWrapExtend=2450(,) |
| 1284 |
|
|
fun void LineEndWrap=2451(,) |
| 1285 |
|
|
fun void LineEndWrapExtend=2452(,) |
| 1286 |
|
|
fun void VCHomeWrap=2453(,) |
| 1287 |
|
|
fun void VCHomeWrapExtend=2454(,) |
| 1288 |
|
|
|
| 1289 |
|
|
# Copy the line containing the caret. |
| 1290 |
|
|
fun void LineCopy=2455(,) |
| 1291 |
|
|
|
| 1292 |
|
|
# Move the caret inside current view if it's not there already. |
| 1293 |
|
|
fun void MoveCaretInsideView=2401(,) |
| 1294 |
|
|
|
| 1295 |
|
|
# How many characters are on a line, not including end of line characters? |
| 1296 |
|
|
fun int LineLength=2350(int line,) |
| 1297 |
|
|
|
| 1298 |
|
|
# Highlight the characters at two positions. |
| 1299 |
|
|
fun void BraceHighlight=2351(position pos1, position pos2) |
| 1300 |
|
|
|
| 1301 |
|
|
# Highlight the character at a position indicating there is no matching brace. |
| 1302 |
|
|
fun void BraceBadLight=2352(position pos,) |
| 1303 |
|
|
|
| 1304 |
|
|
# Find the position of a matching brace or INVALID_POSITION if no match. |
| 1305 |
|
|
fun position BraceMatch=2353(position pos,) |
| 1306 |
|
|
|
| 1307 |
|
|
# Are the end of line characters visible? |
| 1308 |
|
|
get bool GetViewEOL=2355(,) |
| 1309 |
|
|
|
| 1310 |
|
|
# Make the end of line characters visible or invisible. |
| 1311 |
|
|
set void SetViewEOL=2356(bool visible,) |
| 1312 |
|
|
|
| 1313 |
|
|
# Retrieve a pointer to the document object. |
| 1314 |
|
|
get int GetDocPointer=2357(,) |
| 1315 |
|
|
|
| 1316 |
|
|
# Change the document object used. |
| 1317 |
|
|
set void SetDocPointer=2358(, int pointer) |
| 1318 |
|
|
|
| 1319 |
|
|
# Set which document modification events are sent to the container. |
| 1320 |
|
|
set void SetModEventMask=2359(int mask,) |
| 1321 |
|
|
|
| 1322 |
|
|
enu EdgeVisualStyle=EDGE_ |
| 1323 |
|
|
val EDGE_NONE=0 |
| 1324 |
|
|
val EDGE_LINE=1 |
| 1325 |
|
|
val EDGE_BACKGROUND=2 |
| 1326 |
|
|
|
| 1327 |
|
|
# Retrieve the column number which text should be kept within. |
| 1328 |
|
|
get int GetEdgeColumn=2360(,) |
| 1329 |
|
|
|
| 1330 |
|
|
# Set the column number of the edge. |
| 1331 |
|
|
# If text goes past the edge then it is highlighted. |
| 1332 |
|
|
set void SetEdgeColumn=2361(int column,) |
| 1333 |
|
|
|
| 1334 |
|
|
# Retrieve the edge highlight mode. |
| 1335 |
|
|
get int GetEdgeMode=2362(,) |
| 1336 |
|
|
|
| 1337 |
|
|
# The edge may be displayed by a line (EDGE_LINE) or by highlighting text that |
| 1338 |
|
|
# goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE). |
| 1339 |
|
|
set void SetEdgeMode=2363(int mode,) |
| 1340 |
|
|
|
| 1341 |
|
|
# Retrieve the colour used in edge indication. |
| 1342 |
|
|
get colour GetEdgeColour=2364(,) |
| 1343 |
|
|
|
| 1344 |
|
|
# Change the colour used in edge indication. |
| 1345 |
|
|
set void SetEdgeColour=2365(colour edgeColour,) |
| 1346 |
|
|
|
| 1347 |
|
|
# Sets the current caret position to be the search anchor. |
| 1348 |
|
|
fun void SearchAnchor=2366(,) |
| 1349 |
|
|
|
| 1350 |
|
|
# Find some text starting at the search anchor. |
| 1351 |
|
|
# Does not ensure the selection is visible. |
| 1352 |
|
|
fun int SearchNext=2367(int flags, string text) |
| 1353 |
|
|
|
| 1354 |
|
|
# Find some text starting at the search anchor and moving backwards. |
| 1355 |
|
|
# Does not ensure the selection is visible. |
| 1356 |
|
|
fun int SearchPrev=2368(int flags, string text) |
| 1357 |
|
|
|
| 1358 |
|
|
# Retrieves the number of lines completely visible. |
| 1359 |
|
|
get int LinesOnScreen=2370(,) |
| 1360 |
|
|
|
| 1361 |
|
|
# Set whether a pop up menu is displayed automatically when the user presses |
| 1362 |
|
|
# the wrong mouse button. |
| 1363 |
|
|
fun void UsePopUp=2371(bool allowPopUp,) |
| 1364 |
|
|
|
| 1365 |
|
|
# Is the selection rectangular? The alternative is the more common stream selection. |
| 1366 |
|
|
get bool SelectionIsRectangle=2372(,) |
| 1367 |
|
|
|
| 1368 |
|
|
# Set the zoom level. This number of points is added to the size of all fonts. |
| 1369 |
|
|
# It may be positive to magnify or negative to reduce. |
| 1370 |
|
|
set void SetZoom=2373(int zoom,) |
| 1371 |
|
|
# Retrieve the zoom level. |
| 1372 |
|
|
get int GetZoom=2374(,) |
| 1373 |
|
|
|
| 1374 |
|
|
# Create a new document object. |
| 1375 |
|
|
# Starts with reference count of 1 and not selected into editor. |
| 1376 |
|
|
fun int CreateDocument=2375(,) |
| 1377 |
|
|
# Extend life of document. |
| 1378 |
|
|
fun void AddRefDocument=2376(, int doc) |
| 1379 |
|
|
# Release a reference to the document, deleting document if it fades to black. |
| 1380 |
|
|
fun void ReleaseDocument=2377(, int doc) |
| 1381 |
|
|
|
| 1382 |
|
|
# Get which document modification events are sent to the container. |
| 1383 |
|
|
get int GetModEventMask=2378(,) |
| 1384 |
|
|
|
| 1385 |
|
|
# Change internal focus flag. |
| 1386 |
|
|
set void SetFocus=2380(bool focus,) |
| 1387 |
|
|
# Get internal focus flag. |
| 1388 |
|
|
get bool GetFocus=2381(,) |
| 1389 |
|
|
|
| 1390 |
|
|
# Change error status - 0 = OK. |
| 1391 |
|
|
set void SetStatus=2382(int statusCode,) |
| 1392 |
|
|
# Get error status. |
| 1393 |
|
|
get int GetStatus=2383(,) |
| 1394 |
|
|
|
| 1395 |
|
|
# Set whether the mouse is captured when its button is pressed. |
| 1396 |
|
|
set void SetMouseDownCaptures=2384(bool captures,) |
| 1397 |
|
|
# Get whether mouse gets captured. |
| 1398 |
|
|
get bool GetMouseDownCaptures=2385(,) |
| 1399 |
|
|
|
| 1400 |
|
|
enu CursorShape=SC_CURSOR |
| 1401 |
|
|
val SC_CURSORNORMAL=-1 |
| 1402 |
|
|
val SC_CURSORWAIT=4 |
| 1403 |
|
|
# Sets the cursor to one of the SC_CURSOR* values. |
| 1404 |
|
|
set void SetCursor=2386(int cursorType,) |
| 1405 |
|
|
# Get cursor type. |
| 1406 |
|
|
get int GetCursor=2387(,) |
| 1407 |
|
|
|
| 1408 |
|
|
# Change the way control characters are displayed: |
| 1409 |
|
|
# If symbol is < 32, keep the drawn way, else, use the given character. |
| 1410 |
|
|
set void SetControlCharSymbol=2388(int symbol,) |
| 1411 |
|
|
# Get the way control characters are displayed. |
| 1412 |
|
|
get int GetControlCharSymbol=2389(,) |
| 1413 |
|
|
|
| 1414 |
|
|
# Move to the previous change in capitalisation. |
| 1415 |
|
|
fun void WordPartLeft=2390(,) |
| 1416 |
|
|
# Move to the previous change in capitalisation extending selection |
| 1417 |
|
|
# to new caret position. |
| 1418 |
|
|
fun void WordPartLeftExtend=2391(,) |
| 1419 |
|
|
# Move to the change next in capitalisation. |
| 1420 |
|
|
fun void WordPartRight=2392(,) |
| 1421 |
|
|
# Move to the next change in capitalisation extending selection |
| 1422 |
|
|
# to new caret position. |
| 1423 |
|
|
fun void WordPartRightExtend=2393(,) |
| 1424 |
|
|
|
| 1425 |
|
|
# Constants for use with SetVisiblePolicy, similar to SetCaretPolicy. |
| 1426 |
|
|
val VISIBLE_SLOP=0x01 |
| 1427 |
|
|
val VISIBLE_STRICT=0x04 |
| 1428 |
|
|
# Set the way the display area is determined when a particular line |
| 1429 |
|
|
# is to be moved to by Find, FindNext, GotoLine, etc. |
| 1430 |
|
|
fun void SetVisiblePolicy=2394(int visiblePolicy, int visibleSlop) |
| 1431 |
|
|
|
| 1432 |
|
|
# Delete back from the current position to the start of the line. |
| 1433 |
|
|
fun void DelLineLeft=2395(,) |
| 1434 |
|
|
|
| 1435 |
|
|
# Delete forwards from the current position to the end of the line. |
| 1436 |
|
|
fun void DelLineRight=2396(,) |
| 1437 |
|
|
|
| 1438 |
|
|
# Get and Set the xOffset (ie, horizonal scroll position). |
| 1439 |
|
|
set void SetXOffset=2397(int newOffset,) |
| 1440 |
|
|
get int GetXOffset=2398(,) |
| 1441 |
|
|
|
| 1442 |
|
|
# Set the last x chosen value to be the caret x position. |
| 1443 |
|
|
fun void ChooseCaretX=2399(,) |
| 1444 |
|
|
|
| 1445 |
|
|
# Set the focus to this Scintilla widget. |
| 1446 |
|
|
# GTK+ Specific. |
| 1447 |
|
|
fun void GrabFocus=2400(,) |
| 1448 |
|
|
|
| 1449 |
|
|
enu CaretPolicy = CARET_ |
| 1450 |
|
|
# Caret policy, used by SetXCaretPolicy and SetYCaretPolicy. |
| 1451 |
|
|
# If CARET_SLOP is set, we can define a slop value: caretSlop. |
| 1452 |
|
|
# This value defines an unwanted zone (UZ) where the caret is... unwanted. |
| 1453 |
|
|
# This zone is defined as a number of pixels near the vertical margins, |
| 1454 |
|
|
# and as a number of lines near the horizontal margins. |
| 1455 |
|
|
# By keeping the caret away from the edges, it is seen within its context, |
| 1456 |
|
|
# so it is likely that the identifier that the caret is on can be completely seen, |
| 1457 |
|
|
# and that the current line is seen with some of the lines following it which are |
| 1458 |
|
|
# often dependent on that line. |
| 1459 |
|
|
val CARET_SLOP=0x01 |
| 1460 |
|
|
# If CARET_STRICT is set, the policy is enforced... strictly. |
| 1461 |
|
|
# The caret is centred on the display if slop is not set, |
| 1462 |
|
|
# and cannot go in the UZ if slop is set. |
| 1463 |
|
|
val CARET_STRICT=0x04 |
| 1464 |
|
|
# If CARET_JUMPS is set, the display is moved more energetically |
| 1465 |
|
|
# so the caret can move in the same direction longer before the policy is applied again. |
| 1466 |
|
|
val CARET_JUMPS=0x10 |
| 1467 |
|
|
# If CARET_EVEN is not set, instead of having symmetrical UZs, |
| 1468 |
|
|
# the left and bottom UZs are extended up to right and top UZs respectively. |
| 1469 |
|
|
# This way, we favour the displaying of useful information: the begining of lines, |
| 1470 |
|
|
# where most code reside, and the lines after the caret, eg. the body of a function. |
| 1471 |
|
|
val CARET_EVEN=0x08 |
| 1472 |
|
|
|
| 1473 |
|
|
# Set the way the caret is kept visible when going sideway. |
| 1474 |
|
|
# The exclusion zone is given in pixels. |
| 1475 |
|
|
fun void SetXCaretPolicy=2402(int caretPolicy, int caretSlop) |
| 1476 |
|
|
|
| 1477 |
|
|
# Set the way the line the caret is on is kept visible. |
| 1478 |
|
|
# The exclusion zone is given in lines. |
| 1479 |
|
|
fun void SetYCaretPolicy=2403(int caretPolicy, int caretSlop) |
| 1480 |
|
|
|
| 1481 |
|
|
# Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE). |
| 1482 |
|
|
set void SetPrintWrapMode=2406(int mode,) |
| 1483 |
|
|
|
| 1484 |
|
|
# Is printing line wrapped? |
| 1485 |
|
|
get int GetPrintWrapMode=2407(,) |
| 1486 |
|
|
|
| 1487 |
|
|
# Set a fore colour for active hotspots. |
| 1488 |
|
|
set void SetHotspotActiveFore=2410(bool useSetting, colour fore) |
| 1489 |
|
|
|
| 1490 |
|
|
# Set a back colour for active hotspots. |
| 1491 |
|
|
set void SetHotspotActiveBack=2411(bool useSetting, colour back) |
| 1492 |
|
|
|
| 1493 |
|
|
# Enable / Disable underlining active hotspots. |
| 1494 |
|
|
set void SetHotspotActiveUnderline=2412(bool underline,) |
| 1495 |
|
|
|
| 1496 |
|
|
# Limit hotspots to single line so hotspots on two lines don't merge. |
| 1497 |
|
|
set void SetHotspotSingleLine=2421(bool singleLine,) |
| 1498 |
|
|
|
| 1499 |
|
|
# Move caret between paragraphs (delimited by empty lines). |
| 1500 |
|
|
fun void ParaDown=2413(,) |
| 1501 |
|
|
fun void ParaDownExtend=2414(,) |
| 1502 |
|
|
fun void ParaUp=2415(,) |
| 1503 |
|
|
fun void ParaUpExtend=2416(,) |
| 1504 |
|
|
|
| 1505 |
|
|
# Given a valid document position, return the previous position taking code |
| 1506 |
|
|
# page into account. Returns 0 if passed 0. |
| 1507 |
|
|
fun position PositionBefore=2417(position pos,) |
| 1508 |
|
|
|
| 1509 |
|
|
# Given a valid document position, return the next position taking code |
| 1510 |
|
|
# page into account. Maximum value returned is the last position in the document. |
| 1511 |
|
|
fun position PositionAfter=2418(position pos,) |
| 1512 |
|
|
|
| 1513 |
|
|
# Copy a range of text to the clipboard. Positions are clipped into the document. |
| 1514 |
|
|
fun void CopyRange=2419(position start, position end) |
| 1515 |
|
|
|
| 1516 |
|
|
# Copy argument text to the clipboard. |
| 1517 |
|
|
fun void CopyText=2420(int length, string text) |
| 1518 |
|
|
|
| 1519 |
|
|
enu SelectionMode=SC_SEL_ |
| 1520 |
|
|
val SC_SEL_STREAM=0 |
| 1521 |
|
|
val SC_SEL_RECTANGLE=1 |
| 1522 |
|
|
val SC_SEL_LINES=2 |
| 1523 |
|
|
|
| 1524 |
|
|
# Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE) or |
| 1525 |
|
|
# by lines (SC_SEL_LINES). |
| 1526 |
|
|
set void SetSelectionMode=2422(int mode,) |
| 1527 |
|
|
|
| 1528 |
|
|
# Get the mode of the current selection. |
| 1529 |
|
|
get int GetSelectionMode=2423(,) |
| 1530 |
|
|
|
| 1531 |
|
|
# Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line). |
| 1532 |
|
|
fun position GetLineSelStartPosition=2424(int line,) |
| 1533 |
|
|
|
| 1534 |
|
|
# Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line). |
| 1535 |
|
|
fun position GetLineSelEndPosition=2425(int line,) |
| 1536 |
|
|
|
| 1537 |
|
|
## RectExtended rectangular selection moves |
| 1538 |
|
|
# Move caret down one line, extending rectangular selection to new caret position. |
| 1539 |
|
|
fun void LineDownRectExtend=2426(,) |
| 1540 |
|
|
|
| 1541 |
|
|
# Move caret up one line, extending rectangular selection to new caret position. |
| 1542 |
|
|
fun void LineUpRectExtend=2427(,) |
| 1543 |
|
|
|
| 1544 |
|
|
# Move caret left one character, extending rectangular selection to new caret position. |
| 1545 |
|
|
fun void CharLeftRectExtend=2428(,) |
| 1546 |
|
|
|
| 1547 |
|
|
# Move caret right one character, extending rectangular selection to new caret position. |
| 1548 |
|
|
fun void CharRightRectExtend=2429(,) |
| 1549 |
|
|
|
| 1550 |
|
|
# Move caret to first position on line, extending rectangular selection to new caret position. |
| 1551 |
|
|
fun void HomeRectExtend=2430(,) |
| 1552 |
|
|
|
| 1553 |
|
|
# Move caret to before first visible character on line. |
| 1554 |
|
|
# If already there move to first character on line. |
| 1555 |
|
|
# In either case, extend rectangular selection to new caret position. |
| 1556 |
|
|
fun void VCHomeRectExtend=2431(,) |
| 1557 |
|
|
|
| 1558 |
|
|
# Move caret to last position on line, extending rectangular selection to new caret position. |
| 1559 |
|
|
fun void LineEndRectExtend=2432(,) |
| 1560 |
|
|
|
| 1561 |
|
|
# Move caret one page up, extending rectangular selection to new caret position. |
| 1562 |
|
|
fun void PageUpRectExtend=2433(,) |
| 1563 |
|
|
|
| 1564 |
|
|
# Move caret one page down, extending rectangular selection to new caret position. |
| 1565 |
|
|
fun void PageDownRectExtend=2434(,) |
| 1566 |
|
|
|
| 1567 |
|
|
|
| 1568 |
|
|
# Move caret to top of page, or one page up if already at top of page. |
| 1569 |
|
|
fun void StutteredPageUp=2435(,) |
| 1570 |
|
|
|
| 1571 |
|
|
# Move caret to top of page, or one page up if already at top of page, extending selection to new caret position. |
| 1572 |
|
|
fun void StutteredPageUpExtend=2436(,) |
| 1573 |
|
|
|
| 1574 |
|
|
# Move caret to bottom of page, or one page down if already at bottom of page. |
| 1575 |
|
|
fun void StutteredPageDown=2437(,) |
| 1576 |
|
|
|
| 1577 |
|
|
# Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position. |
| 1578 |
|
|
fun void StutteredPageDownExtend=2438(,) |
| 1579 |
|
|
|
| 1580 |
|
|
|
| 1581 |
|
|
# Move caret left one word, position cursor at end of word. |
| 1582 |
|
|
fun void WordLeftEnd=2439(,) |
| 1583 |
|
|
|
| 1584 |
|
|
# Move caret left one word, position cursor at end of word, extending selection to new caret position. |
| 1585 |
|
|
fun void WordLeftEndExtend=2440(,) |
| 1586 |
|
|
|
| 1587 |
|
|
# Move caret right one word, position cursor at end of word. |
| 1588 |
|
|
fun void WordRightEnd=2441(,) |
| 1589 |
|
|
|
| 1590 |
|
|
# Move caret right one word, position cursor at end of word, extending selection to new caret position. |
| 1591 |
|
|
fun void WordRightEndExtend=2442(,) |
| 1592 |
|
|
|
| 1593 |
|
|
# Set the set of characters making up whitespace for when moving or selecting by word. |
| 1594 |
|
|
# Should be called after SetWordChars. |
| 1595 |
|
|
set void SetWhitespaceChars=2443(, string characters) |
| 1596 |
|
|
|
| 1597 |
|
|
# Reset the set of characters for whitespace and word characters to the defaults. |
| 1598 |
|
|
fun void SetCharsDefault=2444(,) |
| 1599 |
|
|
|
| 1600 |
|
|
# Get currently selected item position in the auto-completion list |
| 1601 |
|
|
fun int AutoCGetCurrent=2445(,) |
| 1602 |
|
|
|
| 1603 |
|
|
# Enlarge the document to a particular size of text bytes. |
| 1604 |
|
|
fun void Allocate=2446(int bytes,) |
| 1605 |
|
|
|
| 1606 |
|
|
# Returns the target converted to UTF8. |
| 1607 |
|
|
# Return the length in bytes. |
| 1608 |
|
|
fun int TargetAsUTF8=2447(, stringresult s) |
| 1609 |
|
|
|
| 1610 |
|
|
# Set the length of the utf8 argument for calling EncodedFromUTF8. |
| 1611 |
|
|
# Set to -1 and the string will be measured to the first nul. |
| 1612 |
|
|
fun void SetLengthForEncode=2448(int bytes,) |
| 1613 |
|
|
|
| 1614 |
|
|
# Translates a UTF8 string into the document encoding. |
| 1615 |
|
|
# Return the length of the result in bytes. |
| 1616 |
|
|
# On error return 0. |
| 1617 |
|
|
fun int EncodedFromUTF8=2449(string utf8, stringresult encoded) |
| 1618 |
|
|
|
| 1619 |
|
|
# Find the position of a column on a line taking into account tabs and |
| 1620 |
|
|
# multi-byte characters. If beyond end of line, return line end position. |
| 1621 |
|
|
fun int FindColumn=2456(int line, int column) |
| 1622 |
|
|
|
| 1623 |
|
|
# Can the caret preferred x position only be changed by explicit movement commands? |
| 1624 |
|
|
get bool GetCaretSticky=2457(,) |
| 1625 |
|
|
|
| 1626 |
|
|
# Stop the caret preferred x position changing when the user types. |
| 1627 |
|
|
set void SetCaretSticky=2458(bool useCaretStickyBehaviour,) |
| 1628 |
|
|
|
| 1629 |
|
|
# Switch between sticky and non-sticky: meant to be bound to a key. |
| 1630 |
|
|
fun void ToggleCaretSticky=2459(,) |
| 1631 |
|
|
|
| 1632 |
|
|
# Start notifying the container of all key presses and commands. |
| 1633 |
|
|
fun void StartRecord=3001(,) |
| 1634 |
|
|
|
| 1635 |
|
|
# Stop notifying the container of all key presses and commands. |
| 1636 |
|
|
fun void StopRecord=3002(,) |
| 1637 |
|
|
|
| 1638 |
|
|
# Set the lexing language of the document. |
| 1639 |
|
|
set void SetLexer=4001(int lexer,) |
| 1640 |
|
|
|
| 1641 |
|
|
# Retrieve the lexing language of the document. |
| 1642 |
|
|
get int GetLexer=4002(,) |
| 1643 |
|
|
|
| 1644 |
|
|
# Colourise a segment of the document using the current lexing language. |
| 1645 |
|
|
fun void Colourise=4003(position start, position end) |
| 1646 |
|
|
|
| 1647 |
|
|
# Set up a value that may be used by a lexer for some optional feature. |
| 1648 |
|
|
set void SetProperty=4004(string key, string value) |
| 1649 |
|
|
|
| 1650 |
|
|
# Maximum value of keywordSet parameter of SetKeyWords. |
| 1651 |
|
|
val KEYWORDSET_MAX=8 |
| 1652 |
|
|
|
| 1653 |
|
|
# Set up the key words used by the lexer. |
| 1654 |
|
|
set void SetKeyWords=4005(int keywordSet, string keyWords) |
| 1655 |
|
|
|
| 1656 |
|
|
# Set the lexing language of the document based on string name. |
| 1657 |
|
|
set void SetLexerLanguage=4006(, string language) |
| 1658 |
|
|
|
| 1659 |
|
|
# Load a lexer library (dll / so). |
| 1660 |
|
|
fun void LoadLexerLibrary=4007(, string path) |
| 1661 |
|
|
|
| 1662 |
|
|
# Retrieve a "property" value previously set with SetProperty. |
| 1663 |
|
|
fun int GetProperty=4008(string key, stringresult buf) |
| 1664 |
|
|
|
| 1665 |
|
|
# Retrieve a "property" value previously set with SetProperty, |
| 1666 |
|
|
# with "$()" variable replacement on returned buffer. |
| 1667 |
|
|
fun int GetPropertyExpanded=4009(string key, stringresult buf) |
| 1668 |
|
|
|
| 1669 |
|
|
# Retrieve a "property" value previously set with SetProperty, |
| 1670 |
|
|
# interpreted as an int AFTER any "$()" variable replacement. |
| 1671 |
|
|
get int GetPropertyInt=4010(string key,) |
| 1672 |
|
|
|
| 1673 |
|
|
# Notifications |
| 1674 |
|
|
# Type of modification and the action which caused the modification. |
| 1675 |
|
|
# These are defined as a bit mask to make it easy to specify which notifications are wanted. |
| 1676 |
|
|
# One bit is set from each of SC_MOD_* and SC_PERFORMED_*. |
| 1677 |
|
|
enu ModificationFlags=SC_MOD_ SC_PERFORMED_ SC_LAST SC_MULTI |
| 1678 |
|
|
val SC_MOD_INSERTTEXT=0x1 |
| 1679 |
|
|
val SC_MOD_DELETETEXT=0x2 |
| 1680 |
|
|
val SC_MOD_CHANGESTYLE=0x4 |
| 1681 |
|
|
val SC_MOD_CHANGEFOLD=0x8 |
| 1682 |
|
|
val SC_PERFORMED_USER=0x10 |
| 1683 |
|
|
val SC_PERFORMED_UNDO=0x20 |
| 1684 |
|
|
val SC_PERFORMED_REDO=0x40 |
| 1685 |
|
|
val SC_MULTISTEPUNDOREDO=0x80 |
| 1686 |
|
|
val SC_LASTSTEPINUNDOREDO=0x100 |
| 1687 |
|
|
val SC_MOD_CHANGEMARKER=0x200 |
| 1688 |
|
|
val SC_MOD_BEFOREINSERT=0x400 |
| 1689 |
|
|
val SC_MOD_BEFOREDELETE=0x800 |
| 1690 |
|
|
val SC_MULTILINEUNDOREDO=0x1000 |
| 1691 |
|
|
val SC_MODEVENTMASKALL=0x1FFF |
| 1692 |
|
|
|
| 1693 |
|
|
# For compatibility, these go through the COMMAND notification rather than NOTIFY |
| 1694 |
|
|
# and should have had exactly the same values as the EN_* constants. |
| 1695 |
|
|
# Unfortunately the SETFOCUS and KILLFOCUS are flipped over from EN_* |
| 1696 |
|
|
# As clients depend on these constants, this will not be changed. |
| 1697 |
|
|
val SCEN_CHANGE=768 |
| 1698 |
|
|
val SCEN_SETFOCUS=512 |
| 1699 |
|
|
val SCEN_KILLFOCUS=256 |
| 1700 |
|
|
|
| 1701 |
|
|
# Symbolic key codes and modifier flags. |
| 1702 |
|
|
# ASCII and other printable characters below 256. |
| 1703 |
|
|
# Extended keys above 300. |
| 1704 |
|
|
|
| 1705 |
|
|
enu Keys=SCK_ |
| 1706 |
|
|
val SCK_DOWN=300 |
| 1707 |
|
|
val SCK_UP=301 |
| 1708 |
|
|
val SCK_LEFT=302 |
| 1709 |
|
|
val SCK_RIGHT=303 |
| 1710 |
|
|
val SCK_HOME=304 |
| 1711 |
|
|
val SCK_END=305 |
| 1712 |
|
|
val SCK_PRIOR=306 |
| 1713 |
|
|
val SCK_NEXT=307 |
| 1714 |
|
|
val SCK_DELETE=308 |
| 1715 |
|
|
val SCK_INSERT=309 |
| 1716 |
|
|
val SCK_ESCAPE=7 |
| 1717 |
|
|
val SCK_BACK=8 |
| 1718 |
|
|
val SCK_TAB=9 |
| 1719 |
|
|
val SCK_RETURN=13 |
| 1720 |
|
|
val SCK_ADD=310 |
| 1721 |
|
|
val SCK_SUBTRACT=311 |
| 1722 |
|
|
val SCK_DIVIDE=312 |
| 1723 |
|
|
|
| 1724 |
|
|
enu KeyMod=SCMOD_ |
| 1725 |
|
|
val SCMOD_SHIFT=1 |
| 1726 |
|
|
val SCMOD_CTRL=2 |
| 1727 |
|
|
val SCMOD_ALT=4 |
| 1728 |
|
|
|
| 1729 |
|
|
################################################ |
| 1730 |
|
|
# For SciLexer.h |
| 1731 |
|
|
enu Lexer=SCLEX_ |
| 1732 |
|
|
val SCLEX_CONTAINER=0 |
| 1733 |
|
|
val SCLEX_NULL=1 |
| 1734 |
|
|
val SCLEX_PYTHON=2 |
| 1735 |
|
|
val SCLEX_CPP=3 |
| 1736 |
|
|
val SCLEX_HTML=4 |
| 1737 |
|
|
val SCLEX_XML=5 |
| 1738 |
|
|
val SCLEX_PERL=6 |
| 1739 |
|
|
val SCLEX_SQL=7 |
| 1740 |
|
|
val SCLEX_VB=8 |
| 1741 |
|
|
val SCLEX_PROPERTIES=9 |
| 1742 |
|
|
val SCLEX_ERRORLIST=10 |
| 1743 |
|
|
val SCLEX_MAKEFILE=11 |
| 1744 |
|
|
val SCLEX_BATCH=12 |
| 1745 |
|
|
val SCLEX_XCODE=13 |
| 1746 |
|
|
val SCLEX_LATEX=14 |
| 1747 |
|
|
val SCLEX_LUA=15 |
| 1748 |
|
|
val SCLEX_DIFF=16 |
| 1749 |
|
|
val SCLEX_CONF=17 |
| 1750 |
|
|
val SCLEX_PASCAL=18 |
| 1751 |
|
|
val SCLEX_AVE=19 |
| 1752 |
|
|
val SCLEX_ADA=20 |
| 1753 |
|
|
val SCLEX_LISP=21 |
| 1754 |
|
|
val SCLEX_RUBY=22 |
| 1755 |
|
|
val SCLEX_EIFFEL=23 |
| 1756 |
|
|
val SCLEX_EIFFELKW=24 |
| 1757 |
|
|
val SCLEX_TCL=25 |
| 1758 |
|
|
val SCLEX_NNCRONTAB=26 |
| 1759 |
|
|
val SCLEX_BULLANT=27 |
| 1760 |
|
|
val SCLEX_VBSCRIPT=28 |
| 1761 |
|
|
val SCLEX_BAAN=31 |
| 1762 |
|
|
val SCLEX_MATLAB=32 |
| 1763 |
|
|
val SCLEX_SCRIPTOL=33 |
| 1764 |
|
|
val SCLEX_ASM=34 |
| 1765 |
|
|
val SCLEX_CPPNOCASE=35 |
| 1766 |
|
|
val SCLEX_FORTRAN=36 |
| 1767 |
|
|
val SCLEX_F77=37 |
| 1768 |
|
|
val SCLEX_CSS=38 |
| 1769 |
|
|
val SCLEX_POV=39 |
| 1770 |
|
|
val SCLEX_LOUT=40 |
| 1771 |
|
|
val SCLEX_ESCRIPT=41 |
| 1772 |
|
|
val SCLEX_PS=42 |
| 1773 |
|
|
val SCLEX_NSIS=43 |
| 1774 |
|
|
val SCLEX_MMIXAL=44 |
| 1775 |
|
|
val SCLEX_CLW=45 |
| 1776 |
|
|
val SCLEX_CLWNOCASE=46 |
| 1777 |
|
|
val SCLEX_LOT=47 |
| 1778 |
|
|
val SCLEX_YAML=48 |
| 1779 |
|
|
val SCLEX_TEX=49 |
| 1780 |
|
|
val SCLEX_METAPOST=50 |
| 1781 |
|
|
val SCLEX_POWERBASIC=51 |
| 1782 |
|
|
val SCLEX_FORTH=52 |
| 1783 |
|
|
val SCLEX_ERLANG=53 |
| 1784 |
|
|
val SCLEX_OCTAVE=54 |
| 1785 |
|
|
val SCLEX_MSSQL=55 |
| 1786 |
|
|
val SCLEX_VERILOG=56 |
| 1787 |
|
|
val SCLEX_KIX=57 |
| 1788 |
|
|
val SCLEX_GUI4CLI=58 |
| 1789 |
|
|
val SCLEX_SPECMAN=59 |
| 1790 |
|
|
val SCLEX_AU3=60 |
| 1791 |
|
|
val SCLEX_APDL=61 |
| 1792 |
|
|
val SCLEX_BASH=62 |
| 1793 |
|
|
val SCLEX_ASN1=63 |
| 1794 |
|
|
val SCLEX_VHDL=64 |
| 1795 |
|
|
val SCLEX_CAML=65 |
| 1796 |
|
|
val SCLEX_BLITZBASIC=66 |
| 1797 |
|
|
val SCLEX_PUREBASIC=67 |
| 1798 |
|
|
val SCLEX_HASKELL=68 |
| 1799 |
|
|
val SCLEX_PHPSCRIPT=69 |
| 1800 |
|
|
val SCLEX_TADS3=70 |
| 1801 |
|
|
val SCLEX_REBOL=71 |
| 1802 |
|
|
val SCLEX_SMALLTALK=72 |
| 1803 |
|
|
val SCLEX_FLAGSHIP=73 |
| 1804 |
|
|
val SCLEX_CSOUND=74 |
| 1805 |
|
|
val SCLEX_FREEBASIC=75 |
| 1806 |
|
|
|
| 1807 |
|
|
# When a lexer specifies its language as SCLEX_AUTOMATIC it receives a |
| 1808 |
|
|
# value assigned in sequence from SCLEX_AUTOMATIC+1. |
| 1809 |
|
|
val SCLEX_AUTOMATIC=1000 |
| 1810 |
|
|
# Lexical states for SCLEX_PYTHON |
| 1811 |
|
|
lex Python=SCLEX_PYTHON SCE_P_ |
| 1812 |
|
|
val SCE_P_DEFAULT=0 |
| 1813 |
|
|
val SCE_P_COMMENTLINE=1 |
| 1814 |
|
|
val SCE_P_NUMBER=2 |
| 1815 |
|
|
val SCE_P_STRING=3 |
| 1816 |
|
|
val SCE_P_CHARACTER=4 |
| 1817 |
|
|
val SCE_P_WORD=5 |
| 1818 |
|
|
val SCE_P_TRIPLE=6 |
| 1819 |
|
|
val SCE_P_TRIPLEDOUBLE=7 |
| 1820 |
|
|
val SCE_P_CLASSNAME=8 |
| 1821 |
|
|
val SCE_P_DEFNAME=9 |
| 1822 |
|
|
val SCE_P_OPERATOR=10 |
| 1823 |
|
|
val SCE_P_IDENTIFIER=11 |
| 1824 |
|
|
val SCE_P_COMMENTBLOCK=12 |
| 1825 |
|
|
val SCE_P_STRINGEOL=13 |
| 1826 |
|
|
# Lexical states for SCLEX_CPP |
| 1827 |
|
|
lex Cpp=SCLEX_CPP SCE_C_ |
| 1828 |
|
|
lex Pascal=SCLEX_PASCAL SCE_C_ |
| 1829 |
|
|
lex TCL=SCLEX_TCL SCE_C_ |
| 1830 |
|
|
lex BullAnt=SCLEX_BULLANT SCE_C_ |
| 1831 |
|
|
val SCE_C_DEFAULT=0 |
| 1832 |
|
|
val SCE_C_COMMENT=1 |
| 1833 |
|
|
val SCE_C_COMMENTLINE=2 |
| 1834 |
|
|
val SCE_C_COMMENTDOC=3 |
| 1835 |
|
|
val SCE_C_NUMBER=4 |
| 1836 |
|
|
val SCE_C_WORD=5 |
| 1837 |
|
|
val SCE_C_STRING=6 |
| 1838 |
|
|
val SCE_C_CHARACTER=7 |
| 1839 |
|
|
val SCE_C_UUID=8 |
| 1840 |
|
|
val SCE_C_PREPROCESSOR=9 |
| 1841 |
|
|
val SCE_C_OPERATOR=10 |
| 1842 |
|
|
val SCE_C_IDENTIFIER=11 |
| 1843 |
|
|
val SCE_C_STRINGEOL=12 |
| 1844 |
|
|
val SCE_C_VERBATIM=13 |
| 1845 |
|
|
val SCE_C_REGEX=14 |
| 1846 |
|
|
val SCE_C_COMMENTLINEDOC=15 |
| 1847 |
|
|
val SCE_C_WORD2=16 |
| 1848 |
|
|
val SCE_C_COMMENTDOCKEYWORD=17 |
| 1849 |
|
|
val SCE_C_COMMENTDOCKEYWORDERROR=18 |
| 1850 |
|
|
val SCE_C_GLOBALCLASS=19 |
| 1851 |
|
|
# Lexical states for SCLEX_HTML, SCLEX_XML |
| 1852 |
|
|
lex HTML=SCLEX_HTML SCE_H |
| 1853 |
|
|
lex XML=SCLEX_XML SCE_H |
| 1854 |
|
|
lex ASP=SCLEX_ASP SCE_H |
| 1855 |
|
|
lex PHP=SCLEX_PHP SCE_H |
| 1856 |
|
|
val SCE_H_DEFAULT=0 |
| 1857 |
|
|
val SCE_H_TAG=1 |
| 1858 |
|
|
val SCE_H_TAGUNKNOWN=2 |
| 1859 |
|
|
val SCE_H_ATTRIBUTE=3 |
| 1860 |
|
|
val SCE_H_ATTRIBUTEUNKNOWN=4 |
| 1861 |
|
|
val SCE_H_NUMBER=5 |
| 1862 |
|
|
val SCE_H_DOUBLESTRING=6 |
| 1863 |
|
|
val SCE_H_SINGLESTRING=7 |
| 1864 |
|
|
val SCE_H_OTHER=8 |
| 1865 |
|
|
val SCE_H_COMMENT=9 |
| 1866 |
|
|
val SCE_H_ENTITY=10 |
| 1867 |
|
|
# XML and ASP |
| 1868 |
|
|
val SCE_H_TAGEND=11 |
| 1869 |
|
|
val SCE_H_XMLSTART=12 |
| 1870 |
|
|
val SCE_H_XMLEND=13 |
| 1871 |
|
|
val SCE_H_SCRIPT=14 |
| 1872 |
|
|
val SCE_H_ASP=15 |
| 1873 |
|
|
val SCE_H_ASPAT=16 |
| 1874 |
|
|
val SCE_H_CDATA=17 |
| 1875 |
|
|
val SCE_H_QUESTION=18 |
| 1876 |
|
|
# More HTML |
| 1877 |
|
|
val SCE_H_VALUE=19 |
| 1878 |
|
|
# X-Code |
| 1879 |
|
|
val SCE_H_XCCOMMENT=20 |
| 1880 |
|
|
# SGML |
| 1881 |
|
|
val SCE_H_SGML_DEFAULT=21 |
| 1882 |
|
|
val SCE_H_SGML_COMMAND=22 |
| 1883 |
|
|
val SCE_H_SGML_1ST_PARAM=23 |
| 1884 |
|
|
val SCE_H_SGML_DOUBLESTRING=24 |
| 1885 |
|
|
val SCE_H_SGML_SIMPLESTRING=25 |
| 1886 |
|
|
val SCE_H_SGML_ERROR=26 |
| 1887 |
|
|
val SCE_H_SGML_SPECIAL=27 |
| 1888 |
|
|
val SCE_H_SGML_ENTITY=28 |
| 1889 |
|
|
val SCE_H_SGML_COMMENT=29 |
| 1890 |
|
|
val SCE_H_SGML_1ST_PARAM_COMMENT=30 |
| 1891 |
|
|
val SCE_H_SGML_BLOCK_DEFAULT=31 |
| 1892 |
|
|
# Embedded Javascript |
| 1893 |
|
|
val SCE_HJ_START=40 |
| 1894 |
|
|
val SCE_HJ_DEFAULT=41 |
| 1895 |
|
|
val SCE_HJ_COMMENT=42 |
| 1896 |
|
|
val SCE_HJ_COMMENTLINE=43 |
| 1897 |
|
|
val SCE_HJ_COMMENTDOC=44 |
| 1898 |
|
|
val SCE_HJ_NUMBER=45 |
| 1899 |
|
|
val SCE_HJ_WORD=46 |
| 1900 |
|
|
val SCE_HJ_KEYWORD=47 |
| 1901 |
|
|
val SCE_HJ_DOUBLESTRING=48 |
| 1902 |
|
|
val SCE_HJ_SINGLESTRING=49 |
| 1903 |
|
|
val SCE_HJ_SYMBOLS=50 |
| 1904 |
|
|
val SCE_HJ_STRINGEOL=51 |
| 1905 |
|
|
val SCE_HJ_REGEX=52 |
| 1906 |
|
|
# ASP Javascript |
| 1907 |
|
|
val SCE_HJA_START=55 |
| 1908 |
|
|
val SCE_HJA_DEFAULT=56 |
| 1909 |
|
|
val SCE_HJA_COMMENT=57 |
| 1910 |
|
|
val SCE_HJA_COMMENTLINE=58 |
| 1911 |
|
|
val SCE_HJA_COMMENTDOC=59 |
| 1912 |
|
|
val SCE_HJA_NUMBER=60 |
| 1913 |
|
|
val SCE_HJA_WORD=61 |
| 1914 |
|
|
val SCE_HJA_KEYWORD=62 |
| 1915 |
|
|
val SCE_HJA_DOUBLESTRING=63 |
| 1916 |
|
|
val SCE_HJA_SINGLESTRING=64 |
| 1917 |
|
|
val SCE_HJA_SYMBOLS=65 |
| 1918 |
|
|
val SCE_HJA_STRINGEOL=66 |
| 1919 |
|
|
val SCE_HJA_REGEX=67 |
| 1920 |
|
|
# Embedded VBScript |
| 1921 |
|
|
val SCE_HB_START=70 |
| 1922 |
|
|
val SCE_HB_DEFAULT=71 |
| 1923 |
|
|
val SCE_HB_COMMENTLINE=72 |
| 1924 |
|
|
val SCE_HB_NUMBER=73 |
| 1925 |
|
|
val SCE_HB_WORD=74 |
| 1926 |
|
|
val SCE_HB_STRING=75 |
| 1927 |
|
|
val SCE_HB_IDENTIFIER=76 |
| 1928 |
|
|
val SCE_HB_STRINGEOL=77 |
| 1929 |
|
|
# ASP VBScript |
| 1930 |
|
|
val SCE_HBA_START=80 |
| 1931 |
|
|
val SCE_HBA_DEFAULT=81 |
| 1932 |
|
|
val SCE_HBA_COMMENTLINE=82 |
| 1933 |
|
|
val SCE_HBA_NUMBER=83 |
| 1934 |
|
|
val SCE_HBA_WORD=84 |
| 1935 |
|
|
val SCE_HBA_STRING=85 |
| 1936 |
|
|
val SCE_HBA_IDENTIFIER=86 |
| 1937 |
|
|
val SCE_HBA_STRINGEOL=87 |
| 1938 |
|
|
# Embedded Python |
| 1939 |
|
|
val SCE_HP_START=90 |
| 1940 |
|
|
val SCE_HP_DEFAULT=91 |
| 1941 |
|
|
val SCE_HP_COMMENTLINE=92 |
| 1942 |
|
|
val SCE_HP_NUMBER=93 |
| 1943 |
|
|
val SCE_HP_STRING=94 |
| 1944 |
|
|
val SCE_HP_CHARACTER=95 |
| 1945 |
|
|
val SCE_HP_WORD=96 |
| 1946 |
|
|
val SCE_HP_TRIPLE=97 |
| 1947 |
|
|
val SCE_HP_TRIPLEDOUBLE=98 |
| 1948 |
|
|
val SCE_HP_CLASSNAME=99 |
| 1949 |
|
|
val SCE_HP_DEFNAME=100 |
| 1950 |
|
|
val SCE_HP_OPERATOR=101 |
| 1951 |
|
|
val SCE_HP_IDENTIFIER=102 |
| 1952 |
|
|
# PHP |
| 1953 |
|
|
val SCE_HPHP_COMPLEX_VARIABLE=104 |
| 1954 |
|
|
# ASP Python |
| 1955 |
|
|
val SCE_HPA_START=105 |
| 1956 |
|
|
val SCE_HPA_DEFAULT=106 |
| 1957 |
|
|
val SCE_HPA_COMMENTLINE=107 |
| 1958 |
|
|
val SCE_HPA_NUMBER=108 |
| 1959 |
|
|
val SCE_HPA_STRING=109 |
| 1960 |
|
|
val SCE_HPA_CHARACTER=110 |
| 1961 |
|
|
val SCE_HPA_WORD=111 |
| 1962 |
|
|
val SCE_HPA_TRIPLE=112 |
| 1963 |
|
|
val SCE_HPA_TRIPLEDOUBLE=113 |
| 1964 |
|
|
val SCE_HPA_CLASSNAME=114 |
| 1965 |
|
|
val SCE_HPA_DEFNAME=115 |
| 1966 |
|
|
val SCE_HPA_OPERATOR=116 |
| 1967 |
|
|
val SCE_HPA_IDENTIFIER=117 |
| 1968 |
|
|
# PHP |
| 1969 |
|
|
val SCE_HPHP_DEFAULT=118 |
| 1970 |
|
|
val SCE_HPHP_HSTRING=119 |
| 1971 |
|
|
val SCE_HPHP_SIMPLESTRING=120 |
| 1972 |
|
|
val SCE_HPHP_WORD=121 |
| 1973 |
|
|
val SCE_HPHP_NUMBER=122 |
| 1974 |
|
|
val SCE_HPHP_VARIABLE=123 |
| 1975 |
|
|
val SCE_HPHP_COMMENT=124 |
| 1976 |
|
|
val SCE_HPHP_COMMENTLINE=125 |
| 1977 |
|
|
val SCE_HPHP_HSTRING_VARIABLE=126 |
| 1978 |
|
|
val SCE_HPHP_OPERATOR=127 |
| 1979 |
|
|
# Lexical states for SCLEX_PERL |
| 1980 |
|
|
lex Perl=SCLEX_PERL SCE_PL_ |
| 1981 |
|
|
val SCE_PL_DEFAULT=0 |
| 1982 |
|
|
val SCE_PL_ERROR=1 |
| 1983 |
|
|
val SCE_PL_COMMENTLINE=2 |
| 1984 |
|
|
val SCE_PL_POD=3 |
| 1985 |
|
|
val SCE_PL_NUMBER=4 |
| 1986 |
|
|
val SCE_PL_WORD=5 |
| 1987 |
|
|
val SCE_PL_STRING=6 |
| 1988 |
|
|
val SCE_PL_CHARACTER=7 |
| 1989 |
|
|
val SCE_PL_PUNCTUATION=8 |
| 1990 |
|
|
val SCE_PL_PREPROCESSOR=9 |
| 1991 |
|
|
val SCE_PL_OPERATOR=10 |
| 1992 |
|
|
val SCE_PL_IDENTIFIER=11 |
| 1993 |
|
|
val SCE_PL_SCALAR=12 |
| 1994 |
|
|
val SCE_PL_ARRAY=13 |
| 1995 |
|
|
val SCE_PL_HASH=14 |
| 1996 |
|
|
val SCE_PL_SYMBOLTABLE=15 |
| 1997 |
|
|
val SCE_PL_VARIABLE_INDEXER=16 |
| 1998 |
|
|
val SCE_PL_REGEX=17 |
| 1999 |
|
|
val SCE_PL_REGSUBST=18 |
| 2000 |
|
|
val SCE_PL_LONGQUOTE=19 |
| 2001 |
|
|
val SCE_PL_BACKTICKS=20 |
| 2002 |
|
|
val SCE_PL_DATASECTION=21 |
| 2003 |
|
|
val SCE_PL_HERE_DELIM=22 |
| 2004 |
|
|
val SCE_PL_HERE_Q=23 |
| 2005 |
|
|
val SCE_PL_HERE_QQ=24 |
| 2006 |
|
|
val SCE_PL_HERE_QX=25 |
| 2007 |
|
|
val SCE_PL_STRING_Q=26 |
| 2008 |
|
|
val SCE_PL_STRING_QQ=27 |
| 2009 |
|
|
val SCE_PL_STRING_QX=28 |
| 2010 |
|
|
val SCE_PL_STRING_QR=29 |
| 2011 |
|
|
val SCE_PL_STRING_QW=30 |
| 2012 |
|
|
val SCE_PL_POD_VERB=31 |
| 2013 |
|
|
# Lexical states for SCLEX_RUBY |
| 2014 |
|
|
lex Ruby=SCLEX_RUBY SCE_RB_ |
| 2015 |
|
|
val SCE_RB_DEFAULT=0 |
| 2016 |
|
|
val SCE_RB_ERROR=1 |
| 2017 |
|
|
val SCE_RB_COMMENTLINE=2 |
| 2018 |
|
|
val SCE_RB_POD=3 |
| 2019 |
|
|
val SCE_RB_NUMBER=4 |
| 2020 |
|
|
val SCE_RB_WORD=5 |
| 2021 |
|
|
val SCE_RB_STRING=6 |
| 2022 |
|
|
val SCE_RB_CHARACTER=7 |
| 2023 |
|
|
val SCE_RB_CLASSNAME=8 |
| 2024 |
|
|
val SCE_RB_DEFNAME=9 |
| 2025 |
|
|
val SCE_RB_OPERATOR=10 |
| 2026 |
|
|
val SCE_RB_IDENTIFIER=11 |
| 2027 |
|
|
val SCE_RB_REGEX=12 |
| 2028 |
|
|
val SCE_RB_GLOBAL=13 |
| 2029 |
|
|
val SCE_RB_SYMBOL=14 |
| 2030 |
|
|
val SCE_RB_MODULE_NAME=15 |
| 2031 |
|
|
val SCE_RB_INSTANCE_VAR=16 |
| 2032 |
|
|
val SCE_RB_CLASS_VAR=17 |
| 2033 |
|
|
val SCE_RB_BACKTICKS=18 |
| 2034 |
|
|
val SCE_RB_DATASECTION=19 |
| 2035 |
|
|
val SCE_RB_HERE_DELIM=20 |
| 2036 |
|
|
val SCE_RB_HERE_Q=21 |
| 2037 |
|
|
val SCE_RB_HERE_QQ=22 |
| 2038 |
|
|
val SCE_RB_HERE_QX=23 |
| 2039 |
|
|
val SCE_RB_STRING_Q=24 |
| 2040 |
|
|
val SCE_RB_STRING_QQ=25 |
| 2041 |
|
|
val SCE_RB_STRING_QX=26 |
| 2042 |
|
|
val SCE_RB_STRING_QR=27 |
| 2043 |
|
|
val SCE_RB_STRING_QW=28 |
| 2044 |
|
|
val SCE_RB_WORD_DEMOTED=29 |
| 2045 |
|
|
val SCE_RB_STDIN=30 |
| 2046 |
|
|
val SCE_RB_STDOUT=31 |
| 2047 |
|
|
val SCE_RB_STDERR=40 |
| 2048 |
|
|
val SCE_RB_UPPER_BOUND=41 |
| 2049 |
|
|
# Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC |
| 2050 |
|
|
lex VB=SCLEX_VB SCE_B_ |
| 2051 |
|
|
lex VBScript=SCLEX_VBSCRIPT SCE_B_ |
| 2052 |
|
|
lex PowerBasic=SCLEX_POWERBASIC SCE_B_ |
| 2053 |
|
|
val SCE_B_DEFAULT=0 |
| 2054 |
|
|
val SCE_B_COMMENT=1 |
| 2055 |
|
|
val SCE_B_NUMBER=2 |
| 2056 |
|
|
val SCE_B_KEYWORD=3 |
| 2057 |
|
|
val SCE_B_STRING=4 |
| 2058 |
|
|
val SCE_B_PREPROCESSOR=5 |
| 2059 |
|
|
val SCE_B_OPERATOR=6 |
| 2060 |
|
|
val SCE_B_IDENTIFIER=7 |
| 2061 |
|
|
val SCE_B_DATE=8 |
| 2062 |
|
|
val SCE_B_STRINGEOL=9 |
| 2063 |
|
|
val SCE_B_KEYWORD2=10 |
| 2064 |
|
|
val SCE_B_KEYWORD3=11 |
| 2065 |
|
|
val SCE_B_KEYWORD4=12 |
| 2066 |
|
|
val SCE_B_CONSTANT=13 |
| 2067 |
|
|
val SCE_B_ASM=14 |
| 2068 |
|
|
val SCE_B_LABEL=15 |
| 2069 |
|
|
val SCE_B_ERROR=16 |
| 2070 |
|
|
val SCE_B_HEXNUMBER=17 |
| 2071 |
|
|
val SCE_B_BINNUMBER=18 |
| 2072 |
|
|
# Lexical states for SCLEX_PROPERTIES |
| 2073 |
|
|
lex Properties=SCLEX_PROPERTIES SCE_PROPS_ |
| 2074 |
|
|
val SCE_PROPS_DEFAULT=0 |
| 2075 |
|
|
val SCE_PROPS_COMMENT=1 |
| 2076 |
|
|
val SCE_PROPS_SECTION=2 |
| 2077 |
|
|
val SCE_PROPS_ASSIGNMENT=3 |
| 2078 |
|
|
val SCE_PROPS_DEFVAL=4 |
| 2079 |
|
|
# Lexical states for SCLEX_LATEX |
| 2080 |
|
|
lex LaTeX=SCLEX_LATEX SCE_L_ |
| 2081 |
|
|
val SCE_L_DEFAULT=0 |
| 2082 |
|
|
val SCE_L_COMMAND=1 |
| 2083 |
|
|
val SCE_L_TAG=2 |
| 2084 |
|
|
val SCE_L_MATH=3 |
| 2085 |
|
|
val SCE_L_COMMENT=4 |
| 2086 |
|
|
# Lexical states for SCLEX_LUA |
| 2087 |
|
|
lex Lua=SCLEX_LUA SCE_LUA_ |
| 2088 |
|
|
val SCE_LUA_DEFAULT=0 |
| 2089 |
|
|
val SCE_LUA_COMMENT=1 |
| 2090 |
|
|
val SCE_LUA_COMMENTLINE=2 |
| 2091 |
|
|
val SCE_LUA_COMMENTDOC=3 |
| 2092 |
|
|
val SCE_LUA_NUMBER=4 |
| 2093 |
|
|
val SCE_LUA_WORD=5 |
| 2094 |
|
|
val SCE_LUA_STRING=6 |
| 2095 |
|
|
val SCE_LUA_CHARACTER=7 |
| 2096 |
|
|
val SCE_LUA_LITERALSTRING=8 |
| 2097 |
|
|
val SCE_LUA_PREPROCESSOR=9 |
| 2098 |
|
|
val SCE_LUA_OPERATOR=10 |
| 2099 |
|
|
val SCE_LUA_IDENTIFIER=11 |
| 2100 |
|
|
val SCE_LUA_STRINGEOL=12 |
| 2101 |
|
|
val SCE_LUA_WORD2=13 |
| 2102 |
|
|
val SCE_LUA_WORD3=14 |
| 2103 |
|
|
val SCE_LUA_WORD4=15 |
| 2104 |
|
|
val SCE_LUA_WORD5=16 |
| 2105 |
|
|
val SCE_LUA_WORD6=17 |
| 2106 |
|
|
val SCE_LUA_WORD7=18 |
| 2107 |
|
|
val SCE_LUA_WORD8=19 |
| 2108 |
|
|
# Lexical states for SCLEX_ERRORLIST |
| 2109 |
|
|
lex ErrorList=SCLEX_ERRORLIST SCE_ERR_ |
| 2110 |
|
|
val SCE_ERR_DEFAULT=0 |
| 2111 |
|
|
val SCE_ERR_PYTHON=1 |
| 2112 |
|
|
val SCE_ERR_GCC=2 |
| 2113 |
|
|
val SCE_ERR_MS=3 |
| 2114 |
|
|
val SCE_ERR_CMD=4 |
| 2115 |
|
|
val SCE_ERR_BORLAND=5 |
| 2116 |
|
|
val SCE_ERR_PERL=6 |
| 2117 |
|
|
val SCE_ERR_NET=7 |
| 2118 |
|
|
val SCE_ERR_LUA=8 |
| 2119 |
|
|
val SCE_ERR_CTAG=9 |
| 2120 |
|
|
val SCE_ERR_DIFF_CHANGED=10 |
| 2121 |
|
|
val SCE_ERR_DIFF_ADDITION=11 |
| 2122 |
|
|
val SCE_ERR_DIFF_DELETION=12 |
| 2123 |
|
|
val SCE_ERR_DIFF_MESSAGE=13 |
| 2124 |
|
|
val SCE_ERR_PHP=14 |
| 2125 |
|
|
val SCE_ERR_ELF=15 |
| 2126 |
|
|
val SCE_ERR_IFC=16 |
| 2127 |
|
|
val SCE_ERR_IFORT=17 |
| 2128 |
|
|
val SCE_ERR_ABSF=18 |
| 2129 |
|
|
val SCE_ERR_TIDY=19 |
| 2130 |
|
|
val SCE_ERR_JAVA_STACK=20 |
| 2131 |
|
|
# Lexical states for SCLEX_BATCH |
| 2132 |
|
|
lex Batch=SCLEX_BATCH SCE_BAT_ |
| 2133 |
|
|
val SCE_BAT_DEFAULT=0 |
| 2134 |
|
|
val SCE_BAT_COMMENT=1 |
| 2135 |
|
|
val SCE_BAT_WORD=2 |
| 2136 |
|
|
val SCE_BAT_LABEL=3 |
| 2137 |
|
|
val SCE_BAT_HIDE=4 |
| 2138 |
|
|
val SCE_BAT_COMMAND=5 |
| 2139 |
|
|
val SCE_BAT_IDENTIFIER=6 |
| 2140 |
|
|
val SCE_BAT_OPERATOR=7 |
| 2141 |
|
|
# Lexical states for SCLEX_MAKEFILE |
| 2142 |
|
|
lex MakeFile=SCLEX_MAKEFILE SCE_MAKE_ |
| 2143 |
|
|
val SCE_MAKE_DEFAULT=0 |
| 2144 |
|
|
val SCE_MAKE_COMMENT=1 |
| 2145 |
|
|
val SCE_MAKE_PREPROCESSOR=2 |
| 2146 |
|
|
val SCE_MAKE_IDENTIFIER=3 |
| 2147 |
|
|
val SCE_MAKE_OPERATOR=4 |
| 2148 |
|
|
val SCE_MAKE_TARGET=5 |
| 2149 |
|
|
val SCE_MAKE_IDEOL=9 |
| 2150 |
|
|
# Lexical states for SCLEX_DIFF |
| 2151 |
|
|
lex Diff=SCLEX_DIFF SCE_DIFF_ |
| 2152 |
|
|
val SCE_DIFF_DEFAULT=0 |
| 2153 |
|
|
val SCE_DIFF_COMMENT=1 |
| 2154 |
|
|
val SCE_DIFF_COMMAND=2 |
| 2155 |
|
|
val SCE_DIFF_HEADER=3 |
| 2156 |
|
|
val SCE_DIFF_POSITION=4 |
| 2157 |
|
|
val SCE_DIFF_DELETED=5 |
| 2158 |
|
|
val SCE_DIFF_ADDED=6 |
| 2159 |
|
|
# Lexical states for SCLEX_CONF (Apache Configuration Files Lexer) |
| 2160 |
|
|
lex Conf=SCLEX_CONF SCE_CONF_ |
| 2161 |
|
|
val SCE_CONF_DEFAULT=0 |
| 2162 |
|
|
val SCE_CONF_COMMENT=1 |
| 2163 |
|
|
val SCE_CONF_NUMBER=2 |
| 2164 |
|
|
val SCE_CONF_IDENTIFIER=3 |
| 2165 |
|
|
val SCE_CONF_EXTENSION=4 |
| 2166 |
|
|
val SCE_CONF_PARAMETER=5 |
| 2167 |
|
|
val SCE_CONF_STRING=6 |
| 2168 |
|
|
val SCE_CONF_OPERATOR=7 |
| 2169 |
|
|
val SCE_CONF_IP=8 |
| 2170 |
|
|
val SCE_CONF_DIRECTIVE=9 |
| 2171 |
|
|
# Lexical states for SCLEX_AVE, Avenue |
| 2172 |
|
|
lex Avenue=SCLEX_AVE SCE_AVE_ |
| 2173 |
|
|
val SCE_AVE_DEFAULT=0 |
| 2174 |
|
|
val SCE_AVE_COMMENT=1 |
| 2175 |
|
|
val SCE_AVE_NUMBER=2 |
| 2176 |
|
|
val SCE_AVE_WORD=3 |
| 2177 |
|
|
val SCE_AVE_STRING=6 |
| 2178 |
|
|
val SCE_AVE_ENUM=7 |
| 2179 |
|
|
val SCE_AVE_STRINGEOL=8 |
| 2180 |
|
|
val SCE_AVE_IDENTIFIER=9 |
| 2181 |
|
|
val SCE_AVE_OPERATOR=10 |
| 2182 |
|
|
val SCE_AVE_WORD1=11 |
| 2183 |
|
|
val SCE_AVE_WORD2=12 |
| 2184 |
|
|
val SCE_AVE_WORD3=13 |
| 2185 |
|
|
val SCE_AVE_WORD4=14 |
| 2186 |
|
|
val SCE_AVE_WORD5=15 |
| 2187 |
|
|
val SCE_AVE_WORD6=16 |
| 2188 |
|
|
# Lexical states for SCLEX_ADA |
| 2189 |
|
|
lex Ada=SCLEX_ADA SCE_ADA_ |
| 2190 |
|
|
val SCE_ADA_DEFAULT=0 |
| 2191 |
|
|
val SCE_ADA_WORD=1 |
| 2192 |
|
|
val SCE_ADA_IDENTIFIER=2 |
| 2193 |
|
|
val SCE_ADA_NUMBER=3 |
| 2194 |
|
|
val SCE_ADA_DELIMITER=4 |
| 2195 |
|
|
val SCE_ADA_CHARACTER=5 |
| 2196 |
|
|
val SCE_ADA_CHARACTEREOL=6 |
| 2197 |
|
|
val SCE_ADA_STRING=7 |
| 2198 |
|
|
val SCE_ADA_STRINGEOL=8 |
| 2199 |
|
|
val SCE_ADA_LABEL=9 |
| 2200 |
|
|
val SCE_ADA_COMMENTLINE=10 |
| 2201 |
|
|
val SCE_ADA_ILLEGAL=11 |
| 2202 |
|
|
# Lexical states for SCLEX_BAAN |
| 2203 |
|
|
lex Baan=SCLEX_BAAN SCE_BAAN_ |
| 2204 |
|
|
val SCE_BAAN_DEFAULT=0 |
| 2205 |
|
|
val SCE_BAAN_COMMENT=1 |
| 2206 |
|
|
val SCE_BAAN_COMMENTDOC=2 |
| 2207 |
|
|
val SCE_BAAN_NUMBER=3 |
| 2208 |
|
|
val SCE_BAAN_WORD=4 |
| 2209 |
|
|
val SCE_BAAN_STRING=5 |
| 2210 |
|
|
val SCE_BAAN_PREPROCESSOR=6 |
| 2211 |
|
|
val SCE_BAAN_OPERATOR=7 |
| 2212 |
|
|
val SCE_BAAN_IDENTIFIER=8 |
| 2213 |
|
|
val SCE_BAAN_STRINGEOL=9 |
| 2214 |
|
|
val SCE_BAAN_WORD2=10 |
| 2215 |
|
|
# Lexical states for SCLEX_LISP |
| 2216 |
|
|
lex Lisp=SCLEX_LISP SCE_LISP_ |
| 2217 |
|
|
val SCE_LISP_DEFAULT=0 |
| 2218 |
|
|
val SCE_LISP_COMMENT=1 |
| 2219 |
|
|
val SCE_LISP_NUMBER=2 |
| 2220 |
|
|
val SCE_LISP_KEYWORD=3 |
| 2221 |
|
|
val SCE_LISP_KEYWORD_KW=4 |
| 2222 |
|
|
val SCE_LISP_SYMBOL=5 |
| 2223 |
|
|
val SCE_LISP_STRING=6 |
| 2224 |
|
|
val SCE_LISP_STRINGEOL=8 |
| 2225 |
|
|
val SCE_LISP_IDENTIFIER=9 |
| 2226 |
|
|
val SCE_LISP_OPERATOR=10 |
| 2227 |
|
|
val SCE_LISP_SPECIAL=11 |
| 2228 |
|
|
val SCE_LISP_MULTI_COMMENT=12 |
| 2229 |
|
|
# Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW |
| 2230 |
|
|
lex Eiffel=SCLEX_EIFFEL SCE_EIFFEL_ |
| 2231 |
|
|
lex EiffelKW=SCLEX_EIFFELKW SCE_EIFFEL_ |
| 2232 |
|
|
val SCE_EIFFEL_DEFAULT=0 |
| 2233 |
|
|
val SCE_EIFFEL_COMMENTLINE=1 |
| 2234 |
|
|
val SCE_EIFFEL_NUMBER=2 |
| 2235 |
|
|
val SCE_EIFFEL_WORD=3 |
| 2236 |
|
|
val SCE_EIFFEL_STRING=4 |
| 2237 |
|
|
val SCE_EIFFEL_CHARACTER=5 |
| 2238 |
|
|
val SCE_EIFFEL_OPERATOR=6 |
| 2239 |
|
|
val SCE_EIFFEL_IDENTIFIER=7 |
| 2240 |
|
|
val SCE_EIFFEL_STRINGEOL=8 |
| 2241 |
|
|
# Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer) |
| 2242 |
|
|
lex NNCronTab=SCLEX_NNCRONTAB SCE_NNCRONTAB_ |
| 2243 |
|
|
val SCE_NNCRONTAB_DEFAULT=0 |
| 2244 |
|
|
val SCE_NNCRONTAB_COMMENT=1 |
| 2245 |
|
|
val SCE_NNCRONTAB_TASK=2 |
| 2246 |
|
|
val SCE_NNCRONTAB_SECTION=3 |
| 2247 |
|
|
val SCE_NNCRONTAB_KEYWORD=4 |
| 2248 |
|
|
val SCE_NNCRONTAB_MODIFIER=5 |
| 2249 |
|
|
val SCE_NNCRONTAB_ASTERISK=6 |
| 2250 |
|
|
val SCE_NNCRONTAB_NUMBER=7 |
| 2251 |
|
|
val SCE_NNCRONTAB_STRING=8 |
| 2252 |
|
|
val SCE_NNCRONTAB_ENVIRONMENT=9 |
| 2253 |
|
|
val SCE_NNCRONTAB_IDENTIFIER=10 |
| 2254 |
|
|
# Lexical states for SCLEX_FORTH (Forth Lexer) |
| 2255 |
|
|
lex Forth=SCLEX_FORTH SCE_FORTH_ |
| 2256 |
|
|
val SCE_FORTH_DEFAULT=0 |
| 2257 |
|
|
val SCE_FORTH_COMMENT=1 |
| 2258 |
|
|
val SCE_FORTH_COMMENT_ML=2 |
| 2259 |
|
|
val SCE_FORTH_IDENTIFIER=3 |
| 2260 |
|
|
val SCE_FORTH_CONTROL=4 |
| 2261 |
|
|
val SCE_FORTH_KEYWORD=5 |
| 2262 |
|
|
val SCE_FORTH_DEFWORD=6 |
| 2263 |
|
|
val SCE_FORTH_PREWORD1=7 |
| 2264 |
|
|
val SCE_FORTH_PREWORD2=8 |
| 2265 |
|
|
val SCE_FORTH_NUMBER=9 |
| 2266 |
|
|
val SCE_FORTH_STRING=10 |
| 2267 |
|
|
val SCE_FORTH_LOCALE=11 |
| 2268 |
|
|
# Lexical states for SCLEX_MATLAB |
| 2269 |
|
|
lex MatLab=SCLEX_MATLAB SCE_MATLAB_ |
| 2270 |
|
|
val SCE_MATLAB_DEFAULT=0 |
| 2271 |
|
|
val SCE_MATLAB_COMMENT=1 |
| 2272 |
|
|
val SCE_MATLAB_COMMAND=2 |
| 2273 |
|
|
val SCE_MATLAB_NUMBER=3 |
| 2274 |
|
|
val SCE_MATLAB_KEYWORD=4 |
| 2275 |
|
|
# single quoted string |
| 2276 |
|
|
val SCE_MATLAB_STRING=5 |
| 2277 |
|
|
val SCE_MATLAB_OPERATOR=6 |
| 2278 |
|
|
val SCE_MATLAB_IDENTIFIER=7 |
| 2279 |
|
|
val SCE_MATLAB_DOUBLEQUOTESTRING=8 |
| 2280 |
|
|
# Lexical states for SCLEX_SCRIPTOL |
| 2281 |
|
|
lex Sol=SCLEX_SCRIPTOL SCE_SCRIPTOL_ |
| 2282 |
|
|
val SCE_SCRIPTOL_DEFAULT=0 |
| 2283 |
|
|
val SCE_SCRIPTOL_WHITE=1 |
| 2284 |
|
|
val SCE_SCRIPTOL_COMMENTLINE=2 |
| 2285 |
|
|
val SCE_SCRIPTOL_PERSISTENT=3 |
| 2286 |
|
|
val SCE_SCRIPTOL_CSTYLE=4 |
| 2287 |
|
|
val SCE_SCRIPTOL_COMMENTBLOCK=5 |
| 2288 |
|
|
val SCE_SCRIPTOL_NUMBER=6 |
| 2289 |
|
|
val SCE_SCRIPTOL_STRING=7 |
| 2290 |
|
|
val SCE_SCRIPTOL_CHARACTER=8 |
| 2291 |
|
|
val SCE_SCRIPTOL_STRINGEOL=9 |
| 2292 |
|
|
val SCE_SCRIPTOL_KEYWORD=10 |
| 2293 |
|
|
val SCE_SCRIPTOL_OPERATOR=11 |
| 2294 |
|
|
val SCE_SCRIPTOL_IDENTIFIER=12 |
| 2295 |
|
|
val SCE_SCRIPTOL_TRIPLE=13 |
| 2296 |
|
|
val SCE_SCRIPTOL_CLASSNAME=14 |
| 2297 |
|
|
val SCE_SCRIPTOL_PREPROCESSOR=15 |
| 2298 |
|
|
# Lexical states for SCLEX_ASM |
| 2299 |
|
|
lex Asm=SCLEX_ASM SCE_ASM_ |
| 2300 |
|
|
val SCE_ASM_DEFAULT=0 |
| 2301 |
|
|
val SCE_ASM_COMMENT=1 |
| 2302 |
|
|
val SCE_ASM_NUMBER=2 |
| 2303 |
|
|
val SCE_ASM_STRING=3 |
| 2304 |
|
|
val SCE_ASM_OPERATOR=4 |
| 2305 |
|
|
val SCE_ASM_IDENTIFIER=5 |
| 2306 |
|
|
val SCE_ASM_CPUINSTRUCTION=6 |
| 2307 |
|
|
val SCE_ASM_MATHINSTRUCTION=7 |
| 2308 |
|
|
val SCE_ASM_REGISTER=8 |
| 2309 |
|
|
val SCE_ASM_DIRECTIVE=9 |
| 2310 |
|
|
val SCE_ASM_DIRECTIVEOPERAND=10 |
| 2311 |
|
|
val SCE_ASM_COMMENTBLOCK=11 |
| 2312 |
|
|
val SCE_ASM_CHARACTER=12 |
| 2313 |
|
|
val SCE_ASM_STRINGEOL=13 |
| 2314 |
|
|
val SCE_ASM_EXTINSTRUCTION=14 |
| 2315 |
|
|
# Lexical states for SCLEX_FORTRAN |
| 2316 |
|
|
lex Fortran=SCLEX_FORTRAN SCE_F_ |
| 2317 |
|
|
lex F77=SCLEX_F77 SCE_F_ |
| 2318 |
|
|
val SCE_F_DEFAULT=0 |
| 2319 |
|
|
val SCE_F_COMMENT=1 |
| 2320 |
|
|
val SCE_F_NUMBER=2 |
| 2321 |
|
|
val SCE_F_STRING1=3 |
| 2322 |
|
|
val SCE_F_STRING2=4 |
| 2323 |
|
|
val SCE_F_STRINGEOL=5 |
| 2324 |
|
|
val SCE_F_OPERATOR=6 |
| 2325 |
|
|
val SCE_F_IDENTIFIER=7 |
| 2326 |
|
|
val SCE_F_WORD=8 |
| 2327 |
|
|
val SCE_F_WORD2=9 |
| 2328 |
|
|
val SCE_F_WORD3=10 |
| 2329 |
|
|
val SCE_F_PREPROCESSOR=11 |
| 2330 |
|
|
val SCE_F_OPERATOR2=12 |
| 2331 |
|
|
val SCE_F_LABEL=13 |
| 2332 |
|
|
val SCE_F_CONTINUATION=14 |
| 2333 |
|
|
# Lexical states for SCLEX_CSS |
| 2334 |
|
|
lex CSS=SCLEX_CSS SCE_CSS_ |
| 2335 |
|
|
val SCE_CSS_DEFAULT=0 |
| 2336 |
|
|
val SCE_CSS_TAG=1 |
| 2337 |
|
|
val SCE_CSS_CLASS=2 |
| 2338 |
|
|
val SCE_CSS_PSEUDOCLASS=3 |
| 2339 |
|
|
val SCE_CSS_UNKNOWN_PSEUDOCLASS=4 |
| 2340 |
|
|
val SCE_CSS_OPERATOR=5 |
| 2341 |
|
|
val SCE_CSS_IDENTIFIER=6 |
| 2342 |
|
|
val SCE_CSS_UNKNOWN_IDENTIFIER=7 |
| 2343 |
|
|
val SCE_CSS_VALUE=8 |
| 2344 |
|
|
val SCE_CSS_COMMENT=9 |
| 2345 |
|
|
val SCE_CSS_ID=10 |
| 2346 |
|
|
val SCE_CSS_IMPORTANT=11 |
| 2347 |
|
|
val SCE_CSS_DIRECTIVE=12 |
| 2348 |
|
|
val SCE_CSS_DOUBLESTRING=13 |
| 2349 |
|
|
val SCE_CSS_SINGLESTRING=14 |
| 2350 |
|
|
val SCE_CSS_IDENTIFIER2=15 |
| 2351 |
|
|
val SCE_CSS_ATTRIBUTE=16 |
| 2352 |
|
|
# Lexical states for SCLEX_POV |
| 2353 |
|
|
lex POV=SCLEX_POV SCE_POV_ |
| 2354 |
|
|
val SCE_POV_DEFAULT=0 |
| 2355 |
|
|
val SCE_POV_COMMENT=1 |
| 2356 |
|
|
val SCE_POV_COMMENTLINE=2 |
| 2357 |
|
|
val SCE_POV_NUMBER=3 |
| 2358 |
|
|
val SCE_POV_OPERATOR=4 |
| 2359 |
|
|
val SCE_POV_IDENTIFIER=5 |
| 2360 |
|
|
val SCE_POV_STRING=6 |
| 2361 |
|
|
val SCE_POV_STRINGEOL=7 |
| 2362 |
|
|
val SCE_POV_DIRECTIVE=8 |
| 2363 |
|
|
val SCE_POV_BADDIRECTIVE=9 |
| 2364 |
|
|
val SCE_POV_WORD2=10 |
| 2365 |
|
|
val SCE_POV_WORD3=11 |
| 2366 |
|
|
val SCE_POV_WORD4=12 |
| 2367 |
|
|
val SCE_POV_WORD5=13 |
| 2368 |
|
|
val SCE_POV_WORD6=14 |
| 2369 |
|
|
val SCE_POV_WORD7=15 |
| 2370 |
|
|
val SCE_POV_WORD8=16 |
| 2371 |
|
|
# Lexical states for SCLEX_LOUT |
| 2372 |
|
|
lex LOUT=SCLEX_LOUT SCE_LOUT_ |
| 2373 |
|
|
val SCE_LOUT_DEFAULT=0 |
| 2374 |
|
|
val SCE_LOUT_COMMENT=1 |
| 2375 |
|
|
val SCE_LOUT_NUMBER=2 |
| 2376 |
|
|
val SCE_LOUT_WORD=3 |
| 2377 |
|
|
val SCE_LOUT_WORD2=4 |
| 2378 |
|
|
val SCE_LOUT_WORD3=5 |
| 2379 |
|
|
val SCE_LOUT_WORD4=6 |
| 2380 |
|
|
val SCE_LOUT_STRING=7 |
| 2381 |
|
|
val SCE_LOUT_OPERATOR=8 |
| 2382 |
|
|
val SCE_LOUT_IDENTIFIER=9 |
| 2383 |
|
|
val SCE_LOUT_STRINGEOL=10 |
| 2384 |
|
|
# Lexical states for SCLEX_ESCRIPT |
| 2385 |
|
|
lex ESCRIPT=SCLEX_ESCRIPT SCE_ESCRIPT_ |
| 2386 |
|
|
val SCE_ESCRIPT_DEFAULT=0 |
| 2387 |
|
|
val SCE_ESCRIPT_COMMENT=1 |
| 2388 |
|
|
val SCE_ESCRIPT_COMMENTLINE=2 |
| 2389 |
|
|
val SCE_ESCRIPT_COMMENTDOC=3 |
| 2390 |
|
|
val SCE_ESCRIPT_NUMBER=4 |
| 2391 |
|
|
val SCE_ESCRIPT_WORD=5 |
| 2392 |
|
|
val SCE_ESCRIPT_STRING=6 |
| 2393 |
|
|
val SCE_ESCRIPT_OPERATOR=7 |
| 2394 |
|
|
val SCE_ESCRIPT_IDENTIFIER=8 |
| 2395 |
|
|
val SCE_ESCRIPT_BRACE=9 |
| 2396 |
|
|
val SCE_ESCRIPT_WORD2=10 |
| 2397 |
|
|
val SCE_ESCRIPT_WORD3=11 |
| 2398 |
|
|
# Lexical states for SCLEX_PS |
| 2399 |
|
|
lex PS=SCLEX_PS SCE_PS_ |
| 2400 |
|
|
val SCE_PS_DEFAULT=0 |
| 2401 |
|
|
val SCE_PS_COMMENT=1 |
| 2402 |
|
|
val SCE_PS_DSC_COMMENT=2 |
| 2403 |
|
|
val SCE_PS_DSC_VALUE=3 |
| 2404 |
|
|
val SCE_PS_NUMBER=4 |
| 2405 |
|
|
val SCE_PS_NAME=5 |
| 2406 |
|
|
val SCE_PS_KEYWORD=6 |
| 2407 |
|
|
val SCE_PS_LITERAL=7 |
| 2408 |
|
|
val SCE_PS_IMMEVAL=8 |
| 2409 |
|
|
val SCE_PS_PAREN_ARRAY=9 |
| 2410 |
|
|
val SCE_PS_PAREN_DICT=10 |
| 2411 |
|
|
val SCE_PS_PAREN_PROC=11 |
| 2412 |
|
|
val SCE_PS_TEXT=12 |
| 2413 |
|
|
val SCE_PS_HEXSTRING=13 |
| 2414 |
|
|
val SCE_PS_BASE85STRING=14 |
| 2415 |
|
|
val SCE_PS_BADSTRINGCHAR=15 |
| 2416 |
|
|
# Lexical states for SCLEX_NSIS |
| 2417 |
|
|
lex NSIS=SCLEX_NSIS SCE_NSIS_ |
| 2418 |
|
|
val SCE_NSIS_DEFAULT=0 |
| 2419 |
|
|
val SCE_NSIS_COMMENT=1 |
| 2420 |
|
|
val SCE_NSIS_STRINGDQ=2 |
| 2421 |
|
|
val SCE_NSIS_STRINGLQ=3 |
| 2422 |
|
|
val SCE_NSIS_STRINGRQ=4 |
| 2423 |
|
|
val SCE_NSIS_FUNCTION=5 |
| 2424 |
|
|
val SCE_NSIS_VARIABLE=6 |
| 2425 |
|
|
val SCE_NSIS_LABEL=7 |
| 2426 |
|
|
val SCE_NSIS_USERDEFINED=8 |
| 2427 |
|
|
val SCE_NSIS_SECTIONDEF=9 |
| 2428 |
|
|
val SCE_NSIS_SUBSECTIONDEF=10 |
| 2429 |
|
|
val SCE_NSIS_IFDEFINEDEF=11 |
| 2430 |
|
|
val SCE_NSIS_MACRODEF=12 |
| 2431 |
|
|
val SCE_NSIS_STRINGVAR=13 |
| 2432 |
|
|
val SCE_NSIS_NUMBER=14 |
| 2433 |
|
|
val SCE_NSIS_SECTIONGROUP=15 |
| 2434 |
|
|
val SCE_NSIS_PAGEEX=16 |
| 2435 |
|
|
val SCE_NSIS_FUNCTIONDEF=17 |
| 2436 |
|
|
val SCE_NSIS_COMMENTBOX=18 |
| 2437 |
|
|
# Lexical states for SCLEX_MMIXAL |
| 2438 |
|
|
lex MMIXAL=SCLEX_MMIXAL SCE_MMIXAL_ |
| 2439 |
|
|
val SCE_MMIXAL_LEADWS=0 |
| 2440 |
|
|
val SCE_MMIXAL_COMMENT=1 |
| 2441 |
|
|
val SCE_MMIXAL_LABEL=2 |
| 2442 |
|
|
val SCE_MMIXAL_OPCODE=3 |
| 2443 |
|
|
val SCE_MMIXAL_OPCODE_PRE=4 |
| 2444 |
|
|
val SCE_MMIXAL_OPCODE_VALID=5 |
| 2445 |
|
|
val SCE_MMIXAL_OPCODE_UNKNOWN=6 |
| 2446 |
|
|
val SCE_MMIXAL_OPCODE_POST=7 |
| 2447 |
|
|
val SCE_MMIXAL_OPERANDS=8 |
| 2448 |
|
|
val SCE_MMIXAL_NUMBER=9 |
| 2449 |
|
|
val SCE_MMIXAL_REF=10 |
| 2450 |
|
|
val SCE_MMIXAL_CHAR=11 |
| 2451 |
|
|
val SCE_MMIXAL_STRING=12 |
| 2452 |
|
|
val SCE_MMIXAL_REGISTER=13 |
| 2453 |
|
|
val SCE_MMIXAL_HEX=14 |
| 2454 |
|
|
val SCE_MMIXAL_OPERATOR=15 |
| 2455 |
|
|
val SCE_MMIXAL_SYMBOL=16 |
| 2456 |
|
|
val SCE_MMIXAL_INCLUDE=17 |
| 2457 |
|
|
# Lexical states for SCLEX_CLW |
| 2458 |
|
|
lex Clarion=SCLEX_CLW SCE_CLW_ |
| 2459 |
|
|
val SCE_CLW_DEFAULT=0 |
| 2460 |
|
|
val SCE_CLW_LABEL=1 |
| 2461 |
|
|
val SCE_CLW_COMMENT=2 |
| 2462 |
|
|
val SCE_CLW_STRING=3 |
| 2463 |
|
|
val SCE_CLW_USER_IDENTIFIER=4 |
| 2464 |
|
|
val SCE_CLW_INTEGER_CONSTANT=5 |
| 2465 |
|
|
val SCE_CLW_REAL_CONSTANT=6 |
| 2466 |
|
|
val SCE_CLW_PICTURE_STRING=7 |
| 2467 |
|
|
val SCE_CLW_KEYWORD=8 |
| 2468 |
|
|
val SCE_CLW_COMPILER_DIRECTIVE=9 |
| 2469 |
|
|
val SCE_CLW_RUNTIME_EXPRESSIONS=10 |
| 2470 |
|
|
val SCE_CLW_BUILTIN_PROCEDURES_FUNCTION=11 |
| 2471 |
|
|
val SCE_CLW_STRUCTURE_DATA_TYPE=12 |
| 2472 |
|
|
val SCE_CLW_ATTRIBUTE=13 |
| 2473 |
|
|
val SCE_CLW_STANDARD_EQUATE=14 |
| 2474 |
|
|
val SCE_CLW_ERROR=15 |
| 2475 |
|
|
val SCE_CLW_DEPRECATED=16 |
| 2476 |
|
|
# Lexical states for SCLEX_LOT |
| 2477 |
|
|
lex LOT=SCLEX_LOT SCE_LOT_ |
| 2478 |
|
|
val SCE_LOT_DEFAULT=0 |
| 2479 |
|
|
val SCE_LOT_HEADER=1 |
| 2480 |
|
|
val SCE_LOT_BREAK=2 |
| 2481 |
|
|
val SCE_LOT_SET=3 |
| 2482 |
|
|
val SCE_LOT_PASS=4 |
| 2483 |
|
|
val SCE_LOT_FAIL=5 |
| 2484 |
|
|
val SCE_LOT_ABORT=6 |
| 2485 |
|
|
# Lexical states for SCLEX_YAML |
| 2486 |
|
|
lex YAML=SCLEX_YAML SCE_YAML_ |
| 2487 |
|
|
val SCE_YAML_DEFAULT=0 |
| 2488 |
|
|
val SCE_YAML_COMMENT=1 |
| 2489 |
|
|
val SCE_YAML_IDENTIFIER=2 |
| 2490 |
|
|
val SCE_YAML_KEYWORD=3 |
| 2491 |
|
|
val SCE_YAML_NUMBER=4 |
| 2492 |
|
|
val SCE_YAML_REFERENCE=5 |
| 2493 |
|
|
val SCE_YAML_DOCUMENT=6 |
| 2494 |
|
|
val SCE_YAML_TEXT=7 |
| 2495 |
|
|
val SCE_YAML_ERROR=8 |
| 2496 |
|
|
# Lexical states for SCLEX_TEX |
| 2497 |
|
|
lex TeX=SCLEX_TEX SCE_TEX_ |
| 2498 |
|
|
val SCE_TEX_DEFAULT=0 |
| 2499 |
|
|
val SCE_TEX_SPECIAL=1 |
| 2500 |
|
|
val SCE_TEX_GROUP=2 |
| 2501 |
|
|
val SCE_TEX_SYMBOL=3 |
| 2502 |
|
|
val SCE_TEX_COMMAND=4 |
| 2503 |
|
|
val SCE_TEX_TEXT=5 |
| 2504 |
|
|
lex Metapost=SCLEX_METAPOST SCE_METAPOST_ |
| 2505 |
|
|
val SCE_METAPOST_DEFAULT=0 |
| 2506 |
|
|
val SCE_METAPOST_SPECIAL=1 |
| 2507 |
|
|
val SCE_METAPOST_GROUP=2 |
| 2508 |
|
|
val SCE_METAPOST_SYMBOL=3 |
| 2509 |
|
|
val SCE_METAPOST_COMMAND=4 |
| 2510 |
|
|
val SCE_METAPOST_TEXT=5 |
| 2511 |
|
|
val SCE_METAPOST_EXTRA=6 |
| 2512 |
|
|
# Lexical states for SCLEX_ERLANG |
| 2513 |
|
|
lex Erlang=SCLEX_ERLANG SCE_ERLANG_ |
| 2514 |
|
|
val SCE_ERLANG_DEFAULT=0 |
| 2515 |
|
|
val SCE_ERLANG_COMMENT=1 |
| 2516 |
|
|
val SCE_ERLANG_VARIABLE=2 |
| 2517 |
|
|
val SCE_ERLANG_NUMBER=3 |
| 2518 |
|
|
val SCE_ERLANG_KEYWORD=4 |
| 2519 |
|
|
val SCE_ERLANG_STRING=5 |
| 2520 |
|
|
val SCE_ERLANG_OPERATOR=6 |
| 2521 |
|
|
val SCE_ERLANG_ATOM=7 |
| 2522 |
|
|
val SCE_ERLANG_FUNCTION_NAME=8 |
| 2523 |
|
|
val SCE_ERLANG_CHARACTER=9 |
| 2524 |
|
|
val SCE_ERLANG_MACRO=10 |
| 2525 |
|
|
val SCE_ERLANG_RECORD=11 |
| 2526 |
|
|
val SCE_ERLANG_SEPARATOR=12 |
| 2527 |
|
|
val SCE_ERLANG_NODE_NAME=13 |
| 2528 |
|
|
val SCE_ERLANG_UNKNOWN=31 |
| 2529 |
|
|
# Lexical states for SCLEX_OCTAVE are identical to MatLab |
| 2530 |
|
|
lex Octave=SCLEX_OCTAVE SCE_MATLAB_ |
| 2531 |
|
|
# Lexical states for SCLEX_MSSQL |
| 2532 |
|
|
lex MSSQL=SCLEX_MSSQL SCE_MSSQL_ |
| 2533 |
|
|
val SCE_MSSQL_DEFAULT=0 |
| 2534 |
|
|
val SCE_MSSQL_COMMENT=1 |
| 2535 |
|
|
val SCE_MSSQL_LINE_COMMENT=2 |
| 2536 |
|
|
val SCE_MSSQL_NUMBER=3 |
| 2537 |
|
|
val SCE_MSSQL_STRING=4 |
| 2538 |
|
|
val SCE_MSSQL_OPERATOR=5 |
| 2539 |
|
|
val SCE_MSSQL_IDENTIFIER=6 |
| 2540 |
|
|
val SCE_MSSQL_VARIABLE=7 |
| 2541 |
|
|
val SCE_MSSQL_COLUMN_NAME=8 |
| 2542 |
|
|
val SCE_MSSQL_STATEMENT=9 |
| 2543 |
|
|
val SCE_MSSQL_DATATYPE=10 |
| 2544 |
|
|
val SCE_MSSQL_SYSTABLE=11 |
| 2545 |
|
|
val SCE_MSSQL_GLOBAL_VARIABLE=12 |
| 2546 |
|
|
val SCE_MSSQL_FUNCTION=13 |
| 2547 |
|
|
val SCE_MSSQL_STORED_PROCEDURE=14 |
| 2548 |
|
|
val SCE_MSSQL_DEFAULT_PREF_DATATYPE=15 |
| 2549 |
|
|
val SCE_MSSQL_COLUMN_NAME_2=16 |
| 2550 |
|
|
# Lexical states for SCLEX_VERILOG |
| 2551 |
|
|
lex Verilog=SCLEX_VERILOG SCE_V_ |
| 2552 |
|
|
val SCE_V_DEFAULT=0 |
| 2553 |
|
|
val SCE_V_COMMENT=1 |
| 2554 |
|
|
val SCE_V_COMMENTLINE=2 |
| 2555 |
|
|
val SCE_V_COMMENTLINEBANG=3 |
| 2556 |
|
|
val SCE_V_NUMBER=4 |
| 2557 |
|
|
val SCE_V_WORD=5 |
| 2558 |
|
|
val SCE_V_STRING=6 |
| 2559 |
|
|
val SCE_V_WORD2=7 |
| 2560 |
|
|
val SCE_V_WORD3=8 |
| 2561 |
|
|
val SCE_V_PREPROCESSOR=9 |
| 2562 |
|
|
val SCE_V_OPERATOR=10 |
| 2563 |
|
|
val SCE_V_IDENTIFIER=11 |
| 2564 |
|
|
val SCE_V_STRINGEOL=12 |
| 2565 |
|
|
val SCE_V_USER=19 |
| 2566 |
|
|
# Lexical states for SCLEX_KIX |
| 2567 |
|
|
lex Kix=SCLEX_KIX SCE_KIX_ |
| 2568 |
|
|
val SCE_KIX_DEFAULT=0 |
| 2569 |
|
|
val SCE_KIX_COMMENT=1 |
| 2570 |
|
|
val SCE_KIX_STRING1=2 |
| 2571 |
|
|
val SCE_KIX_STRING2=3 |
| 2572 |
|
|
val SCE_KIX_NUMBER=4 |
| 2573 |
|
|
val SCE_KIX_VAR=5 |
| 2574 |
|
|
val SCE_KIX_MACRO=6 |
| 2575 |
|
|
val SCE_KIX_KEYWORD=7 |
| 2576 |
|
|
val SCE_KIX_FUNCTIONS=8 |
| 2577 |
|
|
val SCE_KIX_OPERATOR=9 |
| 2578 |
|
|
val SCE_KIX_IDENTIFIER=31 |
| 2579 |
|
|
# Lexical states for SCLEX_GUI4CLI |
| 2580 |
|
|
val SCE_GC_DEFAULT=0 |
| 2581 |
|
|
val SCE_GC_COMMENTLINE=1 |
| 2582 |
|
|
val SCE_GC_COMMENTBLOCK=2 |
| 2583 |
|
|
val SCE_GC_GLOBAL=3 |
| 2584 |
|
|
val SCE_GC_EVENT=4 |
| 2585 |
|
|
val SCE_GC_ATTRIBUTE=5 |
| 2586 |
|
|
val SCE_GC_CONTROL=6 |
| 2587 |
|
|
val SCE_GC_COMMAND=7 |
| 2588 |
|
|
val SCE_GC_STRING=8 |
| 2589 |
|
|
val SCE_GC_OPERATOR=9 |
| 2590 |
|
|
# Lexical states for SCLEX_SPECMAN |
| 2591 |
|
|
lex Specman=SCLEX_SPECMAN SCE_SN_ |
| 2592 |
|
|
val SCE_SN_DEFAULT=0 |
| 2593 |
|
|
val SCE_SN_CODE=1 |
| 2594 |
|
|
val SCE_SN_COMMENTLINE=2 |
| 2595 |
|
|
val SCE_SN_COMMENTLINEBANG=3 |
| 2596 |
|
|
val SCE_SN_NUMBER=4 |
| 2597 |
|
|
val SCE_SN_WORD=5 |
| 2598 |
|
|
val SCE_SN_STRING=6 |
| 2599 |
|
|
val SCE_SN_WORD2=7 |
| 2600 |
|
|
val SCE_SN_WORD3=8 |
| 2601 |
|
|
val SCE_SN_PREPROCESSOR=9 |
| 2602 |
|
|
val SCE_SN_OPERATOR=10 |
| 2603 |
|
|
val SCE_SN_IDENTIFIER=11 |
| 2604 |
|
|
val SCE_SN_STRINGEOL=12 |
| 2605 |
|
|
val SCE_SN_REGEXTAG=13 |
| 2606 |
|
|
val SCE_SN_SIGNAL=14 |
| 2607 |
|
|
val SCE_SN_USER=19 |
| 2608 |
|
|
# Lexical states for SCLEX_AU3 |
| 2609 |
|
|
lex Au3=SCLEX_AU3 SCE_AU3_ |
| 2610 |
|
|
val SCE_AU3_DEFAULT=0 |
| 2611 |
|
|
val SCE_AU3_COMMENT=1 |
| 2612 |
|
|
val SCE_AU3_COMMENTBLOCK=2 |
| 2613 |
|
|
val SCE_AU3_NUMBER=3 |
| 2614 |
|
|
val SCE_AU3_FUNCTION=4 |
| 2615 |
|
|
val SCE_AU3_KEYWORD=5 |
| 2616 |
|
|
val SCE_AU3_MACRO=6 |
| 2617 |
|
|
val SCE_AU3_STRING=7 |
| 2618 |
|
|
val SCE_AU3_OPERATOR=8 |
| 2619 |
|
|
val SCE_AU3_VARIABLE=9 |
| 2620 |
|
|
val SCE_AU3_SENT=10 |
| 2621 |
|
|
val SCE_AU3_PREPROCESSOR=11 |
| 2622 |
|
|
val SCE_AU3_SPECIAL=12 |
| 2623 |
|
|
val SCE_AU3_EXPAND=13 |
| 2624 |
|
|
val SCE_AU3_COMOBJ=14 |
| 2625 |
|
|
# Lexical states for SCLEX_APDL |
| 2626 |
|
|
lex APDL=SCLEX_APDL SCE_APDL_ |
| 2627 |
|
|
val SCE_APDL_DEFAULT=0 |
| 2628 |
|
|
val SCE_APDL_COMMENT=1 |
| 2629 |
|
|
val SCE_APDL_COMMENTBLOCK=2 |
| 2630 |
|
|
val SCE_APDL_NUMBER=3 |
| 2631 |
|
|
val SCE_APDL_STRING=4 |
| 2632 |
|
|
val SCE_APDL_OPERATOR=5 |
| 2633 |
|
|
val SCE_APDL_WORD=6 |
| 2634 |
|
|
val SCE_APDL_PROCESSOR=7 |
| 2635 |
|
|
val SCE_APDL_COMMAND=8 |
| 2636 |
|
|
val SCE_APDL_SLASHCOMMAND=9 |
| 2637 |
|
|
val SCE_APDL_STARCOMMAND=10 |
| 2638 |
|
|
val SCE_APDL_ARGUMENT=11 |
| 2639 |
|
|
val SCE_APDL_FUNCTION=12 |
| 2640 |
|
|
# Lexical states for SCLEX_BASH |
| 2641 |
|
|
lex Bash=SCLEX_BASH SCE_SH_ |
| 2642 |
|
|
val SCE_SH_DEFAULT=0 |
| 2643 |
|
|
val SCE_SH_ERROR=1 |
| 2644 |
|
|
val SCE_SH_COMMENTLINE=2 |
| 2645 |
|
|
val SCE_SH_NUMBER=3 |
| 2646 |
|
|
val SCE_SH_WORD=4 |
| 2647 |
|
|
val SCE_SH_STRING=5 |
| 2648 |
|
|
val SCE_SH_CHARACTER=6 |
| 2649 |
|
|
val SCE_SH_OPERATOR=7 |
| 2650 |
|
|
val SCE_SH_IDENTIFIER=8 |
| 2651 |
|
|
val SCE_SH_SCALAR=9 |
| 2652 |
|
|
val SCE_SH_PARAM=10 |
| 2653 |
|
|
val SCE_SH_BACKTICKS=11 |
| 2654 |
|
|
val SCE_SH_HERE_DELIM=12 |
| 2655 |
|
|
val SCE_SH_HERE_Q=13 |
| 2656 |
|
|
# Lexical states for SCLEX_ASN1 |
| 2657 |
|
|
lex Asn1=SCLEX_ASN1 SCE_ASN1_ |
| 2658 |
|
|
val SCE_ASN1_DEFAULT=0 |
| 2659 |
|
|
val SCE_ASN1_COMMENT=1 |
| 2660 |
|
|
val SCE_ASN1_IDENTIFIER=2 |
| 2661 |
|
|
val SCE_ASN1_STRING=3 |
| 2662 |
|
|
val SCE_ASN1_OID=4 |
| 2663 |
|
|
val SCE_ASN1_SCALAR=5 |
| 2664 |
|
|
val SCE_ASN1_KEYWORD=6 |
| 2665 |
|
|
val SCE_ASN1_ATTRIBUTE=7 |
| 2666 |
|
|
val SCE_ASN1_DESCRIPTOR=8 |
| 2667 |
|
|
val SCE_ASN1_TYPE=9 |
| 2668 |
|
|
val SCE_ASN1_OPERATOR=10 |
| 2669 |
|
|
# Lexical states for SCLEX_VHDL |
| 2670 |
|
|
lex VHDL=SCLEX_VHDL SCE_VHDL_ |
| 2671 |
|
|
val SCE_VHDL_DEFAULT=0 |
| 2672 |
|
|
val SCE_VHDL_COMMENT=1 |
| 2673 |
|
|
val SCE_VHDL_COMMENTLINEBANG=2 |
| 2674 |
|
|
val SCE_VHDL_NUMBER=3 |
| 2675 |
|
|
val SCE_VHDL_STRING=4 |
| 2676 |
|
|
val SCE_VHDL_OPERATOR=5 |
| 2677 |
|
|
val SCE_VHDL_IDENTIFIER=6 |
| 2678 |
|
|
val SCE_VHDL_STRINGEOL=7 |
| 2679 |
|
|
val SCE_VHDL_KEYWORD=8 |
| 2680 |
|
|
val SCE_VHDL_STDOPERATOR=9 |
| 2681 |
|
|
val SCE_VHDL_ATTRIBUTE=10 |
| 2682 |
|
|
val SCE_VHDL_STDFUNCTION=11 |
| 2683 |
|
|
val SCE_VHDL_STDPACKAGE=12 |
| 2684 |
|
|
val SCE_VHDL_STDTYPE=13 |
| 2685 |
|
|
val SCE_VHDL_USERWORD=14 |
| 2686 |
|
|
# Lexical states for SCLEX_CAML |
| 2687 |
|
|
lex Caml=SCLEX_CAML SCE_CAML_ |
| 2688 |
|
|
val SCE_CAML_DEFAULT=0 |
| 2689 |
|
|
val SCE_CAML_IDENTIFIER=1 |
| 2690 |
|
|
val SCE_CAML_TAGNAME=2 |
| 2691 |
|
|
val SCE_CAML_KEYWORD=3 |
| 2692 |
|
|
val SCE_CAML_KEYWORD2=4 |
| 2693 |
|
|
val SCE_CAML_LINENUM=5 |
| 2694 |
|
|
val SCE_CAML_OPERATOR=6 |
| 2695 |
|
|
val SCE_CAML_NUMBER=7 |
| 2696 |
|
|
val SCE_CAML_CHAR=8 |
| 2697 |
|
|
val SCE_CAML_STRING=9 |
| 2698 |
|
|
val SCE_CAML_COMMENT=10 |
| 2699 |
|
|
val SCE_CAML_COMMENT1=11 |
| 2700 |
|
|
val SCE_CAML_COMMENT2=12 |
| 2701 |
|
|
val SCE_CAML_COMMENT3=13 |
| 2702 |
|
|
# Lexical states for SCLEX_HASKELL |
| 2703 |
|
|
lex Haskell=SCLEX_HASKELL SCE_HA_ |
| 2704 |
|
|
val SCE_HA_DEFAULT=0 |
| 2705 |
|
|
val SCE_HA_IDENTIFIER=1 |
| 2706 |
|
|
val SCE_HA_KEYWORD=2 |
| 2707 |
|
|
val SCE_HA_NUMBER=3 |
| 2708 |
|
|
val SCE_HA_STRING=4 |
| 2709 |
|
|
val SCE_HA_CHARACTER=5 |
| 2710 |
|
|
val SCE_HA_CLASS=6 |
| 2711 |
|
|
val SCE_HA_MODULE=7 |
| 2712 |
|
|
val SCE_HA_CAPITAL=8 |
| 2713 |
|
|
val SCE_HA_DATA=9 |
| 2714 |
|
|
val SCE_HA_IMPORT=10 |
| 2715 |
|
|
val SCE_HA_OPERATOR=11 |
| 2716 |
|
|
val SCE_HA_INSTANCE=12 |
| 2717 |
|
|
val SCE_HA_COMMENTLINE=13 |
| 2718 |
|
|
val SCE_HA_COMMENTBLOCK=14 |
| 2719 |
|
|
val SCE_HA_COMMENTBLOCK2=15 |
| 2720 |
|
|
val SCE_HA_COMMENTBLOCK3=16 |
| 2721 |
|
|
# Lexical states of SCLEX_TADS3 |
| 2722 |
|
|
lex TADS3=SCLEX_TADS3 SCE_T3_ |
| 2723 |
|
|
val SCE_T3_DEFAULT=0 |
| 2724 |
|
|
val SCE_T3_X_DEFAULT=1 |
| 2725 |
|
|
val SCE_T3_PREPROCESSOR=2 |
| 2726 |
|
|
val SCE_T3_BLOCK_COMMENT=3 |
| 2727 |
|
|
val SCE_T3_LINE_COMMENT=4 |
| 2728 |
|
|
val SCE_T3_OPERATOR=5 |
| 2729 |
|
|
val SCE_T3_KEYWORD=6 |
| 2730 |
|
|
val SCE_T3_NUMBER=7 |
| 2731 |
|
|
val SCE_T3_IDENTIFIER=8 |
| 2732 |
|
|
val SCE_T3_S_STRING=9 |
| 2733 |
|
|
val SCE_T3_D_STRING=10 |
| 2734 |
|
|
val SCE_T3_X_STRING=11 |
| 2735 |
|
|
val SCE_T3_LIB_DIRECTIVE=12 |
| 2736 |
|
|
val SCE_T3_MSG_PARAM=13 |
| 2737 |
|
|
val SCE_T3_HTML_TAG=14 |
| 2738 |
|
|
val SCE_T3_HTML_DEFAULT=15 |
| 2739 |
|
|
val SCE_T3_HTML_STRING=16 |
| 2740 |
|
|
val SCE_T3_USER1=17 |
| 2741 |
|
|
val SCE_T3_USER2=18 |
| 2742 |
|
|
val SCE_T3_USER3=19 |
| 2743 |
|
|
# Lexical states for SCLEX_REBOL |
| 2744 |
|
|
lex Rebol=SCLEX_REBOL SCE_REBOL_ |
| 2745 |
|
|
val SCE_REBOL_DEFAULT=0 |
| 2746 |
|
|
val SCE_REBOL_COMMENTLINE=1 |
| 2747 |
|
|
val SCE_REBOL_COMMENTBLOCK=2 |
| 2748 |
|
|
val SCE_REBOL_PREFACE=3 |
| 2749 |
|
|
val SCE_REBOL_OPERATOR=4 |
| 2750 |
|
|
val SCE_REBOL_CHARACTER=5 |
| 2751 |
|
|
val SCE_REBOL_QUOTEDSTRING=6 |
| 2752 |
|
|
val SCE_REBOL_BRACEDSTRING=7 |
| 2753 |
|
|
val SCE_REBOL_NUMBER=8 |
| 2754 |
|
|
val SCE_REBOL_PAIR=9 |
| 2755 |
|
|
val SCE_REBOL_TUPLE=10 |
| 2756 |
|
|
val SCE_REBOL_BINARY=11 |
| 2757 |
|
|
val SCE_REBOL_MONEY=12 |
| 2758 |
|
|
val SCE_REBOL_ISSUE=13 |
| 2759 |
|
|
val SCE_REBOL_TAG=14 |
| 2760 |
|
|
val SCE_REBOL_FILE=15 |
| 2761 |
|
|
val SCE_REBOL_EMAIL=16 |
| 2762 |
|
|
val SCE_REBOL_URL=17 |
| 2763 |
|
|
val SCE_REBOL_DATE=18 |
| 2764 |
|
|
val SCE_REBOL_TIME=19 |
| 2765 |
|
|
val SCE_REBOL_IDENTIFIER=20 |
| 2766 |
|
|
val SCE_REBOL_WORD=21 |
| 2767 |
|
|
val SCE_REBOL_WORD2=22 |
| 2768 |
|
|
val SCE_REBOL_WORD3=23 |
| 2769 |
|
|
val SCE_REBOL_WORD4=24 |
| 2770 |
|
|
val SCE_REBOL_WORD5=25 |
| 2771 |
|
|
val SCE_REBOL_WORD6=26 |
| 2772 |
|
|
val SCE_REBOL_WORD7=27 |
| 2773 |
|
|
val SCE_REBOL_WORD8=28 |
| 2774 |
|
|
# Lexical states for SCLEX_SQL |
| 2775 |
|
|
lex SQL=SCLEX_SQL SCE_SQL_ |
| 2776 |
|
|
val SCE_SQL_DEFAULT=0 |
| 2777 |
|
|
val SCE_SQL_COMMENT=1 |
| 2778 |
|
|
val SCE_SQL_COMMENTLINE=2 |
| 2779 |
|
|
val SCE_SQL_COMMENTDOC=3 |
| 2780 |
|
|
val SCE_SQL_NUMBER=4 |
| 2781 |
|
|
val SCE_SQL_WORD=5 |
| 2782 |
|
|
val SCE_SQL_STRING=6 |
| 2783 |
|
|
val SCE_SQL_CHARACTER=7 |
| 2784 |
|
|
val SCE_SQL_SQLPLUS=8 |
| 2785 |
|
|
val SCE_SQL_SQLPLUS_PROMPT=9 |
| 2786 |
|
|
val SCE_SQL_OPERATOR=10 |
| 2787 |
|
|
val SCE_SQL_IDENTIFIER=11 |
| 2788 |
|
|
val SCE_SQL_SQLPLUS_COMMENT=13 |
| 2789 |
|
|
val SCE_SQL_COMMENTLINEDOC=15 |
| 2790 |
|
|
val SCE_SQL_WORD2=16 |
| 2791 |
|
|
val SCE_SQL_COMMENTDOCKEYWORD=17 |
| 2792 |
|
|
val SCE_SQL_COMMENTDOCKEYWORDERROR=18 |
| 2793 |
|
|
val SCE_SQL_USER1=19 |
| 2794 |
|
|
val SCE_SQL_USER2=20 |
| 2795 |
|
|
val SCE_SQL_USER3=21 |
| 2796 |
|
|
val SCE_SQL_USER4=22 |
| 2797 |
|
|
# Lexical states for SCLEX_SMALLTALK |
| 2798 |
|
|
lex Smalltalk=SCLEX_SMALLTALK SCE_ST_ |
| 2799 |
|
|
val SCE_ST_DEFAULT=0 |
| 2800 |
|
|
val SCE_ST_STRING=1 |
| 2801 |
|
|
val SCE_ST_NUMBER=2 |
| 2802 |
|
|
val SCE_ST_COMMENT=3 |
| 2803 |
|
|
val SCE_ST_SYMBOL=4 |
| 2804 |
|
|
val SCE_ST_BINARY=5 |
| 2805 |
|
|
val SCE_ST_BOOL=6 |
| 2806 |
|
|
val SCE_ST_SELF=7 |
| 2807 |
|
|
val SCE_ST_SUPER=8 |
| 2808 |
|
|
val SCE_ST_NIL=9 |
| 2809 |
|
|
val SCE_ST_GLOBAL=10 |
| 2810 |
|
|
val SCE_ST_RETURN=11 |
| 2811 |
|
|
val SCE_ST_SPECIAL=12 |
| 2812 |
|
|
val SCE_ST_KWSEND=13 |
| 2813 |
|
|
val SCE_ST_ASSIGN=14 |
| 2814 |
|
|
val SCE_ST_CHARACTER=15 |
| 2815 |
|
|
val SCE_ST_SPEC_SEL=16 |
| 2816 |
|
|
# Lexical states for SCLEX_FLAGSHIP (clipper) |
| 2817 |
|
|
lex FlagShip=SCLEX_FLAGSHIP SCE_FS_ |
| 2818 |
|
|
val SCE_FS_DEFAULT=0 |
| 2819 |
|
|
val SCE_FS_COMMENT=1 |
| 2820 |
|
|
val SCE_FS_COMMENTLINE=2 |
| 2821 |
|
|
val SCE_FS_COMMENTDOC=3 |
| 2822 |
|
|
val SCE_FS_COMMENTLINEDOC=4 |
| 2823 |
|
|
val SCE_FS_COMMENTDOCKEYWORD=5 |
| 2824 |
|
|
val SCE_FS_COMMENTDOCKEYWORDERROR=6 |
| 2825 |
|
|
val SCE_FS_KEYWORD=7 |
| 2826 |
|
|
val SCE_FS_KEYWORD2=8 |
| 2827 |
|
|
val SCE_FS_KEYWORD3=9 |
| 2828 |
|
|
val SCE_FS_KEYWORD4=10 |
| 2829 |
|
|
val SCE_FS_NUMBER=11 |
| 2830 |
|
|
val SCE_FS_STRING=12 |
| 2831 |
|
|
val SCE_FS_PREPROCESSOR=13 |
| 2832 |
|
|
val SCE_FS_OPERATOR=14 |
| 2833 |
|
|
val SCE_FS_IDENTIFIER=15 |
| 2834 |
|
|
val SCE_FS_DATE=16 |
| 2835 |
|
|
val SCE_FS_STRINGEOL=17 |
| 2836 |
|
|
val SCE_FS_CONSTANT=18 |
| 2837 |
|
|
val SCE_FS_ASM=19 |
| 2838 |
|
|
val SCE_FS_LABEL=20 |
| 2839 |
|
|
val SCE_FS_ERROR=21 |
| 2840 |
|
|
val SCE_FS_HEXNUMBER=22 |
| 2841 |
|
|
val SCE_FS_BINNUMBER=23 |
| 2842 |
|
|
# Lexical states for SCLEX_CSOUND |
| 2843 |
|
|
lex Csound=SCLEX_CSOUND SCE_CSOUND_ |
| 2844 |
|
|
val SCE_CSOUND_DEFAULT=0 |
| 2845 |
|
|
val SCE_CSOUND_COMMENT=1 |
| 2846 |
|
|
val SCE_CSOUND_NUMBER=2 |
| 2847 |
|
|
val SCE_CSOUND_OPERATOR=3 |
| 2848 |
|
|
val SCE_CSOUND_INSTR=4 |
| 2849 |
|
|
val SCE_CSOUND_IDENTIFIER=5 |
| 2850 |
|
|
val SCE_CSOUND_OPCODE=6 |
| 2851 |
|
|
val SCE_CSOUND_HEADERSTMT=7 |
| 2852 |
|
|
val SCE_CSOUND_USERKEYWORD=8 |
| 2853 |
|
|
val SCE_CSOUND_COMMENTBLOCK=9 |
| 2854 |
|
|
val SCE_CSOUND_PARAM=10 |
| 2855 |
|
|
val SCE_CSOUND_ARATE_VAR=11 |
| 2856 |
|
|
val SCE_CSOUND_KRATE_VAR=12 |
| 2857 |
|
|
val SCE_CSOUND_IRATE_VAR=13 |
| 2858 |
|
|
val SCE_CSOUND_GLOBAL_VAR=14 |
| 2859 |
|
|
val SCE_CSOUND_STRINGEOL=15 |
| 2860 |
|
|
|
| 2861 |
|
|
# Events |
| 2862 |
|
|
|
| 2863 |
|
|
evt void StyleNeeded=2000(int position) |
| 2864 |
|
|
evt void CharAdded=2001(int ch) |
| 2865 |
|
|
evt void SavePointReached=2002(void) |
| 2866 |
|
|
evt void SavePointLeft=2003(void) |
| 2867 |
|
|
evt void ModifyAttemptRO=2004(void) |
| 2868 |
|
|
# GTK+ Specific to work around focus and accelerator problems: |
| 2869 |
|
|
evt void Key=2005(int ch, int modifiers) |
| 2870 |
|
|
evt void DoubleClick=2006(void) |
| 2871 |
|
|
evt void UpdateUI=2007(void) |
| 2872 |
|
|
evt void Modified=2008(int position, int modificationType, string text, int length, int linesAdded, int line, int foldLevelNow, int foldLevelPrev) |
| 2873 |
|
|
evt void MacroRecord=2009(int message, int wParam, int lParam) |
| 2874 |
|
|
evt void MarginClick=2010(int modifiers, int position, int margin) |
| 2875 |
|
|
evt void NeedShown=2011(int position, int length) |
| 2876 |
|
|
evt void Painted=2013(void) |
| 2877 |
|
|
evt void UserListSelection=2014(int listType, string text) |
| 2878 |
|
|
evt void URIDropped=2015(string text) |
| 2879 |
|
|
evt void DwellStart=2016(int position) |
| 2880 |
|
|
evt void DwellEnd=2017(int position) |
| 2881 |
|
|
evt void Zoom=2018(void) |
| 2882 |
|
|
evt void HotSpotClick=2019(int modifiers, int position) |
| 2883 |
|
|
evt void HotSpotDoubleClick=2020(int modifiers, int position) |
| 2884 |
|
|
evt void CallTipClick=2021(int position) |
| 2885 |
|
|
evt void AutoCSelection=2022(string text) |
| 2886 |
|
|
|
| 2887 |
|
|
cat Deprecated |
| 2888 |
|
|
|
| 2889 |
|
|
# CARET_POLICY changed in 1.47 |
| 2890 |
|
|
fun void SetCaretPolicy=2369(int caretPolicy, int caretSlop) |
| 2891 |
|
|
val CARET_CENTER=0x02 |
| 2892 |
|
|
val CARET_XEVEN=0x08 |
| 2893 |
|
|
val CARET_XJUMPS=0x10 |
| 2894 |
|
|
|
| 2895 |
|
|
# The old name for SCN_UPDATEUI |
| 2896 |
|
|
val SCN_CHECKBRACE=2007 |
| 2897 |
|
|
evt void PosChanged=2012(int position) |
| 2898 |
|
|
|
| 2899 |
|
|
# SCLEX_HTML should be used in preference to these. |
| 2900 |
|
|
val SCLEX_ASP=29 |
| 2901 |
|
|
val SCLEX_PHP=30 |
RSS Feed