ext/scintilla/include/Scintilla.iface

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