Win32::Mechanize::NotepadPlusPlus::Editor - The editor object for Notepad++ automation
use Win32::Mechanize::NotepadPlusPlus qw/:main/; my $editor = editor();
The editor object for Notepad++ automation using Win32::Mechanize::NotepadPlusPlus: this object will interface with Notepad++'s Scintilla component instances.
Please note that because this module is driving Notepad++'s Scintilla components externally, rather than internally through a plugin or inside the actual Notepad++ source code, some messages will take longer than you might expect before they are fully complete; you may find that a "setText" requires 10ms or more to complete, depending on how long the text is, so don't be surprised if you have to add in delays to get your script to reliably execute.
Also note that Notepad++ itself is sending messages to the Scintilla components, so there may be changes in state that are not related to the running Perl code; there may be times when Notepad++ changes things unexpectedly in the middle of the Perl execution (especially for things like the Target-oriented methods like "getTargetText").
The module was developed with Notepad++ v7.7 or newer in mind, though some features should still work on older versions of Notepad++. As Notepad++ adds new features, the minimum version for that method will be indicated in the help.
The Editor objects are created as appropriate, both with the original
use Win32::Mechanize::NotepadPlusPlus;
or, as needed when the Notepad object creates a hidden Scintilla using
my $hidden = notepad()->createScintilla;
Warning: some users of Notepad++'s createScintilla interface in scripting plugins using the same message-based interface as Win32::Mechanize::NotepadPlusPlus have found that they cannot create more than one extra Scintilla instance from inside their scripts without causing instability in Notepad++. The same might be true using this Perl interface as well, so it is recommended that you reuse the same hidden instance throughout your script, rather than trying to create multiple hidden instances, if at all possible.
createScintilla
editor->hwnd(); my $sci_hWnd = editor1->hwnd();
Grabs the window handle of the Scintilla editor.
This is used for sending Windows messages; if you are enhancing the Editor object's functionality (implementing some new Scintilla message that hasn't made its way into this module, for example), you will likely need access to this handle.
These are the object-oriented methods for manipulating the Scintilla editor objects inside the Notepad++ application, usually using the editor() instance for the active editor or editor1() and editor2() for direct control of the two default editors available to Notepad++, and also any $hidden Scintilla instances.
editor()
editor1()
editor2()
editor->setText($text);
Replace the contents of the document with the argument text.
See Scintilla documentation for SCI_SETTEXT
editor->getText();
Retrieve all the text in the document.
See Scintilla documentation for SCI_GETTEXT
editor->setSavePoint();
Remember the current position in the undo history as the position at which the document was saved.
See Scintilla documentation for SCI_SETSAVEPOINT
editor->getLine($line);
Retrieve the contents of a line.
See Scintilla documentation for SCI_GETLINE
editor->replaceSel($text);
Replace the selected text with the argument text.
See Scintilla documentation for SCI_REPLACESEL
editor->setReadOnly($readOnly); editor->getReadOnly();
Set read only or read/write mode.
See Scintilla documentation for SCI_SETREADONLY
See Scintilla documentation for SCI_GETREADONLY
editor->getTextRange($start, $end);
Retrieve a range of text.
See Scintilla documentation for SCI_GETTEXTRANGE
See Scintilla documentation for SCI_GETTEXTRANGEFULL
(The underlying Scintilla library differentiates between SCI_GETTEXTRANGE and SCI_GETTEXTRANGEFULL, but because of the way that Notepad++ defines its header files, I believe the two are equivalent in Notepad++'s instance of Scintilla. If you can show a way that sending SCI_GETTEXTRANGEFULL behaves differently than SCI_GETTEXTRANGE, please open an issue with that example.)
editor->allocate($bytes);
Enlarge the document to a particular size of text bytes.
See Scintilla documentation for SCI_ALLOCATE
editor->allocate($lines);
Allocate line indices to match the $lines argument. This is an optimization that can prevent multiple reallocations of the indices as text is inserted if the application can estimate the number of lines in the document. The number of lines will not be reduced by this call.
$lines
See Scintilla documentation for SCI_ALLOCATELINES
editor->addText($text);
Add text to the document at current position.
See Scintilla documentation for SCI_ADDTEXT
editor->addStyledText($text, $style); editor->addStyledText($text, \@style_array);
Add text with associated style indices.
The first form applies one style index $style to all the characters in $text:
$style
$text
editor->addStyledText("Hello World", 3); # applies style-number-3 to all the characters in the string
The second form requires an array-reference \@style_array (or [list of styles]), with one style index per character in $text:
\@style_array
[list of styles]
@style_array = (1,2,3) editor->addStyledText("One", \@style_array ); # applies style 1 to "O", 2 to "n", and 3 to "e" editor->addStyledText("Two", [9,8,7] ); # applies style 9 to "T", 8 to "w", and 7 to "o"
If there is a size mismatch, it will die:
editor->addStyledText("LongWord", [1,2]); # will die, because there are not enough elements in the anonymous array
See Scintilla documentation for SCI_ADDSTYLEDTEXT
editor->appendText($text);
Append a string to the end of the document without changing the selection.
See Scintilla documentation for SCI_APPENDTEXT
editor->insertText($pos, $text);
Insert string at a position.
See Scintilla documentation for SCI_INSERTTEXT
editor->changeInsertion($length, $text);
Change the text that is being inserted in response to SC_MOD_INSERTCHECK.
(This is only meaningful in a notification handler for the SC_MOD_INSERTCHECK notification, and will not be implemented in this module until notifications and callbacks are implemented.)
See Scintilla documentation for SCI_CHANGEINSERTION
editor->clearAll();
Delete all text in the document.
See Scintilla documentation for SCI_CLEARALL
editor->deleteRange($pos, $deleteLength);
Delete a range of text in the document.
See Scintilla documentation for SCI_DELETERANGE
editor->clearDocumentStyle();
Set all style bytes to 0, remove all folding information.
See Scintilla documentation for SCI_CLEARDOCUMENTSTYLE
editor->getCharAt($pos);
Returns the character byte at the position.
See Scintilla documentation for SCI_GETCHARAT
editor->getStyleAt($pos); editor->getStyleIndexAt($pos);
his returns the style at $pos in the document, or 0 if <$pos> is negative or past the end of the document. getStyleAt may return a negative number for styles over 127 whereas getStyleIndexAt will only return positive numbers. getStyleIndexAt should be preferred as it handles styles more consistently and may avoid problems with lexers that define more than 128 styles.
$pos
getStyleAt
getStyleIndexAt
See Scintilla documentation for SCI_GETSTYLEAT
See Scintilla documentation for SCI_GETSTYLEINDEXAT
getStyleIndexAt command requires at least Scintilla v5.2, found in Notepad++ v8.4 and newer.
editor->getStyledText($start, $end);
Retrieve a buffer of cells. Returns the number of bytes in the buffer not including terminating NULs.
See Scintilla documentation for SCI_GETSTYLEDTEXT
See Scintilla documentation for SCI_GETSTYLEDTEXTFULL
(The underlying Scintilla library differentiates between SCI_GETSTYLEDTEXT and SCI_GETSTYLEDTEXTFULL, but because of the way that Notepad++ defines its header files, I believe the two are equivalent in Notepad++'s instance of Scintilla. If you can show a way that sending SCI_GETSTYLEDTEXTFULL behaves differently than SCI_GETSTYLEDTEXT, please open an issue with that example.)
editor->releaseAllExtendedStyles();
Release all extended (>255) style numbers
See Scintilla documentation for SCI_RELEASEALLEXTENDEDSTYLES
editor->allocateExtendedStyles($numberStyles);
Allocate some extended (>255) style numbers and return the start of the range
See Scintilla documentation for SCI_ALLOCATEEXTENDEDSTYLES
editor->targetAsUTF8();
Returns the target converted to UTF8. Return the length in bytes.
See Scintilla documentation for SCI_TARGETASUTF8
editor->encodedFromUTF8();
Translates a UTF8 string into the document encoding. Return the length of the result in bytes. On error return 0.
See Scintilla documentation for SCI_ENCODEDFROMUTF8
editor->setLengthForEncode($bytes);
Set the length of the utf8 argument for calling EncodedFromUTF8. Set to -1 and the string will be measured to the first nul.
See Scintilla documentation for SCI_SETLENGTHFORENCODE
editor->setTargetStart($pos); editor->getTargetStart(); editor->setTargetStartVirtualSpace($pos); editor->getTargetStartVirtualSpace();
Set the position that starts the target which is used for updating the document without affecting the scroll position.
Use the ...VirtualSpace variants for targets beyond the end of the line (in virtual space).
...VirtualSpace
See Scintilla documentation for SCI_SETTARGETSTART
See Scintilla documentation for SCI_GETTARGETSTART
See Scintilla documentation for SCI_SETTARGETSTARTVIRTUALSPACE
See Scintilla documentation for SCI_GETTARGETSTARTVIRTUALSPACE
editor->setTargetEnd($pos); editor->getTargetEnd(); editor->setTargetEndVirtualSpace($pos); editor->getTargetEndVirtualSpace();
Set the position that ends the target which is used for updating the document without affecting the scroll position.
Use the ...VirtualSpace versions to access a target beyond the end of the line (in virtual space).
See Scintilla documentation for SCI_SETTARGETEND
See Scintilla documentation for SCI_GETTARGETEND
See Scintilla documentation for SCI_SETTARGETENDVIRTUALSPACE
See Scintilla documentation for SCI_GETTARGETENDVIRTUALSPACE
editor->setTargetRange($start, $end);
Sets both the start and end of the target in one call.
See Scintilla documentation for SCI_SETTARGETRANGE
editor->targetFromSelection();
Make the target range start and end be the same as the selection range start and end.
See Scintilla documentation for SCI_TARGETFROMSELECTION
editor->targetWholeDocument();
Sets the target to the whole document.
See Scintilla documentation for SCI_TARGETWHOLEDOCUMENT
Requires at least Scintilla v4.2.0, found in Notepad++ v7.8 and newer.
editor->setSearchFlags($searchFlags); editor->getSearchFlags();
Set the search flags used by searchInTarget.
The c<$searchFlags> should be a combination of the elements from %SC_FIND
See Scintilla documentation for SCI_SETSEARCHFLAGS
See Scintilla documentation for SCI_GETSEARCHFLAGS
See Scintilla documentation for searchFlags
editor->searchInTarget($textRE);
Search for a counted string in the target and set the target to the found range. Text is counted so it can contain NULs. Returns length of range or -1 for failure in which case target is not moved.
$textRE is a Boost regular expression in a string, not a perl qr// regular expression.
$textRE
qr//
See Scintilla documentation for SCI_SEARCHINTARGET
editor->getTargetText();
Retrieve the text in the target.
See Scintilla documentation for SCI_GETTARGETTEXT
editor->replaceTarget($text);
Replace the target text with the argument text. Text is counted so it can contain NULs. Returns the length of the replacement text.
See Scintilla documentation for SCI_REPLACETARGET
editor->replaceTargetMinimal($text);
This is similar to replaceTarget but tries to minimize change history when the current target text shares a common prefix or suffix with the replacement. Only the text that is actually different is marked as changed. This might be used when automatically reformatting some text so that the whole area formatted doesn't show change marks. 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.
replaceTarget
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.
See Scintilla documentation for SCI_REPLACETARGETMINIMAL
editor->replaceTargetRE($textRE);
Replace the target text with the argument text after \d processing. Text is counted so it can contain NULs. Looks for \d where d is between 1 and 9 and replaces these with the strings matched in the last search operation which were surrounded by \( and \). Returns the length of the replacement text including any change caused by processing the \d patterns.
Please note: the $textRE is a string containing a Boost regular expression replacement string, not a perl regular expression qr//. To avoid perl interpolating the \0 and similar in the string, make sure you use perl's single-quote '' or q{} notation (or properly escape the backslashes in the string.)
\0
''
q{}
editor->setText("Hello World"); select undef,undef,undef, 0.01; # after setText, you sometimes need a delay of 10ms or more to ensure the text is there before continuing editor->setTargetRange(0,5); editor->setSearchFlags($SC_FIND{SCFIND_REGEXP}); editor->searchInTarget('([aeiou])'); editor->replaceTargetRE('_\\1_'); print editor->getTargetText(); # "H_e_llo World"
See Scintilla documentation for SCI_REPLACETARGETRE
editor->getTag($tagNumber);
Retrieve the value of a tag from a regular expression search.
See Scintilla documentation for SCI_GETTAG
editor->findText($searchFlags, $start, $end, $textToFind);
Find some text in the document. (*)
Returns the position of the match, or undef if the text is not found.
undef
The $searchFlags should be a combination of the elements from %SC_FIND
$searchFlags
$textToFind is a literal string or a Boost regular expression in a string, not a perl qr// regular expression.
$textToFind
See Scintilla documentation for SCI_FINDTEXT and SCI_FINDTEXTFULL
*: For 64-bit builds of Win32, Scintilla provides separate messages for finding text in a <2GB file and a "full" version for finding text in a >2GB file. However, even before Scintilla offered that, Notepad++ redefined its headers so that the 64-bit builds of Notepad++ always define the "normal" SCI_FINDTEXT so that it uses 64-bit integers for its positions, so findText should be sufficient. If it's not, please open an issue and provide a test case showing that you can grab specific text with a direct call to SCI_FINDTEXTFULL that you cannot find with this implementation of findText() and Notepad++ v8.2.2 or later.
editor->searchAnchor();
Sets the current caret position to be the search anchor.
See Scintilla documentation for SCI_SEARCHANCHOR
editor->searchNext($flags, $text);
Find some text starting at the search anchor. Does not ensure the selection is visible.
See Scintilla documentation for SCI_SEARCHNEXT
editor->searchPrev($flags, $text);
Find some text starting at the search anchor and moving backwards. Does not ensure the selection is visible.
See Scintilla documentation for SCI_SEARCHPREV
editor->setOvertype($overtype); editor->getOvertype();
Set to overtype (true) or insert mode.
See Scintilla documentation for SCI_SETOVERTYPE
See Scintilla documentation for SCI_GETOVERTYPE
editor->cut();
Cut the selection to the clipboard.
See Scintilla documentation for SCI_CUT
editor->copy();
Copy the selection to the clipboard.
See Scintilla documentation for SCI_COPY
editor->paste();
Paste the contents of the clipboard into the document replacing the selection.
See Scintilla documentation for SCI_PASTE
editor->clear();
Clear the selection.
See Scintilla documentation for SCI_CLEAR
editor->canPaste();
Will a paste succeed?
See Scintilla documentation for SCI_CANPASTE
editor->copyRange($start, $end);
Copy a range of text to the clipboard. Positions are clipped into the document.
See Scintilla documentation for SCI_COPYRANGE
editor->copyText($text);
Copy argument text to the clipboard.
See Scintilla documentation for SCI_COPYTEXT
editor->copyAllowLine();
Copy the selection, if selection empty copy the line with the caret
See Scintilla documentation for SCI_COPYALLOWLINE
editor->setPasteConvertEndings($convert); editor->getPasteConvertEndings();
Enable/Disable convert-on-paste for line endings
See Scintilla documentation for SCI_SETPASTECONVERTENDINGS
See Scintilla documentation for SCI_GETPASTECONVERTENDINGS
editor->replaceRectangular($text);
Replaces the selected text or empty selection with the given $text. The insertion is performed similarly to rectangular pastes: new lines in the given text are interpreted as moving to the next line without inserting new lines unless at the end of the document.
See Scintilla documentation for SCI_REPLACERECTANGULAR
These commands require at least Scintilla v5.2, found in Notepad++ v8.4 and newer.
editor->setStatus($statusCode); editor->getStatus();
Change error status. Failures from 1 to 999 are errors, and 1000 and above are warnings. There are predefined errors in %SC_STATUS.
See Scintilla documentation for SCI_SETSTATUS
See Scintilla documentation for SCI_GETSTATUS
editor->undo();
Undo one action in the undo history.
See Scintilla documentation for SCI_UNDO
editor->canUndo();
Are there any undoable actions in the undo history?
See Scintilla documentation for SCI_CANUNDO
editor->emptyUndoBuffer();
Delete the undo history.
See Scintilla documentation for SCI_EMPTYUNDOBUFFER
editor->canRedo();
Are there any redoable actions in the undo history?
See Scintilla documentation for SCI_CANREDO
editor->redo();
Redoes the next action on the undo history.
See Scintilla documentation for SCI_REDO
editor->setUndoCollection($collectUndo); editor->getUndoCollection();
Choose between collecting actions into the undo history and discarding them.
See Scintilla documentation for SCI_SETUNDOCOLLECTION
See Scintilla documentation for SCI_GETUNDOCOLLECTION
editor->beginUndoAction();
Start a sequence of actions that is undone and redone as a unit. May be nested.
See Scintilla documentation for SCI_BEGINUNDOACTION
editor->endUndoAction();
End a sequence of actions that is undone and redone as a unit.
See Scintilla documentation for SCI_ENDUNDOACTION
editor->addUndoAction($token, $flags);
Add a container action to the undo stack.
Use $flags from %SC_UNDO.
See Scintilla documentation for SCI_ADDUNDOACTION
Notepad++ can display document changes (modified, saved, ...) in the margin or in the text.
The main states are original text that has not been modified, modified, and modified then saved. As it is possible to undo to before the save point, there are additional states for reverted from save and reverted back to original from save. The reverted states are different to the saved document on disk so some applications may want to display these states just like the main modified state.
This feature uses a moderate amount of memory proportional to the amount of modifications made. On huge documents, this could be significant so could be disabled when it would cause excessive memory use.
By default, Notepad++ follows the Settings > Preferences > Margins/Border/Edge Display Change History checkbox, but these commands can override Notepad++'s default behavior.
Display Change History
editor->setChangeHistory($changeHistory); $changeHistory = editor->getChangeHistory();
setChangeHistory() turns the Change History feature on and off and determines whether changes are visible in the margin or text or both. getChangeHistory() gets the current state. The possible $changeHistory values can be found in the %SC_CHANGE_HISTORY enumeration; those values can be combined (so you could enable it with just markers, with just indicators, or with both).
setChangeHistory()
getChangeHistory()
$changeHistory
editor->getTextLength();
Retrieve the number of characters in the document.
See Scintilla documentation for SCI_GETTEXTLENGTH
editor->getLength();
Returns the number of bytes in the document.
See Scintilla documentation for SCI_GETLENGTH
editor->getLineCount();
Returns the number of lines in the document. There is always at least one.
See Scintilla documentation for SCI_GETLINECOUNT
editor->linesOnScreen();
Retrieves the number of lines completely visible.
See Scintilla documentation for SCI_LINESONSCREEN
editor->getModify();
Is the document different from when it was last saved?
See Scintilla documentation for SCI_GETMODIFY
editor->setSel($start, $end);
Select a range of text.
See Scintilla documentation for SCI_SETSEL
editor->gotoPos($pos);
Set caret to a position and ensure it is visible.
See Scintilla documentation for SCI_GOTOPOS
editor->gotoLine($line);
Set caret to start of a line and ensure it is visible.
See Scintilla documentation for SCI_GOTOLINE
editor->setCurrentPos($pos); editor->getCurrentPos();
Sets the position of the caret.
See Scintilla documentation for SCI_SETCURRENTPOS
See Scintilla documentation for SCI_GETCURRENTPOS
editor->setAnchor($posAnchor); editor->getAnchor();
Set the selection anchor to a position. The anchor is the opposite end of the selection from the caret.
See Scintilla documentation for SCI_SETANCHOR
See Scintilla documentation for SCI_GETANCHOR
editor->setSelectionStart($pos); editor->getSelectionStart();
Sets or gets the position that starts the selection - this becomes the anchor.
See Scintilla documentation for SCI_SETSELECTIONSTART
See Scintilla documentation for SCI_GETSELECTIONSTART
editor->setSelectionEnd($pos); editor->getSelectionEnd(); Sets the position that ends the selection - this becomes the currentPosition.
See Scintilla documentation for SCI_SETSELECTIONEND
See Scintilla documentation for SCI_GETSELECTIONEND
editor->setEmptySelection($pos);
Set caret to a position, while removing any existing selection.
See Scintilla documentation for SCI_SETEMPTYSELECTION
editor->selectAll();
Select all the text in the document.
See Scintilla documentation for SCI_SELECTALL
editor->lineFromPosition($pos);
Retrieve the line containing a position.
See Scintilla documentation for SCI_LINEFROMPOSITION
editor->positionFromLine($line);
Retrieve the position at the start of a line.
See Scintilla documentation for SCI_POSITIONFROMLINE
editor->getLineEndPosition($line);
Get the position after the last visible characters on a line.
See Scintilla documentation for SCI_GETLINEENDPOSITION
editor->lineLength($line);
How many characters are on a line, including end of line characters?
See Scintilla documentation for SCI_LINELENGTH
editor->getColumn($pos);
Retrieve the column number of a position, taking tab width into account.
See Scintilla documentation for SCI_GETCOLUMN
editor->findColumn($line, $column);
Find the position of a column on a line taking into account tabs and multi-byte characters. If beyond end of line, return line end position.
See Scintilla documentation for SCI_FINDCOLUMN
editor->positionFromPoint($x, $y);
Find the position from a point within the window.
See Scintilla documentation for SCI_POSITIONFROMPOINT
editor->positionFromPointClose($x, $y);
Find the position from a point within the window but return INVALID_POSITION if not close to text.
See Scintilla documentation for SCI_POSITIONFROMPOINTCLOSE
editor->charPositionFromPoint($x, $y);
Find the position of a character from a point within the window.
See Scintilla documentation for SCI_CHARPOSITIONFROMPOINT
editor->charPositionFromPointClose($x, $y);
Find the position of a character from a point within the window. Return INVALID_POSITION if not close to text.
See Scintilla documentation for SCI_CHARPOSITIONFROMPOINTCLOSE
editor->pointXFromPosition($pos);
Retrieve the x value of the point in the window where a position is displayed.
See Scintilla documentation for SCI_POINTXFROMPOSITION
editor->pointYFromPosition($pos);
Retrieve the y value of the point in the window where a position is displayed.
See Scintilla documentation for SCI_POINTYFROMPOSITION
editor->hideSelection($hide); my $hidden = editor->getSelectionHidden();
Draw the selection in normal style (selection "hidden") or with selection highlighted (default).
See Scintilla documentation for SCI_HIDESELECTION
See Scintilla documentation for SCI_GETSELECTIONHIDDEN
The getSelectionHidden command requires at least Scintilla v5.2, found in Notepad++ v8.4 and newer.
getSelectionHidden
editor->getSelText();
Retrieve the selected text. Return the length of the text.
See Scintilla documentation for SCI_GETSELTEXT
editor->getCurLine();
Retrieve the text of the line containing the caret. Returns the index of the caret on the line.
See Scintilla documentation for SCI_GETCURLINE
editor->selectionIsRectangle();
Is the selection rectangular? The alternative is the more common stream selection.
See Scintilla documentation for SCI_SELECTIONISRECTANGLE
editor->setSelectionMode($mode); editor->getSelectionMode();
Set the selection mode to stream (normal selection) or rectangular or by lines.
Use $mode from %SC_SEL.
See Scintilla documentation for SCI_SETSELECTIONMODE
See Scintilla documentation for SCI_GETSELECTIONMODE
editor->getMoveExtendsSelection;
Get whether or not regular caret moves will extend or reduce the selection.
See Scintilla documentation for SCI_GETMOVEEXTENDSSELECTION
editor->getLineSelStartPosition($line);
Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line).
See Scintilla documentation for SCI_GETLINESELSTARTPOSITION
editor->getLineSelEndPosition($line);
Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line).
See Scintilla documentation for SCI_GETLINESELENDPOSITION
editor->moveCaretInsideView();
Move the caret inside current view if it’s not there already.
See Scintilla documentation for SCI_MOVECARETINSIDEVIEW
editor->positionBefore($pos);
Given a valid document position, return the previous position taking code page into account. Returns 0 if passed 0.
See Scintilla documentation for SCI_POSITIONBEFORE
editor->positionAfter($pos);
Given a valid document position, return the next position taking code page into account. Maximum value returned is the last position in the document.
See Scintilla documentation for SCI_POSITIONAFTER
editor->textWidth($style, $text);
Measure the pixel width of some text in a particular style. NUL terminated text argument. Does not handle tab or control characters.
See Scintilla documentation for SCI_TEXTWIDTH
editor->textHeight($line);
Retrieve the height of a particular line of text in pixels.
See Scintilla documentation for SCI_TEXTHEIGHT
editor->chooseCaretX();
Set the last x chosen value to be the caret x position.
See Scintilla documentation for SCI_CHOOSECARETX
editor->moveSelectedLinesUp();
Move the selected lines up one line, shifting the line above after the selection
See Scintilla documentation for SCI_MOVESELECTEDLINESUP
editor->moveSelectedLinesDown();
Move the selected lines down one line, shifting the line below before the selection
See Scintilla documentation for SCI_MOVESELECTEDLINESDOWN
editor->setMouseSelectionRectangularSwitch($mouseSelectionRectangularSwitch); editor->getMouseSelectionRectangularSwitch();
Set whether switching to rectangular mode while selecting with the mouse is allowed.
See Scintilla documentation for SCI_SETMOUSESELECTIONRECTANGULARSWITCH
See Scintilla documentation for SCI_GETMOUSESELECTIONRECTANGULARSWITCH
editor->positionRelative($pos, $relative);
Given a valid document position, return a position that differs in a number of characters. Returned value is always between 0 and last position in document.
See Scintilla documentation for SCI_POSITIONRELATIVE
editor->positionRelativeCodeUnits($pos, $relative);
Given a valid document position, return a position that differs in a number of UTF-16 code units. Returned value is always between 0 and last position in document. The result may point half way (2 bytes) inside a non-BMP character.
See Scintilla documentation for SCI_POSITIONRELATIVECODEUNITS
editor->countCharacters($startPos, $endPos);
Count characters between two positions.
See Scintilla documentation for SCI_COUNTCHARACTERS
editor->countCodeUnits($start, $end);
Count code units between two positions.
See Scintilla documentation for SCI_COUNTCODEUNITS
editor->getLineCharacterIndex();
Retrieve line character index state.
Returns a value from %SC_LINECHARACTERINDEX.
See Scintilla documentation for SCI_GETLINECHARACTERINDEX
editor->allocateLineCharacterIndex($lineCharacterIndex);
Request line character index be created or its use count increased.
Use $lineCharacterIndex from %lineCharacterIndex.
See Scintilla documentation for SCI_ALLOCATELINECHARACTERINDEX
editor->releaseLineCharacterIndex($lineCharacterIndex);
Decrease use count of line character index and remove if 0.
See Scintilla documentation for SCI_RELEASELINECHARACTERINDEX
editor->lineFromIndexPosition($pos, $lineCharacterIndex);
Retrieve the document line containing a position measured in index units.
See Scintilla documentation for SCI_LINEFROMINDEXPOSITION
editor->indexPositionFromLine($line, $lineCharacterIndex);
Retrieve the position measured in index units at the start of a document line.
See Scintilla documentation for SCI_INDEXPOSITIONFROMLINE
editor->setMultipleSelection($multipleSelection); editor->getMultipleSelection();
Set whether multiple selections can be made
See Scintilla documentation for SCI_SETMULTIPLESELECTION
See Scintilla documentation for SCI_GETMULTIPLESELECTION
editor->setAdditionalSelectionTyping($additionalSelectionTyping); editor->getAdditionalSelectionTyping();
Set whether typing can be performed into multiple selections
See Scintilla documentation for SCI_SETADDITIONALSELECTIONTYPING
See Scintilla documentation for SCI_GETADDITIONALSELECTIONTYPING
editor->setMultiPaste($multiPaste); editor->getMultiPaste();
Change the effect of pasting when there are multiple selections.
Use $multiPaste from %SC_MULTIPASTE.
See Scintilla documentation for SCI_SETMULTIPASTE
See Scintilla documentation for SCI_GETMULTIPASTE
editor->setVirtualSpaceOptions($virtualSpaceOptions); editor->getVirtualSpaceOptions();
Returns the position at the end of the selection.
$virtualSpaceOptions from %SC_VIRTUALSPACE
See Scintilla documentation for SCI_SETVIRTUALSPACEOPTIONS
See Scintilla documentation for SCI_GETVIRTUALSPACEOPTIONS
editor->setRectangularSelectionModifier($modifier); editor->getRectangularSelectionModifier();
On GTK+, allow selecting the modifier key to use for mouse-based rectangular selection. Often the window manager requires Alt+Mouse Drag for moving windows. Valid values are SCMOD_CTRL(default), SCMOD_ALT, or SCMOD_SUPER.
See Scintilla documentation for SCI_SETRECTANGULARSELECTIONMODIFIER
See Scintilla documentation for SCI_GETRECTANGULARSELECTIONMODIFIER
editor->getSelections();
How many selections are there?
See Scintilla documentation for SCI_GETSELECTIONS
editor->getSelectionEmpty();
Is every selected range empty?
See Scintilla documentation for SCI_GETSELECTIONEMPTY
editor->clearSelections();
Clear selections to a single empty stream selection
See Scintilla documentation for SCI_CLEARSELECTIONS
editor->setSelection($caret, $anchor);
Set a simple selection
See Scintilla documentation for SCI_SETSELECTION
editor->addSelection($caret, $anchor);
Add a selection
See Scintilla documentation for SCI_ADDSELECTION
editor->dropSelectionN($selection);
Drop one selection
See Scintilla documentation for SCI_DROPSELECTIONN
editor->setMainSelection($selection); editor->getMainSelection();
Set the main selection
See Scintilla documentation for SCI_SETMAINSELECTION
See Scintilla documentation for SCI_GETMAINSELECTION
editor->setSelectionNCaret($selection, $pos); editor->getSelectionNCaret($selection);
Which selection is the main selection
See Scintilla documentation for SCI_SETSELECTIONNCARET
See Scintilla documentation for SCI_GETSELECTIONNCARET
editor->setSelectionNCaretVirtualSpace($selection, $space); editor->getSelectionNCaretVirtualSpace($selection);
See Scintilla documentation for SCI_SETSELECTIONNCARETVIRTUALSPACE
See Scintilla documentation for SCI_GETSELECTIONNCARETVIRTUALSPACE
editor->setSelectionNAnchor($selection, $posAnchor); editor->getSelectionNAnchor($selection);
See Scintilla documentation for SCI_SETSELECTIONNANCHOR
See Scintilla documentation for SCI_GETSELECTIONNANCHOR
editor->setSelectionNAnchorVirtualSpace($selection, $space); editor->getSelectionNAnchorVirtualSpace($selection);
See Scintilla documentation for SCI_SETSELECTIONNANCHORVIRTUALSPACE
See Scintilla documentation for SCI_GETSELECTIONNANCHORVIRTUALSPACE
editor->setSelectionNStart($selection, $pos); editor->getSelectionNStart($selection); editor->getSelectionNStartVirtualSpace($selection);
Sets the position that starts the selection - this becomes the anchor.
Use the getSelectionNStartVirtualSpace version for selections beyond the end of the line (in virtual space).
getSelectionNStartVirtualSpace
See Scintilla documentation for SCI_SETSELECTIONNSTART
See Scintilla documentation for SCI_GETSELECTIONNSTART
See Scintilla documentation for SCI_GETSELECTIONNSTARTVIRTUALSPACE
editor->setSelectionNEnd($selection, $pos); editor->getSelectionNEnd($selection); editor->getSelectionNEndVirtualSpace($selection);
Sets the position that ends the selection - this becomes the currentPosition.
Use the getSelectionNEndVirtualSpace version for selections beyond the end of the line (in virtual space).
getSelectionNEndVirtualSpace
See Scintilla documentation for SCI_SETSELECTIONNEND
See Scintilla documentation for SCI_GETSELECTIONNEND
See Scintilla documentation for SCI_GETSELECTIONNENDVIRTUALSPACE
editor->setRectangularSelectionCaret($pos); editor->getRectangularSelectionCaret();
See Scintilla documentation for SCI_SETRECTANGULARSELECTIONCARET
See Scintilla documentation for SCI_GETRECTANGULARSELECTIONCARET
editor->setRectangularSelectionCaretVirtualSpace($space); editor->getRectangularSelectionCaretVirtualSpace();
See Scintilla documentation for SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE
See Scintilla documentation for SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE
editor->setRectangularSelectionAnchor($posAnchor); editor->getRectangularSelectionAnchor();
See Scintilla documentation for SCI_SETRECTANGULARSELECTIONANCHOR
See Scintilla documentation for SCI_GETRECTANGULARSELECTIONANCHOR
editor->setRectangularSelectionAnchorVirtualSpace($space);
See Scintilla documentation for SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE
editor->getRectangularSelectionAnchorVirtualSpace();
See Scintilla documentation for SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE
editor->setAdditionalSelAlpha($alpha); editor->getAdditionalSelAlpha();
Set the alpha of the selection.
The value for $alpha must be one of the predefined %SC_ALPHA values, or any integer between $SC_ALPHA{SC_ALPHA_TRANSPARENT} and $SC_ALPHA{SC_ALPHA_OPAQUE}, inclusive.
$SC_ALPHA{SC_ALPHA_TRANSPARENT}
$SC_ALPHA{SC_ALPHA_OPAQUE}
See Scintilla documentation for SCI_SETADDITIONALSELALPHA
See Scintilla documentation for SCI_GETADDITIONALSELALPHA
editor->setAdditionalSelFore($fore);
Set the foreground colour of additional selections. Must have previously called SetSelFore with non-zero first argument for this to have an effect.
See Scintilla documentation for SCI_SETADDITIONALSELFORE
editor->setAdditionalSelBack($back);
Set the background colour of additional selections. Must have previously called SetSelBack with non-zero first argument for this to have an effect.
See Scintilla documentation for SCI_SETADDITIONALSELBACK
editor->setAdditionalCaretFore($fore); editor->getAdditionalCaretFore();
Set the foreground colour of additional carets.
See Scintilla documentation for SCI_SETADDITIONALCARETFORE
See Scintilla documentation for SCI_GETADDITIONALCARETFORE
editor->setAdditionalCaretsBlink($additionalCaretsBlink); editor->getAdditionalCaretsBlink();
Set whether additional carets will blink
See Scintilla documentation for SCI_SETADDITIONALCARETSBLINK
See Scintilla documentation for SCI_GETADDITIONALCARETSBLINK
editor->setAdditionalCaretsVisible($additionalCaretsBlink); editor->getAdditionalCaretsVisible();
Set whether additional carets are visible
See Scintilla documentation for SCI_SETADDITIONALCARETSVISIBLE
See Scintilla documentation for SCI_GETADDITIONALCARETSVISIBLE
editor->swapMainAnchorCaret();
Swap that caret and anchor of the main selection.
See Scintilla documentation for SCI_SWAPMAINANCHORCARET
editor->rotateSelection();
Set the main selection to the next selection.
See Scintilla documentation for SCI_ROTATESELECTION
editor->multipleSelectAddNext;
Adds the next occurrence of the main selection within the target to the multi-selection set.
See Scintilla documentation for SCI_MULTIPLESELECTADDNEXT
editor->multipleSelectAddEach;
Adds multiple occurrences of the main selection within the target to the multi-selection set.
See Scintilla documentation for SCI_MULTIPLESELECTADDEACH
editor->setFirstVisibleLine($lineDisplay); editor->getFirstVisibleLine();
Scroll so that a display line is at the top of the display.
See Scintilla documentation for SCI_SETFIRSTVISIBLELINE
See Scintilla documentation for SCI_GETFIRSTVISIBLELINE
editor->setXOffset($newOffset); editor->getXOffset();
Get and Set the xOffset (ie, horizontal scroll position).
See Scintilla documentation for SCI_SETXOFFSET
See Scintilla documentation for SCI_GETXOFFSET
editor->lineScroll($columns, $lines);
Scroll horizontally and vertically.
See Scintilla documentation for SCI_LINESCROLL
editor->scrollCaret();
Ensure the caret is visible.
See Scintilla documentation for SCI_SCROLLCARET
editor->scrollRange($secondary, $primary);
Scroll the argument positions and the range between them into view giving priority to the primary position then the secondary position. This may be used to make a search match visible.
See Scintilla documentation for SCI_SCROLLRANGE
editor->setXCaretPolicy($caretPolicy, $caretSlop);
Set the way the caret is kept visible when going sideways. The exclusion zone ($caretSlop) is given in pixels.
$caretPolicy a combination of %SC_CARETPOLICY values.
$caretPolicy
See Scintilla documentation for SCI_SETXCARETPOLICY
editor->setYCaretPolicy($caretPolicy, $caretSlop);
Set the way the line the caret is on is kept visible. The exclusion zone ($caretSlop) is given in lines.
$caretPolicy from %SC_CARETPOLICY.
See Scintilla documentation for SCI_SETYCARETPOLICY
editor->setVisiblePolicy($visiblePolicy, $visibleSlop);
Set the way the display area is determined when a particular line is to be moved to by Find, FindNext, GotoLine, etc. The exclusion zone ($visibleSlop) is given in lines.
Use $visiblePolicy from %SC_VISIBLE.
See Scintilla documentation for SCI_SETVISIBLEPOLICY
editor->setHScrollBar($show); editor->getHScrollBar();
Show or hide the horizontal scroll bar.
See Scintilla documentation for SCI_SETHSCROLLBAR
See Scintilla documentation for SCI_GETHSCROLLBAR
editor->setVScrollBar($show); editor->getVScrollBar();
Show or hide the vertical scroll bar.
See Scintilla documentation for SCI_SETVSCROLLBAR
See Scintilla documentation for SCI_GETVSCROLLBAR
editor->setScrollWidth($pixelWidth); editor->getScrollWidth();
Sets the document width assumed for scrolling.
See Scintilla documentation for SCI_SETSCROLLWIDTH
See Scintilla documentation for SCI_GETSCROLLWIDTH
editor->setScrollWidthTracking($tracking); editor->getScrollWidthTracking();
Sets whether the maximum width line displayed is used to set scroll width.
See Scintilla documentation for SCI_SETSCROLLWIDTHTRACKING
See Scintilla documentation for SCI_GETSCROLLWIDTHTRACKING
editor->setEndAtLastLine($endAtLastLine); editor->getEndAtLastLine();
Sets the scroll range so that maximum scroll position has the last line at the bottom of the view (default). Setting this to false allows scrolling one page below the last line.
See Scintilla documentation for SCI_SETENDATLASTLINE
See Scintilla documentation for SCI_GETENDATLASTLINE
editor->setViewWS($viewWS); editor->getViewWS();
Make white space characters invisible, always visible or visible outside indentation.
$viewWS from %SC_WHITESPACE
See Scintilla documentation for SCI_SETVIEWWS
See Scintilla documentation for SCI_GETVIEWWS
editor->setWhitespaceFore($useSetting, $fore);
Set the foreground colour of all whitespace and whether to use this setting.
See Scintilla documentation for SCI_SETWHITESPACEFORE
editor->setWhitespaceBack($useSetting, $back);
Set the background colour of all whitespace and whether to use this setting.
See Scintilla documentation for SCI_SETWHITESPACEBACK
editor->setWhitespaceSize($size); editor->getWhitespaceSize();
Set the size of the dots used to mark space characters.
See Scintilla documentation for SCI_SETWHITESPACESIZE
See Scintilla documentation for SCI_GETWHITESPACESIZE
editor->setTabDrawMode($tabDrawMode); editor->getTabDrawMode;
Set how tabs are drawn when whitespace is visible.
Use $tabDrawMode from %SC_TABDRAW.
See Scintilla documentation for SCI_SETTABDRAWMODE
See Scintilla documentation for SCI_GETTABDRAWMODE
editor->setExtraAscent($extraAscent); editor->getExtraAscent();
Set extra ascent for each line
See Scintilla documentation for SCI_SETEXTRAASCENT
See Scintilla documentation for SCI_GETEXTRAASCENT
editor->setExtraDescent($extraDescent); editor->getExtraDescent();
Set extra descent for each line
See Scintilla documentation for SCI_SETEXTRADESCENT
See Scintilla documentation for SCI_GETEXTRADESCENT
editor->setCursor($cursorType); editor->getCursor();
Sets the cursor behavior.
Use $cursor from %SC_CURSOR, either $SC_CURSOR{SC_CURSORNORMAL} or $SC_CURSOR{SC_CURSORWAIT}.
$SC_CURSOR{SC_CURSORNORMAL}
$SC_CURSOR{SC_CURSORWAIT}
See Scintilla documentation for SCI_SETCURSOR
See Scintilla documentation for SCI_GETCURSOR
editor->setMouseDownCaptures($captures); editor->getMouseDownCaptures();
Set whether the mouse is captured when its button is pressed.
See Scintilla documentation for SCI_SETMOUSEDOWNCAPTURES
See Scintilla documentation for SCI_GETMOUSEDOWNCAPTURES
editor->setMouseWheelCaptures($captures); editor->getMouseWheelCaptures;
Sets whether or not the Scintilla instance will handle all WM_MOUSEWHEEL messages if it has the focus, even if the mouse is nowhere near the Scintilla window.
Defaults to on; set $captures to a false value in order to require the mouse cursor to be over the Scintilla window to process those messages.
$captures
See Scintilla documentation for SCI_SETMOUSEWHEELCAPTURES
See Scintilla documentation for SCI_GETMOUSEWHEELCAPTURES
editor->setEOLMode($eolMode); editor->getEOLMode();
Set the current end of line mode.
Use $eolMode from %SC_EOL.
See also "getEOLString()" method for getting the correct string.
See Scintilla documentation for SCI_SETEOLMODE
See Scintilla documentation for SCI_GETEOLMODE
editor->convertEOLs($eolMode);
Convert all line endings in the document to one mode.
See Scintilla documentation for SCI_CONVERTEOLS
editor->setViewEOL($visible); editor->getViewEOL();
Make the end of line characters visible or invisible.
See Scintilla documentation for SCI_SETVIEWEOL
See Scintilla documentation for SCI_GETVIEWEOL
editor->getLineEndTypesSupported();
Returns whether line endings beyond the standard (LF, CR, and CRLF) are supported by the lexer. (Unicode has other line-endings defined, so this will tell you if those line endings are supported or not.)
Returns values from %SC_EOLSUPPORT, but effectively, a true value means Unicode's extra line-endings are supported.
See Scintilla documentation for SCI_GETLINEENDTYPESSUPPORTED
editor->setLineEndTypesAllowed($lineEndBitSet); editor->getLineEndTypesAllowed();
Set the line end types that the application wants to use. May not be used if incompatible with lexer or encoding.
Use $lineEndBitSet from %SC_EOLSUPPORT.
See Scintilla documentation for SCI_SETLINEENDTYPESALLOWED
See Scintilla documentation for SCI_GETLINEENDTYPESALLOWED
editor->getLineEndTypesActive();
Get the line end types currently recognised. May be a subset of the allowed types due to lexer limitation.
See Scintilla documentation for SCI_GETLINEENDTYPESACTIVE
editor->wordStartPosition($pos, $onlyWordCharacters);
Get position of start of word.
See Scintilla documentation for SCI_WORDSTARTPOSITION
editor->wordEndPosition($pos, $onlyWordCharacters);
Get position of end of word.
See Scintilla documentation for SCI_WORDENDPOSITION
editor->isRangeWord($start, $end);
Is the range defined by $start .. $end a word or set of words? (It checks for word-boundary at the beginning and ending of the range; if there are intermediate word boundaries, it will still return true.)
$start
$end
See Scintilla documentation for SCI_ISRANGEWORD
editor->setWordChars($characters); editor->getWordChars();
Set the set of characters making up words for when moving or selecting by word. First sets defaults like setCharsDefault().
See Scintilla documentation for SCI_SETWORDCHARS
See Scintilla documentation for SCI_GETWORDCHARS
editor->setWhitespaceChars($characters); editor->getWhitespaceChars();
Set the set of characters making up whitespace for when moving or selecting by word. Should be called after SetWordChars.
See Scintilla documentation for SCI_SETWHITESPACECHARS
See Scintilla documentation for SCI_GETWHITESPACECHARS
editor->setPunctuationChars($characters); editor->getPunctuationChars();
Set the set of characters making up punctuation characters Should be called after SetWordChars.
See Scintilla documentation for SCI_SETPUNCTUATIONCHARS
See Scintilla documentation for SCI_GETPUNCTUATIONCHARS
editor->setCharsDefault();
Reset the set of characters for whitespace and word characters to the defaults.
See Scintilla documentation for SCI_SETCHARSDEFAULT
editor->setCharacterCategoryOptimization($countCharacters); editor->getCharacterCategoryOptimization;
Optimize speed of character category features like determining whether a character is a space or number at the expense of memory. Mostly used for Unicode documents. The $countCharacters parameter determines how many character starting from 0 are added to a look-up table with one byte used for each character. It is reasonable to cover the set of characters likely to be used in a document so 0x100 for simple Roman text, 0x1000 to cover most simple alphabets, 0x10000 to cover most of East Asian languages, and 0x110000 to cover all possible characters.
$countCharacters
See Scintilla documentation for SCI_SETCHARACTERCATEGORYOPTIMIZATION
See Scintilla documentation for SCI_GETCHARACTERCATEGORYOPTIMIZATION
editor->getEndStyled();
Retrieve the position of the last correctly styled character.
See Scintilla documentation for SCI_GETENDSTYLED
editor->startStyling($pos, $mask);
Set the current styling position to pos and the styling mask to mask. The styling mask can be used to protect some bits in each styling byte from modification.
See Scintilla documentation for SCI_STARTSTYLING
editor->setStyling($length, $style);
Change style from current styling position for length characters to a style and move the current styling position to after this newly styled segment.
See Scintilla documentation for SCI_SETSTYLING
editor->setStylingEx($styles);
Set the styles for a segment of the document.
See Scintilla documentation for SCI_SETSTYLINGEX
editor->setIdleStyling($idleStyling); editor->getIdleStyling;
Defines when and how syntax styling is applied. By default, style visible text; the other options allow styling the whole document in the background, or styling the visible first, and then some or all of the rest of the document is styled as a background process during Notepad++ idle time.
Use $idleStyling from %SC_IDLESTYLING.
Since wrapping also needs to perform styling and also uses idle time, this setting has no effect when the document is displayed wrapped.
See Scintilla documentation for SCI_SETIDLESTYLING
See Scintilla documentation for SCI_GETIDLESTYLING
editor->setLineState($line, $state); editor->getLineState($line);
Used to hold extra styling information for each line.
See Scintilla documentation for SCI_SETLINESTATE
See Scintilla documentation for SCI_GETLINESTATE
editor->getMaxLineState();
Retrieve the last line number that has line state.
See Scintilla documentation for SCI_GETMAXLINESTATE
There are 256 lexer styles that can be set, numbered 0 to $SC_STYLE{STYLE_MAX} (255). There are also some predefined numbered styles starting at 32, available in %SC_STYLE.
editor->styleResetDefault();
Reset the default style to its state at startup
See Scintilla documentation for SCI_STYLERESETDEFAULT
editor->styleClearAll();
Clear all the styles and make equivalent to the global default style.
See Scintilla documentation for SCI_STYLECLEARALL
editor->styleSetFont($style, $fontName); editor->styleGetFont($style);
Set the font of a style.
See Scintilla documentation for SCI_STYLESETFONT
See Scintilla documentation for SCI_STYLEGETFONT
editor->styleSetSize($style, $sizePoints); editor->styleGetSize($style);
Set the size of characters of a style.
See Scintilla documentation for SCI_STYLESETSIZE
See Scintilla documentation for SCI_STYLEGETSIZE
editor->styleSetSizeFractional($style, $caseForce); editor->styleGetSizeFractional($style);
Set the size of characters of a style. Size is in points multiplied by 100.
(Technically, that 100 is from $SC_FONTSIZE{SC_FONT_SIZE_MULTIPLIER}.)
my $style = ...; my $points = 12.5; # want a 12.5pt font editor->styleSetSizeFractional( $style, $points * $SC_FONTSIZE{SC_FONT_SIZE_MULTIPLIER} );
See Scintilla documentation for SCI_STYLESETSIZEFRACTIONAL
See Scintilla documentation for SCI_STYLEGETSIZEFRACTIONAL
editor->styleSetBold($style, $bold); editor->styleGetBold($style);
Set a style to be bold or not.
See Scintilla documentation for SCI_STYLESETBOLD
See Scintilla documentation for SCI_STYLEGETBOLD
editor->styleSetWeight($style, $weight); editor->styleGetWeight($style);
Set the weight of characters of a style.
Use $weight as an integer from 1 to 999, where 1 is very light and 999 is quite heavy; predefined values for normal and bold text can be used from %SC_WEIGHT.
See Scintilla documentation for SCI_STYLESETWEIGHT
See Scintilla documentation for SCI_STYLEGETWEIGHT
editor->styleSetItalic($style, $italic); editor->styleGetItalic($style);
Set a style to be italic or not.
See Scintilla documentation for SCI_STYLESETITALIC
See Scintilla documentation for SCI_STYLEGETITALIC
editor->styleSetUnderline($style, $underline); editor->styleGetUnderline($style);
Set a style to be underlined or not.
See Scintilla documentation for SCI_STYLESETUNDERLINE
See Scintilla documentation for SCI_STYLEGETUNDERLINE
editor->styleSetFore($style, $fore); editor->styleGetFore($style);
Set the foreground colour of a style.
See Scintilla documentation for SCI_STYLESETFORE
See Scintilla documentation for SCI_STYLEGETFORE
editor->styleSetBack($style, $back); editor->styleGetBack($style);
Set the background colour of a style.
See Scintilla documentation for SCI_STYLESETBACK
See Scintilla documentation for SCI_STYLEGETBACK
editor->styleSetEOLFilled($style, $filled); editor->styleGetEOLFilled($style);
Set a style to have its end of line filled or not.
See Scintilla documentation for SCI_STYLESETEOLFILLED
See Scintilla documentation for SCI_STYLEGETEOLFILLED
editor->styleSetCharacterSet($style, $characterSet); editor->styleGetCharacterSet;
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.
Use $characterSet from %SC_CHARSET.
See Scintilla documentation for SCI_STYLESETCHARACTERSET
See Scintilla documentation for SCI_STYLEGETCHARACTERSET
editor->styleSetCase($style, $caseForce); editor->styleGetCase($style);
Set a style to be mixed case, or to force upper or lower case. (Affects how text is displayed, not how it is stored.)
Use $caseForce from %SC_CASE.
See Scintilla documentation for SCI_STYLESETCASE
See Scintilla documentation for SCI_STYLEGETCASE
editor->styleSetVisible($style, $visible); editor->styleGetVisible($style);
Set a style to be visible or not.
See Scintilla documentation for SCI_STYLESETVISIBLE
See Scintilla documentation for SCI_STYLEGETVISIBLE
editor->styleSetChangeable($style, $changeable); editor->styleGetChangeable($style);
Set a style to be changeable or not (read only). Experimental feature, currently buggy.
See Scintilla documentation for SCI_STYLESETCHANGEABLE
See Scintilla documentation for SCI_STYLEGETCHANGEABLE
editor->styleSetHotSpot($style, $hotspot); editor->styleGetHotSpot($style);
Set a style to be a hotspot or not.
See Scintilla documentation for SCI_STYLESETHOTSPOT
See Scintilla documentation for SCI_STYLEGETHOTSPOT
editor->styleSetCheckMonospaced($style, $hotspot); editor->styleGetCheckMonospaced($style);
This attribute indicates that the font may be monospaced over the ASCII graphics characters (' ' … '~', including letters ('a'…'z', 'A'…'Z') and numbers ('0'…'9')). This allows optimizing speed and memory use for some common scenarios where documents are mostly composed from ASCII characters.
See Scintilla documentation for SCI_STYLESETCHECKMONOSPACED
See Scintilla documentation for SCI_STYLEGETCHECKMONOSPACED
editor->styleSetInvisibleRepresentation($style, $representation); $representation = editor->styleGetInvisibleRepresentation($style);
When a style is made invisible with styleSetVisible(), text is difficult to edit as the cursor can be at both sides of the invisible text segment. With these messages invisible text segements can be made visible with a single UTF8 characater giving the user an indication if the cursor is left or right of the invisible text. The character is displayed using the current style.
styleSetVisible()
The $representation parameter is a zero terminated string holding the one character used to represent the invisible text segment. Only the first character is used, the character is decoded as UTF-8.
$representation
See Scintilla documentation for SCI_STYLESETINVISIBLEREPRESENTATION
See Scintilla documentation for SCI_STYLEGETINVISIBLEREPRESENTATION
editor->setFontLocale($localeName); $localeName = editor->getFontLocale();
These messages set the locale used for font selection with language-dependent glyphs. It may, depending on platform and other circumstances influence the display of text, so setting "zh-Hant" may result in traditional Chinese display and "zh-Hans" may result in simplified Chinese display. It is currently only implemented for Win32 using DirectWrite where the value is passed as the localeName argument to CreateTextFormat. The default value is US English "en-us".
See Scintilla documentation for SCI_SETFONTLOCALE
See Scintilla documentation for SCI_GETFONTLOCALE
The colours of some visual elements can be changed with these methods. The available elements often have a defined default colour, sometimes from the system but also from Notepad++. There may be a range of colours and setting an element colour overrides these colours.
This whole group requires at least Scintilla v5.2, found in Notepad++ v8.4 and newer.
editor->setElementColour($element, $colour); $colour = editor->getElementColour($element);
This changes the colour of the indicated visual element overriding any current colour. If the element supports translucency, then the alpha portion of the value is used. An opaque alpha value (0xff) should always be included when an opaque colour is desired as the value 0 is completely transparent and thus invisible.
The $element is one of the values found in %SC_ELEMENT.
$element
See Scintilla documentation for SCI_SETELEMENTCOLOUR
See Scintilla documentation for SCI_GETELEMENTCOLOUR
editor->resetElementColour($element);
This removes the element colour returning to the default colour or set of colours.
See Scintilla documentation for SCI_RESETELEMENTCOLOUR
This command requires at least Scintilla v5.2, found in Notepad++ v8.4 and newer.
$bool = editor->getElementIsSet($element);
Returns true when an element colour has been set. Returns false when a default colour or set of colours is displayed.
See Scintilla documentation for SCI_GETELEMENTISSET
$bool = editor->getElementAllowsTranslucent($element);
Returns true when the element currently allows translucent drawing when an alpha component is included. This may change based on circumstances - different platforms or graphics technologies may implement translucency and newer versions of Scintilla may implement translucency for elements that did not previously support it.
See Scintilla documentation for SCI_GETELEMENTALLOWSTRANSLUCENT
$colour = editor->getElementBaseColour($element);
Returns the default colour of an element. This may be a value defined by Scintilla or it may be derived from the operating system or platform. Which values are set from the operating system may differ between operating systems and operating system versions. When undefined the return value is 0 which is equivalent to completely transparent black. These colours may be useful when defining styles with similarities such as synthesizing dark mode styles that use the same colours as the system
See Scintilla documentation for SCI_GETELEMENTBASECOLOUR
The selection is shown by changing the text and/or background colours. If the selected text colour is not set then that attribute is not changed for the selection. The default is to show the selection by changing the background 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.
editor->setSelFore($useSetting, $fore);
Set the foreground colour of the main and additional selections and whether to use this setting.
See Scintilla documentation for SCI_SETSELFORE
editor->setSelBack($useSetting, $back);
Set the background colour of the main and additional selections and whether to use this setting.
See Scintilla documentation for SCI_SETSELBACK
editor->setSelectionLayer($layer); $layer = editor->getSelectionLayer();
The selection background can be drawn translucently over the text or opaquely on the base layer.
The value for $layer must be one of the predefined %SC_LAYER values.
$layer
See Scintilla documentation for SCI_GETSELECTIONLAYER
See Scintilla documentation for SCI_SETSELECTIONLAYER
editor->setSelAlpha($alpha); editor->getSelAlpha();
Get the alpha of the selection.
See Scintilla documentation for SCI_GETSELALPHA
See Scintilla documentation for SCI_SETSELALPHA
editor->setSelEOLFilled($filled); editor->getSelEOLFilled();
Is the selection end of line filled?
See Scintilla documentation for SCI_GETSELEOLFILLED
See Scintilla documentation for SCI_SETSELEOLFILLED
editor->setCaretFore($fore); editor->getCaretFore();
Set and retrieve the foreground colour of the caret.
See Scintilla documentation for SCI_SETCARETFORE
See Scintilla documentation for SCI_GETCARETFORE
editor->setCaretLineLayer($layer); editor->getCaretLineLayer();
You can choose to make the background colour of the line containing the caret different by setting the SC_ELEMENT_CARET_LINE_BACK element with setElementColour($SC_ELEMENT{SC_ELEMENT_CARET_LINE_BACK}). This effect may be drawn translucently over the text or opaquely on the base layer with setCaretLineLayer. Background colouring has highest priority when a line has markers that would otherwise change the background colour. When drawn translucently other background colours can show through.
setElementColour($SC_ELEMENT{SC_ELEMENT_CARET_LINE_BACK})
setCaretLineLayer
The layer argument can be one of the %SC_LAYER values.
See Scintilla documentation for SCI_SETCARETLINELAYER
See Scintilla documentation for SCI_GETCARETLINELAYER
editor->setCaretLineVisible($show); editor->getCaretLineVisible();
Display the background of the line containing the caret in a different colour.
See Scintilla documentation for SCI_SETCARETLINEVISIBLE
See Scintilla documentation for SCI_GETCARETLINEVISIBLE
editor->setCaretLineBack($back); editor->getCaretLineBack();
Set the colour of the background of the line containing the caret.
See Scintilla documentation for SCI_GETCARETLINEBACK
See Scintilla documentation for SCI_SETCARETLINEBACK
editor->setCaretLineBackAlpha($alpha); editor->getCaretLineBackAlpha();
Set and retrieve background alpha of the caret line.
See Scintilla documentation for SCI_SETCARETLINEBACKALPHA
See Scintilla documentation for SCI_GETCARETLINEBACKALPHA
editor->setCaretLineFrame($width); editor->getCaretLineFrame;
Set and retrieve the width of the frame around the caret line.
See Scintilla documentation for SCI_SETCARETLINEFRAME
See Scintilla documentation for SCI_GETCARETLINEFRAME
editor->setCaretLineVisibleAlways($alwaysVisible); editor->getCaretLineVisibleAlways();
Sets the caret line to always visible.
See Scintilla documentation for SCI_SETCARETLINEVISIBLEALWAYS
See Scintilla documentation for SCI_GETCARETLINEVISIBLEALWAYS
editor->setCaretLineHighlightSubline($subLine); editor->getCaretLineHighlightSubline();
Choose to highlight only the subline containing the caret instead of the whole line. Under the default condition ($subLine is false), the whole caret line is highlighted.
$subLine
See Scintilla documentation for SCI_SETCARETLINEHIGHLIGHTSUBLINE
See Scintilla documentation for SCI_GETCARETLINEHIGHLIGHTSUBLINE
editor->setCaretPeriod($periodMilliseconds); editor->getCaretPeriod();
Get the time in milliseconds that the caret is on and off. 0 = steady on.
See Scintilla documentation for SCI_SETCARETPERIOD
See Scintilla documentation for SCI_GETCARETPERIOD
editor->setCaretStyle($caretStyle); editor->getCaretStyle();
Set the style of the caret to be drawn.
$caretStyle from %SC_CARETSTYLE.
$caretStyle
See Scintilla documentation for SCI_SETCARETSTYLE
See Scintilla documentation for SCI_GETCARETSTYLE
editor->setCaretWidth($pixelWidth); editor->getCaretWidth();
Set the width of the insert mode caret.
See Scintilla documentation for SCI_SETCARETWIDTH
See Scintilla documentation for SCI_GETCARETWIDTH
editor->setHotspotActiveFore($useSetting, $fore); editor->getHotspotActiveFore();
Set a fore colour for active hotspots.
See Scintilla documentation for SCI_SETHOTSPOTACTIVEFORE
See Scintilla documentation for SCI_GETHOTSPOTACTIVEFORE
editor->setHotspotActiveBack($useSetting, $back); editor->getHotspotActiveBack();
Set a back colour for active hotspots.
See Scintilla documentation for SCI_SETHOTSPOTACTIVEBACK
See Scintilla documentation for SCI_GETHOTSPOTACTIVEBACK
editor->setHotspotActiveUnderline($underline); editor->getHotspotActiveUnderline();
Enable / Disable underlining active hotspots.
See Scintilla documentation for SCI_SETHOTSPOTACTIVEUNDERLINE
See Scintilla documentation for SCI_GETHOTSPOTACTIVEUNDERLINE
editor->setHotspotSingleLine($singleLine); editor->getHotspotSingleLine();
Limit hotspots to single line so hotspots on two lines don’t merge.
See Scintilla documentation for SCI_SETHOTSPOTSINGLELINE
See Scintilla documentation for SCI_GETHOTSPOTSINGLELINE
editor->setCaretSticky($useCaretStickyBehaviour); editor->getCaretSticky();
Can the caret preferred x position only be changed by explicit movement commands?
Use $useCaretStickyBehavior from %SC_CARETSTICKY
See Scintilla documentation for SCI_GETCARETSTICKY
See Scintilla documentation for SCI_SETCARETSTICKY
editor->toggleCaretSticky();
Switch between sticky and non-sticky: meant to be bound to a key.
See Scintilla documentation for SCI_TOGGLECARETSTICKY
Some characters, such as control characters and invalid bytes, do not have a visual glyph or use a glyph that is hard to distinguish.
Control characters (characters with codes less than 32, or between 128 and 159 in some encodings) are displayed by Scintilla using their mnemonics inverted in a rounded rectangle. These mnemonics come from the early days of signalling, though some are still used (LF = Line Feed, BS = Back Space, CR = Carriage Return, for example).
For the low 'C0' values: "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".
For the high 'C1' values: "PAD", "HOP", "BPH", "NBH", "IND", "NEL", "SSA", "ESA", "HTS", "HTJ", "VTS", "PLD", "PLU", "RI", "SS2", "SS3", "DCS", "PU1", "PU2", "STS", "CCH", "MW", "SPA", "EPA", "SOS", "SGCI", "SCI", "CSI", "ST", "OSC", "PM", "APC".
Invalid bytes are shown in a similar way with an 'x' followed by their value in hexadecimal, like "xFE".
Notepad++'s Settings > Preferences > Editing > Non-Printing Characters settings can also set up representations for other non-printing characters, such as "NBSP" for the U+00A0 non-breaking space; this list is shown in the usermanual
editor->setRepresentation($encodedCharacter, $representation); editor->getRepresentation();
Set the way a character is drawn.
See Scintilla documentation for SCI_SETREPRESENTATION
See Scintilla documentation for SCI_GETREPRESENTATION
editor->clearRepresentation($encodedCharacter); editor->clearAllRepresentations();
Remove a character representation from $encodedCharacter or from all characters.
$encodedCharacter
See Scintilla documentation for SCI_CLEARREPRESENTATION
See Scintilla documentation for SCI_CLEARALLREPRESENTATIONS
editor->setRepresentationAppearance($encodedCharacter, $appearance); $appearance = editor->getRepresentationAppearance($encodedCharacter);
The appearance may be changed using these flags. If a colour is set and the appearance is set without $SC_REPRESENTATION{SC_REPRESENTATION_COLOUR} then the representation will show in the colour of the underlying text.
$SC_REPRESENTATION{SC_REPRESENTATION_COLOUR}
The $appearance value comes from the %SC_REPRESENTATION hash.
$appearance
See Scintilla documentation for SCI_SETREPRESENTATIONAPPEARANCE
See Scintilla documentation for SCI_GETREPRESENTATIONAPPEARANCE
editor->setRepresentationColour($encodedCharacter, $color); $color = editor->getRepresentationColour($encodedCharacter);
The colour and translucency of a representation may be set.
See Scintilla documentation for SCI_SETREPRESENTATIONCOLOUR
See Scintilla documentation for SCI_GETREPRESENTATIONCOLOUR
editor->setControlCharSymbol($symbol); editor->getControlCharSymbol();
The mnemonics may be replaced by a chosen symbol with a character codepoint 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. The default symbol value is 0.
See Scintilla documentation for SCI_SETCONTROLCHARSYMBOL
See Scintilla documentation for SCI_GETCONTROLCHARSYMBOL
editor->setMargins($numberOfMargins); editor->getMargins;
Allocate the number of margins or find the number of margins currently allocated.
Overrides $SC_MARGIN{SC_MAX_MARGIN}.
See Scintilla documentation for SCI_SETMARGINS
See Scintilla documentation for SCI_GETMARGINS
editor->setMarginTypeN($margin, $marginType); editor->getMarginTypeN($margin);
Set a specific margin to be either numeric or symbolic.
The $margin argument needs to be an index between 0 and $SC_MARGIN{SC_MAX_MARGIN} (inclusive), unless "setMargins" has been called to increase the number of margins available.
Use $marginType value should come from %SC_MARGIN.
See Scintilla documentation for SCI_SETMARGINTYPEN
See Scintilla documentation for SCI_GETMARGINTYPEN
editor->setMarginWidthN($margin, $pixelWidth); editor->getMarginWidthN($margin);
Set the width of a margin to a width expressed in pixels.
See Scintilla documentation for SCI_SETMARGINWIDTHN
See Scintilla documentation for SCI_GETMARGINWIDTHN
editor->setMarginMaskN($margin, $mask); editor->getMarginMaskN($margin);
Set a mask that determines which markers are displayed in a margin.
The $mask is a 32-bit number, where each bit represents one of the 32 numbered markers. If the bit is set in the mask, that marker will be enabled for that margin. It can be useful to only include the seven code-folding markers in bits 25-31 using the predefined mask $SC_MARKNUM{SC_MASK_FOLDER}; to enable all the markers _except_ those seven, use ~$SC_MARKNUM{SC_MASK_FOLDER}.
$SC_MARKNUM{SC_MASK_FOLDER}
~$SC_MARKNUM{SC_MASK_FOLDER}
See Scintilla documentation for SCI_SETMARGINMASKN
See Scintilla documentation for SCI_GETMARGINMASKN
editor->setMarginSensitiveN($margin, $sensitive); editor->getMarginSensitiveN($margin);
Make a margin sensitive or insensitive to mouse clicks.
See Scintilla documentation for SCI_SETMARGINSENSITIVEN
See Scintilla documentation for SCI_GETMARGINSENSITIVEN
editor->setMarginCursorN($margin, $cursor); editor->getMarginCursorN($margin);
Set the cursor shown when the mouse is inside a margin.
Use $cursor from %SC_CURSOR, either $SC_CURSOR{SC_CURSORARROW} or $SC_CURSOR{SC_CURSORREVERSEARROW}
$SC_CURSOR{SC_CURSORARROW}
$SC_CURSOR{SC_CURSORREVERSEARROW}
See Scintilla documentation for SCI_SETMARGINCURSORN
See Scintilla documentation for SCI_GETMARGINCURSORN
editor->setMarginBackN($margin, $backgroundColor); editor->getMarginBackN;
Set and retrieve the background color for the specified margin
See Scintilla documentation for SCI_SETMARGINBACKN
See Scintilla documentation for SCI_GETMARGINBACKN
editor->setMarginLeft($pixelWidth); editor->getMarginLeft();
Sets the size in pixels of the left margin.
See Scintilla documentation for SCI_SETMARGINLEFT
See Scintilla documentation for SCI_GETMARGINLEFT
editor->setMarginRight($pixelWidth); editor->getMarginRight();
Sets the size in pixels of the right margin.
See Scintilla documentation for SCI_SETMARGINRIGHT
See Scintilla documentation for SCI_GETMARGINRIGHT
editor->setFoldMarginColour($useSetting, $back);
Set the colours used as a chequerboard pattern in the fold margin
See Scintilla documentation for SCI_SETFOLDMARGINCOLOUR
editor->setFoldMarginHiColour($useSetting, $fore);
See Scintilla documentation for SCI_SETFOLDMARGINHICOLOUR
editor->marginSetText($line, $text); editor->marginGetText($line);
Set the text in the text margin for a line
See Scintilla documentation for SCI_MARGINSETTEXT
See Scintilla documentation for SCI_MARGINGETTEXT
editor->marginSetStyle($line, $style); editor->marginGetStyle($line);
Set the style number for the text margin for a line.
Use $style from %SC_MARGIN.
See Scintilla documentation for SCI_MARGINSETSTYLE
See Scintilla documentation for SCI_MARGINGETSTYLE
editor->marginSetStyles($line, $styles); editor->marginGetStyles($line);
Set the style in the text margin for a line
See Scintilla documentation for SCI_MARGINSETSTYLES
See Scintilla documentation for SCI_MARGINGETSTYLES
editor->marginTextClearAll();
Clear the margin text on all lines
See Scintilla documentation for SCI_MARGINTEXTCLEARALL
editor->marginSetStyleOffset($style); editor->marginGetStyleOffset();
Get the start of the range of style numbers used for margin text
See Scintilla documentation for SCI_MARGINSETSTYLEOFFSET
See Scintilla documentation for SCI_MARGINGETSTYLEOFFSET
editor->setMarginOptions($marginOptions); editor->getMarginOptions();
Set the margin options.
See Scintilla documentation for SCI_SETMARGINOPTIONS
See Scintilla documentation for SCI_GETMARGINOPTIONS
Annotations are read-only lines of text underneath each line of editable text. An annotation may consist of multiple lines separated by '\n'. Annotations can be used to display an assembler version of code for debugging or to show diagnostic messages inline or to line up different versions of text in a merge tool.
Annotations count as display lines for the methods SCI_VISIBLEFROMDOCLINE and SCI_DOCLINEFROMVISIBLE
editor->annotationSetText($line, $text); editor->annotationGetText($line);
Set the annotation text for a line
See Scintilla documentation for SCI_ANNOTATIONSETTEXT
See Scintilla documentation for SCI_ANNOTATIONGETTEXT
editor->annotationSetStyle($line, $style); editor->annotationGetStyle($line);
Set the style number for the annotations for a line
See Scintilla documentation for SCI_ANNOTATIONSETSTYLE
See Scintilla documentation for SCI_ANNOTATIONGETSTYLE
editor->annotationSetStyles($line, $styles); editor->annotationGetStyles($line);
Set the annotation styles for a line
See Scintilla documentation for SCI_ANNOTATIONSETSTYLES
See Scintilla documentation for SCI_ANNOTATIONGETSTYLES
editor->annotationGetLines($line);
Get the number of annotation lines for a line
See Scintilla documentation for SCI_ANNOTATIONGETLINES
editor->annotationClearAll();
Clear the annotations from all lines
See Scintilla documentation for SCI_ANNOTATIONCLEARALL
editor->annotationSetVisible($visible); editor->annotationGetVisible();
Set the visibility for the annotations for a view, where $visible comes from %SC_ANNOTATION.
$visible
See Scintilla documentation for SCI_ANNOTATIONSETVISIBLE
See Scintilla documentation for SCI_ANNOTATIONGETVISIBLE
editor->annotationSetStyleOffset($style); editor->annotationGetStyleOffset();
Get the start of the range of style numbers used for annotations
See Scintilla documentation for SCI_ANNOTATIONSETSTYLEOFFSET
See Scintilla documentation for SCI_ANNOTATIONGETSTYLEOFFSET
End of Line Annotations are read-only lines of text at the end of each line of editable text. End of Line Annotations can be used to display an assembler version of code for debugging or to show diagnostic messages inline or to line up different versions of text in a merge tool.
editor->eolAnnotationSetText($line, $text); editor->eolAnnotationGetText($line);
Set the end-of-line annotation text for a line
See Scintilla documentation for SCI_EOLANNOTATIONSETTEXT
See Scintilla documentation for SCI_EOLANNOTATIONGETTEXT
editor->eolAnnotationSetStyle($line, $style); editor->eolAnnotationGetStyle($line);
Set the style number for the end-of-line annotations for a line
See Scintilla documentation for SCI_EOLANNOTATIONSETSTYLE
See Scintilla documentation for SCI_EOLANNOTATIONGETSTYLE
editor->eolAnnotationClearAll();
Clear the end-of-line annotations from all lines
See Scintilla documentation for SCI_EOLANNOTATIONCLEARALL
editor->eolAnnotationSetVisible($visible); editor->eolAnnotationGetVisible();
Set the visibility for the end-of-line annotations for a view, where $visible comes from %SC_ANNOTATION.
See Scintilla documentation for SCI_EOLANNOTATIONSETVISIBLE
See Scintilla documentation for SCI_EOLANNOTATIONGETVISIBLE
editor->eolAnnotationSetStyleOffset($style); editor->eolAnnotationGetStyleOffset();
Get the start of the range of style numbers used for end-of-line annotations
See Scintilla documentation for SCI_EOLANNOTATIONSETSTYLEOFFSET
See Scintilla documentation for SCI_EOLANNOTATIONGETSTYLEOFFSET
editor->setBufferedDraw($buffered); editor->getBufferedDraw();
Is drawing done first into a buffer or direct to the screen?
See Scintilla documentation for SCI_GETBUFFEREDDRAW
See Scintilla documentation for SCI_SETBUFFEREDDRAW
editor->setPhasesDraw($phases); editor->getPhasesDraw;
Changes the sequence of drawing a text area, to trade off speed of drawing and allowing all pixels to be seen.
Use $phases from %SC_PHASES.
See Scintilla documentation for SCI_SETPHASESDRAW
See Scintilla documentation for SCI_GETPHASESDRAW
editor->setTechnology($technology); editor->getTechnology();
Set the video card and driver technology used (whether or not to use DirectDraw API). In Windows XP and earlier, only the default video technology is available.
Use $technology from %SC_TECHNOLOGY.
See Scintilla documentation for SCI_SETTECHNOLOGY
See Scintilla documentation for SCI_GETTECHNOLOGY
editor->setFontQuality($fontQuality); editor->getFontQuality();
Choose the quality level (antialiasing method) for text.
Use $fontQuality from %SC_FONTQUAL.
See Scintilla documentation for SCI_SETFONTQUALITY
See Scintilla documentation for SCI_GETFONTQUALITY
editor->setCodePage($codePage); editor->getCodePage();
Set the code page used to interpret the bytes of the document as characters.
Scintilla supports UTF-8, Japanese, Chinese and Korean DBCS along with single byte encodings like Latin-1. UTF-8 (SC_CP_UTF8) is the default. Use this message with codePage set to the code page number to set Scintilla to use code page information to ensure multiple byte characters are treated as one character rather than multiple. This also stops the caret from moving between the bytes in a multi-byte character. Do not use this message to choose between different single byte character sets - use "styleSetCharacterSet" for that. Call with $codePage set to zero to disable multi-byte support.
Use $codePage from %SC_CODEPAGE, or use a valid multibyte-codepage value.
See Scintilla documentation for SCI_SETCODEPAGE
See Scintilla documentation for SCI_GETCODEPAGE
editor->setIMEInteraction($imeInteraction); editor->getIMEInteraction;
Sets or retrieves the Input Method Editor (IME) for Chinese, Japanese, and Korean text.
Use $imeInteraction from %SC_IME.
See Scintilla documentation for SCI_SETIMEINTERACTION
See Scintilla documentation for SCI_GETIMEINTERACTION
editor->setBirdirectional($bidirectional);
editor->getBidirectional;
Per Scintilla, these features are experimental and incomplete. They are used to be able to mix LTR and RTL languages.
Use $bidirectional from %SC_BIDIRECTIONAL.
The default $SC_BIDIRECTIONAL{SC_BIDIRECTIONAL_DISABLED} (0) means that only one direction is supported.
$SC_BIDIRECTIONAL{SC_BIDIRECTIONAL_DISABLED}
Enabling $SC_BIDIRECTIONAL{SC_BIDIRECTIONAL_L2R} (1) means that left-to-right is the normal active direction, but UTF sequences can change text to right-to-left.
$SC_BIDIRECTIONAL{SC_BIDIRECTIONAL_L2R}
Enabling $SC_BIDIRECTIONAL{SC_BIDIRECTIONAL_R2L} (2) means that right-to-left is the normal active direction, but UTF sequences can change text to left-to-right.
$SC_BIDIRECTIONAL{SC_BIDIRECTIONAL_R2L}
You may also need to use "setTechnology" to a DirectWrite option.
See Scintilla documentation for SCI_SETBIDIRECTIONAL
See Scintilla documentation for SCI_GETBIDIRECTIONAL
editor->grabFocus();
Set the focus to this Scintilla widget.
See Scintilla documentation for SCI_GRABFOCUS
editor->setFocus($focus); editor->getFocus();
Change internal focus flag.
See Scintilla documentation for SCI_SETFOCUS
See Scintilla documentation for SCI_GETFOCUS
print editor->scintillaSupportsFeature($feature);
Different platforms support different features and scintillaSupportsFeature can be used to check which are currently available. This call allows applications to tailor their settings.
scintillaSupportsFeature
It uses the values from %SC_SUPPORTS for $feature.
$feature
See Scintilla documentation for SCI_SUPPORTSFEATURE
editor->braceHighlight($pos1, $pos2);
Highlight the characters at two positions.
See Scintilla documentation for SCI_BRACEHIGHLIGHT
editor->braceBadLight($pos);
Highlight the character at a position indicating there is no matching brace.
See Scintilla documentation for SCI_BRACEBADLIGHT
editor->braceHighlightIndicator($useBraceHighlightIndicator, $indicator);
Use specified indicator to highlight matching braces instead of changing their style.
See Scintilla documentation for SCI_BRACEHIGHLIGHTINDICATOR
editor->braceBadLightIndicator($useBraceBadLightIndicator, $indicator);
Use specified indicator to highlight non matching brace instead of changing its style.
See Scintilla documentation for SCI_BRACEBADLIGHTINDICATOR
editor->braceMatch($pos);
Find the position of a matching brace or INVALID_POSITION if no match. $pos is the position of the known brace.
See Scintilla documentation for SCI_BRACEMATCH
editor->braceMatchNext($pos,$startPos);
Find the position of a matching brace or INVALID_POSITION if no match, starting the search at $startPos. $pos is the position of the known brace. $startPos is where to start looking (compared to c<braceMatch>, which starts one left or one right from $pos).
$startPos
See Scintilla documentation for SCI_BRACEMATCHNEXT
editor->setTabMinimumWidth($pixels); editor->getTabMinimumWidth();
Change the minimum size of a tab in pixels to ensure that the tab can be seen. The default value is 2. This is particularly useful with proportional fonts with fractional widths where the character before the tab may end a fraction of a pixel before a tab stop, causing the tab to only be a fraction of a pixel wide without this setting. Where displaying a miniaturized version of the document, setting this to 0 may make the miniaturized version lay out more like the normal size version.
See Scintilla documentation for SCI_SETTABMINIMUMWIDTH
See Scintilla documentation for SCI_GETTABMINIMUMWIDTH
editor->setTabWidth($tabWidth); editor->getTabWidth();
Change the visible size of a tab to be a multiple of the width of a space character.
See Scintilla documentation for SCI_SETTABWIDTH
See Scintilla documentation for SCI_GETTABWIDTH
editor->clearTabStops($line);
Clears explicit tab stops on the indicated $line.
$line
See Scintilla documentation for SCI_CLEARTABSTOPS
editor->addTabStop($line, $pixel);
Adds an explicit tab stop on the indicated $line at the indicated column $pixel.
$pixel
See Scintilla documentation for SCI_ADDTABSTOP
editor->getNextTabStop($line, $pixel);
Finds the next explicit tab stop on the indicated $line after the indicated column <$pixel>.
See Scintilla documentation for SCI_GETNEXTTABSTOP
editor->setUseTabs($useTabs); editor->getUseTabs();
Indentation will only use space characters if useTabs is false, otherwise it will use a combination of tabs and spaces.
See Scintilla documentation for SCI_SETUSETABS
See Scintilla documentation for SCI_GETUSETABS
editor->setIndent($indentSize); editor->getIndent();
Set the number of spaces used for one level of indentation.
See Scintilla documentation for SCI_SETINDENT
See Scintilla documentation for SCI_GETINDENT
editor->setTabIndents($tabIndents); editor->getTabIndents();
Sets whether a tab pressed when caret is within indentation indents.
See Scintilla documentation for SCI_SETTABINDENTS
See Scintilla documentation for SCI_GETTABINDENTS
editor->setBackSpaceUnIndents($bsUnIndents); editor->getBackSpaceUnIndents();
Sets whether a backspace pressed when caret is within indentation unindents.
See Scintilla documentation for SCI_SETBACKSPACEUNINDENTS
See Scintilla documentation for SCI_GETBACKSPACEUNINDENTS
editor->setLineIndentation($line, $indentSize); editor->getLineIndentation($line);
Change the indentation of a line to a number of columns.
See Scintilla documentation for SCI_SETLINEINDENTATION
See Scintilla documentation for SCI_GETLINEINDENTATION
editor->getLineIndentPosition($line);
Retrieve the position before the first non indentation character on a line.
See Scintilla documentation for SCI_GETLINEINDENTPOSITION
editor->setIndentationGuides($indentView); editor->getIndentationGuides();
Show or hide indentation guides.
Use $indentView from %SC_INDENTGUIDE
See Scintilla documentation for SCI_SETINDENTATIONGUIDES
See Scintilla documentation for SCI_GETINDENTATIONGUIDES
editor->setHighlightGuide($column); editor->getHighlightGuide();
Set the highlighted indentation guide column. 0 = no highlighted guide.
See Scintilla documentation for SCI_SETHIGHLIGHTGUIDE
See Scintilla documentation for SCI_GETHIGHLIGHTGUIDE
Scintilla allows for 32 markers, numbered 0 to $SC_MARGIN{MARKER_MAX}. Scintilla reserves marker numbers 25 to 31 for use in code-folding; these are the other keys defined in %SC_MARGIN. Numbers 0 to 24 are available for use, though Notepad++ or its plugins may be using some already. The $markerNumber listed in these methods should be in that range, or use one of the predefined values.
editor->markerDefine($markerNumber, $markerSymbol);
Set the symbol used for a particular marker number.
Use $markerSymbol from %SC_MARK.
See Scintilla documentation for SCI_MARKERDEFINE
editor->markerDefinePixmap($markerNumber, $pixmap);
Define a marker from a pixmap.
See Scintilla documentation for SCI_MARKERDEFINEPIXMAP
editor->rGBAImageSetWidth($width);
Set the width for future RGBA image data.
See Scintilla documentation for SCI_RGBAIMAGESETWIDTH
editor->rGBAImageSetHeight($height);
Set the height for future RGBA image data.
See Scintilla documentation for SCI_RGBAIMAGESETHEIGHT
editor->rGBAImageSetScale($scalePercent);
Set the scale factor in percent for future RGBA image data.
See Scintilla documentation for SCI_RGBAIMAGESETSCALE
editor->markerDefineRGBAImage($markerNumber, $pixels);
Define a marker from RGBA data. It has the width and height from RGBAImageSetWidth/Height
See Scintilla documentation for SCI_MARKERDEFINERGBAIMAGE
editor->markerSymbolDefined($markerNumber);
Which symbol was defined for markerNumber with MarkerDefine
See Scintilla documentation for SCI_MARKERSYMBOLDEFINED
editor->markerSetFore($markerNumber, $fore); editor->markerSetForeTranslucent($markerNumber, $forealpha); editor->markerSetBack($markerNumber, $back); editor->markerSetBackTranslucent($markerNumber, $backalpha); editor->markerSetBackSelected($markerNumber, $back); editor->markerSetBackSelectedTranslucent($markerNumber, $backalpha);
Set the foreground or background colour used for a particular marker number. The "translucent" versions accept colors with alpha (translucency). The "selected" versions set the background for the markers when the folding block is selected.
See Scintilla documentation for SCI_MARKERSETFORE
See Scintilla documentation for SCI_MARKERSETFORETRANSLUCENT
See Scintilla documentation for SCI_MARKERSETBACK
See Scintilla documentation for SCI_MARKERSETBACKTRANSLUCENT
See Scintilla documentation for SCI_MARKERSETBACKSELECTED
See Scintilla documentation for SCI_MARKERSETBACKSELECTEDTRANSLUCENT
The "translucent" versions of these commands require at least Scintilla v5.2, found in Notepad++ v8.4 and newer.
editor->markerSetStrokeWidth($markerNum, $hundredths);
This message sets the stroke width used to draw the marker in hundredths of a pixel. The default value is 100 indicating a single pixel wide line.
See Scintilla documentation for SCI_MARKERSETSTROKEWIDTH
editor->markerEnableHighlight($enabled);
Enable/disable highlight for current folding bloc (smallest one that contains the caret)
See Scintilla documentation for SCI_MARKERENABLEHIGHLIGHT
editor->markerSetLayer($markerNumber, $layer); $layer = editor->markerGetLayer($markerNum);
When markers are drawn in the content area, either because there is no margin for them or they are of SC_MARK_BACKGROUND or SC_MARK_UNDERLINE types, they may be drawn translucently over text or opaquely on the base layer. The layer to draw on is defined by SCI_MARKERSETLAYER. The degree of translucency can be chosen by setting an alpha value. This is only for the content area - in margins, translucency is achieved through the SCI_MARKERSET…TRANSLUCENT methods. The layer argument can be one of the %SC_LAYER values.
See Scintilla documentation for SCI_MARKERSETLAYER
See Scintilla documentation for SCI_MARKERGETLAYER
editor->markerSetAlpha($markerNumber, $alpha);
Set the alpha used for a marker that is drawn in the text area, not the margin.
See Scintilla documentation for SCI_MARKERSETALPHA
editor->markerAdd($line, $markerNumber);
Add a marker to a line, returning an ID which can be used to find or delete the marker.
See Scintilla documentation for SCI_MARKERADD
editor->markerAddSet($line, $set);
Add a set of markers to a line.
See Scintilla documentation for SCI_MARKERADDSET
editor->markerDelete($line, $markerNumber);
Delete a marker from a line.
See Scintilla documentation for SCI_MARKERDELETE
editor->markerDeleteAll($markerNumber);
Delete all markers with a particular number from all lines.
See Scintilla documentation for SCI_MARKERDELETEALL
editor->markerGet($line);
Get a bit mask of all the markers set on a line.
See Scintilla documentation for SCI_MARKERGET
editor->markerNext($lineStart, $markerMask);
Find the next line at or after lineStart that includes a marker in mask. Return -1 when no more lines.
See Scintilla documentation for SCI_MARKERNEXT
editor->markerPrevious($lineStart, $markerMask);
Find the previous line before lineStart that includes a marker in mask.
See Scintilla documentation for SCI_MARKERPREVIOUS
editor->markerLineFromHandle($handle);
Retrieve the line number at which a particular marker is located.
See Scintilla documentation for SCI_MARKERLINEFROMHANDLE
editor->markerDeleteHandle($handle);
Delete a marker.
See Scintilla documentation for SCI_MARKERDELETEHANDLE
editor->markerHandleFromLine($line, $which); editor->markerNumberFromLine($line, $which);
These return the Nth marker handle ($which) or marker number in a given line ($line). Handles are returned by markerAdd. If $which is greater or equal to the number of markers on a line, this returns -1.
$which
markerAdd
See Scintilla documentation for SCI_MARKERHANDLEFROMLINE
Indicators are used to display additional information over the top of styling. They can be used to show, for example, syntax errors, deprecated names and bad indentation by drawing underlines under text or boxes around text. See more at ScintillaDoc#Indicators.
editor->indicSetStyle($indic, $style); editor->indicGetStyle($indic);
Set an indicator to plain, squiggle or TT.
$style from %SC_INDICSTYLE
See Scintilla documentation for SCI_INDICSETSTYLE
See Scintilla documentation for SCI_INDICGETSTYLE
editor->indicSetFore($indic, $fore); editor->indicGetFore($indic);
Set the foreground colour of an indicator.
See Scintilla documentation for SCI_INDICSETFORE
See Scintilla documentation for SCI_INDICGETFORE
editor->indicSetStrokeWidth($indic, $hundredths); $hundredths = editor->indicGetStrokeWidth($indic);
These two commands set and get the stroke width used to draw an indicator in hundredths of a pixel. The default value is 100 indicating a width of one pixel. Some indicator styles do not support setting stroke width, generally where it makes no sense (INDIC_POINT) or wasn't simple (INDIC_SQUIGGLEPIXMAP). The indicators supporting stroke width are: INDIC_PLAIN, INDIC_SQUIGGLE, INDIC_TT, INDIC_DIAGONAL, INDIC_STRIKE, INDIC_BOX, INDIC_ROUNDBOX, INDIC_STRAIGHTBOX, INDIC_FULLBOX, INDIC_DASH, INDIC_DOTS, INDIC_SQUIGGLELOW.
Fractional pixel widths are possible such as 50 for half a pixel wide. On many systems a half pixel value will appear as a fainter line but it allows drawing very thin lines on systems with multiple physical pixels per logical pixel. Half (logical) pixel lines are available on macOS with 'retina' displays, see "scintillaSupportsFeature" in SCI_SUPPORTSFEATURE(SC_SUPPORTS_PIXEL_DIVISIONS).
See Scintilla documentation for SCI_INDICSETSTROKEWIDTH
See Scintilla documentation for SCI_INDICGETSTROKEWIDTH
editor->indicSetAlpha($indicator, $alpha); editor->indicGetAlpha($indicator);
Set the alpha fill colour of the given indicator.
See Scintilla documentation for SCI_INDICSETALPHA
See Scintilla documentation for SCI_INDICGETALPHA
editor->indicSetOutlineAlpha($indicator, $alpha); editor->indicGetOutlineAlpha($indicator);
Set the alpha outline colour of the given indicator.
See Scintilla documentation for SCI_INDICSETOUTLINEALPHA
See Scintilla documentation for SCI_INDICGETOUTLINEALPHA
editor->indicSetUnder($indic, $under); editor->indicGetUnder($indic);
Set an indicator to draw under text or over(default).
See Scintilla documentation for SCI_INDICSETUNDER
See Scintilla documentation for SCI_INDICGETUNDER
editor->indicSetHoverStyle($indicator, $indicatorStyle); editor->indicGetHoverStyle($indicator);
editor->indicSetHoverFore($indicator, $foreground); editor->indicGetHoverFore($indicator);
Used to set or get the style or foreground color used when the mouse cursor is hovering over a piece of text.
See Scintilla documentation for SCI_INDICSETHOVERSTYLE
See Scintilla documentation for SCI_INDICGETHOVERSTYLE See Scintilla documentation for SCI_INDICSETHOVERFORE
See Scintilla documentation for SCI_INDICGETHOVERFORE
editor->indicSetFlags($indicator, $flags); editor->indicGetFlags($indicator);
Sets or retrieves the flags for a particular indicator.
Use $flags from %SC_INDIC
See Scintilla documentation for SCI_INDICSETFLAGS
See Scintilla documentation for SCI_INDICGETFLAGS
editor->setIndicatorCurrent($indicator); editor->getIndicatorCurrent();
Set the indicator used for IndicatorFillRange and IndicatorClearRange
See Scintilla documentation for SCI_SETINDICATORCURRENT
See Scintilla documentation for SCI_GETINDICATORCURRENT
editor->setIndicatorValue($value); editor->getIndicatorValue();
Set the value used for IndicatorFillRange
Use $value as a 24-bit RGB color, ored with $SC_INDIC{SC_INDICVALUEBIT} from %SC_INDIC. To extract just the color from the getIndicatorValue() call, mask it with $SC_INDIC{SC_INDICVALUEMASK}.
$SC_INDIC{SC_INDICVALUEBIT}
getIndicatorValue()
$SC_INDIC{SC_INDICVALUEMASK}
See Scintilla documentation for SCI_SETINDICATORVALUE
See Scintilla documentation for SCI_GETINDICATORVALUE
editor->indicatorFillRange($position, $fillLength);
Turn a indicator on over a range.
See Scintilla documentation for SCI_INDICATORFILLRANGE
editor->indicatorClearRange($position, $clearLength);
Turn a indicator off over a range.
See Scintilla documentation for SCI_INDICATORCLEARRANGE
editor->indicatorAllOnFor($position);
Are any indicators present at position?
See Scintilla documentation for SCI_INDICATORALLONFOR
editor->indicatorValueAt($indicator, $position);
What value does a particular indicator have at at a position?
See Scintilla documentation for SCI_INDICATORVALUEAT
editor->indicatorStart($indicator, $position);
Where does a particular indicator start?
See Scintilla documentation for SCI_INDICATORSTART
editor->indicatorEnd($indicator, $position);
Where does a particular indicator end?
See Scintilla documentation for SCI_INDICATOREND
editor->findIndicatorShow($start, $end);
On OS X, show a find indicator.
See Scintilla documentation for SCI_FINDINDICATORSHOW
editor->findIndicatorFlash($start, $end);
On OS X, flash a find indicator, then fade out.
See Scintilla documentation for SCI_FINDINDICATORFLASH
editor->findIndicatorHide();
On OS X, hide the find indicator.
See Scintilla documentation for SCI_FINDINDICATORHIDE
editor->autoCShow($lenEntered, $itemList);
Display a auto-completion list. The lenEntered parameter indicates how many characters before the caret should be used to provide context.
See Scintilla documentation for SCI_AUTOCSHOW
editor->autoCCancel();
Remove the auto-completion list from the screen.
See Scintilla documentation for SCI_AUTOCCANCEL
editor->autoCActive();
Is there an auto-completion list visible?
See Scintilla documentation for SCI_AUTOCACTIVE
editor->autoCPosStart();
Retrieve the position of the caret when the auto-completion list was displayed.
See Scintilla documentation for SCI_AUTOCPOSSTART
editor->autoCComplete();
User has selected an item so remove the list and insert the selection.
See Scintilla documentation for SCI_AUTOCCOMPLETE
editor->autoCStops($characterSet);
Define a set of character that when typed cancel the auto-completion list.
See Scintilla documentation for SCI_AUTOCSTOPS
editor->autoCSetSeparator($separatorCharacter); editor->autoCGetSeparator();
Change the separator character in the string setting up an auto-completion list. Default is space but can be changed if items contain space.
See Scintilla documentation for SCI_AUTOCSETSEPARATOR
See Scintilla documentation for SCI_AUTOCGETSEPARATOR
editor->autoCSelect($text);
Select the item in the auto-completion list that starts with a string.
See Scintilla documentation for SCI_AUTOCSELECT
editor->autoCGetCurrent();
Get currently selected item position in the auto-completion list
See Scintilla documentation for SCI_AUTOCGETCURRENT
editor->autoCGetCurrentText();
Get currently selected item text in the auto-completion list Returns the length of the item text
See Scintilla documentation for SCI_AUTOCGETCURRENTTEXT
editor->autoCSetCancelAtStart($cancel); editor->autoCGetCancelAtStart();
Should the auto-completion list be cancelled if the user backspaces to a position before where the box was created.
See Scintilla documentation for SCI_AUTOCSETCANCELATSTART
See Scintilla documentation for SCI_AUTOCGETCANCELATSTART
editor->autoCSetFillUps($characterSet);
Define a set of characters that when typed will cause the autocompletion to choose the selected item.
See Scintilla documentation for SCI_AUTOCSETFILLUPS
editor->autoCSetChooseSingle($chooseSingle); editor->autoCGetChooseSingle();
Should a single item auto-completion list automatically choose the item.
See Scintilla documentation for SCI_AUTOCSETCHOOSESINGLE
See Scintilla documentation for SCI_AUTOCGETCHOOSESINGLE
editor->autoCSetIgnoreCase($ignoreCase); editor->autoCGetIgnoreCase();
Set whether case is significant when performing auto-completion searches.
See Scintilla documentation for SCI_AUTOCSETIGNORECASE
See Scintilla documentation for SCI_AUTOCGETIGNORECASE
editor->autoCSetCaseInsensitiveBehaviour($behaviour); editor->autoCGetCaseInsensitiveBehaviour();
Set auto-completion case insensitive behaviour to either prefer case-sensitive matches or have no preference.
Use $behavior from %SC_CASEINSENSITIVE
See Scintilla documentation for SCI_AUTOCSETCASEINSENSITIVEBEHAVIOUR
See Scintilla documentation for SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR
editor->autoCSetMulti($multi); editor->autoCGetMulti;
Determine whether the autocompletion goes into the first area of a multi-selection or into each area of the multi-selection.
Use $multi from %SC_MULTIAUTOC.
See Scintilla documentation for SCI_AUTOCSETMULTI
See Scintilla documentation for SCI_AUTOCGETMULTI
editor->autoCSetOrder($order); editor->autoCGetOrder();
Set the way autocompletion lists are ordered.
Use $order from %SC_AUTOC_ORDER.
See Scintilla documentation for SCI_AUTOCSETORDER
See Scintilla documentation for SCI_AUTOCGETORDER
editor->autoCSetAutoHide($autoHide); editor->autoCGetAutoHide();
Set whether or not autocompletion is hidden automatically when nothing matches.
See Scintilla documentation for SCI_AUTOCSETAUTOHIDE
See Scintilla documentation for SCI_AUTOCGETAUTOHIDE
editor->autoCSetDropRestOfWord($dropRestOfWord); editor->autoCGetDropRestOfWord();
Set whether or not autocompletion deletes any word characters after the inserted text upon completion.
See Scintilla documentation for SCI_AUTOCSETDROPRESTOFWORD
See Scintilla documentation for SCI_AUTOCGETDROPRESTOFWORD
editor->autoCSetOptions($opt); editor->autoCGetOptions();
Set or get options for autocompletion from the %SC_AUTOCOMPLETE hash values.
editor->registerImage($type, $xpmData);
Register an XPM image for use in autocompletion lists.
See Scintilla documentation for SCI_REGISTERIMAGE
editor->registerRGBAImage($type, $pixels);
Register an RGBA image for use in autocompletion lists. It has the width and height from RGBAImageSetWidth/Height
See Scintilla documentation for SCI_REGISTERRGBAIMAGE
editor->clearRegisteredImages();
Clear all the registered XPM images.
See Scintilla documentation for SCI_CLEARREGISTEREDIMAGES
editor->autoCSetTypeSeparator($separatorCharacter); editor->autoCGetTypeSeparator();
Retrieve the auto-completion list type-separator character.
See Scintilla documentation for SCI_AUTOCGETTYPESEPARATOR
See Scintilla documentation for SCI_AUTOCSETTYPESEPARATOR
editor->autoCSetMaxHeight($rowCount); editor->autoCGetMaxHeight();
Set the maximum height, in rows, of auto-completion and user lists. The default is 5 rows.
See Scintilla documentation for SCI_AUTOCSETMAXHEIGHT
See Scintilla documentation for SCI_AUTOCGETMAXHEIGHT
editor->autoCSetMaxWidth($characterCount); editor->autoCGetMaxWidth();
Set the maximum width, in characters, of auto-completion and user lists. Set to 0 to autosize to fit longest item, which is the default.
See Scintilla documentation for SCI_AUTOCSETMAXWIDTH
See Scintilla documentation for SCI_AUTOCGETMAXWIDTH
editor->userListShow($listType, $itemList);
Display a list of strings and send notification when user chooses one.
See Scintilla documentation for SCI_USERLISTSHOW
editor->callTipShow($pos, $definition);
Show a call tip containing a definition near position pos.
See Scintilla documentation for SCI_CALLTIPSHOW
editor->callTipCancel();
Remove the call tip from the screen.
See Scintilla documentation for SCI_CALLTIPCANCEL
editor->callTipActive();
Is there an active call tip?
See Scintilla documentation for SCI_CALLTIPACTIVE
editor->callTipPosStart();
Retrieve the position where the caret was before displaying the call tip.
See Scintilla documentation for SCI_CALLTIPPOSSTART
editor->callTipSetPosStart($posStart);
Set the start position in order to change when backspacing removes the calltip.
See Scintilla documentation for SCI_CALLTIPSETPOSSTART
editor->callTipSetHlt($start, $end);
Highlight a segment of the definition.
See Scintilla documentation for SCI_CALLTIPSETHLT
editor->callTipSetBack($back);
Set the background colour for the call tip.
See Scintilla documentation for SCI_CALLTIPSETBACK
editor->callTipSetFore($fore);
Set the foreground colour for the call tip.
See Scintilla documentation for SCI_CALLTIPSETFORE
editor->callTipSetForeHlt($fore);
Set the foreground colour for the highlighted part of the call tip.
See Scintilla documentation for SCI_CALLTIPSETFOREHLT
editor->callTipUseStyle($tabSize);
Enable use of STYLE_CALLTIP and set call tip tab size in pixels.
See Scintilla documentation for SCI_CALLTIPUSESTYLE
editor->callTipSetPosition($above);
Set position of calltip, above or below text.
See Scintilla documentation for SCI_CALLTIPSETPOSITION
editor->lineDown();
Move caret down one line.
See Scintilla documentation for SCI_LINEDOWN
editor->lineDownExtend();
Move caret down one line extending selection to new caret position.
See Scintilla documentation for SCI_LINEDOWNEXTEND
editor->lineUp();
Move caret up one line.
See Scintilla documentation for SCI_LINEUP
editor->lineUpExtend();
Move caret up one line extending selection to new caret position.
See Scintilla documentation for SCI_LINEUPEXTEND
editor->charLeft();
Move caret left one character.
See Scintilla documentation for SCI_CHARLEFT
editor->charLeftExtend();
Move caret left one character extending selection to new caret position.
See Scintilla documentation for SCI_CHARLEFTEXTEND
editor->charRight();
Move caret right one character.
See Scintilla documentation for SCI_CHARRIGHT
editor->charRightExtend();
Move caret right one character extending selection to new caret position.
See Scintilla documentation for SCI_CHARRIGHTEXTEND
editor->wordLeft();
Move caret left one word.
See Scintilla documentation for SCI_WORDLEFT
editor->wordLeftExtend();
Move caret left one word extending selection to new caret position.
See Scintilla documentation for SCI_WORDLEFTEXTEND
editor->wordRight();
Move caret right one word.
See Scintilla documentation for SCI_WORDRIGHT
editor->wordRightExtend();
Move caret right one word extending selection to new caret position.
See Scintilla documentation for SCI_WORDRIGHTEXTEND
editor->home();
Move caret to first position on line.
See Scintilla documentation for SCI_HOME
editor->homeExtend();
Move caret to first position on line extending selection to new caret position.
See Scintilla documentation for SCI_HOMEEXTEND
editor->lineEnd();
Move caret to last position on line.
See Scintilla documentation for SCI_LINEEND
editor->lineEndExtend();
Move caret to last position on line extending selection to new caret position.
See Scintilla documentation for SCI_LINEENDEXTEND
editor->documentStart();
Move caret to first position in document.
See Scintilla documentation for SCI_DOCUMENTSTART
editor->documentStartExtend();
Move caret to first position in document extending selection to new caret position.
See Scintilla documentation for SCI_DOCUMENTSTARTEXTEND
editor->documentEnd();
Move caret to last position in document.
See Scintilla documentation for SCI_DOCUMENTEND
editor->documentEndExtend();
Move caret to last position in document extending selection to new caret position.
See Scintilla documentation for SCI_DOCUMENTENDEXTEND
editor->pageUp();
Move caret one page up.
See Scintilla documentation for SCI_PAGEUP
editor->pageUpExtend();
Move caret one page up extending selection to new caret position.
See Scintilla documentation for SCI_PAGEUPEXTEND
editor->pageDown();
Move caret one page down.
See Scintilla documentation for SCI_PAGEDOWN
editor->pageDownExtend();
Move caret one page down extending selection to new caret position.
See Scintilla documentation for SCI_PAGEDOWNEXTEND
editor->editToggleOvertype();
Switch from insert to overtype mode or the reverse.
See Scintilla documentation for SCI_EDITTOGGLEOVERTYPE
editor->cancel();
Cancel any modes such as call tip or auto-completion list display.
See Scintilla documentation for SCI_CANCEL
editor->deleteBack();
Delete the selection or if no selection, the character before the caret.
See Scintilla documentation for SCI_DELETEBACK
editor->tab();
If selection is empty or all on one line replace the selection with a tab character. If more than one line selected, indent the lines.
See Scintilla documentation for SCI_TAB
editor->backTab();
Dedent the selected lines.
See Scintilla documentation for SCI_BACKTAB
editor->newLine();
Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
See Scintilla documentation for SCI_NEWLINE
editor->formFeed();
Insert a Form Feed character.
See Scintilla documentation for SCI_FORMFEED
editor->vCHome();
Move caret to before first visible character on line. If already there move to first character on line.
See Scintilla documentation for SCI_VCHOME
editor->vCHomeExtend();
Like VCHome but extending selection to new caret position.
See Scintilla documentation for SCI_VCHOMEEXTEND
editor->delWordLeft();
Delete the word to the left of the caret.
See Scintilla documentation for SCI_DELWORDLEFT
editor->delWordRight();
Delete the word to the right of the caret.
See Scintilla documentation for SCI_DELWORDRIGHT
editor->delWordRightEnd();
Delete the word to the right of the caret, but not the trailing non-word characters.
See Scintilla documentation for SCI_DELWORDRIGHTEND
editor->lineCut();
Cut the line containing the caret.
See Scintilla documentation for SCI_LINECUT
editor->lineDelete();
Delete the line containing the caret.
See Scintilla documentation for SCI_LINEDELETE
editor->lineTranspose();
Switch the current line with the previous.
See Scintilla documentation for SCI_LINETRANSPOSE
editor->lineReverse();
Reverse the current line.
See Scintilla documentation for SCI_LINEREVERSE
editor->lineDuplicate();
Duplicate the current line.
See Scintilla documentation for SCI_LINEDUPLICATE
editor->lowerCase();
Transform the selection to lower case.
See Scintilla documentation for SCI_LOWERCASE
editor->upperCase();
Transform the selection to upper case.
See Scintilla documentation for SCI_UPPERCASE
editor->lineScrollDown();
Scroll the document down, keeping the caret visible.
See Scintilla documentation for SCI_LINESCROLLDOWN
editor->lineScrollUp();
Scroll the document up, keeping the caret visible.
See Scintilla documentation for SCI_LINESCROLLUP
editor->deleteBackNotLine();
Delete the selection or if no selection, the character before the caret. Will not delete the character before at the start of a line.
See Scintilla documentation for SCI_DELETEBACKNOTLINE
editor->homeDisplay();
Move caret to first position on display line.
See Scintilla documentation for SCI_HOMEDISPLAY
editor->homeDisplayExtend();
Move caret to first position on display line extending selection to new caret position.
See Scintilla documentation for SCI_HOMEDISPLAYEXTEND
editor->lineEndDisplay();
Move caret to last position on display line.
See Scintilla documentation for SCI_LINEENDDISPLAY
editor->lineEndDisplayExtend();
Move caret to last position on display line extending selection to new caret position.
See Scintilla documentation for SCI_LINEENDDISPLAYEXTEND
editor->homeWrap();
These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)? except they behave differently when word-wrap is enabled: They go first to the start / end of the display line, like (Home|LineEnd)Display The difference is that, the cursor is already at the point, it goes on to the start or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?.
See Scintilla documentation for SCI_HOMEWRAP
editor->homeWrapExtend();
See Scintilla documentation for SCI_HOMEWRAPEXTEND
editor->lineEndWrap();
See Scintilla documentation for SCI_LINEENDWRAP
editor->lineEndWrapExtend();
See Scintilla documentation for SCI_LINEENDWRAPEXTEND
editor->vCHomeWrap();
See Scintilla documentation for SCI_VCHOMEWRAP
editor->vCHomeWrapExtend();
See Scintilla documentation for SCI_VCHOMEWRAPEXTEND
editor->lineCopy();
Copy the line containing the caret.
See Scintilla documentation for SCI_LINECOPY
editor->wordPartLeft();
Move to the previous change in capitalisation.
See Scintilla documentation for SCI_WORDPARTLEFT
editor->wordPartLeftExtend();
Move to the previous change in capitalisation extending selection to new caret position.
See Scintilla documentation for SCI_WORDPARTLEFTEXTEND
editor->wordPartRight();
Move to the change next in capitalisation.
See Scintilla documentation for SCI_WORDPARTRIGHT
editor->wordPartRightExtend();
Move to the next change in capitalisation extending selection to new caret position.
See Scintilla documentation for SCI_WORDPARTRIGHTEXTEND
editor->delLineLeft();
Delete back from the current position to the start of the line.
See Scintilla documentation for SCI_DELLINELEFT
editor->delLineRight();
Delete forwards from the current position to the end of the line.
See Scintilla documentation for SCI_DELLINERIGHT
editor->paraDown();
Move caret between paragraphs (delimited by empty lines).
See Scintilla documentation for SCI_PARADOWN
editor->paraDownExtend();
See Scintilla documentation for SCI_PARADOWNEXTEND
editor->paraUp();
See Scintilla documentation for SCI_PARAUP
editor->paraUpExtend();
See Scintilla documentation for SCI_PARAUPEXTEND
editor->lineDownRectExtend();
Move caret down one line, extending rectangular selection to new caret position.
See Scintilla documentation for SCI_LINEDOWNRECTEXTEND
editor->lineUpRectExtend();
Move caret up one line, extending rectangular selection to new caret position.
See Scintilla documentation for SCI_LINEUPRECTEXTEND
editor->charLeftRectExtend();
Move caret left one character, extending rectangular selection to new caret position.
See Scintilla documentation for SCI_CHARLEFTRECTEXTEND
editor->charRightRectExtend();
Move caret right one character, extending rectangular selection to new caret position.
See Scintilla documentation for SCI_CHARRIGHTRECTEXTEND
editor->homeRectExtend();
Move caret to first position on line, extending rectangular selection to new caret position.
See Scintilla documentation for SCI_HOMERECTEXTEND
editor->vCHomeRectExtend();
Move caret to before first visible character on line. If already there move to first character on line. In either case, extend rectangular selection to new caret position.
See Scintilla documentation for SCI_VCHOMERECTEXTEND
editor->lineEndRectExtend();
Move caret to last position on line, extending rectangular selection to new caret position.
See Scintilla documentation for SCI_LINEENDRECTEXTEND
editor->pageUpRectExtend();
Move caret one page up, extending rectangular selection to new caret position.
See Scintilla documentation for SCI_PAGEUPRECTEXTEND
editor->pageDownRectExtend();
Move caret one page down, extending rectangular selection to new caret position.
See Scintilla documentation for SCI_PAGEDOWNRECTEXTEND
editor->stutteredPageUp();
Move caret to top of page, or one page up if already at top of page.
See Scintilla documentation for SCI_STUTTEREDPAGEUP
editor->stutteredPageUpExtend();
Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
See Scintilla documentation for SCI_STUTTEREDPAGEUPEXTEND
editor->stutteredPageDown();
Move caret to bottom of page, or one page down if already at bottom of page.
See Scintilla documentation for SCI_STUTTEREDPAGEDOWN
editor->stutteredPageDownExtend();
Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
See Scintilla documentation for SCI_STUTTEREDPAGEDOWNEXTEND
editor->wordLeftEnd();
Move caret left one word, position cursor at end of word.
See Scintilla documentation for SCI_WORDLEFTEND
editor->wordLeftEndExtend();
Move caret left one word, position cursor at end of word, extending selection to new caret position.
See Scintilla documentation for SCI_WORDLEFTENDEXTEND
editor->wordRightEnd();
Move caret right one word, position cursor at end of word.
See Scintilla documentation for SCI_WORDRIGHTEND
editor->wordRightEndExtend();
Move caret right one word, position cursor at end of word, extending selection to new caret position.
See Scintilla documentation for SCI_WORDRIGHTENDEXTEND
editor->selectionDuplicate();
Duplicate the selection. If selection empty duplicate the line containing the caret.
See Scintilla documentation for SCI_SELECTIONDUPLICATE
editor->verticalCentreCaret();
Centre current line in window.
See Scintilla documentation for SCI_VERTICALCENTRECARET
editor->scrollToStart();
Scroll to start of document.
See Scintilla documentation for SCI_SCROLLTOSTART
editor->scrollToEnd();
Scroll to end of document.
See Scintilla documentation for SCI_SCROLLTOEND
editor->vCHomeDisplay();
Move caret to before first visible character on display line. If already there move to first character on display line.
See Scintilla documentation for SCI_VCHOMEDISPLAY
editor->vCHomeDisplayExtend();
Like VCHomeDisplay but extending selection to new caret position.
See Scintilla documentation for SCI_VCHOMEDISPLAYEXTEND
These methods affect keybindings (keyboard shortcuts), and all make use of the from %SC_KEY hash values.
For normal keys (letters, numbers, punctuation), the $km ("key+modifier") code is the codepoint for that character. For special keys (arrows, Escape, and similar), use the $SC_KEY{SCK_*} entry for that key. If you want to indicate a modified key, add on the $SC_KEY{SCK_*} shifted 16 bits up.
$SC_KEY{SCK_*}
# Ctrl+HOME being assigned to SCI_HOME my $km_ctrl_home = $SC_KEY{SCK_HOME} + ($SC_KEY{SCMOD_CTRL}<<16); notepad->assignCmdKey($km_alt_q, $SCIMSG{SCI_HOME}); # Alt+Q being assigned to SCI_SELECTALL my $km_alt_q = ord('Q') + ($SC_KEY{SCMOD_ALT}<<16); notepad->assignCmdKey($km_alt_q, $SCIMSG{SCI_SELECTALL});
editor->assignCmdKey($km, $msg);
When key+modifier combination km is pressed perform msg.
See Scintilla documentation for SCI_ASSIGNCMDKEY
editor->clearCmdKey($km);
When key+modifier combination km is pressed do nothing.
See Scintilla documentation for SCI_CLEARCMDKEY
editor->clearAllCmdKeys();
Drop all key mappings.
See Scintilla documentation for SCI_CLEARALLCMDKEYS
editor->null();
Null operation.
See Scintilla documentation for SCI_NULL
editor->usePopUp($allowPopUp);
Set whether a pop up menu is displayed automatically when the user presses the wrong mouse button.
Use $allowPopUp from %SC_POPUP.
See Scintilla documentation for SCI_USEPOPUP
editor->startRecord();
Start notifying the container of all key presses and commands.
See Scintilla documentation for SCI_STARTRECORD
editor->stopRecord();
Stop notifying the container of all key presses and commands.
See Scintilla documentation for SCI_STOPRECORD
NOT YET IMPLEMENTED
See Scintilla documentation for SCI_FORMATRANGE
See Scintilla documentation for SCI_FORMATRANGEFULL
editor->setPrintMagnification($magnification); editor->getPrintMagnification();
Sets the print magnification added to the point size of each style for printing.
See Scintilla documentation for SCI_SETPRINTMAGNIFICATION
See Scintilla documentation for SCI_GETPRINTMAGNIFICATION
editor->setPrintColourMode($mode); editor->getPrintColourMode();
Modify colours when printing for clearer printed text.
Use $mode from %SC_PRINTCOLOURMODE.
See Scintilla documentation for SCI_SETPRINTCOLOURMODE
See Scintilla documentation for SCI_GETPRINTCOLOURMODE
editor->setPrintWrapMode($mode); editor->getPrintWrapMode();
Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).
See Scintilla documentation for SCI_SETPRINTWRAPMODE
See Scintilla documentation for SCI_GETPRINTWRAPMODE
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); }
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.
editor->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.
The author of this module does not know how to use this "Direct access" function in pure Perl, but if you can figure it out, feel free to make a Pull Request with example usage. You could also presumably pass the pointer from this call into an Inline::C or XS function, and make use of it there.
See Scintilla documentation for SCI_GETDIRECTFUNCTION
editor->getDirectStatusFunction();
This is similar to getDirectFunction(), but the returned function is of type SciFnDirectStatus which also returns the status to the caller through a pointer to an int. This saves performing an extra call to retrieve the status in many situations so can be faster.
getDirectFunction()
editor->getDirectPointer();
Retrieve a pointer value to use as the first argument when calling the function returned by GetDirectFunction.
See Scintilla documentation for SCI_GETDIRECTPOINTER
editor->getCharacterPointer();
Gets a copy of the text of the document, without first allowing Scintilla to make its copy of it. In practice, that means it does exactly the same as editor->getText, however, if you have the possibility of the user interfering with the document _whilst_ getCharacterPointer() is running, then it’s safer to use getText(). On larger documents, getCharacterPointer() could be noticable quicker.
editor->getText
See Scintilla documentation for SCI_GETCHARACTERPOINTER
editor->getRangePointer($start, $lengthRange);
Provides direct access to the range requested.
See Scintilla documentation for SCI_GETRANGEPOINTER
editor->getGapPosition();
Return a position which, to avoid performance costs, should not be within the range of a call to GetRangePointer.
See Scintilla documentation for SCI_GETGAPPOSITION
editor->setDocPointer($pointer); editor->getDocPointer();
Retrieve a pointer to the document object.
See Scintilla documentation for SCI_GETDOCPOINTER
See Scintilla documentation for SCI_SETDOCPOINTER
editor->createDocument();
Create a new document object. Starts with reference count of 1 and not selected into editor.
Use $documentOptions from %SC_DOCUMENTOPTIONS.
See Scintilla documentation for SCI_CREATEDOCUMENT
editor->addRefDocument($doc);
Extend life of document.
See Scintilla documentation for SCI_ADDREFDOCUMENT
editor->releaseDocument($doc);
Release a reference to the document, deleting document if it fades to black.
See Scintilla documentation for SCI_RELEASEDOCUMENT
editor->getDocumentOptions;
Returns the options that were used to create the document.
See Scintilla documentation for SCI_GETDOCUMENTOPTIONS
editor->createLoader($bytes);
Create an ILoader*.
See Scintilla documentation for SCI_CREATELOADER
editor->visibleFromDocLine($line);
Find the display line of a document line taking hidden lines into account.
See Scintilla documentation for SCI_VISIBLEFROMDOCLINE
editor->docLineFromVisible($lineDisplay);
Find the document line of a display line taking hidden lines into account.
See Scintilla documentation for SCI_DOCLINEFROMVISIBLE
editor->showLines($lineStart, $lineEnd);
Make a range of lines visible.
See Scintilla documentation for SCI_SHOWLINES
editor->hideLines($lineStart, $lineEnd);
Make a range of lines invisible.
See Scintilla documentation for SCI_HIDELINES
editor->getLineVisible($line);
Is a line visible?
See Scintilla documentation for SCI_GETLINEVISIBLE
editor->getAllLinesVisible();
Are all lines visible?
See Scintilla documentation for SCI_GETALLLINESVISIBLE
editor->setFoldLevel($line, $level); editor->getFoldLevel($line);
Set the fold level of a line. This encodes an integer level along with flags indicating whether the line is a header and whether it is effectively white space.
Use $level as described in %SC_FOLDLEVEL.
See Scintilla documentation for SCI_SETFOLDLEVEL
See Scintilla documentation for SCI_GETFOLDLEVEL
editor->setAutomaticFold($automaticFold); editor->getAutomaticFold();
Set automatic folding behaviours.
Use $automaticFold from %SC_AUTOMATICFOLD
See Scintilla documentation for SCI_SETAUTOMATICFOLD
See Scintilla documentation for SCI_GETAUTOMATICFOLD
editor->setFoldFlags($flags);
Set some style options for folding.
Use $flags from %SC_FOLDFLAG
See Scintilla documentation for SCI_SETFOLDFLAGS
editor->getLastChild($line, $level);
Find the last child line of a header line.
See Scintilla documentation for SCI_GETLASTCHILD
editor->getFoldParent($line);
Find the parent line of a child line.
See Scintilla documentation for SCI_GETFOLDPARENT
editor->setFoldExpanded($line, $expanded); editor->getFoldExpanded($line);
Show the children of a header line.
See Scintilla documentation for SCI_SETFOLDEXPANDED
See Scintilla documentation for SCI_GETFOLDEXPANDED
editor->contractedFoldNext($lineStart);
Find the next line at or after lineStart that is a contracted fold header line. Return -1 when no more lines.
See Scintilla documentation for SCI_CONTRACTEDFOLDNEXT
editor->toggleFold($line);
Switch a header line between expanded and contracted.
See Scintilla documentation for SCI_TOGGLEFOLD
editor->toggleFoldShowText($line, $text);
Similar to "toggleFold", but also shows the $text tag to the right of the folded text.
See Scintilla documentation for SCI_TOGGLEFOLDSHOWTEXT
editor->foldDisplayTextSetStyle($style); editor->foldDisplayTextGetStyle;
Changes the appearance of fold text tags.
Use $style from %SC_FOLDDISPLAYTEXT.
See Scintilla documentation for SCI_FOLDDISPLAYTEXTSETSTYLE
See Scintilla documentation for SCI_FOLDDISPLAYTEXTGETSTYLE
editor->setDefaultFoldDisplayText; editor->getDefaultFoldDisplayText;
Set and get the default text displayed at the right of the folded text.
See Scintilla documentation for SCI_SETDEFAULTFOLDDISPLAYTEXT
See Scintilla documentation for SCI_GETDEFAULTFOLDDISPLAYTEXT
editor->foldLine($line, $action);
Expand or contract a fold header.
Use $action from %SC_FOLDACTION.
See Scintilla documentation for SCI_FOLDLINE
editor->foldChildren($line, $action);
Expand or contract a fold header and its children.
See Scintilla documentation for SCI_FOLDCHILDREN
editor->foldAll($action);
Expand or contract all fold headers.
See Scintilla documentation for SCI_FOLDALL
editor->expandChildren($line, $level);
Expand a fold header and all children. Use the level argument instead of the line’s current level.
See Scintilla documentation for SCI_EXPANDCHILDREN
editor->ensureVisible($line);
Ensure a particular line is visible by expanding any header line hiding it.
See Scintilla documentation for SCI_ENSUREVISIBLE
editor->ensureVisibleEnforcePolicy($line);
Ensure a particular line is visible by expanding any header line hiding it. Use the currently set visibility policy to determine which range to display.
See Scintilla documentation for SCI_ENSUREVISIBLEENFORCEPOLICY
editor->setWrapMode($mode); editor->getWrapMode();
Sets whether text is word wrapped.
Use $mode from %SC_WRAPMODE.
See Scintilla documentation for SCI_SETWRAPMODE
See Scintilla documentation for SCI_GETWRAPMODE
editor->setWrapVisualFlags($wrapVisualFlags); editor->getWrapVisualFlags();
Set the display mode of visual flags for wrapped lines.
Use $wrapVisualFlags from %SC_WRAPVISUALFLAG.
See Scintilla documentation for SCI_SETWRAPVISUALFLAGS
See Scintilla documentation for SCI_GETWRAPVISUALFLAGS
editor->setWrapVisualFlagsLocation($wrapVisualFlagsLocation); editor->getWrapVisualFlagsLocation();
Set the location of visual flags for wrapped lines.
Use $wrapVisualFlagsLocation from %SC_WRAPVISUALFLAGLOC.
See Scintilla documentation for SCI_SETWRAPVISUALFLAGSLOCATION
See Scintilla documentation for SCI_GETWRAPVISUALFLAGSLOCATION
editor->setWrapIndentMode($mode); editor->getWrapIndentMode();
Sets how wrapped sublines are placed. Default is fixed.
Use $mode from %SC_WRAPINDENT.
See Scintilla documentation for SCI_SETWRAPINDENTMODE
See Scintilla documentation for SCI_GETWRAPINDENTMODE
editor->setWrapStartIndent($indent); editor->getWrapStartIndent();
Set the start indent for wrapped lines.
See Scintilla documentation for SCI_SETWRAPSTARTINDENT
See Scintilla documentation for SCI_GETWRAPSTARTINDENT
editor->setLayoutCache($mode); editor->getLayoutCache();
Sets the degree of caching of layout information.
Use $mode from %SC_CACHE
See Scintilla documentation for SCI_SETLAYOUTCACHE
See Scintilla documentation for SCI_GETLAYOUTCACHE
editor->setPositionCache($size); editor->getPositionCache();
Set number of entries in position cache
See Scintilla documentation for SCI_SETPOSITIONCACHE
See Scintilla documentation for SCI_GETPOSITIONCACHE
if(editor->scintillaSupportsFeature($SC_SUPPORTS{SC_SUPPORTS_THREAD_SAFE_MEASURE_WIDTHS})) { editor->setLayoutThreads($size); editor->getLayoutThreads(); }
The time taken to measure text runs on wide lines or when wrapping can be improved by performing the task concurrently on multiple threads when scintillaSupportsFeature($SC_SUPPORTS{SC_SUPPORTS_THREAD_SAFE_MEASURE_WIDTHS}) is available. This can be a dramatic improvement - a 4 core processor is often able to reduce text layout time to just over one quarter of the single-threaded time.
The default is to use just the main thread but applications may call setLayoutThreads to specify the maximum number of threads to use. The number of threads is limited to the hardware concurrency of the system - for a 4 core processor with hyper-threading that would be 8. If an application just wants maximum concurrency then call with a large number SCI_SETLAYOUTTHREADS(1000) and that will be reduced to a reasonable value.
setLayoutThreads
SCI_SETLAYOUTTHREADS(1000)
See Scintilla documentation for SCI_SETLAYOUTTHREADS
See Scintilla documentation for SCI_GETLAYOUTTHREADS
editor->linesSplit($pixelWidth);
Split the lines in the target into lines that are less wide than pixelWidth where possible.
See Scintilla documentation for SCI_LINESSPLIT
editor->linesJoin();
Join the lines in the target.
See Scintilla documentation for SCI_LINESJOIN
editor->wrapCount($line);
The number of display lines needed to wrap a document line
See Scintilla documentation for SCI_WRAPCOUNT
editor->zoomIn();
Magnify the displayed text by increasing the sizes by 1 point.
See Scintilla documentation for SCI_ZOOMIN
editor->zoomOut();
Make the displayed text smaller by decreasing the sizes by 1 point.
See Scintilla documentation for SCI_ZOOMOUT
editor->setZoom($zoom); editor->getZoom();
Set the zoom level. This number of points is added to the size of all fonts. It may be positive to magnify or negative to reduce.
See Scintilla documentation for SCI_SETZOOM
See Scintilla documentation for SCI_GETZOOM
editor->setEdgeMode($mode); editor->getEdgeMode();
Retrieve the edge highlight mode.
$mode from %SC_EDGEMODE.
See Scintilla documentation for SCI_GETEDGEMODE
See Scintilla documentation for SCI_SETEDGEMODE
editor->setEdgeColumn($column); editor->getEdgeColumn();
Retrieve the column number which text should be kept within.
See Scintilla documentation for SCI_GETEDGECOLUMN
See Scintilla documentation for SCI_SETEDGECOLUMN
editor->setEdgeColour($edgeColour); editor->getEdgeColour();
Retrieve the colour used in edge indication.
See Scintilla documentation for SCI_GETEDGECOLOUR
See Scintilla documentation for SCI_SETEDGECOLOUR
editor->multiEdgeAddLine($column, $edgeColor);
editor->multiEdgeClearAll;
multiEdgeAddLine adds a new vertical edge to the view. The edge will be displayed at the given column number. The resulting edge position depends on the metric of a space character in STYLE_DEFAULT.
multiEdgeAddLine
All the edges can be cleared with multiEdgeClearAll.
multiEdgeClearAll
See Scintilla documentation for SCI_MULTIEDGEADDLINE
See Scintilla documentation for SCI_MULTIEDGECLEARALL
editor->getMultiEdgeColumn($which);
Grab the Nth edge using getMultiEdgeColumn and the zero-based index $which.
getMultiEdgeColumn
See Scintilla documentation for SCI_GETMULTIEDGECOLUMN
Requires at least Scintilla v4.4.6, found in Notepad++ v7.9.4 and newer.
editor->setAccessibility($accessibility); editor->getAccessibility;
These methods may enable or disable accessibility and report its current status. The system caret is manipulated to help screen readers when enabled.
Use $accessibility from %SC_ACCESSIBILITY.
See Scintilla documentation for SCI_SETACCESSIBILITY
See Scintilla documentation for SCI_GETACCESSIBILITY
editor->setLexer($lexer); editor->getLexer();
Set or retrieve the lexing language of the document, as an integer ID.
(The setLexer method may be eliminated from the underlying Scintilla library in favor of the ILexer5-based setILexer.)
setLexer
See Scintilla documentation for SCI_SETLEXER
See Scintilla documentation for SCI_GETLEXER
Deprecated in Notepad++ v8.4 with Scintilla 5.2.x.
editor->setILexer($pointer);
Set the lexer as an ILexer5. The lexer may be implemented by an application or a shared library such as Lexilla.
To test if your lexer assignment worked, use getLexer before and after setting the new lexer to see if the lexer number changed.
See Scintilla documentation for more on Lexer Objects and the new ILexer5.
See Scintilla documentation for SCI_SETILEXER
editor->setLexerLanguage($language); editor->getLexerLanguage();
Set the lexing language of the document based on string name.
See Scintilla documentation for SCI_SETLEXERLANGUAGE
See Scintilla documentation for SCI_GETLEXERLANGUAGE
editor->loadLexerLibrary($path);
Load a lexer library (dll / so).
See Scintilla documentation for SCI_LOADLEXERLIBRARY
Deprecated with Notepad++ v8.4 & Scintilla 5.2.x.
editor->colourise($start, $end);
Colourise a segment of the document using the current lexing language.
See Scintilla documentation for SCI_COLOURISE
editor->changeLexerState($start, $end);
Indicate that the internal state of a lexer has changed over a range and therefore there may be a need to redraw.
See Scintilla documentation for SCI_CHANGELEXERSTATE
editor->propertyNames();
Retrieve a ‘\n’ separated list of properties understood by the current lexer.
See Scintilla documentation for SCI_PROPERTYNAMES
editor->propertyType($name);
Retrieve the type of a property (boolean, integer, or string). Returns one of the values in %SC_TYPE.
See Scintilla documentation for SCI_PROPERTYTYPE
editor->describeProperty();
Describe a property
See Scintilla documentation for SCI_DESCRIBEPROPERTY
editor->setProperty($key, $value); editor->getProperty($key);
Set up a value that may be used by a lexer for some optional feature.
See Scintilla documentation for SCI_SETPROPERTY
See Scintilla documentation for SCI_GETPROPERTY
editor->getPropertyExpanded($key);
Retrieve a “property” value previously set with SetProperty, with “$()” variable replacement on returned buffer.
See Scintilla documentation for SCI_GETPROPERTYEXPANDED
editor->getPropertyInt($key);
Retrieve a “property” value previously set with SetProperty, interpreted as an int AFTER any “$()” variable replacement.
See Scintilla documentation for SCI_GETPROPERTYINT
editor->describeKeyWordSets();
Retrieve a ‘\n’ separated list of descriptions of the keyword sets understood by the current lexer.
See Scintilla documentation for SCI_DESCRIBEKEYWORDSETS
editor->setKeyWords($keywordSet, $keyWords);
Set up the key words used by the lexer.
$keywordSet is an index from 0 to $KEYWORDSET{KEYWORDSET_MAX}, indicating which group of keywords is being defined.
See Scintilla documentation for SCI_SETKEYWORDS
editor->getSubStyleBases();
Get the set of base styles that can be extended with sub styles
See Scintilla documentation for SCI_GETSUBSTYLEBASES
editor->distanceToSecondaryStyles();
Where styles are duplicated by a feature such as active/inactive code return the distance between the two types.
See Scintilla documentation for SCI_DISTANCETOSECONDARYSTYLES
editor->allocateSubStyles($styleBase, $numberStyles);
Allocate a set of sub styles for a particular base style, returning start of range
See Scintilla documentation for SCI_ALLOCATESUBSTYLES
editor->freeSubStyles();
Free allocated sub styles
See Scintilla documentation for SCI_FREESUBSTYLES
editor->getSubStylesStart($styleBase);
The starting style number for the sub styles associated with a base style
See Scintilla documentation for SCI_GETSUBSTYLESSTART
editor->getSubStylesLength($styleBase);
The number of sub styles associated with a base style
See Scintilla documentation for SCI_GETSUBSTYLESLENGTH
editor->getStyleFromSubStyle($subStyle);
For a sub style, return the base style, else return the argument.
See Scintilla documentation for SCI_GETSTYLEFROMSUBSTYLE
editor->getPrimaryStyleFromStyle($style);
For a secondary style, return the primary style, else return the argument.
See Scintilla documentation for SCI_GETPRIMARYSTYLEFROMSTYLE
editor->setIdentifiers($style, $identifiers);
Set the identifiers that are shown in a particular style
See Scintilla documentation for SCI_SETIDENTIFIERS
editor->privateLexerCall($operation, $pointer);
For private communication between an application and a known lexer.
See Scintilla documentation for SCI_PRIVATELEXERCALL
editor->getNamedStyles;
Retrieve the number of named styles for the lexer.
See Scintilla documentation for SCI_GETNAMEDSTYLES
editor->nameOfStyle($style);
Retrieve the name of a style. The name will look like a constant, such as "SCE_C_COMMENTDOC"
See Scintilla documentation for SCI_NAMEOFSTYLE
editor->tagsOfStyle($style);
Retrieve the tags of a style. This is a space-separated set of words like "comment documentation".
See Scintilla documentation for SCI_TAGSOFSTYLE
editor->descriptionOfStyle($style);
Retrieve an English-language description of a style which may be suitable for display in a user interface. This looks like "Doc comment: block comments beginning with /** or /*!".
See Scintilla documentation for SCI_DESCRIPTIONOFSTYLE
editor->setModEventMask($mask); editor->getModEventMask();
Set which document modification events are sent to the container.
Use $mask as a bitwise-or of values from %SC_MOD.
See Scintilla documentation for SCI_SETMODEVENTMASK
See Scintilla documentation for SCI_GETMODEVENTMASK
editor->setCommandEvents($commandEvents); editor->getCommandEvents;
These messages set and get whether SCEN_* command events are sent to the container. $commandEvents needs to be set to 1 to to send the events, or 0 to disable sending.
$commandEvents
See Scintilla documentation for SCI_SETCOMMANDEVENTS
See Scintilla documentation for SCI_GETCOMMANDEVENTS
editor->setMouseDwellTime($periodMilliseconds); editor->getMouseDwellTime();
Sets the time the mouse must sit still to generate a mouse dwell event, in milliseconds (so a value of 1000 would set a dwell time of 1 second).
Use $periodMilliseconds of $SC_TIMEOUT{SC_TIME_FOREVER} to generate no dwell events.
See Scintilla documentation for SCI_SETMOUSEDWELLTIME
See Scintilla documentation for SCI_GETMOUSEDWELLTIME
editor->setIdentifier($identifier); editor->getIdentifier();
Set the identifier reported as idFrom in notification messages.
See Scintilla documentation for SCI_SETIDENTIFIER
See Scintilla documentation for SCI_GETIDENTIFIER
For any messages not implemented in the API, if you know the appropriate $msgid, and what are needed as $wparam and $lparam, you can send the message to the Notepad GUI directly.
If you have developed a wrapper for a missing message, feel free to send in a Pull Request, or open an issue, including your wrapper code.
my $coderef = sub { my ($contents, $lineNumber, $totalLines)=@_; ... }; editor->forEachLine( $coderef );
The $coderef can be an anonymous subroutine (as shown above) or use \&namedFunc to run a named function.
$coderef
\&namedFunc
This helper will run the code found at $coderef, once per line in the editor's document. The function gets passed three arguments: the contents of the line (including any newline sequence), the line number (starts at 0), and the total number of lines.
If the function returns a number, that number is added to the current line number to determine the next line number; if it returns an undef, it will use the default increment of 1 (effectively, $lineNumber += $retval//1)). The function should return a zero to indicate that it should stay on the same line (which is useful if the function deleted a line)
$lineNumber += $retval//1)
For example,
sub testContents { my ($contents, $lineNumber, $totalLines) = @_; chomp($contents); if($contents eq 'rubbish') { editor->deleteLine($lineNumber); return 0; # stay on same line, because it's deleted } elsif($contents eq 'something old') { editor->replaceLine($lineNumber, "something new"); # replaceLine not yet implemented } elsif($contents eq 'little something') { editor->replaceLine($lineNumber, "BIG\r\nSOMETHING"); # replaceLine not yet implemented return 2; # replaced single with two lines, so need to go the extra line } # could return 1 here, but undef works as well; # note in perl, you _could_ just exit without returning, as in the PythonScript example, # but in perl, that would return the last statement value, which isn't what you want return; } editor->forEachLine(\&testContents);
editor->deleteLine($lineNumber);
Deletes the given (zero indexed) line number.
editor->replaceLine($lineNumber, $newContents);
Replaces the given (zero indexed) line number (excluding newline sequence) with the given contents
editor->replaceWholeLine($lineNumber, $newContents);
Replaces the given (zero indexed) line number (including newline sequence) with the given contents: thus, if $newContents does not end with a newline, then it will be on the same line as what was originally line $lineNumber+1.
$lineNumber+1
TODO: need to figure out how to implement the search/replace helper methods described in PythonScript API, as much as is possible.
Until such time as they are implemented, it is recommended you just use the already-existing "Searching" methods; or, if that's not sufficient, use getText() and setText() to pass the whole file into and out of Perl, and use the power of Perl for your text manipulations.
getText()
setText()
editor->search(...);
editor->research(...);
editor->replace(...);
editor->rereplace(...);
editor->flash(); # 50ms (default) editor->flash($sec); # flashes for $sec seconds editor->flash($sec, $force); # force a time that's longer than 1sec if $sec>=1 and $force is true
Flashes the active editor file by inverting the colors of the active file for a time (in seconds) of $sec (or 50ms if no argument passed); after that time has elapsed, it will go back to the normal coloring.
$sec
Please notice that $sec is in seconds, so 50ms would be written as $sec = 0.050;, not $sec = 50;.
$sec = 0.050;
$sec = 50;
If you supply a $sec of 1 or greater, the flash() method will warn you that there will be a long delay, unless you also set $force to a true value.
flash()
$force
editor->getEOLString();
Returns the actual string for the EOL symbol (either \r\n, \r, or \n). This is derived from "getEOLMode", which just returns the mode number.
\r\n
\r
\n
editor->getFileEndPosition();
Returns the position after the final character in the file.
This is similar to getLineCount(), but returns a position rather than a line number.
getLineCount()
This is similar to getLineEndPosition($line), but returns the position of the last line rather than the specified line.
getLineEndPosition($line)
This is similar to getLength(), but in multi-byte encodings, they may or may not be different numbers.
getLength()
my ($startLine, $endLine) = @{ editor->getUserLineSelection() }; my ($startByte, $endByte) = @{ editor->getUserCharSelection() };
Get either the line numbers or byte numbers for the start and end of the currently-active selection (0 indicates the start of the document). If nothing is selected, it will return the start and end positions (lines or bytes) values for the whole file.
These are useful if you want your script to be able to run over a number of lines or characters: if your user selects nothing, the whole file will be processed; if the user selects text, then the actions in your script can be limited to just the active selection.
editor->getWord($position, $useOnlyWordChars); editor->getWord($position); editor->getWord(undef, $useOnlyWordChars); editor->getWord(); editor->getCurrentWord();
Uses wordStartPosition, wordEndPosition, and getTextRange to grab the value of the word at the given $position.
wordStartPosition
wordEndPosition
getTextRange
If $position is not given or undef, the current caret position is used.
$position
$useOnlyWordChars is a boolean which determines whether to use Scintilla's default definition of "words" (see Scintilla "Words" documentation) or not. If it is not given or undef, it will default to a true value.
$useOnlyWordChars
The getCurrentWord method is an alias for getWord() with no arguments (so using the current word and the default "word" definition).
getCurrentWord
getWord()
editor->setTarget($start, $end); # HELPER: alias for setTargetRange
For compatibility reasons, setTarget() is an alias for setTargetRange()
setTarget()
setTargetRange()
editor->write($text); # HELPER: alias for addText
For compatibility reasons, write() is an alias for addText()
write()
addText()
The primary interface is through the "SCINTILLA EDITOR API", implemented through object methods.
However, there are some hash variables that are useful for use with the API. These can be exported individually, or using the :vars or :all tags.
:vars
:all
Exports the variables in Win32::Mechanize::NotepadPlusPlus::Editor::Messages. See that sub-module for details on all the variables available.
It's usually used via Win32::Mechanize::NotepadPlusPlus's :vars tag, which exports the variables in Win32::Mechanize::NotepadPlusPlus::Notepad::Messages and in Win32::Mechanize::NotepadPlusPlus::Editor::Messages:
use Win32::Mechanize::NotepadPlusPlus ':vars';
Exports everything that can be exported.
Installed as part of Win32::Mechanize::NotepadPlusPlus
Peter C. Jones <petercj AT cpan DOT org>
<petercj AT cpan DOT org>
Please report any bugs or feature requests emailing <bug-Win32-Mechanize-NotepadPlusPlus AT rt.cpan.org> or thru the web interface at http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Win32-Mechanize-NotepadPlusPlus, or thru the repository's interface at https://github.com/pryrt/Win32-Mechanize-NotepadPlusPlus/issues.
<bug-Win32-Mechanize-NotepadPlusPlus AT rt.cpan.org>
Copyright (C) 2019,2020,2021 Peter C. Jones
This program is free software; you can redistribute it and/or modify it under the terms of either: the GNU General Public License as published by the Free Software Foundation; or the Artistic License. See http://dev.perl.org/licenses/ for more information.
To install Win32::Mechanize::NotepadPlusPlus, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Win32::Mechanize::NotepadPlusPlus
CPAN shell
perl -MCPAN -e shell install Win32::Mechanize::NotepadPlusPlus
For more information on module installation, please visit the detailed CPAN module installation guide.