From a69b55c674b0528c00598bea54b7a661f4e49f27 Mon Sep 17 00:00:00 2001 From: gregory guy Date: Thu, 7 Oct 2021 15:17:57 +0200 Subject: Conversion to the cmake building system. Signed-off-by: gregory guy --- doc/Scintilla/ScintillaDoc.html | 5350 --------------------------------------- 1 file changed, 5350 deletions(-) delete mode 100644 doc/Scintilla/ScintillaDoc.html (limited to 'doc/Scintilla/ScintillaDoc.html') diff --git a/doc/Scintilla/ScintillaDoc.html b/doc/Scintilla/ScintillaDoc.html deleted file mode 100644 index 3767b3b..0000000 --- a/doc/Scintilla/ScintillaDoc.html +++ /dev/null @@ -1,5350 +0,0 @@ - - - - - - - - - - Scintilla and SciTE - - - - - - - - - - - -

- -

Scintilla Documentation

- -

Last edited 4/February/2006 NH

- -

There is an overview of the internal design of - Scintilla.
- Some notes on using Scintilla.
- How to use the Scintilla Edit Control on Windows.
- A simple sample using Scintilla from - C++ on Windows.
- A simple sample using Scintilla from - Visual Basic.
- Bait is a tiny sample using Scintilla - on GTK+.
- A detailed description of how to write a lexer, including a - discussion of folding.
- - How to implement a lexer in the container.
- - How to implement folding.
- The coding style used in Scintilla and SciTE is - worth following if you want to contribute code to Scintilla but is not compulsory.

- -

Introduction

- -

The Windows version of Scintilla is a Windows Control. As such, its primary programming - interface is through Windows messages. Early versions of Scintilla emulated much of the API - defined by the standard Windows Edit and RichEdit controls but those APIs are now deprecated in - favour of Scintilla's own, more consistent API. In addition to messages performing the actions - of a normal Edit control, Scintilla allows control of syntax styling, folding, markers, autocompletion - and call tips.

- -

The GTK+ version also uses messages in a similar way to the Windows version. This is - different to normal GTK+ practice but made it easier to implement rapidly.

- -

This documentation describes the individual messages and notifications used by Scintilla. It - does not describe how to link them together to form a useful editor. For now, the best way to - work out how to develop using Scintilla is to see how SciTE uses it. SciTE exercises most of - Scintilla's facilities.

- -

In the descriptions that follow, the messages are described as function calls with zero, one - or two arguments. These two arguments are the standard wParam and - lParam familiar to Windows programmers. These parameters are integers that - are large enough to hold pointers, and the return value is also an integer large enough to contain a - pointer. - Although the commands only use the - arguments described, because all messages have two arguments whether Scintilla uses them or - not, it is strongly recommended that any unused arguments are set to 0. This allows future - enhancement of messages without the risk of breaking existing code. Common argument types - are:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

bool	Arguments expect the values 0 for `false` and 1 for - `true`.
int	Arguments are 32-bit signed integers.
const char *	Arguments point at text that is being passed to Scintilla but not modified. The text - may be zero terminated or another argument may specify the character count, the - description will make this clear.
char *	Arguments point at text buffers that Scintilla will fill with text. In some cases, - another argument will tell Scintilla the buffer size. In others, you must make sure that - the buffer is big enough to hold the requested text. If a NULL pointer (0) is passed - then, for SCI_* calls, the length that should be allocated is returned.
colour	Colours are set using the RGB format (Red, Green, Blue). The intensity of each colour - is set in the range 0 to 255. If you have three such intensities, they are combined as: - red \| (green << 8) \| (blue << 16). If you set all intensities to 255, the - colour is white. If you set all intensities to 0, the colour is black. When you set a - colour, you are making a request. What you will get depends on the capabilities of the - system and the current screen mode.
alpha	Translucency is set using an alpha value. - Alpha ranges from 0 (SC_ALPHA_TRANSPARENT) which is completely transparent to - 255 (SC_ALPHA_OPAQUE) which is opaque. The value 256 (SC_ALPHA_NOALPHA) - is opaque and uses code that is not alpha-aware and may be faster. Not all platforms support - translucency and only some Scintilla features implement translucency. - The default alpha value for most features is SC_ALPHA_NOALPHA.
<unused>	This is an unused argument. Setting it to 0 will ensure compatibility with future - enhancements.

- -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

o Text retrieval and - modification	o Searching and replacing	o Overtype
o Cut, copy and paste	o Error handling	o Undo and Redo
o Selection and information	o Scrolling and automatic - scrolling	o White space
o Cursor	o Mouse capture	o Line endings
o Styling	o Style definition	o Caret, selection, and hotspot styles
o Margins	o Other settings	o Brace highlighting
o Tabs and Indentation - Guides	o Markers	o Indicators
o Autocompletion	o User lists	o Call tips
o Keyboard commands	o Key bindings	o Popup edit menu
o Macro recording	o Printing	o Direct access
o Multiple views	o Folding	o Line wrapping
o Zooming	o Long lines	o Lexer
o Notifications	o GTK+	o Deprecated messages
o Edit messages never - supported by Scintilla	o Building Scintilla

- -

Messages with names of the form SCI_SETxxxxx often have a companion - SCI_GETxxxxx. To save tedious repetition, if the SCI_GETxxxxx message - returns the value set by the SCI_SETxxxxx message, the SET routine is - described and the GET routine is left to your imagination.

- -

Text retrieval and modification

- -

Each character in a Scintilla document is followed by an associated byte of styling - information. The combination of a character byte and a style byte is called a cell. Style bytes - are interpreted as a style index in the low 5 bits and as 3 individual bits of indicators. This allows 32 fundamental styles, which is enough for most - languages, and three independent indicators so that, for example, syntax errors, deprecated - names and bad indentation could all be displayed at once. The number of bits used for styles - can be altered with SCI_SETSTYLEBITS up to a maximum of 7 bits. - The remaining bits can be used for indicators.

- -

Positions within the Scintilla document refer to a character or the gap before that - character. The first character in a document is 0, the second 1 and so on. If a document - contains nLen characters, the last character is numbered nLen-1. - The caret exists between character positions and can be located from before the first character (0) - to after the last character (nLen).

- -

There are places where the caret can not go where two character bytes make up one character. - This occurs when a DBCS character from a language like Japanese is included in the document or - when line ends are marked with the CP/M standard of a carriage return followed by a line feed. - The INVALID_POSITION constant (-1) represents an invalid position within the - document.

- -

All lines of text in Scintilla are the same height, and this height is calculated from the - largest font in any current style. This restriction is for performance; if lines differed in - height then calculations involving positioning of text would require the text to be styled - first.

SCI_GETTEXT(int length, char *text)

-     SCI_SETTEXT(<unused>, const char *text)

-     SCI_SETSAVEPOINT

-     SCI_GETLINE(int line, char *text)

-     SCI_REPLACESEL(<unused>, const char
-    *text)

-     SCI_SETREADONLY(bool readOnly)

-     SCI_GETREADONLY

-     SCI_GETTEXTRANGE(<unused>, TextRange
-    *tr)

-     SCI_ALLOCATE(int bytes, <unused>)

-     SCI_ADDTEXT(int length, const char *s)

-     SCI_ADDSTYLEDTEXT(int length, cell *s)

-     SCI_APPENDTEXT(int length, const char *s)

-     SCI_INSERTTEXT(int pos, const char *text)

-     SCI_CLEARALL

-     SCI_CLEARDOCUMENTSTYLE

-     SCI_GETCHARAT(int position)

-     SCI_GETSTYLEAT(int position)

-     SCI_GETSTYLEDTEXT(<unused>, TextRange
-    *tr)

-     SCI_SETSTYLEBITS(int bits)

-     SCI_GETSTYLEBITS

-     SCI_TARGETASUTF8(<unused>, char *s)

-     SCI_ENCODEDFROMUTF8(const char *utf8, char *encoded)

-     SCI_SETLENGTHFORENCODE(int bytes)

-

- -

SCI_GETTEXT(int length, char *text)
- This returns length-1 characters of text from the start of the document plus one - terminating 0 character. To collect all the text in a document, use SCI_GETLENGTH - to get the number of characters in the document (nLen), allocate a character - buffer of length nLen+1 bytes, then call SCI_GETTEXT(nLen+1, char - *text). If the text argument is 0 then the length that should be allocated to store the - entire document is returned. - If you then save the text, you should use SCI_SETSAVEPOINT to mark - the text as unmodified.

- -

SCI_SETTEXT(<unused>, const char *text)
- This replaces all the text in the document with the zero terminated text string you pass - in.

- -

SCI_SETSAVEPOINT
- This message tells Scintilla that the current state of the document is unmodified. This is - usually done when the file is saved or loaded, hence the name "save point". As Scintilla - performs undo and redo operations, it notifies the container that it has entered or left the - save point with SCN_SAVEPOINTREACHED and SCN_SAVEPOINTLEFT notification messages, allowing the container to know if the file - should be considered dirty or not.

- -

See also: SCI_EMPTYUNDOBUFFER, SCI_GETMODIFY

- -

SCI_GETLINE(int line, char *text)
- This fills the buffer defined by text with the contents of the nominated line (lines start at - 0). The buffer is not terminated by a 0 character. It is up to you to make sure that the buffer - is long enough for the text, use SCI_LINELENGTH(int line). The returned value is the - number of characters copied to the buffer. The returned text includes any end of line - characters. If you ask for a line number outside the range of lines in the document, 0 - characters are copied. If the text argument is 0 then the length that should be allocated - to store the entire line is returned.

- -

SCI_REPLACESEL(<unused>, const char *text)
- The currently selected text between the anchor - and the current position is replaced by the 0 terminated text string. If the anchor and - current position are the same, the text is inserted at the caret position. The caret is - positioned after the inserted text and the caret is scrolled into view.

- -

SCI_SETREADONLY(bool readOnly)
- SCI_GETREADONLY
- These messages set and get the read-only flag for the document. If you mark a document as read - only, attempts to modify the text cause the SCN_MODIFYATTEMPTRO notification.

- -

SCI_GETTEXTRANGE(<unused>, TextRange *tr)
- This collects the text between the positions cpMin and cpMax and - copies it to lpstrText (see struct TextRange in - Scintilla.h). If cpMax is -1, text is returned to the end of the - document. The text is 0 terminated, so you must supply a buffer that is at least 1 character - longer than the number of characters you wish to read. The return value is the length of the - returned text not including the terminating 0.

- -

SCI_GETSTYLEDTEXT(<unused>, TextRange *tr)
- This collects styled text into a buffer using two bytes for each cell, with the character at - the lower address of each pair and the style byte at the upper address. Characters between the - positions cpMin and cpMax are copied to lpstrText (see - struct TextRange in Scintilla.h). Two 0 bytes are added to the end of - the text, so the buffer that lpstrText points at must be at least - 2*(cpMax-cpMin)+2 bytes long. No check is made for sensible values of - cpMin or cpMax. Positions outside the document return character codes - and style bytes of 0.

- -

SCI_ALLOCATE(int bytes, <unused>)
- Allocate a document buffer large enough to store a given number of bytes. - The document will not be made smaller than its current contents.

- -

SCI_ADDTEXT(int length, const char *s)
- This inserts the first length characters from the string s - at the current position. This will include any 0's in the string that you might have expected - to stop the insert operation. The current position is set at the end of the inserted text, - but it is not scrolled into view.

- -

SCI_ADDSTYLEDTEXT(int length, cell *s)
- This behaves just like SCI_ADDTEXT, but inserts styled text.

- -

SCI_APPENDTEXT(int length, const char *s)
- This adds the first length characters from the string s to the end - of the document. This will include any 0's in the string that you might have expected to stop - the operation. The current selection is not changed and the new text is not scrolled into - view.

- -

SCI_INSERTTEXT(int pos, const char *text)
- This inserts the zero terminated text string at position pos or at - the current position if pos is -1. If the current position is after the insertion point - then it is moved along with its surrounding text but no scrolling is performed.

- -

SCI_CLEARALL
- Unless the document is read-only, this deletes all the text.

- -

SCI_CLEARDOCUMENTSTYLE
- When wanting to completely restyle the document, for example after choosing a lexer, the - SCI_CLEARDOCUMENTSTYLE can be used to clear all styling information and reset the - folding state.

- -

SCI_GETCHARAT(int pos)
- This returns the character at pos in the document or 0 if pos is - negative or past the end of the document.

- -

SCI_GETSTYLEAT(int pos)
- This returns the style at pos in the document, or 0 if pos is - negative or past the end of the document.

- -

SCI_SETSTYLEBITS(int bits)
- SCI_GETSTYLEBITS
- This pair of routines sets and reads back the number of bits in each cell to use for styling, - to a maximum of 7 style bits. The remaining bits can be used as indicators. The standard - setting is SCI_SETSTYLEBITS(5). - The number of styling bits needed by the current lexer can be found with - SCI_GETSTYLEBITSNEEDED.

- -

TextRange and CharacterRange
- These structures are defined to be exactly the same shape as the Win32 TEXTRANGE - and CHARRANGE, so that older code that treats Scintilla as a RichEdit will - work.

-struct CharacterRange {
-    long cpMin;
-    long cpMax;
-};
-
-struct TextRange {
-    struct CharacterRange chrg;
-    char *lpstrText;
-};
-

- -

GTK+-specific: Access to encoded text

- -

SCI_TARGETASUTF8(<unused>, char *s)
- This method retrieves the value of the target encoded as UTF-8 which is the default - encoding of GTK+ so is useful for retrieving text for use in other parts of the user interface, - such as find and replace dialogs. The length of the encoded text in bytes is returned. -

- -

SCI_ENCODEDFROMUTF8(const char *utf8, char *encoded)
- SCI_SETLENGTHFORENCODE(int bytes)
- SCI_ENCODEDFROMUTF8 converts a UTF-8 string into the document's - encoding which is useful for taking the results of a find dialog, for example, and receiving - a string of bytes that can be searched for in the document. Since the text can contain nul bytes, - the SCI_SETLENGTHFORENCODE method can be used to set the - length that will be converted. If set to -1, the length is determined by finding a nul byte. - The length of the converted string is returned. -

- - -

Searching

SCI_FINDTEXT(int flags, TextToFind
-    *ttf)

-     SCI_SEARCHANCHOR

-     SCI_SEARCHNEXT(int searchFlags, const char
-    *text)

-     SCI_SEARCHPREV(int searchFlags, const char
-    *text)

-     Search and replace using the
-    target

-

- -

searchFlags
- Several of the search routines use flag options, which include a simple regular expression - search. Combine the flag options by adding them:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

`SCFIND_MATCHCASE`	A match only occurs with text that matches the case of the search string.
`SCFIND_WHOLEWORD`	A match only occurs if the characters before and after are not word characters.
`SCFIND_WORDSTART`	A match only occurs if the character before is not a word character.
`SCFIND_REGEXP`	The search string should be interpreted as a regular expression.
`SCFIND_POSIX`	Treat regular expression in a more POSIX compatible manner - by interpreting bare ( and ) for tagged sections rather than $ and $.

- -

If SCFIND_REGEXP is not included in the searchFlags, you can - search backwards to find the previous occurrence of a search string by setting the end of the - search range before the start. If SCFIND_REGEXP is included, searches are always - from a lower position to a higher position, even if the search range is backwards.

- -

In a regular expression, special characters interpreted are:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

`.`	Matches any character
`\(`	This marks the start of a region for tagging a match.
`\)`	This marks the end of a tagged region.
`\n`	Where `n` is 1 through 9 refers to the first through ninth tagged region - when replacing. For example, if the search string was `Fred$[1-9]$XXX` and - the replace string was `Sam\1YYY`, when applied to `Fred2XXX` this - would generate `Sam2YYY`.
`\<`	This matches the start of a word using Scintilla's definitions of words.
\>	This matches the end of a word using Scintilla's definition of words.
`\x`	This allows you to use a character x that would otherwise have a special meaning. For - example, \[ would be interpreted as [ and not as the start of a character set.
`[...]`	This indicates a set of characters, for example, [abc] means any of the characters a, - b or c. You can also use ranges, for example [a-z] for any lower case character.
`[^...]`	The complement of the characters in the set. For example, [^A-Za-z] means any - character except an alphabetic character.
`^`	This matches the start of a line (unless used inside a set, see above).
`$`	This matches the end of a line.
`*`	This matches 0 or more times. For example, `Sa*m` matches `Sm`, - `Sam`, `Saam`, `Saaam` and so on.
`+`	This matches 1 or more times. For example, `Sa+m` matches - `Sam`, `Saam`, `Saaam` and so on.

- -

SCI_FINDTEXT(int searchFlags, TextToFind *ttf)
- This message searches for text in the document. It does not use or move the current selection. - The searchFlags argument controls the - search type, which includes regular expression searches.

- -

The TextToFind structure is defined in Scintilla.h; set - chrg.cpMin and chrg.cpMax with the range of positions in the document - to search. If SCFIND_REGEXP is not included in the flags, you can search backwards by - setting chrg.cpMax less than chrg.cpMin. If SCFIND_REGEXP - is included, the search is always forwards (even if chrg.cpMax is less than chrg.cpMin). - Set the lpstrText member of TextToFind to point at a zero terminated - text string holding the search pattern. If your language makes the use of TextToFind - difficult, you should consider using SCI_SEARCHINTARGET instead.

- -

The return value is -1 if the search fails or the position of the start of the found text if - it succeeds. The chrgText.cpMin and chrgText.cpMax members of - TextToFind are filled in with the start and end positions of the found text.

- -

Search and replace using the target

- -

Using SCI_REPLACESEL, - modifications cause scrolling and other visible changes, which may take some time and cause - unwanted display updates. If performing many changes, such as a replace all command, the target - can be used instead. First, set the target, ie. the range to be replaced. Then call - SCI_REPLACETARGET or SCI_REPLACETARGETRE.

- -

Searching can be performed within the target range with SCI_SEARCHINTARGET, - which uses a counted string to allow searching for null characters. It returns the length of - range or -1 for failure, in which case the target is not moved. The flags used by - SCI_SEARCHINTARGET such as SCFIND_MATCHCASE, - SCFIND_WHOLEWORD, SCFIND_WORDSTART, and SCFIND_REGEXP - can be set with SCI_SETSEARCHFLAGS. SCI_SEARCHINTARGET may be simpler - for some clients to use than SCI_FINDTEXT, as that requires using a pointer to a - structure.

SCI_SETTARGETSTART(int pos)

-     SCI_GETTARGETSTART

-     SCI_SETTARGETEND(int pos)

-     SCI_GETTARGETEND

-     SCI_TARGETFROMSELECTION

-     SCI_SETSEARCHFLAGS(int searchFlags)

-     SCI_GETSEARCHFLAGS

-     SCI_SEARCHINTARGET(int length, const char
-    *text)

-     SCI_REPLACETARGET(int length, const char
-    *text)

-     SCI_REPLACETARGETRE(int length, const char
-    *text)

-

- -

SCI_SETTARGETSTART(int pos)
- SCI_GETTARGETSTART
- SCI_SETTARGETEND(int pos)
- SCI_GETTARGETEND
- These functions set and return the start and end of the target. When searching in non-regular - expression mode, you can set start greater than end to find the last matching text in the - target rather than the first matching text. The target is also set by a successful - SCI_SEARCHINTARGET.

- -

SCI_TARGETFROMSELECTION
- Set the target start and end to the start and end positions of the selection.

- -

SCI_SETSEARCHFLAGS(int searchFlags)
- SCI_GETSEARCHFLAGS
- These get and set the searchFlags used by - SCI_SEARCHINTARGET. There are several option flags including a simple regular - expression search.

- -

SCI_SEARCHINTARGET(int length, const char *text)
- This searches for the first occurrence of a text string in the target defined by - SCI_SETTARGETSTART and SCI_SETTARGETEND. The text string is not zero - terminated; the size is set by length. The search is modified by the search flags - set by SCI_SETSEARCHFLAGS. If the search succeeds, the target is set to the found - text and the return value is the position of the start of the matching text. If the search - fails, the result is -1.

- -

SCI_REPLACETARGET(int length, const char *text)
- If length is -1, text is a zero terminated string, otherwise - length sets the number of character to replace the target with. - After replacement, the target range refers to the replacement text. - The return value - is the length of the replacement string.
- Note that the recommended way to delete text in the document is to set the target to the text to be removed, - and to perform a replace target with an empty string.

- -

SCI_REPLACETARGETRE(int length, const char *text)
- This replaces the target using regular expressions. If length is -1, - text is a zero terminated string, otherwise length is the number of - characters to use. The replacement string is formed from the text string with any sequences of - \1 through \9 replaced by tagged matches from the most recent regular - expression search. - After replacement, the target range refers to the replacement text. - The return value is the length of the replacement string.

- -

Overtype

- -

SCI_SETOVERTYPE(bool overType)
- SCI_GETOVERTYPE
- When overtype is enabled, each typed character replaces the character to the right of the text - caret. When overtype is disabled, characters are inserted at the caret. - SCI_GETOVERTYPE returns TRUE (1) if overtyping is active, otherwise - FALSE (0) will be returned. Use SCI_SETOVERTYPE to set the overtype - mode.

- -

Cut, copy and paste

- -

SCI_CUT

-     SCI_COPY

-     SCI_PASTE

-     SCI_CLEAR

-     SCI_CANPASTE

-     SCI_COPYRANGE(int start, int end)

-     SCI_COPYTEXT(int length,
-     const char *text)

-     SCI_SETPASTECONVERTENDINGS(bool convert)

-     SCI_GETPASTECONVERTENDINGS

-

- -

SCI_CUT
- SCI_COPY
- SCI_PASTE
- SCI_CLEAR
- SCI_CANPASTE
- These commands perform the standard tasks of cutting and copying data to the clipboard, - pasting from the clipboard into the document, and clearing the document. - SCI_CANPASTE returns non-zero if the document isn't read-only and if the selection - doesn't contain protected text. If you need a "can copy" or "can cut", use - SCI_GETSELECTIONSTART()-SCI_GETSELECTIONEND(), which will be non-zero if you can - copy or cut to the clipboard.

- -

GTK+ does not really support SCI_CANPASTE and always returns TRUE - unless the document is read-only.

- -

On X, the clipboard is asynchronous and may require several messages between - the destination and source applications. Data from SCI_PASTE will not arrive in the - document immediately.

- - SCI_COPYRANGE(int start, int end)
- SCI_COPYTEXT(int length, const char *text)
-

SCI_COPYRANGE copies a range of text from the document to - the system clipboard and SCI_COPYTEXT copies a supplied piece of - text to the system clipboard.

- -

SCI_SETPASTECONVERTENDINGS(bool convert)
- SCI_GETPASTECONVERTENDINGS
- If this property is set then when text is pasted any line ends are converted to match the document's - end of line mode as set with - SCI_SETEOLMODE. - Currently only changeable on Windows. On GTK+ pasted text is always converted.

- -

Error handling

- -

SCI_SETSTATUS(int status)
- SCI_GETSTATUS
- If an error occurs, Scintilla may set an internal error number that can be retrieved with - SCI_GETSTATUS. Not currently used but will be in the future. To clear the error - status call SCI_SETSTATUS(0).

- -

Undo and Redo

- -

Scintilla has multiple level undo and redo. It will continue to collect undoable actions - until memory runs out. Scintilla saves actions that change the document. Scintilla does not - save caret and selection movements, view scrolling and the like. Sequences of typing or - deleting are compressed into single actions to make it easier to undo and redo at a sensible - level of detail. Sequences of actions can be combined into actions that are undone as a unit. - These sequences occur between SCI_BEGINUNDOACTION and - SCI_ENDUNDOACTION messages. These sequences can be nested and only the top-level - sequences are undone as units.

SCI_UNDO

-     SCI_CANUNDO

-     SCI_EMPTYUNDOBUFFER

-     SCI_REDO

-     SCI_CANREDO

-     SCI_SETUNDOCOLLECTION(bool
-    collectUndo)

-     SCI_GETUNDOCOLLECTION

-     SCI_BEGINUNDOACTION

-     SCI_ENDUNDOACTION

-

- -

SCI_UNDO
- SCI_CANUNDO
- SCI_UNDO undoes one action, or if the undo buffer has reached a - SCI_ENDUNDOACTION point, all the actions back to the corresponding - SCI_BEGINUNDOACTION.

- -

SCI_CANUNDO returns 0 if there is nothing to undo, and 1 if there is. You would - typically use the result of this message to enable/disable the Edit menu Undo command.

- -

SCI_REDO
- SCI_CANREDO
- SCI_REDO undoes the effect of the last SCI_UNDO operation.

- -

SCI_CANREDO returns 0 if there is no action to redo and 1 if there are undo - actions to redo. You could typically use the result of this message to enable/disable the Edit - menu Redo command.

- -

SCI_EMPTYUNDOBUFFER
- This command tells Scintilla to forget any saved undo or redo history. It also sets the save - point to the start of the undo buffer, so the document will appear to be unmodified. This does - not cause the SCN_SAVEPOINTREACHED notification to be sent to the - container.

- -

Selection and information

- -

Scintilla maintains a selection that stretches between two points, the anchor and the - current position. If the anchor and the current position are the same, there is no selected - text. Positions in the document range from 0 (before the first character), to the document size - (after the last character). If you use messages, there is nothing to stop you setting a - position that is in the middle of a CRLF pair, or in the middle of a 2 byte character. However, - keyboard commands will not move the caret into such positions.

SCI_GETTEXTLENGTH

-     SCI_GETLENGTH

-     SCI_GETLINECOUNT

-     SCI_GETFIRSTVISIBLELINE

-     SCI_LINESONSCREEN

-     SCI_GETMODIFY

-     SCI_SETSEL(int anchorPos, int currentPos)

-     SCI_GOTOPOS(int position)

-     SCI_GOTOLINE(int line)

-     SCI_SETCURRENTPOS(int position)

-     SCI_GETCURRENTPOS

-     SCI_SETANCHOR(int position)

-     SCI_GETANCHOR

-     SCI_SETSELECTIONSTART(int position)

-     SCI_GETSELECTIONSTART

-     SCI_SETSELECTIONEND(int position)

-     SCI_GETSELECTIONEND

-     SCI_SELECTALL

-     SCI_LINEFROMPOSITION(int position)

-     SCI_POSITIONFROMLINE(int line)

-     SCI_GETLINEENDPOSITION(int line)

-     SCI_LINELENGTH(int line)

-     SCI_GETCOLUMN(int position)

-     SCI_FINDCOLUMN(int line, int column)

-     SCI_POSITIONFROMPOINT(int x, int y)

-     SCI_POSITIONFROMPOINTCLOSE(int x, int
-    y)

-     SCI_POINTXFROMPOSITION(<unused>, int
-    position)

-     SCI_POINTYFROMPOSITION(<unused>, int
-    position)

-     SCI_HIDESELECTION(bool hide)

-     SCI_GETSELTEXT(<unused>, char *text)

-     SCI_GETCURLINE(int textLen, char *text)

-     SCI_SELECTIONISRECTANGLE

-     SCI_SETSELECTIONMODE(int mode)

-     SCI_GETSELECTIONMODE

-     SCI_GETLINESELSTARTPOSITION(int line)

-     SCI_GETLINESELENDPOSITION(int line)

-     SCI_MOVECARETINSIDEVIEW

-     SCI_WORDENDPOSITION(int position, bool
-    onlyWordCharacters)

-     SCI_WORDSTARTPOSITION(int position, bool
-    onlyWordCharacters)

-     SCI_POSITIONBEFORE(int position)

-     SCI_POSITIONAFTER(int position)

-     SCI_TEXTWIDTH(int styleNumber, const char *text)

-     SCI_TEXTHEIGHT(int line)

-     SCI_CHOOSECARETX

-

- -

SCI_GETTEXTLENGTH
- SCI_GETLENGTH
- Both these messages return the length of the document in characters.

- -

SCI_GETLINECOUNT
- This returns the number of lines in the document. An empty document contains 1 line. A - document holding only an end of line sequence has 2 lines.

- -

SCI_GETFIRSTVISIBLELINE
- This returns the line number of the first visible line in the Scintilla view. The first line - in the document is numbered 0. The value is a visible line rather than a document line.

- -

SCI_LINESONSCREEN
- This returns the number of complete lines visible on the screen. With a constant line height, - this is the vertical space available divided by the line separation. Unless you arrange to size - your window to an integral number of lines, there may be a partial line visible at the bottom - of the view.

- -

SCI_GETMODIFY
- This returns non-zero if the document is modified and 0 if it is unmodified. The modified - status of a document is determined by the undo position relative to the save point. The save - point is set by SCI_SETSAVEPOINT, - usually when you have saved data to a file.

- -

If you need to be notified when the document becomes modified, Scintilla notifies the - container that it has entered or left the save point with the SCN_SAVEPOINTREACHED and SCN_SAVEPOINTLEFT notification messages.

- -

SCI_SETSEL(int anchorPos, int currentPos)
- This message sets both the anchor and the current position. If currentPos is - negative, it means the end of the document. If anchorPos is negative, it means - remove any selection (i.e. set the anchor to the same position as currentPos). The - caret is scrolled into view after this operation.

- -

SCI_GOTOPOS(int pos)
- This removes any selection, sets the caret at pos and scrolls the view to make - the caret visible, if necessary. It is equivalent to - SCI_SETSEL(pos, pos). The anchor position is set the same as the current - position.

- -

SCI_GOTOLINE(int line)
- This removes any selection and sets the caret at the start of line number line - and scrolls the view (if needed) to make it visible. The anchor position is set the same as the - current position. If line is outside the lines in the document (first line is 0), - the line set is the first or last.

- -

SCI_SETCURRENTPOS(int pos)
- This sets the current position and creates a selection between the anchor and the current - position. The caret is not scrolled into view.

- -

-	anchor	current
`SCI_SETSELECTIONSTART`	`pos`	`Max(pos, current)`
`SCI_SETSELECTIONEND`	`Min(anchor, pos)`	`pos`

Initial state	end, true	end, false	start, true	start, false
..ww..\|..ww..	..ww..\|..ww..	..ww....\|ww..	..ww..\|..ww..	..ww\|....ww..
....ww\|ww....	....wwww\|....	....wwww\|....	....\|wwww....	....\|wwww....
..ww\|....ww..	..ww\|....ww..	..ww....\|ww..	..\|ww....ww..	..\|ww....ww..
..ww....\|ww..	..ww....ww\|..	..ww....ww\|..	..ww....\|ww..	..ww\|....ww..

Scrolling and automatic scrolling

SCI_LINESCROLL(int column, int line)

-     SCI_SCROLLCARET

-     SCI_SETXCARETPOLICY(int caretPolicy, int
-    caretSlop)

-     SCI_SETYCARETPOLICY(int caretPolicy, int
-    caretSlop)

-     SCI_SETVISIBLEPOLICY(int caretPolicy, int
-    caretSlop)

-     SCI_SETHSCROLLBAR(bool visible)

-     SCI_GETHSCROLLBAR

-     SCI_SETVSCROLLBAR(bool visible)

-     SCI_GETVSCROLLBAR

-     SCI_GETXOFFSET

-     SCI_SETXOFFSET(int xOffset)

-     SCI_SETSCROLLWIDTH(int pixelWidth)

-     SCI_GETSCROLLWIDTH

-     SCI_SETENDATLASTLINE(bool
-    endAtLastLine)

-     SCI_GETENDATLASTLINE

-

- -

SCI_LINESCROLL(int column, int line)
- This will attempt to scroll the display by the number of columns and lines that you specify. - Positive line values increase the line number at the top of the screen (i.e. they move the text - upwards as far as the user is concerned), Negative line values do the reverse.

- -

The column measure is the width of a space in the default style. Positive values increase - the column at the left edge of the view (i.e. they move the text leftwards as far as the user - is concerned). Negative values do the reverse.

- -

`CARET_SLOP`	If set, we can define a slop value: `caretSlop`. This value defines an - unwanted zone (UZ) where the caret is... unwanted. This zone is defined as a number of - pixels near the vertical margins, and as a number of lines near the horizontal margins. - By keeping the caret away from the edges, it is seen within its context. This makes it - likely that the identifier that the caret is on can be completely seen, and that the - current line is seen with some of the lines following it, which are often dependent on - that line.
`CARET_STRICT`	If set, the policy set by `CARET_SLOP` is enforced... strictly. The caret - is centred on the display if `caretSlop` is not set, and cannot go in the UZ - if `caretSlop` is set.
`CARET_JUMPS`	If set, the display is moved more energetically so the caret can move in the same - direction longer before the policy is applied again. '3UZ' notation is used to indicate - three time the size of the UZ as a distance to the margin.
`CARET_EVEN`	If not set, instead of having symmetrical UZs, the left and bottom UZs are extended - up to right and top UZs respectively. This way, we favour the displaying of useful - information: the beginning of lines, where most code reside, and the lines after the - caret, for example, the body of a function.

slop	strict	jumps	even	Caret can go to the margin	On reaching limit (going out of visibility - or going into the UZ) display is...
0	0	0	0	Yes	moved to put caret on top/on right
0	0	0	1	Yes	moved by one position
0	0	1	0	Yes	moved to put caret on top/on right
0	0	1	1	Yes	centred on the caret
0	1	-	0	Caret is always on top/on right of display	-
0	1	-	1	No, caret is always centred	-
1	0	0	0	Yes	moved to put caret out of the asymmetrical UZ
1	0	0	1	Yes	moved to put caret out of the UZ
1	0	1	0	Yes	moved to put caret at 3UZ of the top or right margin
1	0	1	1	Yes	moved to put caret at 3UZ of the margin
1	1	-	0	Caret is always at UZ of top/right margin	-
1	1	0	1	No, kept out of UZ	moved by one position
1	1	1	0	No, kept out of UZ	moved to put caret at 3UZ of the margin

White space

SCI_SETVIEWWS(int wsMode)

-     SCI_GETVIEWWS

-     SCI_SETWHITESPACEFORE(bool
-    useWhitespaceForeColour, int colour)

-     SCI_SETWHITESPACEBACK(bool
-    useWhitespaceBackColour, int colour)

-

- -

SCI_SETVIEWWS(int wsMode)
- SCI_GETVIEWWS
- White space can be made visible which may useful for languages in which white space is - significant, such as Python. Space characters appear as small centred dots and tab characters - as light arrows pointing to the right. There are also ways to control the display of end of line characters. The two messages set and get the - white space display mode. The wsMode argument can be one of:

- - - - - - - - - - - - - - - - - - - - - - - - - - - -

`SCWS_INVISIBLE`	0	The normal display mode with white space displayed as an empty background - colour.
`SCWS_VISIBLEALWAYS`	1	White space characters are drawn as dots and arrows,
`SCWS_VISIBLEAFTERINDENT`	2	White space used for indentation is displayed normally but after the first visible - character, it is shown as dots and arrows.

- -

The effect of using any other wsMode value is undefined.

- -

SCI_SETWHITESPACEFORE<(bool useWhitespaceForeColour, int colour)
- SCI_SETWHITESPACEBACK(bool useWhitespaceBackColour, int colour)
- By default, the colour of visible white space is determined by the lexer in use. The - foreground and/or background colour of all visible white space can be set globally, overriding - the lexer's colours with SCI_SETWHITESPACEFORE and - SCI_SETWHITESPACEBACK.

- -

Cursor

- -

SCI_SETCURSOR(int curType)
- SCI_GETCURSOR
- The cursor is normally chosen in a context sensitive way, so it will be different over the - margin than when over the text. When performing a slow action, you may wish to change to a wait - cursor. You set the cursor type with SCI_SETCURSOR. The curType - argument can be:

- - - - - - - - - - - - - - - - - - - -

`SC_CURSORNORMAL`	-1	The normal cursor is displayed.
`SC_CURSORWAIT`	4	The wait cursor is displayed when the mouse is over or owned by the Scintilla - window.

- -

Cursor values 1 through 7 have defined cursors, but only SC_CURSORWAIT is - usefully controllable. Other values of curType cause a pointer to be displayed. - The SCI_GETCURSOR message returns the last cursor type you set, or - SC_CURSORNORMAL (-1) if you have not set a cursor type.

- -

Mouse capture

- -

SCI_SETMOUSEDOWNCAPTURES(bool captures)
- SCI_GETMOUSEDOWNCAPTURES
- When the mouse is pressed inside Scintilla, it is captured so future mouse movement events are - sent to Scintilla. This behavior may be turned off with - SCI_SETMOUSEDOWNCAPTURES(0).

- -

Line endings

- -

Scintilla can interpret any of the three major line end conventions, Macintosh (\r), Unix - (\n) and CP/M / DOS / Windows (\r\n). When the user presses the Enter key, one of these line - end strings is inserted into the buffer. The default is \r\n in Windows and \n in Unix, but - this can be changed with the SCI_SETEOLMODE message. You can also convert the - entire document to one of these line endings with SCI_CONVERTEOLS. Finally, you - can choose to display the line endings with SCI_SETVIEWEOL.

SCI_SETEOLMODE(int eolMode)

-     SCI_GETEOLMODE

-     SCI_CONVERTEOLS(int eolMode)

-     SCI_SETVIEWEOL(bool visible)

-     SCI_GETVIEWEOL

-

- -

SCI_SETEOLMODE(int eolMode)
- SCI_GETEOLMODE
- SCI_SETEOLMODE sets the characters that are added into the document when the user - presses the Enter key. You can set eolMode to one of SC_EOL_CRLF (0), - SC_EOL_CR (1), or SC_EOL_LF (2). The SCI_GETEOLMODE - message retrieves the current state.

- -

SCI_CONVERTEOLS(int eolMode)
- This message changes all the end of line characters in the document to match - eolMode. Valid values are: SC_EOL_CRLF (0), SC_EOL_CR - (1), or SC_EOL_LF (2).

- -

SCI_SETVIEWEOL(bool visible)
- SCI_GETVIEWEOL
- Normally, the end of line characters are hidden, but SCI_SETVIEWEOL allows you to - display (or hide) them by setting visible true (or - false). The visible rendering of the end of line characters is similar to - (CR), (LF), or (CR)(LF). SCI_GETVIEWEOL - returns the current state.

- -

Styling

- -

The styling messages allow you to assign styles to text. The standard Scintilla settings - divide the 8 style bits available for each character into 5 bits (0 to 4 = styles 0 to 31) that set a style and three bits (5 to 7) that - define indicators. You can change the balance between - styles and indicators with SCI_SETSTYLEBITS. If your styling needs can be met by - one of the standard lexers, or if you can write your own, then a lexer is probably the easiest - way to style your document. If you choose to use the container to do the styling you can use - the SCI_SETLEXER command to select - SCLEX_CONTAINER, in which case the container is sent a SCN_STYLENEEDED notification each time text needs styling for display. As another - alternative, you might use idle time to style the document. Even if you use a lexer, you might - use the styling commands to mark errors detected by a compiler. The following commands can be - used.

SCI_GETENDSTYLED

-     SCI_STARTSTYLING(int position, int mask)

-     SCI_SETSTYLING(int length, int style)

-     SCI_SETSTYLINGEX(int length, const char
-    *styles)

-     SCI_SETLINESTATE(int line, int value)

-     SCI_GETLINESTATE(int line)

-     SCI_GETMAXLINESTATE

-

- -

SCI_GETENDSTYLED
- Scintilla keeps a record of the last character that is likely to be styled correctly. This is - moved forwards when characters after it are styled and moved backwards if changes are made to - the text of the document before it. Before drawing text, this position is checked to see if any - styling is needed and, if so, a SCN_STYLENEEDED notification message is sent to the - container. The container can send SCI_GETENDSTYLED to work out where it needs to - start styling. Scintilla will always ask to style whole lines.

- -

SCI_STARTSTYLING(int pos, int mask)
- This prepares for styling by setting the styling position pos to start at and a - mask indicating which bits of the style bytes can be set. The mask allows styling - to occur over several passes, with, for example, basic styling done on an initial pass to - ensure that the text of the code is seen quickly and correctly, and then a second slower pass, - detecting syntax errors and using indicators to show where these are. For example, with the - standard settings of 5 style bits and 3 indicator bits, you would use a mask value - of 31 (0x1f) if you were setting text styles and did not want to change the indicators. After - SCI_STARTSTYLING, send multiple SCI_SETSTYLING messages for each - lexical entity to style.

- -

SCI_SETSTYLING(int length, int style)
- This message sets the style of length characters starting at the styling position - and then increases the styling position by length, ready for the next call. If - sCell is the style byte, the operation is:
- if ((sCell & mask) != style) sCell = (sCell & ~mask) | (style & - mask);
-

- -

SCI_SETSTYLINGEX(int length, const char *styles)
- As an alternative to SCI_SETSTYLING, which applies the same style to each byte, - you can use this message which specifies the styles for each of length bytes from - the styling position and then increases the styling position by length, ready for - the next call. The length styling bytes pointed at by styles should - not contain any bits not set in mask.

- -

SCI_SETLINESTATE(int line, int value)
- SCI_GETLINESTATE(int line)
- As well as the 8 bits of lexical state stored for each character there is also an integer - stored for each line. This can be used for longer lived parse states such as what the current - scripting language is in an ASP page. Use SCI_SETLINESTATE to set the integer - value and SCI_GETLINESTATE to get the value.

- -

SCI_GETMAXLINESTATE
- This returns the last line that has any line state.

- -

Style definition

- -

While the style setting messages mentioned above change the style numbers associated with - text, these messages define how those style numbers are interpreted visually. There are 128 - lexer styles that can be set, numbered 0 to STYLEMAX (127). Unless you use SCI_SETSTYLEBITS to change the number - of style bits, styles 0 to 31 are used to set the text attributes. There are also some - predefined numbered styles starting at 32, The following STYLE_* constants are - defined.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

`STYLE_DEFAULT`	32	This style defines the attributes that all styles receive when the - `SCI_STYLECLEARALL` message is used.
`STYLE_LINENUMBER`	33	This style sets the attributes of the text used to display line numbers in a line - number margin. The background colour set for this style also sets the background colour - for all margins that do not have any folding mask bits set. That is, any margin for which - `mask & SC_MASK_FOLDERS` is 0. See `SCI_SETMARGINMASKN` for more about masks.
`STYLE_BRACELIGHT`	34	This style sets the attributes used when highlighting braces with the `SCI_BRACEHIGHLIGHT` message and - when highlighting the corresponding indentation with `SCI_SETHIGHLIGHTGUIDE`.
`STYLE_BRACEBAD`	35	This style sets the display attributes used when marking an unmatched brace with the - `SCI_BRACEBADLIGHT` - message.
`STYLE_CONTROLCHAR`	36	This style sets the font used when drawing control characters. - Only the font, size, bold, italics, and character set attributes are used and not - the colour attributes. See - also: `SCI_SETCONTROLCHARSYMBOL`.
`STYLE_INDENTGUIDE`	37	This style sets the foreground and background colours used when drawing the - indentation guides.
`STYLE_CALLTIP`	38	Call tips normally use the font attributes defined by `STYLE_DEFAULT`. - Use of `SCI_CALLTIPUSESTYLE` - causes call tips to use this style instead. Only the font face name, font size, - foreground and background colours and character set attributes are used.
`STYLE_LASTPREDEFINED`	39	To make it easier for client code to discover the range of styles that are - predefined, this is set to the style number of the last predefined style. This is - currently set to 39 and the last style with an identifier is 38, which reserves space - for one future predefined style.
`STYLE_MAX`	127	This is not a style but is the number of the maximum style that can be set. Styles - between `STYLE_LASTPREDEFINED` and `STYLE_MAX` would be appropriate - if you used `SCI_SETSTYLEBITS` - to set more than 5 style bits.

- -

For each style you can set the font name, size and use of bold, italic and underline, - foreground and background colour and the character set. You can also choose to hide text with a - given style, display all characters as upper or lower case and fill from the last character on - a line to the end of the line (for embedded languages). There is also an experimental attribute - to make text read-only.

- -

It is entirely up to you how you use styles. If you want to use syntax colouring you might - use style 0 for white space, style 1 for numbers, style 2 for keywords, style 3 for strings, - style 4 for preprocessor, style 5 for operators, and so on.

SCI_STYLERESETDEFAULT

-     SCI_STYLECLEARALL

-     SCI_STYLESETFONT(int styleNumber, char
-    *fontName)

-     SCI_STYLESETSIZE(int styleNumber, int
-    sizeInPoints)

-     SCI_STYLESETBOLD(int styleNumber, bool
-    bold)

-     SCI_STYLESETITALIC(int styleNumber, bool
-    italic)

-     SCI_STYLESETUNDERLINE(int styleNumber, bool
-    underline)

-     SCI_STYLESETFORE(int styleNumber, int
-    colour)

-     SCI_STYLESETBACK(int styleNumber, int
-    colour)

-     SCI_STYLESETEOLFILLED(int styleNumber, bool
-    eolFilled)

-     SCI_STYLESETCHARACTERSET(int styleNumber,
-    int charSet)

-     SCI_STYLESETCASE(int styleNumber, int
-    caseMode)

-     SCI_STYLESETVISIBLE(int styleNumber, bool
-    visible)

-     SCI_STYLESETCHANGEABLE(int styleNumber, bool
-    changeable)

-     SCI_STYLESETHOTSPOT(int styleNumber, bool
-    hotspot)

-

- -

SCI_STYLERESETDEFAULT
- This message resets STYLE_DEFAULT to its state when Scintilla was - initialised.

- -

SCI_STYLECLEARALL
- This message sets all styles to have the same attributes as STYLE_DEFAULT. If you - are setting up Scintilla for syntax colouring, it is likely that the lexical styles you set - will be very similar. One way to set the styles is to:
- 1. Set STYLE_DEFAULT to the common features of all styles.
- 2. Use SCI_STYLECLEARALL to copy this to all styles.
- 3. Set the style attributes that make your lexical styles different.

- -

SCI_STYLESETFONT(int styleNumber, const char *fontName)
- SCI_STYLESETSIZE(int styleNumber, int sizeInPoints)
- SCI_STYLESETBOLD(int styleNumber, bool bold)
- SCI_STYLESETITALIC(int styleNumber, bool italic)
- These messages (plus SCI_STYLESETCHARACTERSET) set the font - attributes that are used to match the fonts you request to those available. The - fontName is a zero terminated string holding the name of a font. Under Windows, - only the first 32 characters of the name are used and the name is not case sensitive. For - internal caching, Scintilla tracks fonts by name and does care about the casing of font names, - so please be consistent. On GTK+ 2.x, either GDK or Pango can be used to display text. - Pango antialiases text, works well with Unicode and is better supported in recent versions of GTK+ - but GDK is faster. - Prepend a '!' character to the font name to use Pango.

- -

SCI_STYLESETUNDERLINE(int styleNumber, bool - underline)
- You can set a style to be underlined. The underline is drawn in the foreground colour. All - characters with a style that includes the underline attribute are underlined, even if they are - white space.

- -

SCI_STYLESETFORE(int styleNumber, int colour)
- SCI_STYLESETBACK(int styleNumber, int colour)
- Text is drawn in the foreground colour. The space in each character cell that is not occupied - by the character is drawn in the background colour.

- -

SCI_STYLESETEOLFILLED(int styleNumber, bool - eolFilled)
- If the last character in the line has a style with this attribute set, the remainder of the - line up to the right edge of the window is filled with the background colour set for the last - character. This is useful when a document contains embedded sections in another language such - as HTML pages with embedded JavaScript. By setting eolFilled to true - and a consistent background colour (different from the background colour set for the HTML - styles) to all JavaScript styles then JavaScript sections will be easily distinguished from - HTML.

- -

SCI_STYLESETCHARACTERSET(int styleNumber, int - charSet)
- You can set a style to use a different character set than the default. The places where such - characters sets are likely to be useful are comments and literal strings. For example, - SCI_STYLESETCHARACTERSET(SCE_C_STRING, SC_CHARSET_RUSSIAN) would ensure that - strings in Russian would display correctly in C and C++ (SCE_C_STRING is the style - number used by the C and C++ lexer to display literal strings; it has the value 6). This - feature works differently on Windows and GTK+.

- -

The character sets supported on Windows are:
- SC_CHARSET_ANSI, SC_CHARSET_ARABIC, SC_CHARSET_BALTIC, - SC_CHARSET_CHINESEBIG5, SC_CHARSET_DEFAULT, - SC_CHARSET_EASTEUROPE, SC_CHARSET_GB2312, - SC_CHARSET_GREEK, SC_CHARSET_HANGUL, SC_CHARSET_HEBREW, - SC_CHARSET_JOHAB, SC_CHARSET_MAC, SC_CHARSET_OEM, - SC_CHARSET_RUSSIAN (code page 1251), - SC_CHARSET_SHIFTJIS, SC_CHARSET_SYMBOL, SC_CHARSET_THAI, - SC_CHARSET_TURKISH, and SC_CHARSET_VIETNAMESE.

- -

The character sets supported on GTK+ are:
- SC_CHARSET_ANSI, SC_CHARSET_CYRILLIC (code page 1251), - SC_CHARSET_EASTEUROPE, - SC_CHARSET_GB2312, SC_CHARSET_HANGUL, - SC_CHARSET_RUSSIAN (KOI8-R), SC_CHARSET_SHIFTJIS, and - SC_CHARSET_8859_15.

- -

SCI_STYLESETCASE(int styleNumber, int caseMode)
- The value of caseMode determines how text is displayed. You can set upper case - (SC_CASE_UPPER, 1) or lower case (SC_CASE_LOWER, 2) or display - normally (SC_CASE_MIXED, 0). This does not change the stored text, only how it is - displayed.

- -

SCI_STYLESETVISIBLE(int styleNumber, bool visible)
- Text is normally visible. However, you can completely hide it by giving it a style with the - visible set to 0. This could be used to hide embedded formatting instructions or - hypertext keywords in HTML or XML.

- -

SCI_STYLESETCHANGEABLE(int styleNumber, bool - changeable)
- This is an experimental and incompletely implemented style attribute. The default setting is - changeable set true but when set false it makes text - read-only. Currently it only stops the caret from being within not-changeable text and does not - yet stop deleting a range that contains not-changeable text.

- -

SCI_STYLESETHOTSPOT(int styleNumber, bool - hotspot)
- This style is used to mark ranges of text that can detect mouse clicks. - The cursor changes to a hand over hotspots, and the foreground, and background colours - may change and an underline appear to indicate that these areas are sensitive to clicking. - This may be used to allow hyperlinks to other documents.

- - SCI_STYLESETHOTSPOT(int styleNumber, bool - hotspot)
- -

Caret, selection, and hotspot styles

- -

The selection is shown by changing the foreground and/or background colours. If one of these - is not set then that attribute is not changed for the selection. The default is to show the - selection by changing the background to light gray and leaving the foreground the same as when - it was not selected. When there is no selection, the current insertion point is marked by the - text caret. This is a vertical line that is normally blinking on and off to attract the users - attention.

SCI_SETSELFORE(bool useSelectionForeColour, int
-    colour)

-     SCI_SETSELBACK(bool useSelectionBackColour, int
-    colour)

-     SCI_SETSELALPHA(int alpha)

-     SCI_GETSELALPHA

-     SCI_SETCARETFORE(int colour)

-     SCI_GETCARETFORE

-     SCI_SETCARETLINEVISIBLE(bool
-    show)

-     SCI_GETCARETLINEVISIBLE

-     SCI_SETCARETLINEBACK(int colour)

-     SCI_GETCARETLINEBACK

-     SCI_SETCARETLINEBACKALPHA(int alpha)

-     SCI_GETCARETLINEBACKALPHA

-     SCI_SETCARETPERIOD(int milliseconds)

-     SCI_GETCARETPERIOD

-     SCI_SETCARETWIDTH(int pixels)

-     SCI_GETCARETWIDTH

-     SCI_SETHOTSPOTACTIVEFORE

-     SCI_SETHOTSPOTACTIVEBACK

-     SCI_SETHOTSPOTACTIVEUNDERLINE

-     SCI_SETHOTSPOTSINGLELINE

-     SCI_SETCONTROLCHARSYMBOL(int
-    symbol)

-     SCI_GETCONTROLCHARSYMBOL

-     SCI_SETCARETSTICKY

-     SCI_GETCARETSTICKY

-     SCI_TOGGLECARETSTICKY

-

- -

SCI_SETSELFORE(bool useSelectionForeColour, int colour)
- SCI_SETSELBACK(bool useSelectionBackColour, int colour)
- You can choose to override the default selection colouring with these two messages. The colour - you provide is used if you set useSelection*Colour to true. If it is - set to false, the default colour colouring is used and the colour - argument has no effect.

SCI_SETSELALPHA(int alpha)
- SCI_GETSELALPHA
- The selection can be drawn translucently in the selection background colour by - setting an alpha value.

- -

SCI_SETCARETFORE(int colour)
- SCI_GETCARETFORE
- The colour of the caret can be set with SCI_SETCARETFORE and retrieved with - SCI_CETCARETFORE.

- -

SCI_SETCARETLINEVISIBLE(bool show)
- SCI_GETCARETLINEVISIBLE
- SCI_SETCARETLINEBACK(int colour)
- SCI_GETCARETLINEBACK
- SCI_SETCARETLINEBACKALPHA(int alpha)
- SCI_GETCARETLINEBACKALPHA
- You can choose to make the background colour of the line containing the caret different with - these messages. To do this, set the desired background colour with - SCI_SETCARETLINEBACK, then use SCI_SETCARETLINEVISIBLE(true) to - enable the effect. You can cancel the effect with SCI_SETCARETLINEVISIBLE(false). - The two SCI_GETCARET* functions return the state and the colour. This form of - background colouring has highest priority when a line has markers that would otherwise change - the background colour. - The caret line may also be drawn translucently which allows other background colours to show - through. This is done by setting the alpha (translucency) value by calling - SCI_SETCARETLINEBACKALPHA. When the alpha is not SC_ALPHA_NOALPHA, - the caret line is drawn after all other features so will affect the colour of all other features. -

- -

SCI_SETCARETPERIOD(int milliseconds)
- SCI_GETCARETPERIOD
- The rate at which the caret blinks can be set with SCI_SETCARETPERIOD which - determines the time in milliseconds that the caret is visible or invisible before changing - state. Setting the period to 0 stops the caret blinking. The default value is 500 milliseconds. - SCI_GETCARETPERIOD returns the current setting.

- -

SCI_SETCARETWIDTH(int pixels)
- SCI_GETCARETWIDTH
- The width of the caret can be set with SCI_SETCARETWIDTH to a value of 0, 1, 2 or - 3 pixels. The default width is 1 pixel. You can read back the current width with - SCI_GETCARETWIDTH. A width of 0 makes the caret invisible (added at version - 1.50).

- -

SCI_SETHOTSPOTACTIVEFORE(bool useHotSpotForeColour, int colour)
- SCI_SETHOTSPOTACTIVEBACK(bool useHotSpotBackColour, int colour)
- SCI_SETHOTSPOTACTIVEUNDERLINE(bool underline,)
- SCI_SETHOTSPOTSINGLELINE(bool singleLine,)
- While the cursor hovers over text in a style with the hotspot attribute set, - the default colouring can be modified and an underline drawn with these settings. - Single line mode stops a hotspot from wrapping onto next line.

- -

SCI_SETCONTROLCHARSYMBOL(int symbol)
- SCI_GETCONTROLCHARSYMBOL
- By default, Scintilla displays control characters (characters with codes less than 32) in a - rounded rectangle as ASCII mnemonics: "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL", - "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", - "SYN", "ETB", "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US". These mnemonics come from the - early days of signaling, though some are still used (LF = Line Feed, BS = Back Space, CR = - Carriage Return, for example).

- -

You can choose to replace these mnemonics by a nominated symbol with an ASCII code in the - range 32 to 255. If you set a symbol value less than 32, all control characters are displayed - as mnemonics. The symbol you set is rendered in the font of the style set for the character. - You can read back the current symbol with the SCI_GETCONTROLCHARSYMBOL message. - The default symbol value is 0.

- -

SCI_SETCARETSTICKY(bool useCaretStickyBehaviour)
- SCI_GETCARETSTICKY
- SCI_TOGGLECARETSTICKY
- These messages set, get or toggle the caretSticky flag which controls when the last position - of the caret on the line is saved. When set to true, the position is not saved when you type - a character, a tab, paste the clipboard content or press backspace.

- -

Margins

- -

There may be up to five margins to the left of the text display, plus a gap either side of - the text. Each margin can be set to display either symbols or line numbers with SCI_SETMARGINTYPEN. The markers - that can be displayed in each margin are set with SCI_SETMARGINMASKN. Any markers not associated with - a visible margin will be displayed as changes in background colour in the text. A width in - pixels can be set for each margin. Margins with a zero width are ignored completely. You can - choose if a mouse click in a margin sends a SCN_MARGINCLICK notification to the container or - selects a line of text.

- -

The margins are numbered 0 to 4. Using a margin number outside the valid range has no - effect. By default, margin 0 is set to display line numbers, but is given a width of 0, so it - is hidden. Margin 1 is set to display non-folding symbols and is given a width of 16 pixels, so - it is visible. Margin 2 is set to display the folding symbols, but is given a width of 0, so it - is hidden. Of course, you can set the margins to be whatever you wish.

SCI_SETMARGINTYPEN(int margin, int
-    type)

-     SCI_GETMARGINTYPEN(int margin)

-     SCI_SETMARGINWIDTHN(int margin, int
-    pixelWidth)

-     SCI_GETMARGINWIDTHN(int margin)

-     SCI_SETMARGINMASKN(int margin, int
-    mask)

-     SCI_GETMARGINMASKN(int margin)

-     SCI_SETMARGINSENSITIVEN(int margin, bool
-    sensitive)

-     SCI_GETMARGINSENSITIVEN(int
-    margin)

-     SCI_SETMARGINLEFT(<unused>, int
-    pixels)

-     SCI_GETMARGINLEFT

-     SCI_SETMARGINRIGHT(<unused>, int
-    pixels)

-     SCI_GETMARGINRIGHT

-     SCI_SETFOLDMARGINCOLOUR(bool useSetting, int colour)

-     SCI_SETFOLDMARGINHICOLOUR(bool useSetting, int colour)

-

- -

SCI_SETMARGINTYPEN(int margin, int iType)
- SCI_GETMARGINTYPEN(int margin)
- These two routines set and get the type of a margin. The margin argument should be 0, 1, 2, 3 or 4. - You can use the predefined constants SC_MARGIN_SYMBOL (0) and - SC_MARGIN_NUMBER (1) to set a margin as either a line number or a symbol margin. - By convention, margin 0 is used for line numbers and the next two are used for symbols. You can - also use the constants SC_MARGIN_BACK (2) and SC_MARGIN_FORE (3) for - symbol margins that set their background colour to match the STYLE_DEFAULT background and - foreground colours.

- -

SCI_SETMARGINWIDTHN(int margin, int pixelWidth)
- SCI_GETMARGINWIDTHN(int margin)
- These routines set and get the width of a margin in pixels. A margin with zero width is - invisible. By default, Scintilla sets margin 1 for symbols with a width of 16 pixels, so this - is a reasonable guess if you are not sure what would be appropriate. Line number margins widths - should take into account the number of lines in the document and the line number style. You - could use something like SCI_TEXTWIDTH(STYLE_LINENUMBER, "_99999") to get a - suitable width.

- -

SCI_SETMARGINMASKN(int margin, int mask)
- SCI_GETMARGINMASKN(int margin)
- The mask is a 32-bit value. Each bit corresponds to one of 32 logical symbols that can be - displayed in a margin that is enabled for symbols. There is a useful constant, - SC_MASK_FOLDERS (0xFE000000 or -33554432), that is a mask for the 7 logical - symbols used to denote folding. You can assign a wide range of symbols and colours to each of - the 32 logical symbols, see Markers for more information. If (mask - & SC_MASK_FOLDERS)==0, the margin background colour is controlled by style 33 (STYLE_LINENUMBER).

- -

You add logical markers to a line with SCI_MARKERADD. If a line has an associated marker that - does not appear in the mask of any margin with a non-zero width, the marker changes the - background colour of the line. For example, suppose you decide to use logical marker 10 to mark - lines with a syntax error and you want to show such lines by changing the background colour. - The mask for this marker is 1 shifted left 10 times (1<<10) which is 0x400. If you make - sure that no symbol margin includes 0x400 in its mask, any line with the marker gets the - background colour changed.

- -

To set a non-folding margin 1 use SCI_SETMARGINMASKN(1, ~SC_MASK_FOLDERS); to - set a folding margin 2 use SCI_SETMARGINMASKN(2, SC_MASK_FOLDERS). This is the - default set by Scintilla. ~SC_MASK_FOLDERS is 0x1FFFFFF in hexadecimal or 33554431 - decimal. Of course, you may need to display all 32 symbols in a margin, in which case use - SCI_SETMARGINMASKN(margin, -1).

- -

SCI_SETMARGINSENSITIVEN(int margin, bool - sensitive)
- SCI_GETMARGINSENSITIVEN(int margin)
- Each of the five margins can be set sensitive or insensitive to mouse clicks. A click in a - sensitive margin sends a SCN_MARGINCLICK notification to the container. Margins that are not sensitive act as - selection margins which make it easy to select ranges of lines. By default, all margins are - insensitive.

- -

SCI_SETMARGINLEFT(<unused>, int pixels)
- SCI_GETMARGINLEFT
- SCI_SETMARGINRIGHT(<unused>, int pixels)
- SCI_GETMARGINRIGHT
- These messages set and get the width of the blank margin on both sides of the text in pixels. - The default is to one pixel on each side.

- -

SCI_SETFOLDMARGINCOLOUR(bool useSetting, int colour)
- SCI_SETFOLDMARGINHICOLOUR(bool useSetting, int colour)
- These messages allow changing the colour of the fold margin and fold margin highlight. - On Windows the fold margin colour defaults to ::GetSysColor(COLOR_3DFACE) and the fold margin highlight - colour to ::GetSysColor(COLOR_3DHIGHLIGHT).

- -

Other settings

SCI_SETUSEPALETTE(bool
-    allowPaletteUse)

-     SCI_GETUSEPALETTE

-     SCI_SETBUFFEREDDRAW(bool isBuffered)

-     SCI_GETBUFFEREDDRAW

-     SCI_SETTWOPHASEDRAW(bool twoPhase)

-     SCI_GETTWOPHASEDRAW

-     SCI_SETCODEPAGE(int codePage)

-     SCI_GETCODEPAGE

-     SCI_SETWORDCHARS(<unused>, const char
-    *chars)

-     SCI_SETWHITESPACECHARS(<unused>, const char
-    *chars)

-     SCI_SETCHARSDEFAULT

-     SCI_GRABFOCUS

-     SCI_SETFOCUS(bool focus)

-     SCI_GETFOCUS

-

- -

SCI_SETUSEPALETTE(bool allowPaletteUse)
- SCI_GETUSEPALETTE
- On 8 bit displays, which can only display a maximum of 256 colours, the graphics environment - mediates between the colour needs of applications through the use of palettes. On GTK+, - Scintilla always uses a palette.

- -

On Windows, there are some problems with visual flashing when switching between applications - with palettes and it is also necessary for the application containing the Scintilla control to - forward some messages to Scintilla for its palette code to work. Because of this, by default, - the palette is not used and the application must tell Scintilla to use one. If Scintilla is not - using a palette, it will only display in those colours already available, which are often the - 20 Windows system colours.

- -

To see an example of how to enable palette support in Scintilla, search the text of SciTE - for WM_PALETTECHANGED, WM_QUERYNEWPALETTE and - SCI_SETUSEPALETTE. The Windows messages to forward are:
- WM_SYSCOLORCHANGE, WM_PALETTECHANGED, - WM_QUERYNEWPALETTE (should return TRUE).

- -

To forward a message (WM_XXXX, WPARAM, LPARAM) to Scintilla, you can use - SendMessage(hScintilla, WM_XXXX, WPARAM, LPARAM) where hScintilla is - the handle to the Scintilla window you created as your editor.

- -

While we are on the subject of forwarding messages in Windows, the top level window should - forward any WM_SETTINGCHANGE messages to Scintilla (this is currently used to - collect changes to mouse settings, but could be used for other user interface items in the - future).

- -

SCI_SETBUFFEREDDRAW(bool isBuffered)
- SCI_GETBUFFEREDDRAW
- These messages turn buffered drawing on or off and report the buffered drawing state. Buffered - drawing draws each line into a bitmap rather than directly to the screen and then copies the - bitmap to the screen. This avoids flickering although it does take longer. The default is for - drawing to be buffered.

- -

SCI_SETTWOPHASEDRAW(bool twoPhase)
- SCI_GETTWOPHASEDRAW
- Two phase drawing is a better but slower way of drawing text. - In single phase drawing each run of characters in one style is drawn along with its background. - If a character overhangs the end of a run, such as in "V_" where the - "V" is in a different style from the "_", then this can cause the right hand - side of the "V" to be overdrawn by the background of the "_" which - cuts it off. Two phase drawing - fixes this by drawing all the backgrounds first and then drawing the text in - transparent mode. Two phase drawing may flicker more than single phase - unless buffered drawing is on. The default is for drawing to be two phase.

- -

SCI_SETCODEPAGE(int codePage)
- SCI_GETCODEPAGE
- Scintilla has some support for Japanese, Chinese and Korean DBCS. Use this message with - codePage set to the code page number to set Scintilla to use code page information - to ensure double byte characters are treated as one character rather than two. This also stops - the caret from moving between the two bytes in a double byte character. - Do not use this message to choose between different single byte character sets: it doesn't do that. - Call with - codePage set to zero to disable DBCS support. The default is - SCI_SETCODEPAGE(0).

- -

Code page SC_CP_UTF8 (65001) sets Scintilla into Unicode mode with the document - treated as a sequence of characters expressed in UTF-8. The text is converted to the platform's - normal Unicode encoding before being drawn by the OS and thus can display Hebrew, Arabic, - Cyrillic, and Han characters. Languages which can use two characters stacked vertically in one - horizontal space, such as Thai, will mostly work but there are some issues where the characters - are drawn separately leading to visual glitches. Bi-directional text is not supported. Characters outside the - Basic Multilingual Plane are unlikely to work.

- -

On Windows, code page can be set to 932 (Japanese Shift-JIS), 936 (Simplified Chinese GBK), - 949 (Korean Unified Hangul Code), 950 (Traditional Chinese Big5), or 1361 (Korean Johab) - although these may require installation of language specific support.

- -

On GTK+, code page SC_CP_DBCS (1) sets Scintilla into - multi byte character mode as is required for Japanese language processing with - the EUC encoding.

- -

For GTK+ 1.x, the locale should be set to a Unicode locale with a call similar to - setlocale(LC_CTYPE, "en_US.UTF-8"). Fonts with an "iso10646" registry - should be used in a font set. Font sets are a comma separated list of partial font - specifications where each partial font specification can be in the form: - foundry-fontface-charsetregistry-encoding or - fontface-charsetregistry-encoding or foundry-fontface or - fontface. An example is "misc-fixed-iso10646-1,*". - On GTK+ 2.x, Pango fonts should be used rather than font sets.

- -

Setting codePage to a non-zero value that is not SC_CP_UTF8 is - operating system dependent.

- -

SCI_SETWORDCHARS(<unused>, const char *chars)
- Scintilla has several functions that operate on words, which are defined to be contiguous - sequences of characters from a particular set of characters. This message defines which - characters are members of that set. The character sets are set to default values before processing this - function. - For example, if you don't allow '_' in your set of characters - use:
- SCI_SETWORDCHARS(0, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");

- -

SCI_SETWHITESPACECHARS(<unused>, const char *chars)
- Similar to SCI_SETWORDCHARS, this message allows the user to define which chars Scintilla considers - as whitespace. Setting the whitespace chars allows the user to fine-tune Scintilla's behaviour doing - such things as moving the cursor to the start or end of a word; for example, by defining punctuation chars - as whitespace, they will be skipped over when the user presses ctrl+left or ctrl+right. - This function should be called after SCI_SETWORDCHARS as it will - reset the whitespace characters to the default set.

SCI_SETCHARSDEFAULT
- Use the default sets of word and whitespace characters. This sets whitespace to space, tab and other - characters with codes less than 0x20, with word characters set to alphanumeric and '_'. -

- - -

SCI_GRABFOCUS
- SCI_SETFOCUS(bool focus)
- SCI_GETFOCUS
- Scintilla can be told to grab the focus with this message. This is needed more on GTK+ where - focus handling is more complicated than on Windows.

- -

The internal focus flag can be set with SCI_SETFOCUS. This is used by clients - that have complex focus requirements such as having their own window that gets the real focus - but with the need to indicate that Scintilla has the logical focus.

- -

Brace highlighting

SCI_BRACEHIGHLIGHT(int pos1, int
-    pos2)

-     SCI_BRACEBADLIGHT(int pos1)

-     SCI_BRACEMATCH(int position, int
-    maxReStyle)

-

- -

SCI_BRACEHIGHLIGHT(int pos1, int pos2)
- Up to two characters can be highlighted in a 'brace highlighting style', which is defined as - style number STYLE_BRACELIGHT (34). - If you have enabled indent guides, you may also wish to highlight the indent that corresponds - with the brace. You can locate the column with SCI_GETCOLUMN and highlight the indent with SCI_SETHIGHLIGHTGUIDE.

- -

SCI_BRACEBADLIGHT(int pos1)
- If there is no matching brace then the brace - badlighting style, style BRACE_BADLIGHT (35), can be used to show the brace - that is unmatched. Using a position of INVALID_POSITION (-1) removes the - highlight.

- -

SCI_BRACEMATCH(int pos, int maxReStyle)
- The SCI_BRACEMATCH message finds a corresponding matching brace given - pos, the position of one brace. The brace characters handled are '(', ')', '[', - ']', '{', '}', '<', and '>'. The search is forwards from an opening brace and backwards - from a closing brace. If the character at position is not a brace character, or a matching - brace cannot be found, the return value is -1. Otherwise, the return value is the position of - the matching brace.

- -

A match only occurs if the style of the matching brace is the same as the starting brace or - the matching brace is beyond the end of styling. Nested braces are handled correctly. The - maxReStyle parameter must currently be 0 - it may be used in the future to limit - the length of brace searches.

- -

Tabs and Indentation Guides

- -

Indentation (the white space at the start of a line) is often used by programmers to clarify - program structure and in some languages, for example Python, it may be part of the language - syntax. Tabs are normally used in editors to insert a tab character or to pad text with spaces - up to the next tab.

- -

Scintilla can be set to treat tab and backspace in the white space at the start of a line in - a special way: inserting a tab indents the line to the next indent position rather than just - inserting a tab at the current character position and backspace unindents the line rather than - deleting a character. Scintilla can also display indentation guides (vertical lines) to help - you to generate code.

SCI_SETTABWIDTH(int widthInChars)

-     SCI_GETTABWIDTH

-     SCI_SETUSETABS(bool useTabs)

-     SCI_GETUSETABS

-     SCI_SETINDENT(int widthInChars)

-     SCI_GETINDENT

-     SCI_SETTABINDENTS(bool tabIndents)

-     SCI_GETTABINDENTS

-     SCI_SETBACKSPACEUNINDENTS(bool
-    bsUnIndents)

-     SCI_GETBACKSPACEUNINDENTS

-     SCI_SETLINEINDENTATION(int line, int
-    indentation)

-     SCI_GETLINEINDENTATION(int line)

-     SCI_GETLINEINDENTPOSITION(int
-    line)

-     SCI_SETINDENTATIONGUIDES(bool
-    view)

-     SCI_GETINDENTATIONGUIDES

-     SCI_SETHIGHLIGHTGUIDE(int column)

-     SCI_GETHIGHLIGHTGUIDE

-

- -

SCI_SETTABWIDTH(int widthInChars)
- SCI_GETTABWIDTH
- SCI_SETTABWIDTH sets the size of a tab as a multiple of the size of a space - character in STYLE_DEFAULT. The default tab width is 8 characters. There are no - limits on tab sizes, but values less than 1 or large values may have undesirable effects.

- -

SCI_SETUSETABS(bool useTabs)
- SCI_GETUSETABS
- SCI_SETUSETABS determines whether indentation should be created out of a mixture - of tabs and spaces or be based purely on spaces. Set useTabs to false - (0) to create all tabs and indents out of spaces. The default is true. You can use - SCI_GETCOLUMN to get the column of a - position taking the width of a tab into account.

- SCI_SETINDENT(int widthInChars)
- SCI_GETINDENT
- SCI_SETINDENT sets the size of indentation in terms of the width of a space in STYLE_DEFAULT. If you set a width of - 0, the indent size is the same as the tab size. There are no limits on indent sizes, but values - less than 0 or large values may have undesirable effects.
-
- - -

SCI_SETTABINDENTS(bool tabIndents)
- SCI_GETTABINDENTS
- SCI_SETBACKSPACEUNINDENTS(bool bsUnIndents)
- SCI_GETBACKSPACEUNINDENTS
-

- -

Inside indentation white space, the tab and backspace keys can be made to indent and - unindent rather than insert a tab character or delete a character with the - SCI_SETTABINDENTS and SCI_SETBACKSPACEUNINDENTS functions.

- -

SCI_SETLINEINDENTATION(int line, int indentation)
- SCI_GETLINEINDENTATION(int line)
- The amount of indentation on a line can be discovered and set with - SCI_GETLINEINDENTATION and SCI_SETLINEINDENTATION. The indentation is - measured in character columns, which correspond to the width of space characters.

- -

SCI_GETLINEINDENTPOSITION(int line)
- This returns the position at the end of indentation of a line.

- -

SCI_SETINDENTATIONGUIDES(bool view)
- SCI_GETINDENTATIONGUIDES
- Indentation guides are dotted vertical lines that appear within indentation white space every - indent size columns. They make it easy to see which constructs line up especially when they - extend over multiple pages. Style STYLE_INDENTGUIDE (37) is used to specify the - foreground and background colour of the indentation guides.

- -

SCI_SETHIGHLIGHTGUIDE(int column)
- SCI_GETHIGHLIGHTGUIDE
- When brace highlighting occurs, the indentation guide corresponding to the braces may be - highlighted with the brace highlighting style, STYLE_BRACELIGHT (34). Set column to 0 to - cancel this highlight.

- -

Markers

- -

There are 32 markers, numbered 0 to 31, and you can assign any combination of them to each - line in the document. Markers appear in the selection - margin to the left of the text. If the selection margin is set to zero width, the - background colour of the whole line is changed instead. Marker numbers 25 to 31 are used by - Scintilla in folding margins, and have symbolic names of the form SC_MARKNUM_*, - for example SC_MARKNUM_FOLDEROPEN.

- -

Marker numbers 0 to 24 have no pre-defined function; you can use them to mark syntax errors - or the current point of execution, break points, or whatever you need marking. If you do not - need folding, you can use all 32 for any purpose you wish.

- -

Each marker number has a symbol associated with it. You can also set the foreground and - background colour for each marker number, so you can use the same symbol more than once with - different colouring for different uses. Scintilla has a set of symbols you can assign - (SC_MARK_*) or you can use characters. By default, all 32 markers are set to - SC_MARK_CIRCLE with a black foreground and a white background.

- -

The markers are drawn in the order of their numbers, so higher numbered markers appear on - top of lower numbered ones. Markers try to move with their text by tracking where the start of - their line moves. When a line is deleted, its markers are combined, by an OR - operation, with the markers of the previous line.

SCI_MARKERDEFINE(int markerNumber, int
-    markerSymbols)

-     SCI_MARKERDEFINEPIXMAP(int markerNumber,
-    const char *xpm)

-     SCI_MARKERSETFORE(int markerNumber, int
-    colour)

-     SCI_MARKERSETBACK(int markerNumber, int
-    colour)

-     SCI_MARKERSETALPHA(int markerNumber, int
-    alpha)

-     SCI_MARKERADD(int line, int markerNumber)

-     SCI_MARKERADDSET(int line, int markerMask)

-     SCI_MARKERDELETE(int line, int
-    markerNumber)

-     SCI_MARKERDELETEALL(int markerNumber)

-     SCI_MARKERGET(int line)

-     SCI_MARKERNEXT(int lineStart, int
-    markerMask)

-     SCI_MARKERPREVIOUS(int lineStart, int
-    markerMask)

-     SCI_MARKERLINEFROMHANDLE(int
-    handle)

-     SCI_MARKERDELETEHANDLE(int handle)

-

- -

SCI_MARKERDEFINE(int markerNumber, int markerSymbols)
- This message associates a marker number in the range 0 to 31 with one of the marker symbols or - an ASCII character. The general-purpose marker symbols currently available are:
- SC_MARK_CIRCLE, SC_MARK_ROUNDRECT, SC_MARK_ARROW, - SC_MARK_SMALLRECT, SC_MARK_SHORTARROW, SC_MARK_EMPTY, - SC_MARK_ARROWDOWN, SC_MARK_MINUS, SC_MARK_PLUS, - SC_MARK_ARROWS, SC_MARK_DOTDOTDOT, SC_MARK_EMPTY, - SC_MARK_BACKGROUND and SC_MARK_FULLRECT.

- -

The SC_MARK_BACKGROUND marker changes the background colour of the line only. - The SC_MARK_FULLRECT symbol mirrors this, changing only the margin background colour. - The SC_MARK_EMPTY symbol is invisible, allowing client code to track the movement - of lines. You would also use it if you changed the folding style and wanted one or more of the - SC_FOLDERNUM_* markers to have no associated symbol.

- -

There are also marker symbols designed for use in the folding margin in a flattened tree - style.
- SC_MARK_BOXMINUS, SC_MARK_BOXMINUSCONNECTED, - SC_MARK_BOXPLUS, SC_MARK_BOXPLUSCONNECTED, - SC_MARK_CIRCLEMINUS, SC_MARK_CIRCLEMINUSCONNECTED, - SC_MARK_CIRCLEPLUS, SC_MARK_CIRCLEPLUSCONNECTED, - SC_MARK_LCORNER, SC_MARK_LCORNERCURVE, SC_MARK_TCORNER, - SC_MARK_TCORNERCURVE, and SC_MARK_VLINE.

- Characters can be used as markers by adding the ASCII value of the character to - SC_MARK_CHARACTER (10000). For example, to use 'A' (ASCII code 65) as marker - number 1 use:
- SCI_MARKERDEFINE(1, SC_MARK_CHARACTER+65).
- -

The marker numbers SC_MARKNUM_FOLDER and SC_MARKNUM_FOLDEROPEN are - used for showing that a fold is present and open or closed. Any symbols may be assigned for - this purpose although the (SC_MARK_PLUS, SC_MARK_MINUS) pair or the - (SC_MARK_ARROW, SC_MARK_ARROWDOWN) pair are good choices. As well as - these two, more assignments are needed for the flattened tree style: - SC_MARKNUM_FOLDEREND, SC_MARKNUM_FOLDERMIDTAIL, - SC_MARKNUM_FOLDEROPENMID, SC_MARKNUM_FOLDERSUB, and - SC_MARKNUM_FOLDERTAIL. The bits used for folding are specified by - SC_MASK_FOLDERS, which is commonly used as an argument to - SCI_SETMARGINMASKN when defining a margin to be used for folding.

- -

This table shows which SC_MARK_* symbols should be assigned to which - SC_MARKNUM_* marker numbers to obtain four folding styles: Arrow (mimics - Macintosh), plus/minus shows folded lines as '+' and opened folds as '-', Circle tree, Box - tree.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

`SC_MARKNUM_`*	Arrow	Plus/minus	Circle tree	Box tree
`FOLDEROPEN`	`ARROWDOWN`	`MINUS`	`CIRCLEMINUS`	`BOXMINUS`
`FOLDER`	`ARROW`	`PLUS`	`CIRCLEPLUS`	`BOXPLUS`
`FOLDERSUB`	`EMPTY`	`EMPTY`	`VLINE`	`VLINE`
`FOLDERTAIL`	`EMPTY`	`EMPTY`	`LCORNERCURVE`	`LCORNER`
`FOLDEREND`	`EMPTY`	`EMPTY`	`CIRCLEPLUSCONNECTED`	`BOXPLUSCONNECTED`
`FOLDEROPENMID`	`EMPTY`	`EMPTY`	`CIRCLEMINUSCONNECTED`	`BOXMINUSCONNECTED`
`FOLDERMIDTAIL`	`EMPTY`	`EMPTY`	`TCORNERCURVE`	`TCORNER`

- -

SCI_MARKERDEFINEPIXMAP(int markerNumber, const char - *xpm)
- Markers can be set to pixmaps with this message. The XPM format is used for the pixmap and it - is limited to pixmaps that use one character per pixel. The data should be null terminated. - Pixmaps use the SC_MARK_PIXMAP marker symbol. You can find the full description of - the XPM format here.

- -

SCI_MARKERSETFORE(int markerNumber, int colour)
- SCI_MARKERSETBACK(int markerNumber, int colour)
- These two messages set the foreground and background colour of a marker number.

SCI_MARKERSETALPHA(int markerNumber, int alpha)
- When markers are drawn in the content area, either because there is no margin for them or - they are of SC_MARK_BACKGROUND type, they may be drawn translucently by - setting an alpha value.

- -

SCI_MARKERADD(int line, int markerNumber)
- This message adds marker number markerNumber to a line. The message returns -1 if - this fails (illegal line number, out of memory) or it returns a marker handle number that - identifies the added marker. You can use this returned handle with SCI_MARKERLINEFROMHANDLE to find where a - marker is after moving or combining lines and with SCI_MARKERDELETEHANDLE to delete the marker - based on its handle. The message does not check the value of markerNumber, nor does it - check if the line already contains the marker.

- -

SCI_MARKERADDSET(int line, int markerMask)
- This message can add one or more markers to a line with a single call, specified in the same "one-bit-per-marker" 32-bit integer format returned by - SCI_MARKERGET - (and used by the mask-based marker search functions - SCI_MARKERNEXT and - SCI_MARKERPREVIOUS). - As with - SCI_MARKERADD, no check is made - to see if any of the markers are already present on the targeted line.

- -

SCI_MARKERDELETE(int line, int markerNumber)
- This searches the given line number for the given marker number and deletes it if it is - present. If you added the same marker more than once to the line, this will delete one copy - each time it is used. If you pass in a marker number of -1, all markers are deleted from the - line.

- -

SCI_MARKERDELETEALL(int markerNumber)
- This removes markers of the given number from all lines. If markerNumber is -1, it deletes all - markers from all lines.

- -

SCI_MARKERGET(int line)
- This returns a 32-bit integer that indicates which markers were present on the line. Bit 0 is - set if marker 0 is present, bit 1 for marker 1 and so on.

- -

SCI_MARKERNEXT(int lineStart, int markerMask)
- SCI_MARKERPREVIOUS(int lineStart, int markerMask)
- These messages search efficiently for lines that include a given set of markers. The search - starts at line number lineStart and continues forwards to the end of the file - (SCI_MARKERNEXT) or backwards to the start of the file - (SCI_MARKERPREVIOUS). The markerMask argument should have one bit set - for each marker you wish to find. Set bit 0 to find marker 0, bit 1 for marker 1 and so on. The - message returns the line number of the first line that contains one of the markers in - markerMask or -1 if no marker is found.

- -

SCI_MARKERLINEFROMHANDLE(int markerHandle)
- The markerHandle argument is an identifier for a marker returned by SCI_MARKERADD. This function searches - the document for the marker with this handle and returns the line number that contains it or -1 - if it is not found.

- -

SCI_MARKERDELETEHANDLE(int markerHandle)
- The markerHandle argument is an identifier for a marker returned by SCI_MARKERADD. This function searches - the document for the marker with this handle and deletes the marker if it is found.

- -

Indicators

- -

By default, Scintilla organizes the style byte associated with each text byte as 5 bits of - style information (for 32 styles) and 3 bits of indicator information for 3 independent - indicators so that, for example, syntax errors, deprecated names and bad indentation could all - be displayed at once. Indicators may be displayed as simple underlines, squiggly underlines, a - line of small 'T' shapes, a line of diagonal hatching, a strike-out or a rectangle around the text.

- -

The indicators are set using SCI_STARTSTYLING with a INDICS_MASK mask - and SCI_SETSTYLING with the values - INDIC0_MASK, INDIC1_MASK and INDIC2_MASK.

- -

If you are using indicators in a buffer that has a lexer active - (see SCI_SETLEXER), - you must save lexing state information before setting any indicators and restore it afterwards. - Use SCI_GETENDSTYLED - to retrieve the current "styled to" position and - SCI_STARTSTYLING - to reset the styling position and mask (0x1f in the default layout of 5 style bits and 3 indicator bits) - when you are done.

- -

The number of bits used for styles can be altered with SCI_SETSTYLEBITS from 0 to 7 bits. The remaining bits - can be used for indicators, so there can be from 1 to 8 indicators. However, the - INDIC*_MASK constants defined in Scintilla.h all assume 5 bits of - styling information and 3 indicators. If you use a different arrangement, you must define your - own constants.

- -

The SCI_INDIC* messages allow you to get and set the visual appearance of the - indicators. They all use an indicatorNumber argument in the range 0 to 7 to set - the indicator to style. With the default settings, only indicators 0, 1 and 2 will have any - visible effect.

SCI_INDICSETSTYLE(int indicatorNumber, int
-    indicatorStyle)

-     SCI_INDICGETSTYLE(int indicatorNumber)

-     SCI_INDICSETFORE(int indicatorNumber, int
-    colour)

-     SCI_INDICGETFORE(int indicatorNumber)

-

- -

SCI_INDICSETSTYLE(int indicatorNumber, int - indicatorStyle)
- SCI_INDICGETSTYLE(int indicatorNumber)
- These two messages set and get the style for a particular indicator. The indicator styles - currently available are:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Symbol	Value	Visual effect
`INDIC_PLAIN`	0	Underlined with a single, straight line.
`INDIC_SQUIGGLE`	1	A squiggly underline.
`INDIC_TT`	2	A line of small T shapes.
`INDIC_DIAGONAL`	3	Diagonal hatching.
`INDIC_STRIKE`	4	Strike out.
`INDIC_HIDDEN`	5	An indicator with no visual effect.
`INDIC_BOX`	6	A rectangle around the text.
`INDIC_ROUNDBOX`	7	A rectangle with rounded corners around the text using translucent drawing with the - interior more transparent than the border.

- -

The default indicator styles are equivalent to:
- SCI_INDICSETSTYLE(0, INDIC_SQUIGGLE);
- SCI_INDICSETSTYLE(1, INDIC_TT);
- SCI_INDICSETSTYLE(2, INDIC_PLAIN);

- -

SCI_INDICSETFORE(int indicatorNumber, int colour)
- SCI_INDICGETFORE(int indicatorNumber)
- These two messages set and get the colour used to draw an indicator. The default indicator - colours are equivalent to:
- SCI_INDICSETFORE(0, 0x007f00); (dark green)
- SCI_INDICSETFORE(1, 0xff0000); (light blue)
- SCI_INDICSETFORE(2, 0x0000ff); (light red)

- -

Autocompletion

- -

Autocompletion displays a list box showing likely identifiers based upon the user's typing. - The user chooses the currently selected item by pressing the tab character or another character - that is a member of the fillup character set defined with SCI_AUTOCSETFILLUPS. - Autocompletion is triggered by your application. For example, in C if you detect that the user - has just typed fred. you could look up fred, and if it has a known - list of members, you could offer them in an autocompletion list. Alternatively, you could - monitor the user's typing and offer a list of likely items once their typing has narrowed down - the choice to a reasonable list. As yet another alternative, you could define a key code to - activate the list.

- -

When the user makes a selection from the list the container is sent a SCN_AUTOCSELECTION notification message. On return from the notification Scintilla will insert - the selected text unless the autocompletion list has been cancelled, for example by the container sending - SCI_AUTOCCANCEL.

- -

To make use of autocompletion you must monitor each character added to the document. See - SciTEBase::CharAdded() in SciTEBase.cxx for an example of autocompletion.

SCI_AUTOCSHOW(int lenEntered, const char
-    *list)

-     SCI_AUTOCCANCEL

-     SCI_AUTOCACTIVE

-     SCI_AUTOCPOSSTART

-     SCI_AUTOCCOMPLETE

-     SCI_AUTOCSTOPS(<unused>, const char
-    *chars)

-     SCI_AUTOCSETSEPARATOR(char
-    separator)

-     SCI_AUTOCGETSEPARATOR

-     SCI_AUTOCSELECT(<unused>, const char
-    *select)

-     SCI_AUTOCGETCURRENT

-     SCI_AUTOCSETCANCELATSTART(bool
-    cancel)

-     SCI_AUTOCGETCANCELATSTART

-     SCI_AUTOCSETFILLUPS(<unused>, const char
-    *chars)

-     SCI_AUTOCSETCHOOSESINGLE(bool
-    chooseSingle)

-     SCI_AUTOCGETCHOOSESINGLE

-     SCI_AUTOCSETIGNORECASE(bool
-    ignoreCase)

-     SCI_AUTOCGETIGNORECASE

-     SCI_AUTOCSETAUTOHIDE(bool autoHide)

-     SCI_AUTOCGETAUTOHIDE

-     SCI_AUTOCSETDROPRESTOFWORD(bool
-    dropRestOfWord)

-     SCI_AUTOCGETDROPRESTOFWORD

-     SCI_REGISTERIMAGE

-     SCI_CLEARREGISTEREDIMAGES

-     SCI_AUTOCSETTYPESEPARATOR(char separatorCharacter)

-     SCI_AUTOCGETTYPESEPARATOR

-     SCI_AUTOCSETMAXHEIGHT(int rowCount)

-     SCI_AUTOCGETMAXHEIGHT

-     SCI_AUTOCSETMAXWIDTH(int characterCount)

-     SCI_AUTOCGETMAXWIDTH

-

- -

SCI_AUTOCSHOW(int lenEntered, const char *list)
- This message causes a list to be displayed. lenEntered is the number of - characters of the word already entered and list is the list of words separated by - separator characters. The initial separator character is a space but this can be set or got - with SCI_AUTOCSETSEPARATOR - and SCI_AUTOCGETSEPARATOR.

- -

The list of words should be in sorted order. If set to ignore case mode with SCI_AUTOCSETIGNORECASE, then - strings are matched after being converted to upper case. One result of this is that the list - should be sorted with the punctuation characters '[', '\', ']', '^', '_', and '`' sorted after - letters.

- -

SCI_AUTOCCANCEL
- This message cancels any displayed autocompletion list. When in autocompletion mode, the list - should disappear when the user types a character that can not be part of the autocompletion, - such as '.', '(' or '[' when typing an identifier. A set of characters that will cancel - autocompletion can be specified with SCI_AUTOCSTOPS.

- -

SCI_AUTOCACTIVE
- This message returns non-zero if there is an active autocompletion list and zero if there is - not.

- -

SCI_AUTOCPOSSTART
- This returns the value of the current position when SCI_AUTOCSHOW started display - of the list.

- -

SCI_AUTOCCOMPLETE
- This message triggers autocompletion. This has the same effect as the tab key.

- -

SCI_AUTOCSTOPS(<unused>, const char *chars)
- The chars argument is a string containing a list of characters that will - automatically cancel the autocompletion list. When you start the editor, this list is - empty.

- -

SCI_AUTOCSETSEPARATOR(char separator)
- SCI_AUTOCGETSEPARATOR
- These two messages set and get the separator character used to separate words in the - SCI_AUTOCSHOW list. The default is the space character.

- -

SCI_AUTOCSELECT(<unused>, const char *select)
- SCI_AUTOCGETCURRENT
- This message selects an item in the autocompletion list. It searches the list of words for the - first that matches select. By default, comparisons are case sensitive, but you can - change this with SCI_AUTOCSETIGNORECASE. The match is character - by character for the length of the select string. That is, if select is "Fred" it - will match "Frederick" if this is the first item in the list that begins with "Fred". If an - item is found, it is selected. If the item is not found, the autocompletion list closes if - auto-hide is true (see SCI_AUTOCSETAUTOHIDE).
- The current selection can be retrieved with SCI_AUTOCGETCURRENT -

- -

SCI_AUTOCSETCANCELATSTART(bool cancel)
- SCI_AUTOCGETCANCELATSTART
- The default behavior is for the list to be cancelled if the caret moves before the location it - was at when the list was displayed. By calling this message with a false argument, - the list is not cancelled until the caret moves before the first character of the word being - completed.

- -

SCI_AUTOCSETFILLUPS(<unused>, const char *chars)
- If a fillup character is typed with an autocompletion list active, the currently selected item - in the list is added into the document, then the fillup character is added. Common fillup - characters are '(', '[' and '.' but others are possible depending on the language. By default, - no fillup characters are set.

- -

SCI_AUTOCSETCHOOSESINGLE(bool chooseSingle)
- SCI_AUTOCGETCHOOSESINGLE
- If you use SCI_AUTOCSETCHOOSESINGLE(1) and a list has only one item, it is - automatically added and no list is displayed. The default is to display the list even if there - is only a single item.

- -

SCI_AUTOCSETIGNORECASE(bool ignoreCase)
- SCI_AUTOCGETIGNORECASE
- By default, matching of characters to list members is case sensitive. These messages let you - set and get case sensitivity.

- -

SCI_AUTOCSETAUTOHIDE(bool autoHide)
- SCI_AUTOCGETAUTOHIDE
- By default, the list is cancelled if there are no viable matches (the user has typed - characters that no longer match a list entry). If you want to keep displaying the original - list, set autoHide to false. This also effects SCI_AUTOCSELECT.

- -

SCI_AUTOCSETDROPRESTOFWORD(bool dropRestOfWord)
- SCI_AUTOCGETDROPRESTOFWORD
- When an item is selected, any word characters following the caret are first erased if - dropRestOfWord is set true. The default is false.

- -

- SCI_REGISTERIMAGE(int type, const char *xpmData)
- SCI_CLEARREGISTEREDIMAGES
- SCI_AUTOCSETTYPESEPARATOR(char separatorCharacter)
- SCI_AUTOCGETTYPESEPARATOR
- - Autocompletion list items may display an image as well as text. Each image is first registered with an integer - type. Then this integer is included in the text of the list separated by a '?' from the text. For example, - "fclose?2 fopen" displays image 2 before the string "fclose" and no image before "fopen". - The images are in XPM format as is described for - SCI_MARKERDEFINEPIXMAP - The set of registered images can be cleared with SCI_CLEARREGISTEREDIMAGES and the '?' separator changed - with SCI_AUTOCSETTYPESEPARATOR. -

- -

- SCI_AUTOCSETMAXHEIGHT(int rowCount)
- SCI_AUTOCGETMAXHEIGHT
- - Get or set the maximum number of rows that will be visible in an autocompletion list. If there are more rows in the list, then a vertical - scrollbar is shown. The default is 5. -

- -

- SCI_AUTOCSETMAXWIDTH(int characterCount)
- SCI_AUTOCGETMAXWIDTH
- - Get or set the maximum width of an autocompletion list expressed as the number of characters in the longest item that will be totally visible. - If zero (the default) then the list's width is calculated to fit the item with the most characters. Any items that cannot be fully displayed within - the available width are indicated by the presence of ellipsis. -

- -

User lists

- -

User lists use the same internal mechanisms as autocompletion lists, and all the calls - listed for autocompletion work on them; you cannot display a user list at the same time as an - autocompletion list is active. They differ in the following respects:

- -

o The SCI_AUTOCSETCHOOSESINGLE message has no - effect.
- o When the user makes a selection you are sent a SCN_USERLISTSELECTION notification message rather than SCN_AUTOCSELECTION.

- -

BEWARE: if you have set fillup characters or stop characters, these will still be active - with the user list, and may result in items being selected or the user list cancelled due to - the user typing into the editor.

- -

SCI_USERLISTSHOW(int listType, const char *list)
- The listType parameter is returned to the container as the wParam - field of the SCNotification - structure. It must be greater than 0 as this is how Scintilla tells the difference between an - autocompletion list and a user list. If you have different types of list, for example a list of - buffers and a list of macros, you can use listType to tell which one has returned - a selection.

- -

Call tips

- -

Call tips are small windows displaying the arguments to a function and are displayed after - the user has typed the name of the function. They normally display characters using the font - facename, size and character set defined by - STYLE_DEFAULT. You can choose to - use STYLE_CALLTIP to define the - facename, size, foreground and background colours and character set with - SCI_CALLTIPUSESTYLE. - This also enables support for Tab characters. - - There is some interaction between call tips and autocompletion lists in that showing a - call tip cancels any active autocompletion list, and vice versa.

- -

Call tips can highlight part of the text within them. You could use this to highlight the - current argument to a function by counting the number of commas (or whatever separator your - language uses). See SciTEBase::CharAdded() in SciTEBase.cxx for an - example of call tip use.

- -

The mouse may be clicked on call tips and this causes a - SCN_CALLTIPCLICK - notification to be sent to the container. Small up an down arrows may be displayed within - a call tip by, respectively, including the characters '\001', or '\002'. This is useful - for showing that there are overloaded variants of one function name and that the user can - click on the arrows to cycle through the overloads.

- -

Alternatively, call tips can be displayed when you leave the mouse pointer for a while over - a word in response to the SCN_DWELLSTART notification and cancelled in response to SCN_DWELLEND. This method could be used in a debugger to give - the value of a variable, or during editing to give information about the word under the - pointer.

SCI_CALLTIPSHOW(int posStart, const char
-    *definition)

-     SCI_CALLTIPCANCEL

-     SCI_CALLTIPACTIVE

-     SCI_CALLTIPPOSSTART

-     SCI_CALLTIPSETHLT(int highlightStart, int
-    highlightEnd)

-     SCI_CALLTIPSETBACK(int colour)

-     SCI_CALLTIPSETFORE(int colour)

-     SCI_CALLTIPSETFOREHLT(int colour)

-     SCI_CALLTIPUSESTYLE(int tabsize)

-

- -

SCI_CALLTIPSHOW(int posStart, const char *definition)
- This message starts the process by displaying the call tip window. If a call tip is already - active, this has no effect.
- posStart is the position in the document at which to align the call tip. The call - tip text is aligned to start 1 line below this character unless you have included up and/or - down arrows in the call tip text in which case the tip is aligned to the right-hand edge of - the rightmost arrow. The assumption is that you will start the text with something like - "\001 1 of 3 \002".
- definition is the call tip text. This can contain multiple lines separated by - '\n' (Line Feed, ASCII code 10) characters. Do not include '\r' (Carriage Return, ASCII - code 13), as this will most likely print as an empty box. '\t' (Tab, ASCII code 9) is - supported if you set a tabsize with - SCI_CALLTIPUSESTYLE.

- -

SCI_CALLTIPCANCEL
- This message cancels any displayed call tip. Scintilla will also cancel call tips for you if - you use any keyboard commands that are not compatible with editing the argument list of a - function.

- -

SCI_CALLTIPACTIVE
- This returns 1 if a call tip is active and 0 if it is not active.

- -

SCI_CALLTIPPOSSTART
- This message returns the value of the current position when SCI_CALLTIPSHOW - started to display the tip.

- -

SCI_CALLTIPSETHLT(int hlStart, int hlEnd)
- This sets the region of the call tips text to display in a highlighted style. - hlStart is the zero-based index into the string of the first character to - highlight and hlEnd is the index of the first character after the highlight. - hlEnd must be greater than hlStart; hlEnd-hlStart is the - number of characters to highlight. Highlights can extend over line ends if this is - required.

- -

Unhighlighted text is drawn in a mid gray. Selected text is drawn in a dark blue. The - background is white. These can be changed with - SCI_CALLTIPSETBACK, - SCI_CALLTIPSETFORE, and - SCI_CALLTIPSETFOREHLT. -

- -

SCI_CALLTIPSETBACK(int colour)
- The background colour of call tips can be set with this message; the default colour is white. - It is not a good idea to set a dark colour as the background as the default colour for normal - calltip text is mid gray and the defaultcolour for highlighted text is dark blue. This also - sets the background colour of STYLE_CALLTIP.

- -

SCI_CALLTIPSETFORE(int colour)
- The colour of call tip text can be set with this message; the default colour is mid gray. - This also sets the foreground colour of STYLE_CALLTIP.

- -

SCI_CALLTIPSETFOREHLT(int colour)
- The colour of highlighted call tip text can be set with this message; the default colour - is dark blue.

- -

SCI_CALLTIPUSESTYLE(int tabsize)
- This message changes the style used for call tips from STYLE_DEFAULT to - STYLE_CALLTIP and sets a tab size in screen pixels. If tabsize is - less than 1, Tab characters are not treated specially. Once this call has been used, the - call tip foreground and background colours are also taken from the style.

- - -

Keyboard commands

- -

To allow the container application to perform any of the actions available to the user with - keyboard, all the keyboard actions are messages. They do not take any parameters. These - commands are also used when redefining the key bindings with the SCI_ASSIGNCMDKEY message.

`SCI_LINEDOWN`	`SCI_LINEDOWNEXTEND`	`SCI_LINEDOWNRECTEXTEND`	`SCI_LINESCROLLDOWN`
`SCI_LINEUP`	`SCI_LINEUPEXTEND`	`SCI_LINEUPRECTEXTEND`	`SCI_LINESCROLLUP`
`SCI_PARADOWN`	`SCI_PARADOWNEXTEND`	`SCI_PARAUP`	`SCI_PARAUPEXTEND`
`SCI_CHARLEFT`	`SCI_CHARLEFTEXTEND`	`SCI_CHARLEFTRECTEXTEND`
`SCI_CHARRIGHT`	`SCI_CHARRIGHTEXTEND`	`SCI_CHARRIGHTRECTEXTEND`
`SCI_WORDLEFT`	`SCI_WORDLEFTEXTEND`	`SCI_WORDRIGHT`	`SCI_WORDRIGHTEXTEND`
`SCI_WORDLEFTEND`	`SCI_WORDLEFTENDEXTEND`	`SCI_WORDRIGHTEND`	`SCI_WORDRIGHTENDEXTEND`
`SCI_WORDPARTLEFT`	`SCI_WORDPARTLEFTEXTEND`	`SCI_WORDPARTRIGHT`	`SCI_WORDPARTRIGHTEXTEND`
`SCI_HOME`	`SCI_HOMEEXTEND`	`[SCI_HOMERECTEXTEND]`
`SCI_HOMEDISPLAY`	`SCI_HOMEDISPLAYEXTEND`	`SCI_HOMEWRAP`	`SCI_HOMEWRAPEXTEND`
`SCI_VCHOME`	`SCI_VCHOMEEXTEND`	`SCI_VCHOMERECTEXTEND`
`SCI_VCHOMEWRAP`	`SCI_VCHOMEWRAPEXTEND`
`SCI_LINEEND`	`SCI_LINEENDEXTEND`	`SCI_LINEENDRECTEXTEND`
`SCI_LINEENDDISPLAY`	`SCI_LINEENDDISPLAYEXTEND`	`SCI_LINEENDWRAP`	`SCI_LINEENDWRAPEXTEND`
`SCI_DOCUMENTSTART`	`SCI_DOCUMENTSTARTEXTEND`	`SCI_DOCUMENTEND`	`SCI_DOCUMENTENDEXTEND`
`SCI_PAGEUP`	`SCI_PAGEUPEXTEND`	`SCI_PAGEUPRECTEXTEND`
`SCI_PAGEDOWN`	`SCI_PAGEDOWNEXTEND`	`SCI_PAGEDOWNRECTEXTEND`
`SCI_STUTTEREDPAGEUP`	`SCI_STUTTEREDPAGEUPEXTEND`
`SCI_STUTTEREDPAGEDOWN`	`SCI_STUTTEREDPAGEDOWNEXTEND`
`SCI_DELETEBACK`	`SCI_DELETEBACKNOTLINE`	`SCI_DELWORDLEFT`	`SCI_DELWORDRIGHT`
`SCI_DELLINELEFT`	`SCI_DELLINERIGHT`	`SCI_LINEDELETE`
`SCI_LINECUT`	`SCI_LINECOPY`	`SCI_LINETRANSPOSE`	`SCI_LINEDUPLICATE`
`SCI_LOWERCASE`	`SCI_UPPERCASE`	`SCI_CANCEL`	`SCI_EDITTOGGLEOVERTYPE`
`SCI_NEWLINE`	`SCI_FORMFEED`	`SCI_TAB`	`SCI_BACKTAB`
`SCI_SELECTIONDUPLICATE`

- -

The SCI_*EXTEND messages extend the selection.

- -

The SCI_*RECTEXTEND messages extend the rectangular selection - (and convert regular selection to rectangular one, if any).

- -

The SCI_WORDPART* commands are used to move between word segments marked by - capitalisation (aCamelCaseIdentifier) or underscores (an_under_bar_ident).

- -

The SCI_HOME* commands move the caret to the start of the line, while the - SCI_VCHOME*commands move the caret to the first non-blank character of the line - (ie. just after the indentation) unless it is already there; in this case, it acts as SCI_HOME*.

- -

The SCI_[HOME|LINEEND]DISPLAY* commands are used when in line wrap mode to - allow movement to the start or end of display lines as opposed to the normal - SCI_[HOME|LINEEND] commands which move to the start or end of document lines.

- -

The SCI_[[VC]HOME|LINEEND]WRAP* commands are like their namesakes - SCI_[[VC]HOME|LINEEND]* except they behave differently when word-wrap is enabled: - They go first to the start / end of the display line, like SCI_[HOME|LINEEND]DISPLAY*, - but if the cursor is already at the point, it goes on to the start or end of the document line, - as appropriate for SCI_[[VC]HOME|LINEEND]*. -

- -

Key bindings

- -

There is a default binding of keys to commands that is defined in the Scintilla source in - the file KeyMap.cxx by the constant KeyMap::MapDefault[]. This table - maps key definitions to SCI_* messages with no parameters (mostly the keyboard commands discussed above, but any Scintilla - command that has no arguments can be mapped). You can change the mapping to suit your own - requirements.

SCI_ASSIGNCMDKEY(int keyDefinition, int
-    sciCommand)

-     SCI_CLEARCMDKEY(int keyDefinition)

-     SCI_CLEARALLCMDKEYS

-     SCI_NULL

-

- -

keyDefinition
- A key definition contains the key code in the low 16-bits and the key modifiers in the high - 16-bits. To combine keyCode and keyMod set:
-
- keyDefinition = keyCode + (keyMod << 16)

- -

The key code is a visible or control character or a key from the SCK_* - enumeration, which contains:
- SCK_ADD, SCK_BACK, SCK_DELETE, SCK_DIVIDE, - SCK_DOWN, SCK_END, SCK_ESCAPE, SCK_HOME, - SCK_INSERT, SCK_LEFT, SCK_NEXT (Page Down), - SCK_PRIOR (Page Up), SCK_RETURN, SCK_RIGHT, - SCK_SUBTRACT, SCK_TAB, and SCK_UP.

- -

The modifiers are a combination of zero or more of SCMOD_ALT, - SCMOD_CTRL, and SCMOD_SHIFT. If you are building a table, you might - want to use SCMOD_NORM, which has the value 0, to mean no modifiers.

- -

SCI_ASSIGNCMDKEY(int keyDefinition, int sciCommand)
- This assigns the given key definition to a Scintilla command identified by - sciCommand. sciCommand can be any SCI_* command that has - no arguments.

- -

SCI_CLEARCMDKEY(int keyDefinition)
- This makes the given key definition do nothing by assigning the action SCI_NULL - to it.

- -

SCI_CLEARALLCMDKEYS
- This command removes all keyboard command mapping by setting an empty mapping table.

- -

SCI_NULL
- The SCI_NULL does nothing and is the value assigned to keys that perform no - action. SCI_NULL ensures that keys do not propagate to the parent window as that may - cause focus to move. If you want the standard platform behaviour use the constant 0 instead.

- -

Popup edit menu

- -

SCI_USEPOPUP(bool bEnablePopup)
- Clicking the wrong button on the mouse pops up a short default editing menu. This may be - turned off with SCI_USEPOPUP(0). If you turn it off, context menu commands (in - Windows, WM_CONTEXTMENU) will not be handled by Scintilla, so the parent of the - Scintilla window will have the opportunity to handle the message.

- -

Macro recording

- -

Start and stop macro recording mode. In macro recording mode, actions are reported to the - container through SCN_MACRORECORD - notifications. It is then up to the container to - record these actions for future replay.

- -

SCI_STARTRECORD
- SCI_STOPRECORD
- These two messages turn macro recording on and off.

- -

Printing

- -

On Windows SCI_FORMATRANGE can be used to draw the text onto a display context - which can include a printer display context. Printed output shows text styling as on the - screen, but it hides all margins except a line number margin. All special marker effects are - removed and the selection and caret are hidden.

SCI_FORMATRANGE(bool bDraw, RangeToFormat
-    *pfr)

-     SCI_SETPRINTMAGNIFICATION(int
-    magnification)

-     SCI_GETPRINTMAGNIFICATION

-     SCI_SETPRINTCOLOURMODE(int mode)

-     SCI_GETPRINTCOLOURMODE

-     SCI_SETPRINTWRAPMODE

-     SCI_GETPRINTWRAPMODE

-

- -

SCI_FORMATRANGE(bool bDraw, RangeToFormat *pfr)
- This call allows Windows users to render a range of text into a device context. If you use - this for printing, you will probably want to arrange a page header and footer; Scintilla does - not do this for you. See SciTEWin::Print() in SciTEWinDlg.cxx for an - example. Each use of this message renders a range of text into a rectangular area and returns - the position in the document of the next character to print.

- -

bDraw controls if any output is done. Set this to false if you are paginating - (for example, if you use this with MFC you will need to paginate in - OnBeginPrinting() before you output each page.

-struct RangeToFormat {
-    SurfaceID hdc;        // The HDC (device context) we print to
-    SurfaceID hdcTarget;  // The HDC we use for measuring (may be same as hdc)
-    PRectangle rc;        // Rectangle in which to print
-    PRectangle rcPage;    // Physically printable page size
-    CharacterRange chrg;  // Range of characters to print
-};
-

- -

hdc and hdcTarget should both be set to the device context handle - of the output device (usually a printer). If you print to a metafile these will not be the same - as Windows metafiles (unlike extended metafiles) do not implement the full API for returning - information. In this case, set hdcTarget to the screen DC.
- rcPage is the rectangle {0, 0, maxX, maxY} where maxX+1 - and maxY+1 are the number of physically printable pixels in x and y.
- rc is the rectangle to render the text in (which will, of course, fit within the - rectangle defined by rcPage).
- chrg.cpMin and chrg.cpMax define the start position and maximum - position of characters to output. All of each line within this character range is drawn.

- -

When printing, the most tedious part is always working out what the margins should be to - allow for the non-printable area of the paper and printing a header and footer. If you look at - the printing code in SciTE, you will find that most of it is taken up with this. The loop that - causes Scintilla to render text is quite simple if you strip out all the margin, non-printable - area, header and footer code.

- -

SCI_SETPRINTMAGNIFICATION(int magnification)
- SCI_GETPRINTMAGNIFICATION
- SCI_GETPRINTMAGNIFICATION lets you to print at a different size than the screen - font. magnification is the number of points to add to the size of each screen - font. A value of -3 or -4 gives reasonably small print. You can get this value with - SCI_GETPRINTMAGNIFICATION.

- -

SCI_SETPRINTCOLOURMODE(int mode)
- SCI_GETPRINTCOLOURMODE
- These two messages set and get the method used to render coloured text on a printer that is - probably using white paper. It is especially important to consider the treatment of colour if - you use a dark or black screen background. Printing white on black uses up toner and ink very - many times faster than the other way around. You can set the mode to one of:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Symbol	Value	Purpose
`SC_PRINT_NORMAL`	0	Print using the current screen colours. This is the default.
`SC_PRINT_INVERTLIGHT`	1	If you use a dark screen background this saves ink by inverting the light value of - all colours and printing on a white background.
`SC_PRINT_BLACKONWHITE`	2	Print all text as black on a white background.
`SC_PRINT_COLOURONWHITE`	3	Everything prints in its own colour on a white background.
`SC_PRINT_COLOURONWHITEDEFAULTBG`	4	Everything prints in its own colour on a white background except that line numbers - use their own background colour.

- -

SCI_SETPRINTWRAPMODE(int wrapMode)
- SCI_GETPRINTWRAPMODE
- These two functions get and set the printer wrap mode. wrapMode can be - set to SC_WRAP_NONE (0), SC_WRAP_WORD (1) or - SC_WRAP_CHAR (2). The default is - SC_WRAP_WORD, which wraps printed output so that all characters fit - into the print rectangle. If you set SC_WRAP_NONE, each line of text - generates one line of output and the line is truncated if it is too long to fit - into the print area.
- SC_WRAP_WORD tries to wrap only between words as indicated by - white space or style changes although if a word is longer than a line, it will be wrapped before - the line end. SC_WRAP_CHAR is preferred to - SC_WRAP_WORD for Asian languages where there is no white space - between words.

- -

Direct access

SCI_GETDIRECTFUNCTION

-     SCI_GETDIRECTPOINTER

-

- -

On Windows, the message-passing scheme used to communicate between the container and - Scintilla is mediated by the operating system SendMessage function and can lead to - bad performance when calling intensively. To avoid this overhead, Scintilla provides messages - that allow you to call the Scintilla message function directly. The code to do this in C/C++ is - of the form:

-#include "Scintilla.h"
-SciFnDirect pSciMsg = (SciFnDirect)SendMessage(hSciWnd, SCI_GETDIRECTFUNCTION, 0, 0);
-sptr_t pSciWndData = (sptr_t)SendMessage(hSciWnd, SCI_GETDIRECTPOINTER, 0, 0);
-
-// now a wrapper to call Scintilla directly
-sptr_t CallScintilla(unsigned int iMessage, uptr_t wParam, sptr_t lParam){
-    return pSciMsg(pSciWndData, iMessage, wParam, lParam);
-}
-

- -

SciFnDirect, sptr_t and uptr_t are declared in - Scintilla.h. hSciWnd is the window handle returned when you created - the Scintilla window.

- -

While faster, this direct calling will cause problems if performed from a different thread - to the native thread of the Scintilla window in which case SendMessage(hSciWnd, SCI_*, - wParam, lParam) should be used to synchronize with the window's thread.

- -

This feature also works on GTK+ but has no significant impact on speed.

- -

From version 1.47 on Windows, Scintilla exports a function called - Scintilla_DirectFunction that can be used the same as the function returned by - SCI_GETDIRECTFUNCTION. This saves you the call to - SCI_GETDIRECTFUNCTION and the need to call Scintilla indirectly via the function - pointer.

- -

SCI_GETDIRECTFUNCTION
- This message returns the address of the function to call to handle Scintilla messages without - the overhead of passing through the Windows messaging system. You need only call this once, - regardless of the number of Scintilla windows you create.

- -

SCI_GETDIRECTPOINTER
- This returns a pointer to data that identifies which Scintilla window is in use. You must call - this once for each Scintilla window you create. When you call the direct function, you must - pass in the direct pointer associated with the target window.

- -

Multiple views

- -

A Scintilla window and the document that it displays are separate entities. When you create - a new window, you also create a new, empty document. Each document has a reference count that - is initially set to 1. The document also has a list of the Scintilla windows that are linked to - it so when any window changes the document, all other windows in which it appears are notified - to cause them to update. The system is arranged in this way so that you can work with many - documents in a single Scintilla window and so you can display a single document in multiple - windows (for use with splitter windows).

- -

Although these messages use document *pDoc, to ensure compatibility with future - releases of Scintilla you should treat pDoc as an opaque void*. That - is, you can use and store the pointer as described in this section but you should not - dereference it.

SCI_GETDOCPOINTER

-     SCI_SETDOCPOINTER(<unused>, document
-    *pDoc)

-     SCI_CREATEDOCUMENT

-     SCI_ADDREFDOCUMENT(<unused>, document
-    *pDoc)

-     SCI_RELEASEDOCUMENT(<unused>, document
-    *pDoc)

-

- -

SCI_GETDOCPOINTER
- This returns a pointer to the document currently in use by the window. It has no other - effect.

- -

SCI_SETDOCPOINTER(<unused>, document *pDoc)
- This message does the following:
- 1. It removes the current window from the list held by the current document.
- 2. It reduces the reference count of the current document by 1.
- 3. If the reference count reaches 0, the document is deleted.
- 4. pDoc is set as the new document for the window.
- 5. If pDoc was 0, a new, empty document is created and attached to the - window.
- 6. If pDoc was not 0, its reference count is increased by 1.

- -

SCI_CREATEDOCUMENT
- This message creates a new, empty document and returns a pointer to it. This document is not - selected into the editor and starts with a reference count of 1. This means that you have - ownership of it and must either reduce its reference count by 1 after using - SCI_SETDOCPOINTER so that the Scintilla window owns it or you must make sure that - you reduce the reference count by 1 with SCI_RELEASEDOCUMENT before you close the - application to avoid memory leaks.

- -

SCI_ADDREFDOCUMENT(<unused>, document *pDoc)
- This increases the reference count of a document by 1. If you want to replace the current - document in the Scintilla window and take ownership of the current document, for example if you - are editing many documents in one window, do the following:
- 1. Use SCI_GETDOCPOINTER to get a pointer to the document, - pDoc.
- 2. Use SCI_ADDREFDOCUMENT(0, pDoc) to increment the reference count.
- 3. Use SCI_SETDOCPOINTER(0, pNewDoc) to set a different document or - SCI_SETDOCPOINTER(0, 0) to set a new, empty document.

- -

SCI_RELEASEDOCUMENT(<unused>, document *pDoc)
- This message reduces the reference count of the document identified by pDoc. pDoc - must be the result of SCI_GETDOCPOINTER or SCI_CREATEDOCUMENT and - must point at a document that still exists. If you call this on a document with a reference - count of 1 that is still attached to a Scintilla window, bad things will happen. To keep the - world spinning in its orbit you must balance each call to SCI_CREATEDOCUMENT or - SCI_ADDREFDOCUMENT with a call to SCI_RELEASEDOCUMENT.

- -

Folding

- -

The fundamental operation in folding is making lines invisible or visible. Line visibility - is a property of the view rather than the document so each view may be displaying a different - set of lines. From the point of view of the user, lines are hidden and displayed using fold - points. Generally, the fold points of a document are based on the hierarchical structure of the - document contents. In Python, the hierarchy is determined by indentation and in C++ by brace - characters. This hierarchy can be represented within a Scintilla document object by attaching a - numeric "fold level" to each line. The fold level is most easily set by a lexer, but you can - also set it with messages.

- -

It is up to your code to set the connection between user actions and folding and unfolding. - The best way to see how this is done is to search the SciTE source code for the messages used - in this section of the documentation and see how they are used. You will also need to use - markers and a folding margin to complete your folding implementation. - The "fold" property should be set to "1" with - SCI_SETPROPERTY("fold", "1") to enable folding.

SCI_VISIBLEFROMDOCLINE(int
-    docLine)

-     SCI_DOCLINEFROMVISIBLE(int
-    displayLine)

-     SCI_SHOWLINES(int lineStart, int lineEnd)

-     SCI_HIDELINES(int lineStart, int lineEnd)

-     SCI_GETLINEVISIBLE(int line)

-     SCI_SETFOLDLEVEL(int line, int level)

-     SCI_GETFOLDLEVEL(int line)

-     SCI_SETFOLDFLAGS(int flags)

-     SCI_GETLASTCHILD(int line, int level)

-     SCI_GETFOLDPARENT(int line)

-     SCI_SETFOLDEXPANDED(int line, bool
-    expanded)

-     SCI_GETFOLDEXPANDED(int line)

-     SCI_TOGGLEFOLD(int line)

-     SCI_ENSUREVISIBLE(int line)

-     SCI_ENSUREVISIBLEENFORCEPOLICY(int
-    line)

-

- -

SCI_VISIBLEFROMDOCLINE(int docLine)
- When some lines are folded, then a particular line in the document may be displayed at a - different position to its document position. If no lines are folded, this message returns - docLine. Otherwise, this returns the display line (counting the very first visible - line as 0). The display line of an invisible line is the same as the previous visible line. The - display line number of the first line in the document is 0. If there is folding and - docLine is outside the range of lines in the document, the return value is -1. - Lines can occupy more than one display line if they wrap.

- -

SCI_DOCLINEFROMVISIBLE(int displayLine)
- When some lines are hidden, then a particular line in the document may be displayed at a - different position to its document position. This message returns the document line number that - corresponds to a display line (counting the display line of the first line in the document as - 0). If displayLine is less than or equal to 0, the result is 0. If - displayLine is greater than or equal to the number of displayed lines, the result - is the number of lines in the document.

- -

SCI_SHOWLINES(int lineStart, int lineEnd)
- SCI_HIDELINES(int lineStart, int lineEnd)
- SCI_GETLINEVISIBLE(int line)
- The first two messages mark a range of lines as visible or invisible and then redraw the - display. The third message reports on the visible state of a line and returns 1 if it is - visible and 0 if it is not visible. These messages have no effect on fold levels or fold - flags.

- -

SCI_SETFOLDLEVEL(int line, int level)
- SCI_GETFOLDLEVEL(int line)
- These two messages set and get a 32-bit value that contains the fold level of a line and some - flags associated with folding. The fold level is a number in the range 0 to - SC_FOLDLEVELNUMBERMASK (4095). However, the initial fold level is set to - SC_FOLDLEVELBASE (1024) to allow unsigned arithmetic on folding levels. There are - two addition flag bits. SC_FOLDLEVELWHITEFLAG indicates that the line is blank and - allows it to be treated slightly different then its level may indicate. For example, blank - lines should generally not be fold points and will be considered part of the preceding section even though - they may have a lesser fold level. - SC_FOLDLEVELHEADERFLAG indicates that - the line is a header (fold point).

- -

Use SCI_GETFOLDLEVEL(line) & SC_FOLDLEVELNUMBERMASK to get the fold level - of a line. Likewise, use SCI_GETFOLDLEVEL(line) & SC_FOLDLEVEL*FLAG to get the - state of the flags. To set the fold level you must or in the associated flags. For instance, to - set the level to thisLevel and mark a line as being a fold point use: - SCI_SETFOLDLEVEL(line, thisLevel | SC_FOLDLEVELHEADERFLAG).

- If you use a lexer, you should not need to use SCI_SETFOLDLEVEL as this is far - better handled by the lexer. You will need to use SCI_GETFOLDLEVEL to decide how - to handle user folding requests. If you do change the fold levels, the folding margin will - update to match your changes. - -

SCI_SETFOLDFLAGS(int flags)
- In addition to showing markers in the folding margin, you can indicate folds to the user by - drawing lines in the text area. The lines are drawn in the foreground colour set for STYLE_DEFAULT. Bits set in - flags determine where folding lines are drawn:
-

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Value	Effect
1	Experimental - draw boxes if expanded
2	Draw above if expanded
4	Draw above if not expanded
8	Draw below if expanded
16	Draw below if not expanded
64	display hexadecimal fold levels in line margin to aid debugging of - folding. This feature needs to be redesigned to be sensible.

- -

This message causes the display to redraw.

- -

SCI_GETLASTCHILD(int startLine, int level)
- This message searches for the next line after startLine, that has a folding level - that is less than or equal to level and then returns the previous line number. If - you set level to -1, level is set to the folding level of line - startLine. If from is a fold point, SCI_GETLASTCHILD(from, - -1) returns the last line that would be in made visible or hidden by toggling the fold - state.

- -

SCI_GETFOLDPARENT(int startLine)
- This message returns the line number of the first line before startLine that is - marked as a fold point with SC_FOLDLEVELHEADERFLAG and has a fold level less than - the startLine. If no line is found, or if the header flags and fold levels are - inconsistent, the return value is -1.

- -

SCI_TOGGLEFOLD(int line)
- Each fold point may be either expanded, displaying all its child lines, or contracted, hiding - all the child lines. This message toggles the folding state of the given line as long as it has - the SC_FOLDLEVELHEADERFLAG set. This message takes care of folding or expanding - all the lines that depend on the line. The display updates after this message.

- -

SCI_SETFOLDEXPANDED(int line, bool expanded)
- SCI_GETFOLDEXPANDED(int line)
- These messages set and get the expanded state of a single line. The set message has no effect - on the visible state of the line or any lines that depend on it. It does change the markers in - the folding margin. If you ask for the expansion state of a line that is outside the document, - the result is false (0).

- -

If you just want to toggle the fold state of one line and handle all the lines that are - dependent on it, it is much easier to use SCI_TOGGLEFOLD. You would use the - SCI_SETFOLDEXPANDED message to process many folds without updating the display - until you had finished. See SciTEBase::FoldAll() and - SciTEBase::Expand() for examples of the use of these messages.

- -

SCI_ENSUREVISIBLE(int line)
- SCI_ENSUREVISIBLEENFORCEPOLICY(int line)
- A line may be hidden because more than one of its parent lines is contracted. Both these - message travels up the fold hierarchy, expanding any contracted folds until they reach the top - level. The line will then be visible. If you use SCI_ENSUREVISIBLEENFORCEPOLICY, - the vertical caret policy set by SCI_SETVISIBLEPOLICY is then applied.

- -

Line wrapping

- -

SCI_SETWRAPMODE(int wrapMode)

-     SCI_GETWRAPMODE

-     SCI_SETWRAPVISUALFLAGS(int wrapVisualFlags)

-     SCI_GETWRAPVISUALFLAGS

-     SCI_SETWRAPSTARTINDENT(int indent)

-     SCI_GETWRAPSTARTINDENT

-     SCI_SETLAYOUTCACHE(int cacheMode)

-     SCI_GETLAYOUTCACHE

-     SCI_LINESSPLIT(int pixelWidth)

-     SCI_LINESJOIN

-     SCI_WRAPCOUNT(int docLine)

-

- -

By default, Scintilla does not wrap lines of text. If you enable line wrapping, lines wider - than the window width are continued on the following lines. Lines are broken after space or tab - characters or between runs of different styles. If this is not possible because a word in one - style is wider than the window then the break occurs after the last character that completely - fits on the line. The horizontal scroll bar does not appear when wrap mode is on.

- -

For wrapped lines Scintilla can draw visual flags (little arrows) at end of a a subline of a - wrapped line and at begin of the next subline. These can be enabled individually, but if Scintilla - draws the visual flag at begin of the next subline this subline will be indented by one char. - Independent from drawing a visual flag at the begin the subline can have an indention.

- -

Much of the time used by Scintilla is spent on laying out and drawing text. The same text - layout calculations may be performed many times even when the data used in these calculations - does not change. To avoid these unnecessary calculations in some circumstances, the line layout - cache can store the results of the calculations. The cache is invalidated whenever the - underlying data, such as the contents or styling of the document changes. Caching the layout of - the whole document has the most effect, making dynamic line wrap as much as 20 times faster but - this requires 7 times the memory required by the document contents plus around 80 bytes per - line.

- -

Wrapping is not performed immediately there is a change but is delayed until the display - is redrawn. This delay improves peformance by allowing a set of changes to be performed - and then wrapped and displayed once. Because of this, some operations may not occur as - expected. If a file is read and the scroll position moved to a particular line in the text, - such as occurs when a container tries to restore a previous editing session, then - the scroll position will have been determined before wrapping so an unexpected range - of text will be displayed. To scroll to the position correctly, delay the scroll until the - wrapping has been performed by waiting for an initial - SCN_PAINTED notification.

- -

SCI_SETWRAPMODE(int wrapMode)
- SCI_GETWRAPMODE
- Set wrapMode to SC_WRAP_WORD (1) to enable wrapping - on word boundaries, SC_WRAP_CHAR (2) to enable wrapping - between any characters, and to SC_WRAP_NONE (0) to disable line - wrapping. SC_WRAP_CHAR is preferred to - SC_WRAP_WORD for Asian languages where there is no white space - between words.

- - -

SCI_SETWRAPVISUALFLAGS(int wrapVisualFlags)
- SCI_GETWRAPVISUALFLAGS
- You can enable the drawing of visual flags to indicate a line is wrapped. Bits set in - wrapVisualFlags determine which visual flags are drawn. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Symbol Value Effect
SC_WRAPVISUALFLAG_NONE 0 No visual flags
SC_WRAPVISUALFLAG_END 1 Visual flag at end of subline of a wrapped line.
SC_WRAPVISUALFLAG_START 2 Visual flag at begin of subline of a wrapped line.
- Subline is indented by at least 1 to make room for the flag.
-
- -

Symbol	Value	Effect
`SC_WRAPVISUALFLAG_NONE`	0	No visual flags
`SC_WRAPVISUALFLAG_END`	1	Visual flag at end of subline of a wrapped line.
`SC_WRAPVISUALFLAG_START`	2	Visual flag at begin of subline of a wrapped line. - Subline is indented by at least 1 to make room for the flag. -

SCI_SETWRAPVISUALFLAGSLOCATION(int wrapVisualFlagsLocation)
- SCI_GETWRAPVISUALFLAGSLOCATION
- You can set wether the visual flags to indicate a line is wrapped are drawn near the border or near the text. - Bits set in wrapVisualFlagsLocation set the location to near the text for the corresponding visual flag. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Symbol Value Effect
SC_WRAPVISUALFLAGLOC_DEFAULT 0 Visual flags drawn near border
SC_WRAPVISUALFLAGLOC_END_BY_TEXT 1 Visual flag at end of subline drawn near text
SC_WRAPVISUALFLAGLOC_START_BY_TEXT 2 Visual flag at begin of subline drawn near text
- -
- -

Symbol	Value	Effect
`SC_WRAPVISUALFLAGLOC_DEFAULT`	0	Visual flags drawn near border
`SC_WRAPVISUALFLAGLOC_END_BY_TEXT`	1	Visual flag at end of subline drawn near text
`SC_WRAPVISUALFLAGLOC_START_BY_TEXT`	2	Visual flag at begin of subline drawn near text

SCI_SETWRAPSTARTINDENT(int indent)
- SCI_GETWRAPSTARTINDENT
- SCI_SETWRAPSTARTINDENT sets the size of indentation of sublines for - wrapped lines in terms of the width of a space in - STYLE_DEFAULT. - There are no limits on indent sizes, but values less than 0 or large values may have - undesirable effects.
- The indention of sublines is independent of visual flags, but if - SC_WRAPVISUALFLAG_START is set an indent of at least 1 is used. -

- -

SCI_SETLAYOUTCACHE(int cacheMode)
- SCI_GETLAYOUTCACHE
- You can set cacheMode to one of the symbols in the table:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Symbol	Value	Layout cached for these lines
`SC_CACHE_NONE`	0	No lines are cached.
`SC_CACHE_CARET`	1	The line containing the text caret. This is the default.
`SC_CACHE_PAGE`	2	Visible lines plus the line containing the caret.
`SC_CACHE_DOCUMENT`	3	All lines in the document.

-
- -

SCI_LINESSPLIT(int pixelWidth)
- Split a range of lines indicated by the target into lines that are at most pixelWidth wide. - Splitting occurs on word boundaries wherever possible in a similar manner to line wrapping. - When pixelWidth is 0 then the width of the window is used. -

- -

SCI_LINESJOIN
- Join a range of lines indicated by the target into one line by - removing line end characters. - Where this would lead to no space between words, an extra space is inserted. -

- -

SCI_WRAPCOUNT(int docLine)
- Document lines can occupy more than one display line if they wrap and this - returns the number of display lines needed to wrap a document line.

- -

Zooming

- -

Scintilla incorporates a "zoom factor" that lets you make all the text in the document - larger or smaller in steps of one point. The displayed point size never goes below 2, whatever - zoom factor you set. You can set zoom factors in the range -10 to +20 points.

SCI_ZOOMIN

-     SCI_ZOOMOUT

-     SCI_SETZOOM(int zoomInPoints)

-     SCI_GETZOOM

-

- -

SCI_ZOOMIN
- SCI_ZOOMOUT
- SCI_ZOOMIN increases the zoom factor by one point if the current zoom factor is - less than 20 points. SCI_ZOOMOUT decreases the zoom factor by one point if the - current zoom factor is greater than -10 points.

- -

SCI_SETZOOM(int zoomInPoints)
- SCI_GETZOOM
- These messages let you set and get the zoom factor directly. There is no limit set on the - factors you can set, so limiting yourself to -10 to +20 to match the incremental zoom functions - is a good idea.

- -

Long lines

- -

You can choose to mark lines that exceed a given length by drawing a vertical line or by - colouring the background of characters that exceed the set length.

SCI_SETEDGEMODE(int mode)

-     SCI_GETEDGEMODE

-     SCI_SETEDGECOLUMN(int column)

-     SCI_GETEDGECOLUMN

-     SCI_SETEDGECOLOUR(int colour)

-     SCI_GETEDGECOLOUR

-

- -

SCI_SETEDGEMODE(int edgeMode)
- SCI_GETEDGEMODE
- These two messages set and get the mode used to display long lines. You can set one of the - values in the table:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Symbol	Value	Long line display mode
`EDGE_NONE`	0	Long lines are not marked. This is the default state.
`EDGE_LINE`	1	A vertical line is drawn at the column number set by `SCI_SETEDGECOLUMN`. - This works well for monospaced fonts. The line is drawn at a position based on the width - of a space character in `STYLE_DEFAULT`, so it may not work very well if - your styles use proportional fonts or if your style have varied font sizes or you use a - mixture of bold, italic and normal text. .
`EDGE_BACKGROUND`	2	The background colour of characters after the column limit is changed to the colour - set by `SCI_SETEDGECOLOUR`. This is recommended for proportional fonts.

-
-
- - -

SCI_SETEDGECOLUMN(int column)
- SCI_GETEDGECOLUMN
- These messages set and get the column number at which to display the long line marker. When - drawing lines, the column sets a position in units of the width of a space character in - STYLE_DEFAULT. When setting the background colour, the column is a character count - (allowing for tabs) into the line.

- -

SCI_SETEDGECOLOUR(int colour)
- SCI_GETEDGECOLOUR
- These messages set and get the colour of the marker used to show that a line has exceeded the - length set by SCI_SETEDGECOLUMN.

- -

Lexer

- -

If you define the symbol SCI_LEXER when building Scintilla, (this is sometimes - called the SciLexer version of Scintilla), lexing support for a wide range programming - languages is included and the messages in this section are supported. If you want to set - styling and fold points for an unsupported language you can either do this in the container or - better still, write your own lexer following the pattern of one of the existing ones.

- -

Scintilla also supports external lexers. These are DLLs (on Windows) or .so modules (on GTK+/Linux) that export four - functions: GetLexerCount, GetLexerName, Lex and - Fold. See externalLexer.cxx for more.

SCI_SETLEXER(int lexer)

-     SCI_GETLEXER

-     SCI_SETLEXERLANGUAGE(<unused>, char
-    *name)

-     SCI_LOADLEXERLIBRARY(<unused>, char
-    *path)

-     SCI_COLOURISE(int start, int end)

-     SCI_SETPROPERTY(const char *key, const char *value)

-     SCI_GETPROPERTY(const char *key, char *value)

-     SCI_GETPROPERTYEXPANDED(const char *key, char *value)

-     SCI_GETPROPERTYINT(const char *key, int default)

-     SCI_SETKEYWORDS(int keyWordSet, const char
-    *keyWordList)

-     SCI_GETSTYLEBITSNEEDED
-    

-

- -

SCI_SETLEXER(int lexer)
- SCI_GETLEXER
- You can select the lexer to use with an integer code from the SCLEX_* enumeration - in Scintilla.h. There are two codes in this sequence that do not use lexers: - SCLEX_NULL to select no lexing action and SCLEX_CONTAINER which sends - the SCN_STYLENEEDED notification to - the container whenever a range of text needs to be styled. You cannot use the - SCLEX_AUTOMATIC value; this identifies additional external lexers that Scintilla - assigns unused lexer numbers to.

- -

SCI_SETLEXERLANGUAGE(<unused>, const char *name)
- This message lets you select a lexer by name, and is the only method if you are using an - external lexer or if you have written a lexer module for a language of your own and do not wish - to assign it an explicit lexer number. To select an existing lexer, set name to - match the (case sensitive) name given to the module, for example "ada" or "python", not "Ada" - or "Python". To locate the name for the built-in lexers, open the relevant - Lex*.cxx file and search for LexerModule. The third argument in the - LexerModule constructor is the name to use.

- -

To test if your lexer assignment worked, use SCI_GETLEXER before and after setting the new lexer to - see if the lexer number changed.

- -

SCI_LOADLEXERLIBRARY(<unused>, const char *path)
- Load a lexer implemented in a shared library. This is a .so file on GTK+/Linux or a .DLL file on Windows. -

- -

SCI_COLOURISE(int startPos, int endPos)
- This requests the current lexer or the container (if the lexer is set to - SCLEX_CONTAINER) to style the document between startPos and - endPos. If endPos is -1, the document is styled from - startPos to the end. If the "fold" property is set to - "1" and your lexer or container supports folding, fold levels are also set. This - message causes a redraw.

- -

SCI_SETPROPERTY(const char *key, const char *value)
- You can communicate settings to lexers with keyword:value string pairs. There is no limit to - the number of keyword pairs you can set, other than available memory. key is a - case sensitive keyword, value is a string that is associated with the keyword. If - there is already a value string associated with the keyword, it is replaced. If you pass a zero - length string, the message does nothing. Both key and value are used - without modification; extra spaces at the beginning or end of key are - significant.

- -

The value string can refer to other keywords. For example, - SCI_SETPROPERTY("foldTimes10", "$(fold)0") stores the string - "$(fold)0", but when this is accessed, the $(fold) is replaced by the - value of the "fold" keyword (or by nothing if this keyword does not exist).

- -

Currently the "fold" property is defined for most of the lexers to set the fold structure if - set to "1". SCLEX_PYTHON understands "tab.timmy.whinge.level" as a - setting that determines how to indicate bad indentation. Most keywords have values that are - interpreted as integers. Search the lexer sources for GetPropertyInt to see how - properties are used.

- -

SCI_GETPROPERTY(const char *key, char *value)
- Lookup a keyword:value pair using the specified key; if found, copy the value to the user-supplied - buffer and return the length (not including the terminating 0). If not found, copy an empty string - to the buffer and return 0.

- -

Note that "keyword replacement" as described in - SCI_SETPROPERTY will not be performed.

- -

If the value argument is 0 then the length that should be allocated to store the value is returned; - again, the terminating 0 is not included.

- -

SCI_GETPROPERTYEXPANDED(const char *key, char *value)
- Lookup a keyword:value pair using the specified key; if found, copy the value to the user-supplied - buffer and return the length (not including the terminating 0). If not found, copy an empty string - to the buffer and return 0.

- -

Note that "keyword replacement" as described in - SCI_SETPROPERTY will be performed.

- -

If the value argument is 0 then the length that should be allocated to store the value (including any indicated keyword replacement) - is returned; again, the terminating 0 is not included.

- -

SCI_GETPROPERTYINT(const char *key, int default)
- Lookup a keyword:value pair using the specified key; if found, interpret the value as an integer and return it. - If not found (or the value is an empty string) then return the supplied default. If the keyword:value pair is found but is not - a number, then return 0.

- -

Note that "keyword replacement" as described in - SCI_SETPROPERTY will be performed before any numeric interpretation.

- -

SCI_SETKEYWORDS(int keyWordSet, const char *keyWordList)
- You can set up to 9 lists of keywords for use by the current lexer. This was increased from 6 - at revision 1.50. keyWordSet can be 0 to 8 (actually 0 to KEYWORDSET_MAX) - and selects which keyword list to replace. keyWordList is a list of keywords - separated by spaces, tabs, "\n" or "\r" or any combination of these. - It is expected that the keywords will be composed of standard ASCII printing characters, - but there is nothing to stop you using any non-separator character codes from 1 to 255 - (except common sense).

- -

How these keywords are used is entirely up to the lexer. Some languages, such as HTML may - contain embedded languages, VBScript and JavaScript are common for HTML. For HTML, key word set - 0 is for HTML, 1 is for JavaScript and 2 is for VBScript, 3 is for Python, 4 is for PHP and 5 - is for SGML and DTD keywords. Review the lexer code to see examples of keyword list. A fully - conforming lexer sets the fourth argument of the LexerModule constructor to be a - list of strings that describe the uses of the keyword lists.

- -

Alternatively, you might use set 0 for general keywords, set 1 for keywords that cause - indentation and set 2 for keywords that cause unindentation. Yet again, you might have a simple - lexer that colours keywords and you could change languages by changing the keywords in set 0. - There is nothing to stop you building your own keyword lists into the lexer, but this means - that the lexer must be rebuilt if more keywords are added.

- -

SCI_GETSTYLEBITSNEEDED
- Retrieve the number of bits the current lexer needs for styling. This should normally be the argument - to SCI_SETSTYLEBITS. -

- -

Notifications

- -

Notifications are sent (fired) from the Scintilla control to its container when an event has - occurred that may interest the container. Notifications are sent using the - WM_NOTIFY message on Windows and the "notify" signal on GTK+. The container is - passed a SCNotification structure containing information about the event.

-struct NotifyHeader {   // This matches the Win32 NMHDR structure
-    void *hwndFrom;     // environment specific window handle/pointer
-    uptr_t idFrom;	// CtrlID of the window issuing the notification
-    unsigned int code;  // The SCN_* notification code
-};
-
-struct SCNotification {
-    struct NotifyHeader nmhdr;
-    int position;
-    // SCN_STYLENEEDED, SCN_DOUBLECLICK, SCN_MODIFIED, SCN_DWELLSTART,
-    // SCN_DWELLEND, SCN_CALLTIPCLICK,
-    // SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK
-    int ch;             // SCN_CHARADDED, SCN_KEY
-    int modifiers;      // SCN_KEY, SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK
-    int modificationType; // SCN_MODIFIED
-    const char *text;   // SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_AUTOCSELECTION
-    int length;         // SCN_MODIFIED
-    int linesAdded;     // SCN_MODIFIED
-    int message;        // SCN_MACRORECORD
-    uptr_t wParam;      // SCN_MACRORECORD
-    sptr_t lParam;      // SCN_MACRORECORD
-    int line;           // SCN_MODIFIED, SCN_DOUBLECLICK
-    int foldLevelNow;   // SCN_MODIFIED
-    int foldLevelPrev;  // SCN_MODIFIED
-    int margin;         // SCN_MARGINCLICK
-    int listType;       // SCN_USERLISTSELECTION, SCN_AUTOCSELECTION
-    int x;              // SCN_DWELLSTART, SCN_DWELLEND
-    int y;              // SCN_DWELLSTART, SCN_DWELLEND
-};
-

- -

The notification messages that your container can choose to handle and the messages - associated with them are:

SCN_STYLENEEDED

-     SCN_CHARADDED

-     SCN_SAVEPOINTREACHED

-     SCN_SAVEPOINTLEFT

-     SCN_MODIFYATTEMPTRO

-     SCN_KEY

-     SCN_DOUBLECLICK

-     SCN_UPDATEUI

-     SCN_MODIFIED

-     SCN_MACRORECORD

-     SCN_MARGINCLICK

-     SCN_NEEDSHOWN

-     SCN_PAINTED

-     SCN_USERLISTSELECTION

-     SCN_URIDROPPED

-     SCN_DWELLSTART

-     SCN_DWELLEND

-     SCN_ZOOM

-     SCN_HOTSPOTCLICK

-     SCN_HOTSPOTDOUBLECLICK

-     SCN_CALLTIPCLICK

-     SCN_AUTOCSELECTION

-

- -

The following SCI_* messages are associated with these notifications:

SCI_SETMODEVENTMASK(int
-    eventMask)

-     SCI_GETMODEVENTMASK

-     SCI_SETMOUSEDWELLTIME

-     SCI_GETMOUSEDWELLTIME

-

- -

The following additional notifications are sent using the WM_COMMAND message on - Windows and the "Command" signal on GTK+. This emulates the Windows Edit control. Only the lower - 16 bits of the control's ID is passed in these notifications.

SCEN_CHANGE

-     SCEN_SETFOCUS

-     SCEN_KILLFOCUS

-

- -

SCN_STYLENEEDED
- If you used SCI_SETLEXER(SCLEX_CONTAINER) to make the container act as the - lexer, you will receive this notification when Scintilla is about to display or print text that - requires styling. You are required to style the text from the line that contains the position - returned by SCI_GETENDSTYLED up to - the position passed in SCNotification.position. Symbolically, you need code of the - form:

-    startPos = SCI_GETENDSTYLED()
-    lineNumber = SCI_LINEFROMPOSITION(startPos);
-    startPos = SCI_POSITIONFROMLINE(lineNumber);
-    MyStyleRoutine(startPos, SCNotification.position);
-

- -

SCN_CHARADDED
- This is sent when the user types an ordinary text character (as opposed to a command - character) that is entered into the text. The container can use this to decide to display a call tip or an auto - completion list. The character is in SCNotification.ch. - This notification is sent before the character has been styled so processing that depends on - styling should instead be performed in the SCN_UPDATEUI notification.

- -

SCN_SAVEPOINTREACHED
- SCN_SAVEPOINTLEFT
- Sent to the container when the save point is entered or left, allowing the container to - display a "document dirty" indicator and change its menus.
- See also: SCI_SETSAVEPOINT, SCI_GETMODIFY

- -

SCN_MODIFYATTEMPTRO
- When in read-only mode, this notification is sent to the container if the user tries to change - the text. This can be used to check the document out of a version control system. You can set - the read-only state of a document with SCI_SETREADONLY.

- -

SCN_KEY
- Reports all keys pressed but not consumed by Scintilla. Used on GTK+ because of - some problems with keyboard focus and is not sent by the Windows version. SCNotification.ch holds the key code and - SCNotification.modifiers holds the modifiers. This notification is sent if the - modifiers include SCMOD_ALT or SCMOD_CTRL and the key code is less - than 256.

- -

SCN_DOUBLECLICK
- The mouse button was double clicked in editor. The position field is set to the text position of the - double click and the line field is set to the line of the double click.

- -

SCN_UPDATEUI
- Either the text or styling of the document has changed or the selection range has changed. Now - would be a good time to update any container UI elements that depend on document or view state. - This was previously called SCN_CHECKBRACE because a common use is to check whether the - caret is next to a brace and set highlights on this brace and its corresponding matching brace. - This also replaces SCN_POSCHANGED, - which is now deprecated.

- -

SCN_MODIFIED
- This notification is sent when the text or styling of the document changes or is about to - change. You can set a mask for the notifications that are sent to the container with SCI_SETMODEVENTMASK. The - notification structure contains information about what changed, how the change occurred and - whether this changed the number of lines in the document. No modifications may be performed - while in a SCN_MODIFIED event. The SCNotification fields used - are:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Field	Usage
`modificationType`	A set of flags that identify the change(s) made. See the next - table.
`position`	Start position of a text or styling change. Set to 0 if not used.
`length`	Length of the change in cells or characters when the text or styling - changes. Set to 0 if not used.
`linesAdded`	Number of added lines. If negative, the number of deleted lines. Set to - 0 if not used or no lines added or deleted.
`text`	Valid for text changes, not for style changes. If we are collecting undo - information this holds a pointer to the text that is handed to the Undo system, otherwise - it is zero. For user performed SC_MOD_BEFOREDELETE the text field is 0 and - for user performed SC_MOD_BEFOREINSERT the text field points to an array of cells, - not bytes and the length is the number of cells.
`line`	The line number at which a fold level or marker change occurred. This is - 0 if unused and may be -1 if more than one line changed.
`foldLevelNow`	The new fold level applied to the line or 0 if this field is - unused.
`foldLevelPrev`	The previous folding level of the line or 0 if this field is - unused.

- -

The SCNotification.modificationType field has bits set to tell you what has - been done. The SC_MOD_* bits correspond to actions. The - SC_PERFORMED_* bits tell you if the action was done by the user, or the result of - Undo or Redo of a previous action.

Symbol	Value	Meaning	SCNotification fields
`SC_MOD_INSERTTEXT`	0x01	Text has been inserted into the document.	`position, length, text, linesAdded`
`SC_MOD_DELETETEXT`	0x02	Text has been removed from the document.	`position, length, text, linesAdded`
`SC_MOD_CHANGESTYLE`	0x04	A style change has occurred.	`position, length`
`SC_MOD_CHANGEFOLD`	0x08	A folding change has occurred.	`line, foldLevelNow, foldLevelPrev`
`SC_PERFORMED_USER`	0x10	Information: the operation was done by the user.	None
`SC_PERFORMED_UNDO`	0x20	Information: this was the result of an Undo.	None
`SC_PERFORMED_REDO`	0x40	Information: this was the result of a Redo.	None
`SC_MULTISTEPUNDOREDO`	0x80	This is part of a multi-step Undo or Redo.	None
`SC_LASTSTEPINUNDOREDO`	0x100	This is the final step in an Undo or Redo.	None
`SC_MOD_CHANGEMARKER`	0x200	One or more markers has changed in a line.	`line`
`SC_MOD_BEFOREINSERT`	0x400	Text is about to be inserted into the document.	`position, if performed by user then text in cells, length in cells`
`SC_MOD_BEFOREDELETE`	0x800	Text is about to be deleted from the document.	`position, length`
`SC_MULTILINEUNDOREDO`	0x1000	This is part of an Undo or Redo with multi-line changes.	None
`SC_MODEVENTMASKALL`	0x1fff	This is a mask for all valid flags. This is the default mask state set by `SCI_SETMODEVENTMASK`.	None

- -

SCEN_CHANGE
- SCEN_CHANGE (768) is fired when the text (not the style) of the document changes. - This notification is sent using the WM_COMMAND message on Windows and the - "Command" signal on GTK+ as this is the behavior of the standard Edit control - (SCEN_CHANGE has the same value as the Windows Edit control - EN_CHANGE). No other information is sent. If you need more detailed information - use SCN_MODIFIED. You can filter the - types of changes you are notified about with SCI_SETMODEVENTMASK.

- -

SCI_SETMODEVENTMASK(int eventMask)
- SCI_GETMODEVENTMASK
- These messages set and get an event mask that determines which document change events are - notified to the container with SCN_MODIFIED and SCEN_CHANGE. For example, a container may decide to see - only notifications about changes to text and not styling changes by calling - SCI_SETMODEVENTMASK(SC_MOD_INSERTTEXT|SC_MOD_DELETETEXT).

- -

The possible notification types are the same as the modificationType bit flags - used by SCN_MODIFIED: SC_MOD_INSERTTEXT, - SC_MOD_DELETETEXT, SC_MOD_CHANGESTYLE, - SC_MOD_CHANGEFOLD, SC_PERFORMED_USER, SC_PERFORMED_UNDO, - SC_PERFORMED_REDO, SC_MULTISTEPUNDOREDO, - SC_LASTSTEPINUNDOREDO, SC_MOD_CHANGEMARKER, - SC_MOD_BEFOREINSERT, SC_MOD_BEFOREDELETE, - SC_MULTILINEUNDOREDO, and SC_MODEVENTMASKALL.

- -

SCEN_SETFOCUS
- SCEN_KILLFOCUS
- SCEN_SETFOCUS (512) is fired when Scintilla receives focus and - SCEN_KILLFOCUS (256) when it loses focus. These notifications are sent using the - WM_COMMAND message on Windows and the "Command" signal on GTK+ as this is the - behavior of the standard Edit control. Unfortunately, these codes do not match the Windows Edit - notification codes EN_SETFOCUS (256) and EN_KILLFOCUS (512). It is - now too late to change the Scintilla codes as clients depend on the current values.

- -

SCN_MACRORECORD
- The SCI_STARTRECORD and SCI_STOPRECORD messages enable and - disable macro recording. When enabled, each time a recordable change occurs, the - SCN_MACRORECORD notification is sent to the container. It is up to the container - to record the action. To see the complete list of SCI_* messages that are - recordable, search the Scintilla source Editor.cxx for - Editor::NotifyMacroRecord. The fields of SCNotification set in this - notification are:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Field	Usage
`message`	The `SCI_*` message that caused the notification.
`wParam`	The value of `wParam` in the `SCI_*` message.
`lParam`	The value of `lParam` in the `SCI_*` message.

- -

SCN_MARGINCLICK
- This notification tells the container that the mouse was clicked inside a margin that was marked as sensitive (see SCI_SETMARGINSENSITIVEN). This can be used to - perform folding or to place breakpoints. The following SCNotification fields are - used:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Field	Usage
`modifiers`	The appropriate combination of `SCI_SHIFT`, - `SCI_CTRL` and `SCI_ALT` to indicate the keys that were held down - at the time of the margin click.
`position`	The position of the start of the line in the document that corresponds - to the margin click.
`margin`	The margin number that was clicked.

- -

SCN_NEEDSHOWN
- Scintilla has determined that a range of lines that is currently invisible should be made - visible. An example of where this may be needed is if the end of line of a contracted fold - point is deleted. This message is sent to the container in case it wants to make the line - visible in some unusual way such as making the whole document visible. Most containers will - just ensure each line in the range is visible by calling SCI_ENSUREVISIBLE. The position and - length fields of SCNotification indicate the range of the document - that should be made visible. The container code will be similar to the following code - skeleton:

-firstLine = SCI_LINEFROMPOSITION(scn.position)
-lastLine = SCI_LINEFROMPOSITION(scn.position+scn.length-1)
-for line = lineStart to lineEnd do SCI_ENSUREVISIBLE(line) next
-

- -

SCN_PAINTED
- Painting has just been done. Useful when you want to update some other widgets based on a - change in Scintilla, but want to have the paint occur first to appear more responsive. There is - no other information in SCNotification.

- -

SCN_USERLISTSELECTION
- The user has selected an item in a user list. The - SCNotification fields used are:

- - - - - - - - - - - - - - - - - - - - - - - -

Field	Usage
`wParam`	This is set to the `listType` parameter from the `SCI_USERLISTSHOW` message that - initiated the list.
`text`	The text of the selection.

-
-
- - -

SCN_URIDROPPED
- Only on the GTK+ version. Indicates that the user has dragged a URI such as a file name or Web - address onto Scintilla. The container could interpret this as a request to open the file. The - text field of SCNotification points at the URI text.

- -

SCN_DWELLSTART
- SCN_DWELLEND
- SCN_DWELLSTART is generated when the user keeps the mouse in one position for the - dwell period (see SCI_SETMOUSEDWELLTIME). SCN_DWELLEND is - generated after a SCN_DWELLSTART and the mouse is moved or other activity such as - key press indicates the dwell is over. Both notifications set the same fields in - SCNotification:

- - - - - - - - - - - - - - - - - - - - - - - -

Field	Usage
`position`	This is the nearest position in the document to the position where the - mouse pointer was lingering.
`x, y`	Where the pointer lingered. The `position` field is set to - `SCI_POSITIONFROMPOINTCLOSE(x, y)`.

-
-
- -

SCI_SETMOUSEDWELLTIME
- SCI_GETMOUSEDWELLTIME
- These two messages set and get the time the mouse must sit still, in milliseconds, to generate - a SCN_DWELLSTART notification. If - set to SC_TIME_FOREVER, the default, no dwell events are generated.

- -

SCN_ZOOM
- This notification is generated when the user zooms the display using the keyboard or the - SCI_SETZOOM method is called. This - notification can be used to recalculate positions, such as the width of the line number margin - to maintain sizes in terms of characters rather than pixels. SCNotification has no - additional information.

- -

- SCN_HOTSPOTCLICK
- SCN_HOTSPOTDOUBLECLICK
- These notifications are generated when the user clicks or double clicks on - text that is in a style with the hotspot attribute set. - This notification can be used to link to variable definitions or web pages. - The position field is set the text position of the click or - double click and the modifiers field set to the key modifiers - held down in a similar manner to SCN_KEY.

- -

SCN_CALLTIPCLICK
- This notification is generated when the user clicks on a calltip. - This notification can be used to display the next function prototype when a - function name is overloaded with different arguments. - The position field is set to 1 if the click is in an up arrow, - 2 if in a down arrow, and 0 if elsewhere.

- -

SCN_AUTOCSELECTION
- The user has selected an item in an autocompletion list. The - notification is sent before the selection is inserted. Automatic insertion can be cancelled by sending a - SCI_AUTOCCANCEL message - before returning from the notification. The SCNotification fields used are:

- - - - - - - - - - - - - - - - - - - - - - -

Field	Usage
`lParam`	The start position of the word being completed.
`text`	The text of the selection.

- -

GTK+

On GTK+, the following functions create a Scintilla widget, communicate with it and allow - resources to be released after all Scintilla widgets hace been destroyed.

GtkWidget *scintilla_new()

-     void scintilla_set_id(ScintillaObject *sci, uptr_t id)

-     sptr_t scintilla_send_message(ScintillaObject *sci,unsigned int iMessage, uptr_t wParam, sptr_t lParam)

-     void scintilla_release_resources()

-

- -

GtkWidget *scintilla_new()
- Create a new Scintilla widget. The returned pointer can be added to a container and displayed in the same way as other - widgets.

- -

void scintilla_set_id(ScintillaObject *sci, uptr_t id)
- Set the control ID which will be used in the idFrom field of the NotifyHeader structure of all - notifications for this instance. When an application creates multiple Scintilla widgets, this allows - the source of each notification to be found. The value should be small, preferrably less than 16 bits, - rather than a pointer as some of the functions will only transmit 16 or 32 bits.

- -

sptr_t scintilla_send_message(ScintillaObject *sci,unsigned int iMessage, uptr_t wParam, sptr_t lParam)
- The main entry point allows sending any of the messages described in this document.

- -

void scintilla_release_resources()
- Call this to free any remaining resources after all the Scintilla widgets have been destroyed.

- -

Deprecated messages and notifications

- -

The following messages are currently supported to emulate existing Windows controls, but - they will be removed in future versions of Scintilla. If you use these messages you should - replace them with the Scintilla equivalent.

-WM_GETTEXT(int length, char *text)
-WM_SETTEXT(<unused>, const char *text)
-EM_GETLINE(int line, char *text)
-EM_REPLACESEL(<unused>, const char *text)
-EM_SETREADONLY
-EM_GETTEXTRANGE(<unused>, TEXTRANGE *tr)
-WM_CUT
-WM_COPY
-WM_PASTE
-WM_CLEAR
-WM_UNDO
-EM_CANUNDO
-EM_EMPTYUNDOBUFFER
-WM_GETTEXTLENGTH
-EM_GETFIRSTVISIBLELINE
-EM_GETLINECOUNT
-EM_GETMODIFY
-EM_SETMODIFY(bool isModified)
-EM_GETRECT(RECT *rect)
-EM_GETSEL(int *start, int *end)
-EM_EXGETSEL(<unused>, CHARRANGE *cr)
-EM_SETSEL(int start, int end)
-EM_EXSETSEL(<unused>, CHARRANGE *cr)
-EM_GETSELTEXT(<unused>, char *text)
-EM_LINEFROMCHAR(int position)
-EM_EXLINEFROMCHAR(int position)
-EM_LINEINDEX(int line)
-EM_LINELENGTH(int position)
-EM_SCROLL(int line)
-EM_LINESCROLL(int column, int line)
-EM_SCROLLCARET()
-EM_CANPASTE
-EM_CHARFROMPOS(<unused>, POINT *location)
-EM_POSFROMCHAR(int position, POINT *location)
-EM_SELECTIONTYPE
-EM_HIDESELECTION(bool hide)
-EM_FINDTEXT(int flags, FINDTEXTEX *ft)
-EM_FINDTEXTEX(int flags, FINDTEXTEX *ft)
-EM_GETMARGINS
-EM_SETMARGINS(EC_LEFTMARGIN or EC_RIGHTMARGIN or EC_USEFONTINFO, int val)
-EM_FORMATRANGE
-

- -

The following are features that are only included if you define - INCLUDE_DEPRECATED_FEATURES in Scintilla.h. To ensure future - compatibility you should change them as indicated.

- -

SCN_POSCHANGED() Deprecated
- Fired when the user moves the cursor to a different position in the text. Use SCN_UPDATEUI instead.

- -

SCN_CHECKBRACE Deprecated
- Either the text or styling of the document has changed or the selection range has changed. - This is replaced by SCN_UPDATEUI. You - can also use SCN_MODIFIED for more - detailed information on text and styling changes,

- -

Edit messages never supported by Scintilla

-EM_GETWORDBREAKPROC EM_GETWORDBREAKPROCEX
-EM_SETWORDBREAKPROC EM_SETWORDBREAKPROCEX
-EM_GETWORDWRAPMODE EM_SETWORDWRAPMODE
-EM_LIMITTEXT EM_EXLIMITTEXT
-EM_SETRECT EM_SETRECTNP
-EM_FMTLINES
-EM_GETHANDLE EM_SETHANDLE
-EM_GETPASSWORDCHAR EM_SETPASSWORDCHAR
-EM_SETTABSTOPS
-EM_FINDWORDBREAK
-EM_GETCHARFORMAT EM_SETCHARFORMAT
-EM_GETOLEINTERFACE EM_SETOLEINTERFACE
-EM_SETOLECALLBACK
-EM_GETPARAFORMAT EM_SETPARAFORMAT
-EM_PASTESPECIAL
-EM_REQUESTRESIZE
-EM_GETBKGNDCOLOR EM_SETBKGNDCOLOR
-EM_STREAMIN EM_STREAMOUT
-EM_GETIMECOLOR EM_SETIMECOLOR
-EM_GETIMEOPTIONS EM_SETIMEOPTIONS
-EM_GETOPTIONS EM_SETOPTIONS
-EM_GETPUNCTUATION EM_SETPUNCTUATION
-EM_GETTHUMB
-EM_GETEVENTMASK
-EM_SETEVENTMASK
-EM_DISPLAYBAND
-EM_SETTARGETDEVICE
-

- -

Scintilla tries to be a superset of the standard windows Edit and RichEdit controls wherever - that makes sense. As it is not intended for use in a word processor, some edit messages can not - be sensibly handled. Unsupported messages have no effect.

- -

Building Scintilla

- -

To build Scintilla or SciTE, see the README file present in both the Scintilla and SciTE - directories. For Windows, GCC 3.2, Borland C++ or Microsoft Visual Studio .NET can be used - for building. There is a make file for building Scintilla but not SciTE with Visual C++ 6 at - scintilla/win32/scintilla_vc6.mak. For GTK+, GCC 3.1 should be used. GTK+ 1.2x and 2.0x are - supported. The version of GTK+ installed should be detected automatically. - When both GTK+ 1 and GTK+ 2 are present, building for GTK+ 1.x requires defining GTK1 - on the command line.

- -

Static linking

- -

On Windows, Scintilla is normally used as a dynamic library as a .DLL file. If you want to - link Scintilla directly into your application .EXE or .DLL file, then the - STATIC_BUILD preprocessor symbol should be defined and - Scintilla_RegisterClasses called. STATIC_BUILD prevents compiling the - DllMain function which will conflict with any DllMain defined in your - code. Scintilla_RegisterClasses takes the HINSTANCE of your - application and ensures that the "Scintilla" window class is registered. To make sure that the - right pointing arrow cursor used in the margin is displayed by Scintilla add the - scintilla/win32/Margin.cur file to your application's resources with the ID - IDC_MARGIN which is defined in scintilla/win32/platfromRes.h as - 400.

- -

Ensuring lexers are linked into Scintilla

- -

Depending on the compiler and linker used, the lexers may be stripped out. This is most - often caused when building a static library. To ensure the lexers are linked in, the - Scintilla_LinkLexers() function may be called.

- -

Changing set of lexers

- -

To change the set of lexers in Scintilla, add and remove lexer source files - (Lex*.cxx) from the scintilla/src directory and run the - src/LexGen.py script from the src directory to update the make files - and KeyWords.cxx. LexGen.py requires Python 2.1 or later. If you do - not have access to Python, you can hand edit KeyWords.cxx in a simple-minded way, - following the patterns of other lexers. The important thing is to include - LINK_LEXER(lmMyLexer); to correspond with the LexerModule - lmMyLexer(...); in your lexer source code.

- - - -- cgit v1.2.3

Initial state	end, true	end, false	start, true	start, false
..ww..\|..ww..	..ww..\|..ww..	..ww....\|ww..	..ww..\|..ww..	..ww\|....ww..
....ww\|ww....	....wwww\|....	....wwww\|....	....\|wwww....	....\|wwww....
..ww\|....ww..	..ww\|....ww..	..ww....\|ww..	..\|ww....ww..	..\|ww....ww..
..ww....\|ww..	..ww....ww\|..	..ww....ww\|..	..ww....\|ww..	..ww\|....ww..

Scintilla Documentation

Introduction

Contents

Text retrieval and modification

GTK+-specific: Access to encoded text

Searching

Search and replace using the target

Overtype

Cut, copy and paste

Error handling

Undo and Redo

Selection and information

Scrolling and automatic scrolling

White space

Cursor

Mouse capture

Line endings

Styling

Style definition

Caret, selection, and hotspot styles

Margins

Other settings

Brace highlighting

Tabs and Indentation Guides

Markers

Indicators

Autocompletion

User lists

Call tips

Keyboard commands

Key bindings

Popup edit menu

Macro recording

Printing

Direct access

Multiple views

Folding

Line wrapping

Zooming

Long lines

Lexer

Notifications

GTK+

Deprecated messages and notifications

Edit messages never supported by Scintilla

Building Scintilla

Static linking

Ensuring lexers are linked into Scintilla

Changing set of lexers