Navigation

  • index
  • next |
  • PythonScript v0.7.0.0 documentation »

Welcome to PythonScript’s documentation!

Contents:

  • Plugin Installation and Usage
    • Installation
    • Usage
    • Startup
  • Introduction
  • Objects
  • Npp Module
  • Handling Notifications
    • Overview
    • A simple example
    • Cancelling Callbacks
    • The Callback smallprint
  • Python Primer
    • Introduction
    • Basics
    • If Statements
    • Functions
    • Strings
    • Further Information
  • Notepad++ Object
  • Editor Object
    • Scintilla Methods
    • Helper Methods
  • Console Object
  • Enums
    • FORMATTYPE
    • BUFFERENCODING
    • STATUSBARSECTION
    • NOTIFICATION
    • MESSAGEBOXFLAGS
    • MENUCOMMAND
    • CARETPOLICY
    • CASEVISIBLE
    • FOLDFLAG
    • CARETSTYLE
    • STATUS
    • WRAPVISUALLOCATION
    • KEYS
    • KEYMOD
    • ANNOTATIONVISIBLE
    • CHARACTERSET
    • PRINTOPTION
    • MARKERSYMBOL
    • INDICATORSTYLE
    • WRAPVISUALFLAG
    • LEXER
    • CURSORSHAPE
    • MARGINTYPE
    • FINDOPTION
    • VIRTUALSPACE
    • EDGEVISUALSTYLE
    • WHITESPACE
    • MARKEROUTLINE
    • FOLDLEVEL
    • WRAPINDENTMODE
    • LINECACHE
    • MULTIPASTE
    • STYLESCOMMON
    • INDENTVIEW
    • WRAP
    • SELECTIONMODE
    • FONTQUALITY
    • ENDOFLINE
  • Interface for Other Plugins

Indices and tables

  • Index
  • Search Page

Navigation

  • index
  • next |
  • PythonScript v0.7.0.0 documentation »
© Copyright 2010, Dave Brotherstone. Created using Sphinx 1.0.


  • next |
  • previous |
  • PythonScript v0.7.0.0 documentation »

Plugin Installation and Usage

Installation

Installation is very simple, either through Plugin Manager, or manually. The zip or 7zip archive contains the the files in the correct layout - just copy to your Notepad++ directory (e.g. c:Program FilesNotepad++)

The file layout is as follows:

Notepad++            (your main Notepad++ directory, probably under "C:\Program Files")
 +
 |-- python26.dll     (this is important. This needs to go in the main program directory of Notepad++, next to notepad++.exe)
 |                    (unless you have a Python installation already, in which case it's probably in C:\windows already)
 +-- plugins
           \
           |-- PythonScript.dll
           |
           |-- PythonScript
           |   \
           |   |-- lib
           |   |    \
           |   |     |-- (*.py)   lots of *.py files and subdirectories
           |   |
           |   |-- scripts
           |             \
           |             |-- (machine-level scripts)
           |
           |
           |-- doc
           |    \
           |     |-- PythonScript
           |             \
           |             |-- PythonScript.chm         (optional, if it's not there context-sensitive help will use the web)
           |
           |
           |
           |
           |
           |-- Config     (this config directory can also be in %APPDATA%\Notepad++\plugins\config\)
                         |
                         \-- PythonScript
                                         \
                                         |-- scripts
                                                   \
                                                   |-- (user level scripts go here)

Usage

To use Python Script, you’ll first need to create a script. Click New Script from the Python Script menu in the Plugins menu. This creates a new user script (in your config directory). When you’ve typed your script out, you can run it from the Scripts submenu.

The `Scripts` submenu is automatically updated whenever you save a script, so if you copy a file into the scripts directory manually, you’ll need to make a change (a dummy new line or comment etc) and save a script (any will do) in Notepad++ for it to update.

To edit the script, just hold Ctrl down and click the script in the Scripts menu.

If you click Configuration, you can assign the script either to a toolbar icon, or to the Python Script menu itself. If you assign a script to the menu, then it will appear immediately, but you will not be able to assign a shortcut to it until next time Notepad++ starts.

If you assign it to a toolbar icon, then it will only appear on the next start of Notepad++.

Context-Sensitive help is available - if your cursor is on and notepad, editor or console function, the Context-Help menu will take you straight to the documentation for that function. If the CHM file is not in the relevant location, it will open the documentation from the web.

Startup

The script called startup.py (in either the “machine” directory or “user” directory - see Installation) is run when Python Script starts up. Normally, that is the first time a script is called. The default startup.py script does some small things like directing the error output to the console, and importing some commonly used modules.

If you want to register an callback (see Handling Notifications) to run from when Notepad++ starts up, you need to change the startup type to ATSTARTUP, instead of LAZY. You can do this in the Configuration dialog.

Navigation

  • index
  • next |
  • previous |


  • next |
  • previous |
  • PythonScript v0.7.0.0 documentation »

Introduction

Python Script enables you to script every conceivable action you can perform in Notepad++. If you want to run a macro 1000 times, do 15 different search and replaces in one go, then save the file under a different name, it’s all possible, and, most importantly, easy.

Don’t worry if you’ve not seen, or never even heard of Python, it’s incredibly easy to learn, and the beauty of it is that for the majority of scripts, you hardly need to know any Python at all.

To whet your appetite, here’s a quick (complete) sample script that shows some of the power of Python Script.:

1
2
3
4
5
editor.replace("old", "new")
editor.pyreplace(r"^Code: ([A-Z]{4,8})", r"The code is \1")

notepad.runMenuCommand("TextFX Tools", "Delete Blank Lines")
notepad.save()

Line 1 performs a normal search and replace on the current document, replacing the word “old” with the word “new”.

Line 2 also performs a search and replace, but uses Python regular expressions, which is a much more complete implementation of regular expressions than is natively supported in Notepad++.

Line 4 runs the menu command called “Delete Blank Lines” from the TextFX Tools menu.

Line 5 saves the current document (equivalent to clicking File, Save).

Objects

There are 3 special objects you can use for manipulating Notepad++, and the text.

notepad is the object for everything to do with Notepad++ itself, not the text in the document. Things like opening and saving files, selecting different tabs, converting formats, running plugin commands and so on.

editor is the object for everything to do with the text. It’s actually a fairly complete wrapper for the Scintilla component, the edit component that Notepad++ uses for the text area. This object has many functions, as Scintilla has many options and features that you can use - not all of them are natively supported in Notepad++, so you can actually customise it and do even more with Python Script than you can in Notepad++ alone. There’s also a healthy set of helper functions to assist in common functions (e.g. searching and replacing including Python’s regular expressions and some useful functions for doing things common in scripts, like getting the start and end line numbers of the selection). The helper functions just wrap up a series of Scintilla or Notepad++ commands, so they’re just there to make life easier.

editor1 always refers to the “first” Scintilla window, normally on the left or the top.

editor2 always refers to the “second” Scintilla window, normally on the right or the bottom.

You normally only need to use editor1 and editor2 if you’re doing something special with multiple views, or you’re applying a setting, for instance in the startup.py script.

console is the object for manipulating the console window. It’s fairly simple, in that there’s not much you can do - show it, clear it and write a message in it. However, there’s also a run command, which runs a command line and diverts the output to the console. So, you can use Python Script to call your compiler, or run any other command line tool.

Npp Module

This section is really for the Pythoneers, but, for those of us that are just starting out, here’s what you need to know.

The Npp module contains all the objects and classes that Python Script defines for manipulating Notepad++ (notepad, editor and console). The notepad object is an instance of class Notepad, editor an instance of class Editor and console an instance of class Console.

The startup.py script performs the following:

from Npp import *

which effectively says that everything that’s in Npp module, is now available locally. So we can just use editor.getText() instead of Npp.editor.getText().

If you create a new module (i.e. a new file), and want to use the functions defined in that module in a script (using import``_), then you will need to either ``import Npp or from Npp import * at the top of your module to use the editor, notepad and so on objects.

As the startup script runs in the same namespace as the scripts (__main__), you don’t need to import the Npp module in the scripts.

Handling Notifications

Overview

You can call a Python function when events occur in Notepad++ or Scintilla. Events in Notepad++ are things like the active document changing, a file being opened or saved etc. Events in Scintilla are things like a character being added, a save point being reached, the document being made dirty and so on.

Basically, you register in a script a Python function to call when an event occurs, and thereafter the function always runs whenever that event occurs. One function can be registered to handle more than one event.

You can unregister the callback later, either by using the name of the function, or the event names, or a combination.

A simple example

Let’s register a callback for the FILESAVING event - the occurs just before the file is saved, and we’ll add a “saved on” log entry to the end of the file, if the filename ends in ‘.log’.:

1
2
3
4
5
6
7
import datetime

def addSaveStamp(args):
        if notepad.getCurrentFilename()[-4:] == '.log':
                editor.appendText("File saved on %s\r\n" % datetime.date.today())

notepad.callback(addSaveStamp, [NOTIFICATION.FILEBEFORESAVE])

Line 1 imports the datetime module so we can get today’s date.

Line 3 defines a function called addSaveStamp.

Line 4 checks that the extension of the file is ‘.log’.

Line 5 appends text like "File saved on 2009-07-15" to the file.

Line 7 registers the callback function for the FILESAVING event. Notice the square brackets around the NOTIFICATION.FILESAVING. This is a list, and can contain more than one item (so that the function is called when any of the events are triggered).

Really, we should improve this function a little. Currently, it assumes the file being saved is the active document - in the case of using “Save All”, it isn’t necessarily. However, it’s easy to fix...

The args parameter to the function is a map (similar a dictionary in C# or a hashmap in Java), that contains the arguments for the event - many events are signalled for a BufferID, which is the Notepad++ internal number for a particular file or tab. We can do things with the bufferID like get the filename, switch to it to make it active and so on.

So, first we’ll change it so that we check the filename of the bufferID being saved, rather than the active document. Then, if the filename has a ‘.log’ extension, we’ll change to it and add our “File saved on .....” line.:

1
2
3
4
5
6
7
8
import datetime

def addSaveStamp(args):
        if notepad.getBufferFilename(args["bufferID"])[-4:] == '.log':
                notepad.activateBufferID(args["bufferID"])
                editor.appendText("File saved on %s\r\n" % datetime.date.today())

notepad.callback(addSaveStamp, [NOTIFICATION.FILEBEFORESAVE])

Great, now it works properly. There’s a side effect though, if we do use save-all, we might change the active document, which might seem a bit strange when we use it. Again, very easy to fix.:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import datetime

def addSaveStamp(args):
        if notepad.getBufferFilename(args["bufferID"])[-4:] == '.log':
                currentBufferID = notepad.getCurrentBufferID()
                notepad.activateBufferID(args["bufferID"])
                editor.appendText("File saved on %s\r\n" % datetime.date.today())
                notepad.activateBufferID(currentBufferID)

notepad.callback(addSaveStamp, [NOTIFICATION.FILEBEFORESAVE])

Now everything works as should, and it’s nice and easy to see what’s going on, and we leave the user with the same document they had open if they use Save-All.

See the NOTIFICATION enum for more details on what arguments are provided for each notification, and the different events that are available.

Cancelling Callbacks

You may wish to cancel a callback - perhaps you’ve finished editing log files, and want to run a script to disable the callback.

The simplest form is:

notepad.clearCallbacks()

This unregisters all callbacks for all events. If you want to just clear one or more events, just pass the list of NOTIFICATION events you wish to clear.:

notepad.clearCallbacks([NOTIFICATION.FILESAVING, NOTIFICATION.FILESAVED])

Note that if you want to clear the callback for just one event, you still need to pass a list (i.e. surrounded with square brackets)

To unregister a callback for a particular function, just pass the function.:

notepad.clearCallbacks(addSaveStamp)

To unregister a callback for a particular function, for particular events (perhaps you want to keep the function registered for FILESAVING, but don’t want FILESAVED anymore)

notepad.clearCallbacks(addSaveStamp, [NOTIFICATION.FILESAVED])

Note that redefining the function (in this case ``addSaveStamp``) will mean that this method no longer works, as the function name is now a new object.

The Callback smallprint

Due to the nature of Scintilla events, they are processed internally slightly differently to Notepad++ events. Notepad++ events are always processed sychronously, i.e. your event handler finishes before Python Script lets Notepad++ continue. Scintilla events are placed in a queue, and your event handlers process the queue (this happens automatically, you don’t need to do anything different) - the only difference is that if you have a lot of callbacks registered, you might receive the event some time after it has actually occurred. In normal circumstances the time delay is so small it doesn’t matter, but you may need to be aware of it if you’re doing something time-sensitive.

If this causes anyone a problem, please let me know, and I’ll certainly see what I can do - but no promises!

Navigation

  • index
  • next |


  • next |
  • previous |
  • PythonScript v0.7.0.0 documentation »

Python Primer

Introduction

This is a little introduction to Python. It is not meant to teach you Python, just give you enough syntax to write scripts for Notepad++.

Basics

The key, is indentation. That separates out the blocks of code. Some people initially don’t like this approach, thinking it might be unclear or easy to get wrong - I did. Now I think it’s just great :)

There are no semi-colons (;) at the end of lines like in C or Java.

You can define a variable simply by using it.:

x = 5

To call a function, just type the name, followed by brackets, with any arguments in brackets.:

x = 5
console.write(x)

If Statements

An if statement doesn’t need brackets around the test, just a colon (:) at the end of the line. The colon signifies the start of a new block. The next line must be indented more than the if line.

The if block continues until the indentation reverts to the same indentation as the if line.:

1
2
3
4
5
6
console.write("Let's go")

if x == 3:
        console.write("So x is 3 then")
        console.write("This line is also run if x is 3")
console.write("this line is run always")

To use an else, place the else at the same level as the if, and append a colon:

1
2
3
4
5
6
7
8
if x == 3:
        console.write("So x is 3 then")
        console.write("This line is also run if x is 3")
else:
        console.write("Guess x isn't 3 this time.")
        console.write("Better luck next time")

console.write("this line is run always")

If you want an “else if”, use elif:

1
2
3
4
5
6
7
8
if x == 3:
        console.write("So x is 3 then")
        console.write("This line is also run if x is 3")
elif x == 6:
        console.write("Hey it's your lucky day, x is 6")
else:
        console.write("x is not 3 or 6 this time.")
        console.write("Better luck next time")

Functions

To define a function, just use def. Again, the indentation is important, the function definition lasts as long as the indentation stays the same:

1
2
3
4
5
def printNameAge(name, age):
        console.write("Hello {0}, ".format(name))
        console.write("how was your {0} birthday?".format(age))

printNameAge("Dave", 99)

Line 1 defines the function, the body of the function is lines 2 and 3. Line 5 calls the function with the arguments “Dave” and 99.

You can read about the format() function (and what the {0} in the string means) in Python‘s documentation.

To pass the function to another function (as in callbacks in Python Script), just use the name of the function without brackets:

def printNameAge(name, age):
        console.write("Hello {0}, ".format(name))
        console.write("how was your {0} birthday?".format(age))

def callFunc(func)
        console.write("Calling function...\n")
        func("Dave", 99)

callFunc(printNameAge)

Line 11 calls the callFunc function, passing the printNameAge function to it. The callFunc function then calls printNameAge on line 8.

Strings

Strings use double or single quotes. There’s no difference, but that helps if you want to include one type or other in the string.:

someString = "this is a string with a ' single quote inside"
someOther  = 'this is a string with a " double quote inside'

If you need both, just use \ to escape them:

someString = "here's a string with both types of \" in it"

If you need to use \ itself, just include two:

someString = "here's a demo of using a \\ backslash"

You can also use raw strings. These don’t need the \\ to mean \, which can make certain strings (particularly regular expressions) easier to understand. However, you also can’t escape a quote. To make a raw string, just put an r before the string

someString = r”this is also a string using a backslash”

Further Information

This guide may be extended in the future, if people request it, and either I get time, or somebody puts some time into it. There are many good sources of information on the Internet, I’ve included a few here.

<http://www.python.org>


  • next |
  • previous |
  • PythonScript v0.7.0.0 documentation »

Notepad++ Object

class Notepad
Notepad.activateBufferID(bufferID)

Activates the given bufferID:

bufferID = notepad.getCurrentBufferID()
...
notepad.activateBufferID(bufferID)
Notepad.activateFile(filename)

Activates the document with the given filename

Notepad.activateIndex(view, index)

Activates the document with the given view and index. view is 0 or 1.

Notepad.callback(function, notifications)

Registers a callback function for a notification. notifications is a list of messages to call the function for.:

def my_callback(args):
        console.write("Buffer Activated %d\n" % args["bufferID"]

notepad.callback(my_callback, [NOTIFICATION.BUFFERACTIVATED])

The NOTIFICATION enum corresponds to the NPPN_* plugin notifications. The function arguments is a map, and the contents vary dependant on the notification.

Note that the callback will live on past the life of the script, so you can use this to perform operations whenever a document is opened, saved, changed etc.

Also note that it is good practice to put the function in another module (file), and then import that module in the script that calls notepad.callback(). This way you can unregister the callback easily.

For Scintilla notifications, see editor.callback()

Returns:
True if the registration was successful
Notepad.clearCallbacks()

Unregisters all callbacks

Notepad.clearCallbacks(function)

Unregisters all callbacks for the given function. Note that this uses the actual function object, so if the function has been redefined since it was registered, this will fail. If this has happened, use one of the other clearCallbacks() functions.

Notepad.clearCallbacks(eventsList)

Unregisters all callbacks for the given list of events.:

notepad.clearCallbacks([NOTIFICATION.BUFFERACTIVATED, NOTIFICATION.FILESAVED])

See NOTIFICATION

Notepad.clearCallbacks(function, eventsList)

Unregisters the callback for the given callback function for the list of events.

Notepad.close()

Closes the currently active document

Notepad.closeAll()

Closes all open documents

Notepad.closeAllButCurrent()

Closes all but the currently active document

Notepad.createScintilla()

Create a new Scintilla handle. Returns an Editor object

Notepad.destroyScintilla(editor)

Destroy a Scintilla handle created with createScintilla

Notepad.getCommandLine()

Gets the command line used to start Notepad++

Notepad.getCurrentBufferID()

Gets the bufferID of the currently active buffer

Notepad.getCurrentDocIndex(view)

Gets the current active index for the given view (0 or 1)

Notepad.getCurrentFilename()

Gets the filename of the active document

Notepad.getCurrentLang()

Get the current language type

Returns:
LANGTYPE
Notepad.getCurrentView()

Get the currently active view (0 or 1)

Notepad.getEncoding([bufferID]) → BUFFERENCODING

Gets the encoding of the given bufferID. If no bufferID is given, then the encoding of the currently active buffer is returned.

Returns:
BUFFERENCODING
Notepad.getFiles()

Gets a list of the open filenames.

Returns:
A list of tuples containing (filename, bufferID, index, view)
Notepad.getFormatType([bufferID]) → FORMATTYPE

Gets the format type (i.e. Windows, Unix or Mac) of the given bufferID. If no bufferID is given, then the format of the currently active buffer is returned.

Returns:
FORMATTYPE
Notepad.getLangType([bufferID]) → LANGTYPE

Gets the language type of the given bufferID. If no bufferID is given, then the language of the currently active buffer is returned.

Returns:
LANGTYPE
Notepad.getNppDir() → str

Gets the directory Notepad++ is running in (i.e. the location of notepad++.exe)

Notepad.getPluginConfigDir() → str

Gets the plugin config directory.

Notepad.getPluginMenuHandle() → int

Gets the handle for the Plugins menu.

Notepad.getVersion() → tuple

Gets the Notepad++ version as a tuple - e.g. 5.6.8 becomes (5,6,8)

Notepad.hideTabBar()

Hides the Tab bar

Notepad.menuCommand(menuCommand)

Runs a Notepad++ menu command. Use the MENUCOMMAND enum, or integers directly from the nativeLang.xml file.

Notepad.messageBox(message[, title[, flags]]) → MessageBoxFlags

Displays a message box with the given message and title.

Flags can be 0 for a standard ‘OK’ message box, or a combination of MESSAGEBOXFLAGS. title is “Python Script for Notepad++” by default, and flags is 0 by default.

Returns:
A RESULTxxxx member of MESSAGEBOXFLAGS as to which button was pressed.
Notepad.new()

Create a new document.

Notepad.open(filename)

Opens the given file.

Notepad.prompt(prompt, title[, defaultText]) → str

Prompts the user for some text. Optionally provide the default text to initialise the entry field.

Returns:

The string entered.

None if cancel was pressed (note that is different to an empty string, which means that no input was given)
Notepad.reloadBuffer(bufferID)

Reloads the given bufferID

Notepad.reloadCurrentDocument()

Reloads the current document

Notepad.reloadFile(filename)

Reloads a filename.

Notepad.runMenuCommand(menuName, menuOption[, refreshCache]) → bool

Runs a command from the menus. For built-in menus use notepad.menuCommand(), for non built-in menus (e.g. TextFX and macros you’ve defined), use notepad.runMenuCommand(menuName, menuOption). For other plugin commands (in the plugin menu), use Notepad.runPluginCommand(pluginName, menuOption)_

Menus are searched for the text, and when found, the internal ID of the menu command is cached. When runMenuCommand is called, the cache is first checked if it holds the internal ID for the given menuName and menuOption. If it does, it simply uses the value from the cache. If the ID could have been updated (for example, you’re calling the name of macro that has been removed and added again), set refreshCache to True. This is False by default.

Returns:
True if the menu command was found, otherwise False

e.g.:

notepad.runMenuCommand('TextFX Edit', 'Delete Blank Lines')
Notepad.runPluginCommand(pluginName, menuOption[, refreshCache])

Runs a command from the plugin menu. Use to run direct commands from the Plugins menu. To call TextFX or other menu functions, either use notepad.menuCommand(menuCommand)_ (for Notepad++ menu commands), or notepad.runMenuCommand(menuName, menuOption)_ for TextFX or non standard menus (such as macro names).

Note that menuOption can be a submenu in a plugin’s menu. So:

notepad.runPluginCommand('Python Script', 'demo script')

Could run a script called “demo script” from the Scripts submenu of Python Script.

Menus are searched for the text, and when found, the internal ID of the menu command is cached. When runPluginCommand is called, the cache is first checked if it holds the internal ID for the given menuName and menuOption. If it does, it simply uses the value from the cache. If the ID could have been updated (for example, you’re calling the name of macro that has been removed and added again), set refreshCache to True. This is False by default.

e.g.::
notepad.runPluginCommand(‘XML Tools’, ‘Pretty Print (XML only)’)
Notepad.save()

Save the current file

Notepad.saveAllFiles()

Saves all currently unsaved files

Notepad.saveAs(filename)

Save the current file as the specified filename

Only works in Notepad++ 5.7 onwards

Notepad.saveAsCopy(filename)

Save the current file as the specified filename, but don’t change the filename for the buffer in Notepad++

Only works in Notepad++ 5.7 onwards

Notepad.saveCurrentSession(filename)

Save the current session (list of open files) to a file.

Notepad.saveSession(filename, filesList)

Saves a session file with the list of filenames.

Notepad.setCurrentLang(langType)

Set the language type of the currently active buffer (see LANGTYPE)

Notepad.setFormatType(formatType[, bufferID])

Sets the format type (i.e. Windows, Unix or Mac) of the specified buffer ID. If not bufferID is passed, then the format type of the currently active buffer is set.

Notepad.setLangType(langType[, bufferID])

Sets the language type of the given bufferID. If not bufferID is given, sets the language for the currently active buffer.

Notepad.setStatusBar(statusBarSection, text)

Sets the status bar text. For statusBarSection, use one of the STATUSBARSECTION constants.

Notepad.showTabBar()

Shows the Tab bar


  • next |
  • previous |
  • PythonScript v0.7.0.0 documentation »

Editor Object

The Editor class, with the instance name of Npp.editor (or normally simply editor) represents the Scintilla component of Notepad++. Scintilla is the “edit” component, the place where text is entered and altered. Scintilla is well documented, and Python Script allows you to call any of the Scintilla functions in a Pythonised way.

Npp.editor (or editor) always refers to the active document. To switch to another document (or open a new one, etc), use the notepad object.

The arguments to the functions are therefore slightly different to the original Scintilla arguments, effectively simplified by Python.

For example:

SCI_ADDTEXT has the arguments:

SCI_ADDTEXT(int length, const char *text)

In Python, that just becomes:

editor.addText(text)

Likewise, return parameters are converted to return values. So SCI_GETTEXT has the arguments:

SCI_GETTEXT(int length, char *text)

In Python, that becomes:

text = editor.getText()

The comments for each function have been taken directly from Scintilla, so occassionally you may see reference to a parameter that doesn’t exist. I’m sure you’ll cope :)

Colours are a tuple of (red, green, blue) where each of red, green, and blue is between 0 and 255.

There are some Helper Methods discussed at the end, that perform some common functions with Scintilla. For instance, searching and replacing, regular expressions, replacing and deleting lines and so on.

Scintilla Methods

class Editor
Editor.addText(text) → int

Add text to the document at current position.

See Scintilla documentation for SCI_ADDTEXT

Editor.addStyledText(c) → int

Add array of cells to document.

See Scintilla documentation for SCI_ADDSTYLEDTEXT

Editor.insertText(pos, text)

Insert string at a position.

See Scintilla documentation for SCI_INSERTTEXT

Editor.clearAll()

Delete all text in the document.

See Scintilla documentation for SCI_CLEARALL

Editor.clearDocumentStyle()

Set all style bytes to 0, remove all folding information.

See Scintilla documentation for SCI_CLEARDOCUMENTSTYLE

Editor.getLength() → int

Returns the number of bytes in the document.

See Scintilla documentation for SCI_GETLENGTH

Editor.getCharAt(pos) → int

Returns the character byte at the position.

See Scintilla documentation for SCI_GETCHARAT

Editor.getCurrentPos() → int

Returns the position of the caret.

See Scintilla documentation for SCI_GETCURRENTPOS

Editor.getAnchor() → int

Returns the position of the opposite end of the selection to the caret.

See Scintilla documentation for SCI_GETANCHOR

Editor.getStyleAt(pos) → int

Returns the style byte at the position.

See Scintilla documentation for SCI_GETSTYLEAT

Editor.redo()

Redoes the next action on the undo history.

See Scintilla documentation for SCI_REDO

Editor.setUndoCollection(collectUndo)

Choose between collecting actions into the undo history and discarding them.

See Scintilla documentation for SCI_SETUNDOCOLLECTION

Editor.selectAll()

Select all the text in the document.

See Scintilla documentation for SCI_SELECTALL

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.getStyledText(start, end) → tuple

Retrieve a buffer of cells. Returns the number of bytes in the buffer not including terminating NULs.

See Scintilla documentation for SCI_GETSTYLEDTEXT

Editor.canRedo() → bool

Are there any redoable actions in the undo history?

See Scintilla documentation for SCI_CANREDO

Editor.markerLineFromHandle(handle) → int

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.getUndoCollection() → bool

Is undo history being collected?

See Scintilla documentation for SCI_GETUNDOCOLLECTION

Editor.getViewWS() → int

Are white space characters currently visible? Returns one of SCWS_* constants.

See Scintilla documentation for SCI_GETVIEWWS

Editor.setViewWS(viewWS)

Make white space characters invisible, always visible or visible outside indentation.

See Scintilla documentation for SCI_SETVIEWWS

Editor.positionFromPoint(x, y) → int

Find the position from a point within the window.

See Scintilla documentation for SCI_POSITIONFROMPOINT

Editor.positionFromPointClose(x, y) → int

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.gotoLine(line)

Set caret to start of a line and ensure it is visible.

See Scintilla documentation for SCI_GOTOLINE

Editor.gotoPos(pos)

Set caret to a position and ensure it is visible.

See Scintilla documentation for SCI_GOTOPOS

Editor.setAnchor(posAnchor)

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

Editor.getCurLine() → str

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.getEndStyled() → int

Retrieve the position of the last correctly styled character.

See Scintilla documentation for SCI_GETENDSTYLED

Editor.convertEOLs(eolMode)

Convert all line endings in the document to one mode.

See Scintilla documentation for SCI_CONVERTEOLS

Editor.getEOLMode() → int

Retrieve the current end of line mode - one of CRLF, CR, or LF.

See Scintilla documentation for SCI_GETEOLMODE

Editor.setEOLMode(eolMode)

Set the current end of line mode.

See Scintilla documentation for SCI_SETEOLMODE

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.getBufferedDraw() → bool

Is drawing done first into a buffer or direct to the screen?

See Scintilla documentation for SCI_GETBUFFEREDDRAW

Editor.setBufferedDraw(buffered)

If drawing is buffered then each line of text is drawn into a bitmap buffer before drawing it to the screen to avoid flicker.

See Scintilla documentation for SCI_SETBUFFEREDDRAW

Editor.setTabWidth(tabWidth)

Change the visible size of a tab to be a multiple of the width of a space character.

See Scintilla documentation for SCI_SETTABWIDTH

Editor.getTabWidth() → int

Retrieve the visible size of a tab.

See Scintilla documentation for SCI_GETTABWIDTH

Editor.setCodePage(codePage)

Set the code page used to interpret the bytes of the document as characters. The SC_CP_UTF8 value can be used to enter Unicode mode.

See Scintilla documentation for SCI_SETCODEPAGE

Editor.setUsePalette(usePalette)

In palette mode, Scintilla uses the environment’s palette calls to display more colours. This may lead to ugly displays.

See Scintilla documentation for SCI_SETUSEPALETTE

Editor.markerDefine(markerNumber, markerSymbol)

Set the symbol used for a particular marker number.

See Scintilla documentation for SCI_MARKERDEFINE

Editor.markerSetFore(markerNumber, fore)

Set the foreground colour used for a particular marker number.

See Scintilla documentation for SCI_MARKERSETFORE

Editor.markerSetBack(markerNumber, back)

Set the background colour used for a particular marker number.

See Scintilla documentation for SCI_MARKERSETBACK

Editor.markerAdd(line, markerNumber) → int

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.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) → int

Get a bit mask of all the markers set on a line.

See Scintilla documentation for SCI_MARKERGET

Editor.markerNext(lineStart, markerMask) → int

Find the next line after lineStart that includes a marker in mask.

See Scintilla documentation for SCI_MARKERNEXT

Editor.markerPrevious(lineStart, markerMask) → int

Find the previous line before lineStart that includes a marker in mask.

See Scintilla documentation for SCI_MARKERPREVIOUS

Editor.markerDefinePixmap(markerNumber, pixmap)

Define a marker from a pixmap.

See Scintilla documentation for SCI_MARKERDEFINEPIXMAP

Editor.markerAddSet(line, set)

Add a set of markers to a line.

See Scintilla documentation for SCI_MARKERADDSET

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.setMarginTypeN(margin, marginType)

Set a margin to be either numeric or symbolic.

See Scintilla documentation for SCI_SETMARGINTYPEN

Editor.getMarginTypeN(margin) → int

Retrieve the type of a margin.

See Scintilla documentation for SCI_GETMARGINTYPEN

Editor.setMarginWidthN(margin, pixelWidth)

Set the width of a margin to a width expressed in pixels.

See Scintilla documentation for SCI_SETMARGINWIDTHN

Editor.getMarginWidthN(margin) → int

Retrieve the width of a margin in pixels.

See Scintilla documentation for SCI_GETMARGINWIDTHN

Editor.setMarginMaskN(margin, mask)

Set a mask that determines which markers are displayed in a margin.

See Scintilla documentation for SCI_SETMARGINMASKN

Editor.getMarginMaskN(margin) → int

Retrieve the marker mask of a margin.

See Scintilla documentation for SCI_GETMARGINMASKN

Editor.setMarginSensitiveN(margin, sensitive)

Make a margin sensitive or insensitive to mouse clicks.

See Scintilla documentation for SCI_SETMARGINSENSITIVEN

Editor.getMarginSensitiveN(margin) → bool

Retrieve the mouse click sensitivity of a margin.

See Scintilla documentation for SCI_GETMARGINSENSITIVEN

Editor.styleClearAll()

Clear all the styles and make equivalent to the global default style.

See Scintilla documentation for SCI_STYLECLEARALL

Editor.styleSetFore(style, fore)

Set the foreground colour of a style.

See Scintilla documentation for SCI_STYLESETFORE

Editor.styleSetBack(style, back)

Set the background colour of a style.

See Scintilla documentation for SCI_STYLESETBACK

Editor.styleSetBold(style, bold)

Set a style to be bold or not.

See Scintilla documentation for SCI_STYLESETBOLD

Editor.styleSetItalic(style, italic)

Set a style to be italic or not.

See Scintilla documentation for SCI_STYLESETITALIC

Editor.styleSetSize(style, sizePoints)

Set the size of characters of a style.

See Scintilla documentation for SCI_STYLESETSIZE

Editor.styleSetFont(style, fontName)

Set the font of a style.

See Scintilla documentation for SCI_STYLESETFONT

Editor.styleSetEOLFilled(style, filled)

Set a style to have its end of line filled or not.

See Scintilla documentation for SCI_STYLESETEOLFILLED

Editor.styleResetDefault()

Reset the default style to its state at startup

See Scintilla documentation for SCI_STYLERESETDEFAULT

Editor.styleSetUnderline(style, underline)

Set a style to be underlined or not.

See Scintilla documentation for SCI_STYLESETUNDERLINE

Editor.styleGetFore(style) → tuple

Get the foreground colour of a style.

See Scintilla documentation for SCI_STYLEGETFORE

Editor.styleGetBack(style) → tuple

Get the background colour of a style.

See Scintilla documentation for SCI_STYLEGETBACK

Editor.styleGetBold(style) → bool

Get is a style bold or not.

See Scintilla documentation for SCI_STYLEGETBOLD

Editor.styleGetItalic(style) → bool

Get is a style italic or not.

See Scintilla documentation for SCI_STYLEGETITALIC

Editor.styleGetSize(style) → int

Get the size of characters of a style.

See Scintilla documentation for SCI_STYLEGETSIZE

Editor.styleGetFont() → str

Get the font of a style. Returns the length of the fontName

See Scintilla documentation for SCI_STYLEGETFONT

Editor.styleGetEOLFilled(style) → bool

Get is a style to have its end of line filled or not.

See Scintilla documentation for SCI_STYLEGETEOLFILLED

Editor.styleGetUnderline(style) → bool

Get is a style underlined or not.

See Scintilla documentation for SCI_STYLEGETUNDERLINE

Editor.styleGetCase(style) → int

Get is a style mixed case, or to force upper or lower case.

See Scintilla documentation for SCI_STYLEGETCASE

Editor.styleGetCharacterSet(style) → int

Get the character get of the font in a style.

See Scintilla documentation for SCI_STYLEGETCHARACTERSET

Editor.styleGetVisible(style) → bool

Get is a style visible or not.

See Scintilla documentation for SCI_STYLEGETVISIBLE

Editor.styleGetChangeable(style) → bool

Get is a style changeable or not (read only). Experimental feature, currently buggy.

See Scintilla documentation for SCI_STYLEGETCHANGEABLE

Editor.styleGetHotSpot(style) → bool

Get is a style a hotspot or not.

See Scintilla documentation for SCI_STYLEGETHOTSPOT

Editor.styleSetCase(style, caseForce)

Set a style to be mixed case, or to force upper or lower case.

See Scintilla documentation for SCI_STYLESETCASE

Editor.styleSetCharacterSet(style, characterSet)

Set the character set of the font in a style.

See Scintilla documentation for SCI_STYLESETCHARACTERSET

Editor.styleSetHotSpot(style, hotspot)

Set a style to be a hotspot or not.

See Scintilla documentation for SCI_STYLESETHOTSPOT

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.getSelAlpha() → int

Get the alpha of the selection.

See Scintilla documentation for SCI_GETSELALPHA

Editor.setSelAlpha(alpha)

Set the alpha of the selection.

See Scintilla documentation for SCI_SETSELALPHA

Editor.getSelEOLFilled() → bool

Is the selection end of line filled?

See Scintilla documentation for SCI_GETSELEOLFILLED

Editor.setSelEOLFilled(filled)

Set the selection to have its end of line filled or not.

See Scintilla documentation for SCI_SETSELEOLFILLED

Editor.setCaretFore(fore)

Set the foreground colour of the caret.

See Scintilla documentation for SCI_SETCARETFORE

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.setStylingEx(styles) → int

Set the styles for a segment of the document.

See Scintilla documentation for SCI_SETSTYLINGEX

Editor.styleSetVisible(style, visible)

Set a style to be visible or not.

See Scintilla documentation for SCI_STYLESETVISIBLE

Editor.getCaretPeriod() → int

Get the time in milliseconds that the caret is on and off.

See Scintilla documentation for SCI_GETCARETPERIOD

Editor.setCaretPeriod(periodMilliseconds)

Get the time in milliseconds that the caret is on and off. 0 = steady on.

See Scintilla documentation for SCI_SETCARETPERIOD

Editor.setWordChars(characters)

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

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.indicSetStyle(indic, style)

Set an indicator to plain, squiggle or TT.

See Scintilla documentation for SCI_INDICSETSTYLE

Editor.indicGetStyle(indic) → int

Retrieve the style of an indicator.

See Scintilla documentation for SCI_INDICGETSTYLE

Editor.indicSetFore(indic, fore)

Set the foreground colour of an indicator.

See Scintilla documentation for SCI_INDICSETFORE

Editor.indicGetFore(indic) → tuple

Retrieve the foreground colour of an indicator.

See Scintilla documentation for SCI_INDICGETFORE

Editor.indicSetUnder(indic, under)

Set an indicator to draw under text or over(default).

See Scintilla documentation for SCI_INDICSETUNDER

Editor.indicGetUnder(indic) → bool

Retrieve whether indicator drawn under or over text.

See Scintilla documentation for SCI_INDICGETUNDER

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)

Set the size of the dots used to mark space characters.

See Scintilla documentation for SCI_SETWHITESPACESIZE

Editor.getWhitespaceSize() → int

Get the size of the dots used to mark space characters.

See Scintilla documentation for SCI_GETWHITESPACESIZE

Editor.setStyleBits(bits)

Divide each styling byte into lexical class bits (default: 5) and indicator bits (default: 3). If a lexer requires more than 32 lexical states, then this is used to expand the possible states.

See Scintilla documentation for SCI_SETSTYLEBITS

Editor.getStyleBits() → int

Retrieve number of bits in style bytes used to hold the lexical state.

See Scintilla documentation for SCI_GETSTYLEBITS

Editor.setLineState(line, state)

Used to hold extra styling information for each line.

See Scintilla documentation for SCI_SETLINESTATE

Editor.getLineState(line) → int

Retrieve the extra styling information for a line.

See Scintilla documentation for SCI_GETLINESTATE

Editor.getMaxLineState() → int

Retrieve the last line number that has line state.

See Scintilla documentation for SCI_GETMAXLINESTATE

Editor.getCaretLineVisible() → bool

Is the background of the line containing the caret in a different colour?

See Scintilla documentation for SCI_GETCARETLINEVISIBLE

Editor.setCaretLineVisible(show)

Display the background of the line containing the caret in a different colour.

See Scintilla documentation for SCI_SETCARETLINEVISIBLE

Editor.getCaretLineBack() → tuple

Get the colour of the background of the line containing the caret.

See Scintilla documentation for SCI_GETCARETLINEBACK

Editor.setCaretLineBack(back)

Set the colour of the background of the line containing the caret.

See Scintilla documentation for SCI_SETCARETLINEBACK

Editor.styleSetChangeable(style, changeable)

Set a style to be changeable or not (read only). Experimental feature, currently buggy.

See Scintilla documentation for SCI_STYLESETCHANGEABLE

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() → bool

Is there an auto-completion list visible?

See Scintilla documentation for SCI_AUTOCACTIVE

Editor.autoCPosStart() → int

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)

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

Editor.autoCGetSeparator() → int

Retrieve the auto-completion list separator character.

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.autoCSetCancelAtStart(cancel)

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

Editor.autoCGetCancelAtStart() → bool

Retrieve whether auto-completion cancelled by backspacing before start.

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)

Should a single item auto-completion list automatically choose the item.

See Scintilla documentation for SCI_AUTOCSETCHOOSESINGLE

Editor.autoCGetChooseSingle() → bool

Retrieve whether a single item auto-completion list automatically choose the item.

See Scintilla documentation for SCI_AUTOCGETCHOOSESINGLE

Editor.autoCSetIgnoreCase(ignoreCase)

Set whether case is significant when performing auto-completion searches.

See Scintilla documentation for SCI_AUTOCSETIGNORECASE

Editor.autoCGetIgnoreCase() → bool

Retrieve state of ignore case flag.

See Scintilla documentation for SCI_AUTOCGETIGNORECASE

Editor.userListShow(listType, itemList)

Display a list of strings and send notification when user chooses one.

See Scintilla documentation for SCI_USERLISTSHOW

Editor.autoCSetAutoHide(autoHide)

Set whether or not autocompletion is hidden automatically when nothing matches.

See Scintilla documentation for SCI_AUTOCSETAUTOHIDE

Editor.autoCGetAutoHide() → bool

Retrieve whether or not autocompletion is hidden automatically when nothing matches.

See Scintilla documentation for SCI_AUTOCGETAUTOHIDE

Editor.autoCSetDropRestOfWord(dropRestOfWord)

Set whether or not autocompletion deletes any word characters after the inserted text upon completion.

See Scintilla documentation for SCI_AUTOCSETDROPRESTOFWORD

Editor.autoCGetDropRestOfWord() → bool

Retrieve whether or not autocompletion deletes any word characters after the inserted text upon completion.

See Scintilla documentation for SCI_AUTOCGETDROPRESTOFWORD

Editor.registerImage(type, xpmData)

Register an XPM image for use in autocompletion lists.

See Scintilla documentation for SCI_REGISTERIMAGE

Editor.clearRegisteredImages()

Clear all the registered XPM images.

See Scintilla documentation for SCI_CLEARREGISTEREDIMAGES

Editor.autoCGetTypeSeparator() → int

Retrieve the auto-completion list type-separator character.

See Scintilla documentation for SCI_AUTOCGETTYPESEPARATOR

Editor.autoCSetTypeSeparator(separatorCharacter)

Change the type-separator character in the string setting up an auto-completion list. Default is ‘?’ but can be changed if items contain ‘?’.

See Scintilla documentation for SCI_AUTOCSETTYPESEPARATOR

Editor.autoCSetMaxWidth(characterCount)

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

Editor.autoCGetMaxWidth() → int

Get the maximum width, in characters, of auto-completion and user lists.

See Scintilla documentation for SCI_AUTOCGETMAXWIDTH

Editor.autoCSetMaxHeight(rowCount)

Set the maximum height, in rows, of auto-completion and user lists. The default is 5 rows.

See Scintilla documentation for SCI_AUTOCSETMAXHEIGHT

Editor.autoCGetMaxHeight() → int

Set the maximum height, in rows, of auto-completion and user lists.

See Scintilla documentation for SCI_AUTOCGETMAXHEIGHT

Editor.setIndent(indentSize)

Set the number of spaces used for one level of indentation.

See Scintilla documentation for SCI_SETINDENT

Editor.getIndent() → int

Retrieve indentation size.

See Scintilla documentation for SCI_GETINDENT

Editor.setUseTabs(useTabs)

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

Editor.getUseTabs() → bool

Retrieve whether tabs will be used in indentation.

See Scintilla documentation for SCI_GETUSETABS

Editor.setLineIndentation(line, indentSize)

Change the indentation of a line to a number of columns.

See Scintilla documentation for SCI_SETLINEINDENTATION

Editor.getLineIndentation(line) → int

Retrieve the number of columns that a line is indented.

See Scintilla documentation for SCI_GETLINEINDENTATION

Editor.getLineIndentPosition(line) → int

Retrieve the position before the first non indentation character on a line.

See Scintilla documentation for SCI_GETLINEINDENTPOSITION

Editor.getColumn(pos) → int

Retrieve the column number of a position, taking tab width into account.

See Scintilla documentation for SCI_GETCOLUMN

Editor.setHScrollBar(show)

Show or hide the horizontal scroll bar.

See Scintilla documentation for SCI_SETHSCROLLBAR

Editor.getHScrollBar() → bool

Is the horizontal scroll bar visible?

See Scintilla documentation for SCI_GETHSCROLLBAR

Editor.setIndentationGuides(indentView)

Show or hide indentation guides.

See Scintilla documentation for SCI_SETINDENTATIONGUIDES

Editor.getIndentationGuides() → int

Are the indentation guides visible?

See Scintilla documentation for SCI_GETINDENTATIONGUIDES

Editor.setHighlightGuide(column)

Set the highlighted indentation guide column. 0 = no highlighted guide.

See Scintilla documentation for SCI_SETHIGHLIGHTGUIDE

Editor.getHighlightGuide() → int

Get the highlighted indentation guide column.

See Scintilla documentation for SCI_GETHIGHLIGHTGUIDE

Editor.getLineEndPosition(line) → int

Get the position after the last visible characters on a line.

See Scintilla documentation for SCI_GETLINEENDPOSITION

Editor.getCodePage() → int

Get the code page used to interpret the bytes of the document as characters.

See Scintilla documentation for SCI_GETCODEPAGE

Editor.getCaretFore() → tuple

Get the foreground colour of the caret.

See Scintilla documentation for SCI_GETCARETFORE

Editor.getUsePalette() → bool

In palette mode?

See Scintilla documentation for SCI_GETUSEPALETTE

Editor.getReadOnly() → bool

In read-only mode?

See Scintilla documentation for SCI_GETREADONLY

Editor.setCurrentPos(pos)

Sets the position of the caret.

See Scintilla documentation for SCI_SETCURRENTPOS

Editor.setSelectionStart(pos)

Sets the position that starts the selection - this becomes the anchor.

See Scintilla documentation for SCI_SETSELECTIONSTART

Editor.getSelectionStart() → int

Returns the position at the start of the selection.

See Scintilla documentation for SCI_GETSELECTIONSTART

Editor.setSelectionEnd(pos)

Sets the position that ends the selection - this becomes the currentPosition.

See Scintilla documentation for SCI_SETSELECTIONEND

Editor.getSelectionEnd() → int

Returns the position at the end of the selection.

See Scintilla documentation for SCI_GETSELECTIONEND

Editor.setPrintMagnification(magnification)

Sets the print magnification added to the point size of each style for printing.

See Scintilla documentation for SCI_SETPRINTMAGNIFICATION

Editor.getPrintMagnification() → int

Returns the print magnification.

See Scintilla documentation for SCI_GETPRINTMAGNIFICATION

Editor.setPrintColourMode(mode)

Modify colours when printing for clearer printed text.

See Scintilla documentation for SCI_SETPRINTCOLOURMODE

Editor.getPrintColourMode() → int

Returns the print colour mode.

See Scintilla documentation for SCI_GETPRINTCOLOURMODE

Editor.findText(flags, start, end, ft) → object

Find some text in the document.

See Scintilla documentation for SCI_FINDTEXT

Editor.getFirstVisibleLine() → int

Retrieve the display line at the top of the display.

See Scintilla documentation for SCI_GETFIRSTVISIBLELINE

Editor.getLine(line) → str

Retrieve the contents of a line. Returns the length of the line.

See Scintilla documentation for SCI_GETLINE

Editor.getLineCount() → int

Returns the number of lines in the document. There is always at least one.

See Scintilla documentation for SCI_GETLINECOUNT

Editor.setMarginLeft(pixelWidth)

Sets the size in pixels of the left margin.

See Scintilla documentation for SCI_SETMARGINLEFT

Editor.getMarginLeft() → int

Returns the size in pixels of the left margin.

See Scintilla documentation for SCI_GETMARGINLEFT

Editor.setMarginRight(pixelWidth)

Sets the size in pixels of the right margin.

See Scintilla documentation for SCI_SETMARGINRIGHT

Editor.getMarginRight() → int

Returns the size in pixels of the right margin.

See Scintilla documentation for SCI_GETMARGINRIGHT

Editor.getModify() → bool

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.getSelText() → str

Retrieve the selected text. Return the length of the text.

See Scintilla documentation for SCI_GETSELTEXT

Editor.getTextRange(start, end) → str

Retrieve a range of text. Return the length of the text.

See Scintilla documentation for SCI_GETTEXTRANGE

Editor.hideSelection(normal)

Draw the selection in normal style or with selection highlighted.

See Scintilla documentation for SCI_HIDESELECTION

Editor.pointXFromPosition(pos) → int

Retrieve the x value of the point in the window where a position is displayed.

See Scintilla documentation for SCI_POINTXFROMPOSITION

Editor.pointYFromPosition(pos) → int

Retrieve the y value of the point in the window where a position is displayed.

See Scintilla documentation for SCI_POINTYFROMPOSITION

Editor.lineFromPosition(pos) → int

Retrieve the line containing a position.

See Scintilla documentation for SCI_LINEFROMPOSITION

Editor.positionFromLine(line) → int

Retrieve the position at the start of a line.

See Scintilla documentation for SCI_POSITIONFROMLINE

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.replaceSel(text)

Replace the selected text with the argument text.

See Scintilla documentation for SCI_REPLACESEL

Editor.setReadOnly(readOnly)

Set to read only or read write.

See Scintilla documentation for SCI_SETREADONLY

Editor.null()

Null operation.

See Scintilla documentation for SCI_NULL

Editor.canPaste() → bool

Will a paste succeed?

See Scintilla documentation for SCI_CANPASTE

Editor.canUndo() → bool

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.undo()

Undo one action in the undo history.

See Scintilla documentation for SCI_UNDO

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.setText(text)

Replace the contents of the document with the argument text.

See Scintilla documentation for SCI_SETTEXT

Editor.getText() → str

Retrieve all the text in the document. Returns number of characters retrieved.

See Scintilla documentation for SCI_GETTEXT

Editor.getTextLength() → int

Retrieve the number of characters in the document.

See Scintilla documentation for SCI_GETTEXTLENGTH

Editor.getDirectFunction() → int

Retrieve a pointer to a function that processes messages for this Scintilla.

See Scintilla documentation for SCI_GETDIRECTFUNCTION

Editor.getDirectPointer() → int

Retrieve a pointer value to use as the first argument when calling the function returned by GetDirectFunction.

See Scintilla documentation for SCI_GETDIRECTPOINTER

Editor.setOvertype(overtype)

Set to overtype (true) or insert mode.

See Scintilla documentation for SCI_SETOVERTYPE

Editor.getOvertype() → bool

Returns true if overtype mode is active otherwise false is returned.

See Scintilla documentation for SCI_GETOVERTYPE

Editor.setCaretWidth(pixelWidth)

Set the width of the insert mode caret.

See Scintilla documentation for SCI_SETCARETWIDTH

Editor.getCaretWidth() → int

Returns the width of the insert mode caret.

See Scintilla documentation for SCI_GETCARETWIDTH

Editor.setTargetStart(pos)

Sets the position that starts the target which is used for updating the document without affecting the scroll position.

See Scintilla documentation for SCI_SETTARGETSTART

Editor.getTargetStart() → int

Get the position that starts the target.

See Scintilla documentation for SCI_GETTARGETSTART

Editor.setTargetEnd(pos)

Sets the position that ends the target which is used for updating the document without affecting the scroll position.

See Scintilla documentation for SCI_SETTARGETEND

Editor.getTargetEnd() → int

Get the position that ends the target.

See Scintilla documentation for SCI_GETTARGETEND

Editor.replaceTarget(text) → int

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.replaceTargetRE(text) → int

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.

See Scintilla documentation for SCI_REPLACETARGETRE

Editor.searchInTarget(text) → int

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.

See Scintilla documentation for SCI_SEARCHINTARGET

Editor.setSearchFlags(flags)

Set the search flags used by SearchInTarget.

See Scintilla documentation for SCI_SETSEARCHFLAGS

Editor.getSearchFlags() → int

Get the search flags used by SearchInTarget.

See Scintilla documentation for SCI_GETSEARCHFLAGS

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() → bool

Is there an active call tip?

See Scintilla documentation for SCI_CALLTIPACTIVE

Editor.callTipPosStart() → int

Retrieve the position where the caret was before displaying the call tip.

See Scintilla documentation for SCI_CALLTIPPOSSTART

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.visibleFromDocLine(line) → int

Find the display line of a document line taking hidden lines into account.

See Scintilla documentation for SCI_VISIBLEFROMDOCLINE

Editor.docLineFromVisible(lineDisplay) → int

Find the document line of a display line taking hidden lines into account.

See Scintilla documentation for SCI_DOCLINEFROMVISIBLE

Editor.wrapCount(line) → int

The number of display lines needed to wrap a document line

See Scintilla documentation for SCI_WRAPCOUNT

Editor.setFoldLevel(line, level)

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.

See Scintilla documentation for SCI_SETFOLDLEVEL

Editor.getFoldLevel(line) → int

Retrieve the fold level of a line.

See Scintilla documentation for SCI_GETFOLDLEVEL

Editor.getLastChild(line, level) → int

Find the last child line of a header line.

See Scintilla documentation for SCI_GETLASTCHILD

Editor.getFoldParent(line) → int

Find the parent line of a child line.

See Scintilla documentation for SCI_GETFOLDPARENT

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) → bool

Is a line visible?

See Scintilla documentation for SCI_GETLINEVISIBLE

Editor.setFoldExpanded(line, expanded)

Show the children of a header line.

See Scintilla documentation for SCI_SETFOLDEXPANDED

Editor.getFoldExpanded(line) → bool

Is a header line expanded?

See Scintilla documentation for SCI_GETFOLDEXPANDED

Editor.toggleFold(line)

Switch a header line between expanded and contracted.

See Scintilla documentation for SCI_TOGGLEFOLD

Editor.ensureVisible(line)

Ensure a particular line is visible by expanding any header line hiding it.

See Scintilla documentation for SCI_ENSUREVISIBLE

Editor.setFoldFlags(flags)

Set some style options for folding.

See Scintilla documentation for SCI_SETFOLDFLAGS

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.setTabIndents(tabIndents)

Sets whether a tab pressed when caret is within indentation indents.

See Scintilla documentation for SCI_SETTABINDENTS

Editor.getTabIndents() → bool

Does a tab pressed when caret is within indentation indent?

See Scintilla documentation for SCI_GETTABINDENTS

Editor.setBackSpaceUnIndents(bsUnIndents)

Sets whether a backspace pressed when caret is within indentation unindents.

See Scintilla documentation for SCI_SETBACKSPACEUNINDENTS

Editor.getBackSpaceUnIndents() → bool

Does a backspace pressed when caret is within indentation unindent?

See Scintilla documentation for SCI_GETBACKSPACEUNINDENTS

Editor.setMouseDwellTime(periodMilliseconds)

Sets the time the mouse must sit still to generate a mouse dwell event.

See Scintilla documentation for SCI_SETMOUSEDWELLTIME

Editor.getMouseDwellTime() → int

Retrieve the time the mouse must sit still to generate a mouse dwell event.

See Scintilla documentation for SCI_GETMOUSEDWELLTIME

Editor.wordStartPosition(pos, onlyWordCharacters) → int

Get position of start of word.

See Scintilla documentation for SCI_WORDSTARTPOSITION

Editor.wordEndPosition(pos, onlyWordCharacters) → int

Get position of end of word.

See Scintilla documentation for SCI_WORDENDPOSITION

Editor.setWrapMode(mode)

Sets whether text is word wrapped.

See Scintilla documentation for SCI_SETWRAPMODE

Editor.getWrapMode() → int

Retrieve whether text is word wrapped.

See Scintilla documentation for SCI_GETWRAPMODE

Editor.setWrapVisualFlags(wrapVisualFlags)

Set the display mode of visual flags for wrapped lines.

See Scintilla documentation for SCI_SETWRAPVISUALFLAGS

Editor.getWrapVisualFlags() → int

Retrive the display mode of visual flags for wrapped lines.

See Scintilla documentation for SCI_GETWRAPVISUALFLAGS

Editor.setWrapVisualFlagsLocation(wrapVisualFlagsLocation)

Set the location of visual flags for wrapped lines.

See Scintilla documentation for SCI_SETWRAPVISUALFLAGSLOCATION

Editor.getWrapVisualFlagsLocation() → int

Retrive the location of visual flags for wrapped lines.

See Scintilla documentation for SCI_GETWRAPVISUALFLAGSLOCATION

Editor.setWrapStartIndent(indent)

Set the start indent for wrapped lines.

See Scintilla documentation for SCI_SETWRAPSTARTINDENT

Editor.getWrapStartIndent() → int

Retrive the start indent for wrapped lines.

See Scintilla documentation for SCI_GETWRAPSTARTINDENT

Editor.setWrapIndentMode(mode)

Sets how wrapped sublines are placed. Default is fixed.

See Scintilla documentation for SCI_SETWRAPINDENTMODE

Editor.getWrapIndentMode() → int

Retrieve how wrapped sublines are placed. Default is fixed.

See Scintilla documentation for SCI_GETWRAPINDENTMODE

Editor.setLayoutCache(mode)

Sets the degree of caching of layout information.

See Scintilla documentation for SCI_SETLAYOUTCACHE

Editor.getLayoutCache() → int

Retrieve the degree of caching of layout information.

See Scintilla documentation for SCI_GETLAYOUTCACHE

Editor.setScrollWidth(pixelWidth)

Sets the document width assumed for scrolling.

See Scintilla documentation for SCI_SETSCROLLWIDTH

Editor.getScrollWidth() → int

Retrieve the document width assumed for scrolling.

See Scintilla documentation for SCI_GETSCROLLWIDTH

Editor.setScrollWidthTracking(tracking)

Sets whether the maximum width line displayed is used to set scroll width.

See Scintilla documentation for SCI_SETSCROLLWIDTHTRACKING

Editor.getScrollWidthTracking() → bool

Retrieve whether the scroll width tracks wide lines.

See Scintilla documentation for SCI_GETSCROLLWIDTHTRACKING

Editor.textWidth(style, text) → int

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.setEndAtLastLine(endAtLastLine)

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

Editor.getEndAtLastLine() → bool

Retrieve whether the maximum scroll position has the last line at the bottom of the view.

See Scintilla documentation for SCI_GETENDATLASTLINE

Editor.textHeight(line) → int

Retrieve the height of a particular line of text in pixels.

See Scintilla documentation for SCI_TEXTHEIGHT

Editor.setVScrollBar(show)

Show or hide the vertical scroll bar.

See Scintilla documentation for SCI_SETVSCROLLBAR

Editor.getVScrollBar() → bool

Is the vertical scroll bar visible?

See Scintilla documentation for SCI_GETVSCROLLBAR

Editor.appendText(text) → int

Append a string to the end of the document without changing the selection.

See Scintilla documentation for SCI_APPENDTEXT

Editor.getTwoPhaseDraw() → bool

Is drawing done in two phases with backgrounds drawn before faoregrounds?

See Scintilla documentation for SCI_GETTWOPHASEDRAW

Editor.setTwoPhaseDraw(twoPhase)

In twoPhaseDraw mode, drawing is performed in two phases, first the background and then the foreground. This avoids chopping off characters that overlap the next run.

See Scintilla documentation for SCI_SETTWOPHASEDRAW

Editor.setFontQuality(fontQuality)

Choose the quality level for text from the FontQuality enumeration.

See Scintilla documentation for SCI_SETFONTQUALITY

Editor.getFontQuality() → int

Retrieve the quality level for text.

See Scintilla documentation for SCI_GETFONTQUALITY

Editor.setFirstVisibleLine(lineDisplay)

Scroll so that a display line is at the top of the display.

See Scintilla documentation for SCI_SETFIRSTVISIBLELINE

Editor.setMultiPaste(multiPaste)

Change the effect of pasting when there are multiple selections.

See Scintilla documentation for SCI_SETMULTIPASTE

Editor.getMultiPaste() → int

Retrieve the effect of pasting when there are multiple selections..

See Scintilla documentation for SCI_GETMULTIPASTE

Editor.getTag() → str

Retrieve the value of a tag from a regular expression search.

See Scintilla documentation for SCI_GETTAG

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.linesJoin()

Join the lines in the target.

See Scintilla documentation for SCI_LINESJOIN

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.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)

Set the colours used as a chequerboard pattern in the fold margin

See Scintilla documentation for SCI_SETFOLDMARGINHICOLOUR

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.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.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.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()

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_HOMEWRAPEXTEND

Editor.lineEndWrap()

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_LINEENDWRAP

Editor.lineEndWrapExtend()

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_LINEENDWRAPEXTEND

Editor.vCHomeWrap()

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_VCHOMEWRAP

Editor.vCHomeWrapExtend()

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_VCHOMEWRAPEXTEND

Editor.lineCopy()

Copy the line containing the caret.

See Scintilla documentation for SCI_LINECOPY

Editor.moveCaretInsideView()

Move the caret inside current view if it’s not there already.

See Scintilla documentation for SCI_MOVECARETINSIDEVIEW

Editor.lineLength(line) → int

How many characters are on a line, including end of line characters?

See Scintilla documentation for SCI_LINELENGTH

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.braceMatch(pos) → int

Find the position of a matching brace or INVALID_POSITION if no match.

See Scintilla documentation for SCI_BRACEMATCH

Editor.getViewEOL() → bool

Are the end of line characters visible?

See Scintilla documentation for SCI_GETVIEWEOL

Editor.setViewEOL(visible)

Make the end of line characters visible or invisible.

See Scintilla documentation for SCI_SETVIEWEOL

Editor.getDocPointer() → int

Retrieve a pointer to the document object.

See Scintilla documentation for SCI_GETDOCPOINTER

Editor.setDocPointer(pointer)

Change the document object used.

See Scintilla documentation for SCI_SETDOCPOINTER

Editor.setModEventMask(mask)

Set which document modification events are sent to the container.

See Scintilla documentation for SCI_SETMODEVENTMASK

Editor.getEdgeColumn() → int

Retrieve the column number which text should be kept within.

See Scintilla documentation for SCI_GETEDGECOLUMN

Editor.setEdgeColumn(column)

Set the column number of the edge. If text goes past the edge then it is highlighted.

See Scintilla documentation for SCI_SETEDGECOLUMN

Editor.getEdgeMode() → int

Retrieve the edge highlight mode.

See Scintilla documentation for SCI_GETEDGEMODE

Editor.setEdgeMode(mode)

The edge may be displayed by a line (EDGE_LINE) or by highlighting text that goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).

See Scintilla documentation for SCI_SETEDGEMODE

Editor.getEdgeColour() → tuple

Retrieve the colour used in edge indication.

See Scintilla documentation for SCI_GETEDGECOLOUR

Editor.setEdgeColour(edgeColour)

Change the colour used in edge indication.

See Scintilla documentation for SCI_SETEDGECOLOUR

Editor.searchAnchor()

Sets the current caret position to be the search anchor.

See Scintilla documentation for SCI_SEARCHANCHOR

Editor.searchNext(flags, text) → int

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) → int

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.linesOnScreen() → int

Retrieves the number of lines completely visible.

See Scintilla documentation for SCI_LINESONSCREEN

Editor.usePopUp(allowPopUp)

Set whether a pop up menu is displayed automatically when the user presses the wrong mouse button.

See Scintilla documentation for SCI_USEPOPUP

Editor.selectionIsRectangle() → bool

Is the selection rectangular? The alternative is the more common stream selection.

See Scintilla documentation for SCI_SELECTIONISRECTANGLE

Editor.setZoom(zoom)

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

Editor.getZoom() → int

Retrieve the zoom level.

See Scintilla documentation for SCI_GETZOOM

Editor.createDocument() → int

Create a new document object. Starts with reference count of 1 and not selected into editor.

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.getModEventMask() → int

Get which document modification events are sent to the container.

See Scintilla documentation for SCI_GETMODEVENTMASK

Editor.setFocus(focus)

Change internal focus flag.

See Scintilla documentation for SCI_SETFOCUS

Editor.getFocus() → bool

Get internal focus flag.

See Scintilla documentation for SCI_GETFOCUS

Editor.setStatus(statusCode)

Change error status - 0 = OK.

See Scintilla documentation for SCI_SETSTATUS

Editor.getStatus() → int

Get error status.

See Scintilla documentation for SCI_GETSTATUS

Editor.setMouseDownCaptures(captures)

Set whether the mouse is captured when its button is pressed.

See Scintilla documentation for SCI_SETMOUSEDOWNCAPTURES

Editor.getMouseDownCaptures() → bool

Get whether mouse gets captured.

See Scintilla documentation for SCI_GETMOUSEDOWNCAPTURES

Editor.setCursor(cursorType)

Sets the cursor to one of the SC_CURSOR* values.

See Scintilla documentation for SCI_SETCURSOR

Editor.getCursor() → int

Get cursor type.

See Scintilla documentation for SCI_GETCURSOR

Editor.setControlCharSymbol(symbol)

Change the way control characters are displayed: If symbol is < 32, keep the drawn way, else, use the given character.

See Scintilla documentation for SCI_SETCONTROLCHARSYMBOL

Editor.getControlCharSymbol() → int

Get the way control characters are displayed.

See Scintilla documentation for SCI_GETCONTROLCHARSYMBOL

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.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.

See Scintilla documentation for SCI_SETVISIBLEPOLICY

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.setXOffset(newOffset)

Get and Set the xOffset (ie, horizonal scroll position).

See Scintilla documentation for SCI_SETXOFFSET

Editor.getXOffset() → int

Get and Set the xOffset (ie, horizonal scroll position).

See Scintilla documentation for SCI_GETXOFFSET

Editor.chooseCaretX()

Set the last x chosen value to be the caret x position.

See Scintilla documentation for SCI_CHOOSECARETX

Editor.grabFocus()

Set the focus to this Scintilla widget.

See Scintilla documentation for SCI_GRABFOCUS

Editor.setXCaretPolicy(caretPolicy, caretSlop)

Set the way the caret is kept visible when going sideway. The exclusion zone is given in pixels.

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 is given in lines.

See Scintilla documentation for SCI_SETYCARETPOLICY

Editor.setPrintWrapMode(mode)

Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).

See Scintilla documentation for SCI_SETPRINTWRAPMODE

Editor.getPrintWrapMode() → int

Is printing line wrapped?

See Scintilla documentation for SCI_GETPRINTWRAPMODE

Editor.setHotspotActiveFore(useSetting, fore)

Set a fore colour for active hotspots.

See Scintilla documentation for SCI_SETHOTSPOTACTIVEFORE

Editor.getHotspotActiveFore() → tuple

Get the fore colour for active hotspots.

See Scintilla documentation for SCI_GETHOTSPOTACTIVEFORE

Editor.setHotspotActiveBack(useSetting, back)

Set a back colour for active hotspots.

See Scintilla documentation for SCI_SETHOTSPOTACTIVEBACK

Editor.getHotspotActiveBack() → tuple

Get the back colour for active hotspots.

See Scintilla documentation for SCI_GETHOTSPOTACTIVEBACK

Editor.setHotspotActiveUnderline(underline)

Enable / Disable underlining active hotspots.

See Scintilla documentation for SCI_SETHOTSPOTACTIVEUNDERLINE

Editor.getHotspotActiveUnderline() → bool

Get whether underlining for active hotspots.

See Scintilla documentation for SCI_GETHOTSPOTACTIVEUNDERLINE

Editor.setHotspotSingleLine(singleLine)

Limit hotspots to single line so hotspots on two lines don’t merge.

See Scintilla documentation for SCI_SETHOTSPOTSINGLELINE

Editor.getHotspotSingleLine() → bool

Get the HotspotSingleLine property

See Scintilla documentation for SCI_GETHOTSPOTSINGLELINE

Editor.paraDown()

Move caret between paragraphs (delimited by empty lines).

See Scintilla documentation for SCI_PARADOWN

Editor.paraDownExtend()

Move caret between paragraphs (delimited by empty lines).

See Scintilla documentation for SCI_PARADOWNEXTEND

Editor.paraUp()

Move caret between paragraphs (delimited by empty lines).

See Scintilla documentation for SCI_PARAUP

Editor.paraUpExtend()

Move caret between paragraphs (delimited by empty lines).

See Scintilla documentation for SCI_PARAUPEXTEND

Editor.positionBefore(pos) → int

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) → int

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.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) → int

Copy argument text to the clipboard.

See Scintilla documentation for SCI_COPYTEXT

Editor.setSelectionMode(mode)

Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or by lines (SC_SEL_LINES).

See Scintilla documentation for SCI_SETSELECTIONMODE

Editor.getSelectionMode() → int

Get the mode of the current selection.

See Scintilla documentation for SCI_GETSELECTIONMODE

Editor.getLineSelStartPosition(line) → int

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) → int

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.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.setWhitespaceChars(characters)

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

Editor.setCharsDefault()

Reset the set of characters for whitespace and word characters to the defaults.

See Scintilla documentation for SCI_SETCHARSDEFAULT

Editor.autoCGetCurrent() → int

Get currently selected item position in the auto-completion list

See Scintilla documentation for SCI_AUTOCGETCURRENT

Editor.autoCGetCurrentText() → str

Get currently selected item text in the auto-completion list Returns the length of the item text

See Scintilla documentation for SCI_AUTOCGETCURRENTTEXT

Editor.allocate(bytes)

Enlarge the document to a particular size of text bytes.

See Scintilla documentation for SCI_ALLOCATE

Editor.targetAsUTF8() → str

Returns the target converted to UTF8. Return the length in bytes.

See Scintilla documentation for SCI_TARGETASUTF8

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.encodedFromUTF8() → str

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.findColumn(line, column) → int

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.getCaretSticky() → bool

Can the caret preferred x position only be changed by explicit movement commands?

See Scintilla documentation for SCI_GETCARETSTICKY

Editor.setCaretSticky(useCaretStickyBehaviour)

Stop the caret preferred x position changing when the user types.

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

Editor.setPasteConvertEndings(convert)

Enable/Disable convert-on-paste for line endings

See Scintilla documentation for SCI_SETPASTECONVERTENDINGS

Editor.getPasteConvertEndings() → bool

Get convert-on-paste setting

See Scintilla documentation for SCI_GETPASTECONVERTENDINGS

Editor.selectionDuplicate()

Duplicate the selection. If selection empty duplicate the line containing the caret.

See Scintilla documentation for SCI_SELECTIONDUPLICATE

Editor.setCaretLineBackAlpha(alpha)

Set background alpha of the caret line.

See Scintilla documentation for SCI_SETCARETLINEBACKALPHA

Editor.getCaretLineBackAlpha() → int

Get the background alpha of the caret line.

See Scintilla documentation for SCI_GETCARETLINEBACKALPHA

Editor.setCaretStyle(caretStyle)

Set the style of the caret to be drawn.

See Scintilla documentation for SCI_SETCARETSTYLE

Editor.getCaretStyle() → int

Returns the current style of the caret.

See Scintilla documentation for SCI_GETCARETSTYLE

Editor.setIndicatorCurrent(indicator)

Set the indicator used for IndicatorFillRange and IndicatorClearRange

See Scintilla documentation for SCI_SETINDICATORCURRENT

Editor.getIndicatorCurrent() → int

Get the current indicator

See Scintilla documentation for SCI_GETINDICATORCURRENT

Editor.setIndicatorValue(value)

Set the value used for IndicatorFillRange

See Scintilla documentation for SCI_SETINDICATORVALUE

Editor.getIndicatorValue() → int

Get the current indicator vaue

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) → int

Are any indicators present at position?

See Scintilla documentation for SCI_INDICATORALLONFOR

Editor.indicatorValueAt(indicator, position) → int

What value does a particular indicator have at at a position?

See Scintilla documentation for SCI_INDICATORVALUEAT

Editor.indicatorStart(indicator, position) → int

Where does a particular indicator start?

See Scintilla documentation for SCI_INDICATORSTART

Editor.indicatorEnd(indicator, position) → int

Where does a particular indicator end?

See Scintilla documentation for SCI_INDICATOREND

Editor.setPositionCache(size)

Set number of entries in position cache

See Scintilla documentation for SCI_SETPOSITIONCACHE

Editor.getPositionCache() → int

How many entries are allocated to the position cache?

See Scintilla documentation for SCI_GETPOSITIONCACHE

Editor.copyAllowLine()

Copy the selection, if selection empty copy the line with the caret

See Scintilla documentation for SCI_COPYALLOWLINE

Editor.getCharacterPointer() → int

Compact the document buffer and return a read-only pointer to the characters in the document.

See Scintilla documentation for SCI_GETCHARACTERPOINTER

Editor.setKeysUnicode(keysUnicode)

Always interpret keyboard input as Unicode

See Scintilla documentation for SCI_SETKEYSUNICODE

Editor.getKeysUnicode() → bool

Are keys always interpreted as Unicode?

See Scintilla documentation for SCI_GETKEYSUNICODE

Editor.indicSetAlpha(indicator, alpha)

Set the alpha fill colour of the given indicator.

See Scintilla documentation for SCI_INDICSETALPHA

Editor.indicGetAlpha(indicator) → int

Get the alpha fill colour of the given indicator.

See Scintilla documentation for SCI_INDICGETALPHA

Editor.setExtraAscent(extraAscent)

Set extra ascent for each line

See Scintilla documentation for SCI_SETEXTRAASCENT

Editor.getExtraAscent() → int

Get extra ascent for each line

See Scintilla documentation for SCI_GETEXTRAASCENT

Editor.setExtraDescent(extraDescent)

Set extra descent for each line

See Scintilla documentation for SCI_SETEXTRADESCENT

Editor.getExtraDescent() → int

Get extra descent for each line

See Scintilla documentation for SCI_GETEXTRADESCENT

Editor.markerSymbolDefined(markerNumber) → int

Which symbol was defined for markerNumber with MarkerDefine

See Scintilla documentation for SCI_MARKERSYMBOLDEFINED

Editor.marginSetText(line, text)

Set the text in the text margin for a line

See Scintilla documentation for SCI_MARGINSETTEXT

Editor.marginGetText(line) → str

Get the text in the text margin for a line

See Scintilla documentation for SCI_MARGINGETTEXT

Editor.marginSetStyle(line, style)

Set the style number for the text margin for a line

See Scintilla documentation for SCI_MARGINSETSTYLE

Editor.marginGetStyle(line) → int

Get the style number for the text margin for a line

See Scintilla documentation for SCI_MARGINGETSTYLE

Editor.marginSetStyles(line, styles)

Set the style in the text margin for a line

See Scintilla documentation for SCI_MARGINSETSTYLES

Editor.marginGetStyles(line) → str

Get the styles in the text margin for a line

See Scintilla documentation for SCI_MARGINGETSTYLES

Editor.marginTextClearAll()

Clear the margin text on all lines

See Scintilla documentation for SCI_MARGINTEXTCLEARALL

Editor.marginSetStyleOffset(style)

Get the start of the range of style numbers used for margin text

See Scintilla documentation for SCI_MARGINSETSTYLEOFFSET

Editor.marginGetStyleOffset() → int

Get the start of the range of style numbers used for margin text

See Scintilla documentation for SCI_MARGINGETSTYLEOFFSET

Editor.annotationSetText(line, text)

Set the annotation text for a line

See Scintilla documentation for SCI_ANNOTATIONSETTEXT

Editor.annotationGetText(line) → str

Get the annotation text for a line

See Scintilla documentation for SCI_ANNOTATIONGETTEXT

Editor.annotationSetStyle(line, style)

Set the style number for the annotations for a line

See Scintilla documentation for SCI_ANNOTATIONSETSTYLE

Editor.annotationGetStyle(line) → int

Get the style number for the annotations for a line

See Scintilla documentation for SCI_ANNOTATIONGETSTYLE

Editor.annotationSetStyles(line, styles)

Set the annotation styles for a line

See Scintilla documentation for SCI_ANNOTATIONSETSTYLES

Editor.annotationGetStyles(line) → str

Get the annotation styles for a line

See Scintilla documentation for SCI_ANNOTATIONGETSTYLES

Editor.annotationGetLines(line) → int

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)

Set the visibility for the annotations for a view

See Scintilla documentation for SCI_ANNOTATIONSETVISIBLE

Editor.annotationGetVisible() → int

Get the visibility for the annotations for a view

See Scintilla documentation for SCI_ANNOTATIONGETVISIBLE

Editor.annotationSetStyleOffset(style)

Get the start of the range of style numbers used for annotations

See Scintilla documentation for SCI_ANNOTATIONSETSTYLEOFFSET

Editor.annotationGetStyleOffset() → int

Get the start of the range of style numbers used for annotations

See Scintilla documentation for SCI_ANNOTATIONGETSTYLEOFFSET

Editor.addUndoAction(token, flags)

Add a container action to the undo stack

See Scintilla documentation for SCI_ADDUNDOACTION

Editor.charPositionFromPoint(x, y) → int

Find the position of a character from a point within the window.

See Scintilla documentation for SCI_CHARPOSITIONFROMPOINT

Editor.charPositionFromPointClose(x, y) → int

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.setMultipleSelection(multipleSelection)

Set whether multiple selections can be made

See Scintilla documentation for SCI_SETMULTIPLESELECTION

Editor.getMultipleSelection() → bool

Whether multiple selections can be made

See Scintilla documentation for SCI_GETMULTIPLESELECTION

Editor.setAdditionalSelectionTyping(additionalSelectionTyping)

Set whether typing can be performed into multiple selections

See Scintilla documentation for SCI_SETADDITIONALSELECTIONTYPING

Editor.getAdditionalSelectionTyping() → bool

Whether typing can be performed into multiple selections

See Scintilla documentation for SCI_GETADDITIONALSELECTIONTYPING

Editor.setAdditionalCaretsBlink(additionalCaretsBlink)

Set whether additional carets will blink

See Scintilla documentation for SCI_SETADDITIONALCARETSBLINK

Editor.getAdditionalCaretsBlink() → bool

Whether additional carets will blink

See Scintilla documentation for SCI_GETADDITIONALCARETSBLINK

Editor.setAdditionalCaretsVisible(additionalCaretsBlink)

Set whether additional carets are visible

See Scintilla documentation for SCI_SETADDITIONALCARETSVISIBLE

Editor.getAdditionalCaretsVisible() → bool

Whether additional carets are visible

See Scintilla documentation for SCI_GETADDITIONALCARETSVISIBLE

Editor.getSelections() → int

How many selections are there?

See Scintilla documentation for SCI_GETSELECTIONS

Editor.clearSelections()

Clear selections to a single empty stream selection

See Scintilla documentation for SCI_CLEARSELECTIONS

Editor.setSelection(caret, anchor) → int

Set a simple selection

See Scintilla documentation for SCI_SETSELECTION

Editor.addSelection(caret, anchor) → int

Add a selection

See Scintilla documentation for SCI_ADDSELECTION

Editor.setMainSelection(selection)

Set the main selection

See Scintilla documentation for SCI_SETMAINSELECTION

Editor.getMainSelection() → int

Which selection is the main selection

See Scintilla documentation for SCI_GETMAINSELECTION

Editor.setSelectionNCaret(selection, pos)

Which selection is the main selection

See Scintilla documentation for SCI_SETSELECTIONNCARET

Editor.getSelectionNCaret(selection) → int

Which selection is the main selection

See Scintilla documentation for SCI_GETSELECTIONNCARET

Editor.setSelectionNAnchor(selection, posAnchor)

Which selection is the main selection

See Scintilla documentation for SCI_SETSELECTIONNANCHOR

Editor.getSelectionNAnchor(selection) → int

Which selection is the main selection

See Scintilla documentation for SCI_GETSELECTIONNANCHOR

Editor.setSelectionNCaretVirtualSpace(selection, space)

Which selection is the main selection

See Scintilla documentation for SCI_SETSELECTIONNCARETVIRTUALSPACE

Editor.getSelectionNCaretVirtualSpace(selection) → int

Which selection is the main selection

See Scintilla documentation for SCI_GETSELECTIONNCARETVIRTUALSPACE

Editor.setSelectionNAnchorVirtualSpace(selection, space)

Which selection is the main selection

See Scintilla documentation for SCI_SETSELECTIONNANCHORVIRTUALSPACE

Editor.getSelectionNAnchorVirtualSpace(selection) → int

Which selection is the main selection

See Scintilla documentation for SCI_GETSELECTIONNANCHORVIRTUALSPACE

Editor.setSelectionNStart(selection, pos)

Sets the position that starts the selection - this becomes the anchor.

See Scintilla documentation for SCI_SETSELECTIONNSTART

Editor.getSelectionNStart(selection) → int

Returns the position at the start of the selection.

See Scintilla documentation for SCI_GETSELECTIONNSTART

Editor.setSelectionNEnd(selection, pos)

Sets the position that ends the selection - this becomes the currentPosition.

See Scintilla documentation for SCI_SETSELECTIONNEND

Editor.getSelectionNEnd(selection) → int

Returns the position at the end of the selection.

See Scintilla documentation for SCI_GETSELECTIONNEND

Editor.setRectangularSelectionCaret(pos)

Returns the position at the end of the selection.

See Scintilla documentation for SCI_SETRECTANGULARSELECTIONCARET

Editor.getRectangularSelectionCaret() → int

Returns the position at the end of the selection.

See Scintilla documentation for SCI_GETRECTANGULARSELECTIONCARET

Editor.setRectangularSelectionAnchor(posAnchor)

Returns the position at the end of the selection.

See Scintilla documentation for SCI_SETRECTANGULARSELECTIONANCHOR

Editor.getRectangularSelectionAnchor() → int

Returns the position at the end of the selection.

See Scintilla documentation for SCI_GETRECTANGULARSELECTIONANCHOR

Editor.setRectangularSelectionCaretVirtualSpace(space)

Returns the position at the end of the selection.

See Scintilla documentation for SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE

Editor.getRectangularSelectionCaretVirtualSpace() → int

Returns the position at the end of the selection.

See Scintilla documentation for SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE

Editor.setRectangularSelectionAnchorVirtualSpace(space)

Returns the position at the end of the selection.

See Scintilla documentation for SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE

Editor.getRectangularSelectionAnchorVirtualSpace() → int

Returns the position at the end of the selection.

See Scintilla documentation for SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE

Editor.setVirtualSpaceOptions(virtualSpaceOptions)

Returns the position at the end of the selection.

See Scintilla documentation for SCI_SETVIRTUALSPACEOPTIONS

Editor.getVirtualSpaceOptions() → int

Returns the position at the end of the selection.

See Scintilla documentation for SCI_GETVIRTUALSPACEOPTIONS

Editor.setRectangularSelectionModifier(modifier)

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

Editor.getRectangularSelectionModifier() → int

Get the modifier key used for rectangular selection.

See Scintilla documentation for SCI_GETRECTANGULARSELECTIONMODIFIER

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.setAdditionalSelAlpha(alpha)

Set the alpha of the selection.

See Scintilla documentation for SCI_SETADDITIONALSELALPHA

Editor.getAdditionalSelAlpha() → int

Get the alpha of the selection.

See Scintilla documentation for SCI_GETADDITIONALSELALPHA

Editor.setAdditionalCaretFore(fore)

Set the foreground colour of additional carets.

See Scintilla documentation for SCI_SETADDITIONALCARETFORE

Editor.getAdditionalCaretFore() → tuple

Get the foreground colour of additional carets.

See Scintilla documentation for SCI_GETADDITIONALCARETFORE

Editor.rotateSelection()

Set the main selection to the next selection.

See Scintilla documentation for SCI_ROTATESELECTION

Editor.swapMainAnchorCaret()

Swap that caret and anchor of the main selection.

See Scintilla documentation for SCI_SWAPMAINANCHORCARET

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

Editor.setLexer(lexer)

Set the lexing language of the document.

See Scintilla documentation for SCI_SETLEXER

Editor.getLexer() → int

Retrieve the lexing language of the document.

See Scintilla documentation for SCI_GETLEXER

Editor.colourise(start, end)

Colourise a segment of the document using the current lexing language.

See Scintilla documentation for SCI_COLOURISE

Editor.setProperty(key, value)

Set up a value that may be used by a lexer for some optional feature.

See Scintilla documentation for SCI_SETPROPERTY

Editor.setKeyWords(keywordSet, keyWords)

Set up the key words used by the lexer.

See Scintilla documentation for SCI_SETKEYWORDS

Editor.setLexerLanguage(language)

Set the lexing language of the document based on string name.

See Scintilla documentation for SCI_SETLEXERLANGUAGE

Editor.loadLexerLibrary(path)

Load a lexer library (dll / so).

See Scintilla documentation for SCI_LOADLEXERLIBRARY

Editor.getProperty() → str

Retrieve a “property” value previously set with SetProperty.

See Scintilla documentation for SCI_GETPROPERTY

Editor.getPropertyExpanded() → str

Retrieve a “property” value previously set with SetProperty, with “$()” variable replacement on returned buffer.

See Scintilla documentation for SCI_GETPROPERTYEXPANDED

Editor.getPropertyInt(key) → int

Retrieve a “property” value previously set with SetProperty, interpreted as an int AFTER any “$()” variable replacement.

See Scintilla documentation for SCI_GETPROPERTYINT

Editor.getStyleBitsNeeded() → int

Retrieve the number of bits the current lexer needs for styling.

See Scintilla documentation for SCI_GETSTYLEBITSNEEDED

Editor.getLexerLanguage() → str

Retrieve the name of the lexer. Return the length of the text.

See Scintilla documentation for SCI_GETLEXERLANGUAGE

Helper Methods

Editor.forEachLine(function)

Runs the function passed for each line in the current document. The function gets passed 3 arguments, the contents of the line, the line number (starting from zero), and the total number of lines. If the function returns a number, that number is added to the current line number for the next iteration.

That way, if you delete the current line, you should return 0, so as to stay on the current physical line.

Under normal circumstances, you do not need to return anything from the function (i.e. None)

e.g.:

def testContents(contents, lineNumber, totalLines):
        if contents.strip() == "rubbish":
                editor.deleteLine(lineNumber)
                # As we've deleted the line, the "next" line to process
                # is actually the current line, so we return 0 to advance zero lines
                # and hence stay on the same line
                return 0

        elif contents.strip() == "something old":
                editor.replaceLine(lineNumber, "something new")

        elif contents.strip() == "little something":
                editor.replaceLine(lineNumber, "BIG\nSOMETHING"
                # Here we return 2, as we've inserted a newline,
                # and we don't want to test the "SOMETHING" line again
                return 2

        # if you wanted, you could optionally return 1 here, to move the next line
        # but that's the default, so you don't need to bother.

editor.forEachLine(testContents)
Editor.deleteLine(line)

Deletes the given (zero indexed) line number.

Editor.replaceLine(line, newContents)

Replaces the given (zero indexed) line number with the given contents. e.g.:

editor.replaceLine(3, "New contents")
Editor.replaceWholeLine(line, newContents)

Replaces the given (zero indexed) line number with the given contents, including the line break (ie. the line break from the old line is removed, no line break on the replacement will result in joining lines).

e.g.:

editor.replaceWholeLine(3, "New contents")
Editor.setTarget(start, end)

Sets the target start and end in one call. See Editor.setTargetStart and Editor.setTargetEnd

Editor.getUserLineSelection() -> (startLine, endLine)

Gets the start and end (zero indexed) line numbers of the user selection, or the whole document if nothing is selected.

Useful if you want to run your script over a number of lines - using this allows the user to select nothing, and have the script run for the whole document, or select just the section they want to run the script over.

Editor.getUserCharSelection() -> (startByte, endByte)

Gets the start and end (zero indexed) byte numbers of the user selection, or the whole document if nothing is selected.

Editor.clearCallbacks()

Clears all callbacks

Editor.clearCallbacks(function)

Clears all callbacks for a given function

Editor.clearCallbacks(eventsList)

Clears all callbacks for the given list of events

Editor.clearCallbacks(function, eventsList)

Clears the callback for the given callback function for the list of events

Editor.replace(search, replace)

Simple search and replace.

Editor.rereplace(regex, replace)

Simple regular expression search and replace (using Notepad++/Scintilla regular expressions).

Editor.pyreplace(search, replace[, count[, flags[, startLine[, endLine]]]])

Python regular expression search and replace. Full support for Python regular expressions. Works line-by-line, so does not require significant memory overhead, however multiline regular expressions won’t work (see pymlreplace).

flags are from the re module (e.g. re.IGNORECASE), so import re if you use the flags. A maximum of count replacements are made, if zero or not given, then all replacements are made.

startLine and endLine are optional, and if provided refer the first and last (zero indexed) lines to perform the replace on.

Note that as ``$`` only matches ``n``, for Windows line ending files (i.e. ``rn``) if you want to match the end of the line, you need to use ``r$`` - see note about ``Editor.INCLUDELINEENDINGS``

As each line is searched individually, if you want to remove the line breaks, for instance to join lines together, you need to add a flag Editor.INCLUDELINEENDINGS. This includes the line endings in the search string, and also in the replacement.

To just add a star (*) to the end of every line, you’d just use:

editor.pyreplace("$", "*")

However, to join lines together, and put a pipe character (|) in between each one:

editor.pyreplace(r"\r$\n", "|", 0, Editor.INCLUDELINEENDINGS)

Would result in:

this is line 1
this is line 2
this is line 3

Becoming:

this is line 1|this is line 2|this is line 3
Editor.pymlreplace(search, replace[, count[, flags[, startPosition[, endPosition]]]])

Python Multiline regular expression search and replace - works for multiline regular expressions, but makes at least 2 copies of the entire document, so is unsuitable for large documents. Note that re.MULTILINE is specified in the flags automatically.

flags are from the re module (e.g. re.IGNORECASE), so import re if you use the flags. A maximum of count replacements are made, if zero or not given, then all replacements are made.

startPosition and endPosition are optional, if provided they refer to the section of text, in offset bytes, to perform the search and replace in.

Note that as ``$`` only matches ``n``, for Windows line ending files (i.e. ``rn``) if you want to match the end of the line, you need to use ``r$``

Editor.pysearch(expression, function[, flags[, startLine[, endLine]]])

Python regular expression search, calling a function for each match found. The function gets called with the (zero indexed) line number, and the match object.

startLine and endLine are optional, and if provided refer the first and last (zero indexed) lines to perform the replace on.

Note that the match object start and end refer to the positions **within the line* and not the entire document. Use editor.positionFromLine to find the location in the document*

Editor.pymlsearch(expression, function[, flags[, startPosition[, endPosition]]])

Python multiline regular expression search, calling a function for each match found. The function gets called with the (zero indexed) line number, and the match object.

Note that this runs the search on the entire text, and therefore makes at least 2 copies of the entire document, therefore it may not be suitable for large documents.

startPosition and endPosition are optional, if provided they refer to the section of text, in offset bytes, to perform the search in.

Note that the match object start and end refer to the positions within the entire document, unlike :ref:`editor.pysearch`


  • next |
  • previous |
  • PythonScript v0.7.0.0 documentation »

Console Object

class Console
Console.write(string)

Writes text to the console.

Console.writeError(string)

Writes text to the console in red

Console.clear()

Clears the console

Console.show()

Shows the console window.

Console.hide()

Hides the console window

Console.run(commandLine[, stdout[, stderr]])

Runs an external program, with output optionally directed to the given objects (which must support a write method).

Not supplying stdout means that the console is used for stdout.

Not supplying stderr means that the default values from sys.stderr (normally the console, in red) is used.

e.g.:

# The basic form, run a normal command line.
console.run('cl.exe "myfile.c"')

# Create a new document in Notepad++
notepad.new()

# Run someprogram.exe, and have the output written to the new document.
console.run('someprogram.exe', editor)

The console will automatically parse Python, Visual Studio and GCC style errors and warnings. The filenames are then clickable to open the file at the line number given. If you would like some other form of warnings or errors parsed, please send me an email (davegb@pobox.com). Also if you find a line that is parsed as an error or warning and it shouldn’t have been, also let me know.

Console.editor

An Editor object for the console window. This enables you to change colours, styles, even add and remove text if you so wish, from the console window. Note that the console window is always left in a read-only state, so in order to change text, you would need to first perform a console.editor.setReadOnly(0). Any subsequent console.write or console.writeError calls will make the console read-only again.

The styles use a bit mask to represent different things within the console.

Bit | Value | Meaning
0 | 1 | STDERR output, or a parsed error
1 | 2 | Hotspot - clickable link
2 | 4 | A parsed warning

This produces the following style values:

Style | Description
0 | Standard (default) style
1 | STDERR or error
2 | Hotspot clickable link, but not error or warning
3 | Hotspot clickable link, Error
4 | Warning, but not clickable
5 | Warning produced on stderr, not clickable
6 | Clickable warning, from stdout
7 | Clickable warning on stderr


  • next |
  • previous |
  • PythonScript v0.7.0.0 documentation »

Enums

FORMATTYPE

class FORMATTYPE
FORMATTYPE.MAC
FORMATTYPE.UNIX
FORMATTYPE.WIN

BUFFERENCODING

class BUFFERENCODING
BUFFERENCODING.ANSI
BUFFERENCODING.COOKIE
BUFFERENCODING.ENC8BIT
BUFFERENCODING.UCS2BE
BUFFERENCODING.UCS2BE_NOBOM
BUFFERENCODING.UCS2LE
BUFFERENCODING.UCS2LE_NOBOM
BUFFERENCODING.UTF8

STATUSBARSECTION

class STATUSBARSECTION
STATUSBARSECTION.CURPOS
STATUSBARSECTION.DOCSIZE
STATUSBARSECTION.DOCTYPE
STATUSBARSECTION.EOFFORMAT
STATUSBARSECTION.TYPINGMODE
STATUSBARSECTION.UNICODETYPE

NOTIFICATION

class NOTIFICATION
NOTIFICATION.BUFFERACTIVATED

Arguments contains: bufferID

NOTIFICATION.FILEBEFORECLOSE

Arguments contains: bufferID

NOTIFICATION.FILEBEFORELOAD
NOTIFICATION.FILEBEFOREOPEN

Arguments contains: bufferID

NOTIFICATION.FILEBEFORESAVE

Arguments contains: bufferID

NOTIFICATION.FILECLOSED

Arguments contains: bufferID

NOTIFICATION.FILELOADFAILED

Arguments contains: bufferID

NOTIFICATION.FILEOPENED

Arguments contains: bufferID

NOTIFICATION.FILESAVED
NOTIFICATION.LANGCHANGED

Arguments contains: bufferID

NOTIFICATION.READONLYCHANGED

Arguments contains: bufferID, readonly, and dirty. dirty is set to True if the file is currently marked as dirty.

NOTIFICATION.READY
NOTIFICATION.SHORTCUTREMAPPED

Arguments contains: commandID, key, isCtrl, isAlt and isShift.

NOTIFICATION.SHUTDOWN
NOTIFICATION.TBMODIFICATION
NOTIFICATION.WORDSTYLESUPDATED

Arguments contains: bufferID

MESSAGEBOXFLAGS

class MESSAGEBOXFLAGS
MESSAGEBOXFLAGS.ABORTRETRYIGNORE
MESSAGEBOXFLAGS.CANCELTRYCONTINUE
MESSAGEBOXFLAGS.DEFBUTTON1
MESSAGEBOXFLAGS.DEFBUTTON2
MESSAGEBOXFLAGS.DEFBUTTON3
MESSAGEBOXFLAGS.DEFBUTTON4
MESSAGEBOXFLAGS.ICONASTERISK
MESSAGEBOXFLAGS.ICONERROR
MESSAGEBOXFLAGS.ICONEXCLAMATION
MESSAGEBOXFLAGS.ICONHAND
MESSAGEBOXFLAGS.ICONINFORMATION
MESSAGEBOXFLAGS.ICONQUESTION
MESSAGEBOXFLAGS.ICONSTOP
MESSAGEBOXFLAGS.ICONWARNING
MESSAGEBOXFLAGS.OK
MESSAGEBOXFLAGS.OKCANCEL
MESSAGEBOXFLAGS.RETRYCANCEL
MESSAGEBOXFLAGS.YESNO
MESSAGEBOXFLAGS.YESNOCANCEL
MESSAGEBOXFLAGS.RESULTCONTINUE
MESSAGEBOXFLAGS.RESULTABORT
MESSAGEBOXFLAGS.RESULTCANCEL
MESSAGEBOXFLAGS.RESULTIGNORE
MESSAGEBOXFLAGS.RESULTNO
MESSAGEBOXFLAGS.RESULTOK
MESSAGEBOXFLAGS.RESULTRETRY
MESSAGEBOXFLAGS.RESULTTRYAGAIN
MESSAGEBOXFLAGS.RESULTYES

MENUCOMMAND

class MENUCOMMAND
MENUCOMMAND.CLEAN_RECENT_FILE_LIST
MENUCOMMAND.EDIT_AUTOCOMPLETE
MENUCOMMAND.EDIT_AUTOCOMPLETE_CURRENTFILE
MENUCOMMAND.EDIT_BLOCK_COMMENT
MENUCOMMAND.EDIT_BLOCK_COMMENT_SET
MENUCOMMAND.EDIT_BLOCK_UNCOMMENT
MENUCOMMAND.EDIT_CLEARREADONLY
MENUCOMMAND.EDIT_COLUMNMODE
MENUCOMMAND.EDIT_COPY
MENUCOMMAND.EDIT_CURRENTDIRTOCLIP
MENUCOMMAND.EDIT_CUT
MENUCOMMAND.EDIT_DELETE
MENUCOMMAND.EDIT_DUP_LINE
MENUCOMMAND.EDIT_FILENAMETOCLIP
MENUCOMMAND.EDIT_FULLPATHTOCLIP
MENUCOMMAND.EDIT_FUNCCALLTIP
MENUCOMMAND.EDIT_INS_TAB
MENUCOMMAND.EDIT_JOIN_LINES
MENUCOMMAND.EDIT_LINE_DOWN
MENUCOMMAND.EDIT_LINE_UP
MENUCOMMAND.EDIT_LOWERCASE
MENUCOMMAND.EDIT_LTR
MENUCOMMAND.EDIT_PASTE
MENUCOMMAND.EDIT_REDO
MENUCOMMAND.EDIT_RMV_TAB
MENUCOMMAND.EDIT_RTL
MENUCOMMAND.EDIT_SELECTALL
MENUCOMMAND.EDIT_SETREADONLY
MENUCOMMAND.EDIT_SPLIT_LINES
MENUCOMMAND.EDIT_STREAM_COMMENT
MENUCOMMAND.EDIT_TRANSPOSE_LINE
MENUCOMMAND.EDIT_TRIMTRAILING
MENUCOMMAND.EDIT_UNDO
MENUCOMMAND.EDIT_UPPERCASE
MENUCOMMAND.FILE_CLOSE
MENUCOMMAND.FILE_CLOSEALL
MENUCOMMAND.FILE_CLOSEALL_BUT_CURRENT
MENUCOMMAND.FILE_DELETE
MENUCOMMAND.FILE_EXIT
MENUCOMMAND.FILE_LOADSESSION
MENUCOMMAND.FILE_NEW
MENUCOMMAND.FILE_OPEN
MENUCOMMAND.FILE_PRINT
MENUCOMMAND.FILE_PRINTNOW
MENUCOMMAND.FILE_RELOAD
MENUCOMMAND.FILE_RENAME
MENUCOMMAND.FILE_SAVE
MENUCOMMAND.FILE_SAVEALL
MENUCOMMAND.FILE_SAVEAS
MENUCOMMAND.FILE_SAVECOPYAS
MENUCOMMAND.FILE_SAVESESSION
MENUCOMMAND.FOCUS_ON_FOUND_RESULTS
MENUCOMMAND.FORMAT_ANSI
MENUCOMMAND.FORMAT_AS_UTF_8
MENUCOMMAND.FORMAT_BIG5
MENUCOMMAND.FORMAT_CONV2_ANSI
MENUCOMMAND.FORMAT_CONV2_AS_UTF_8
MENUCOMMAND.FORMAT_CONV2_UCS_2BE
MENUCOMMAND.FORMAT_CONV2_UCS_2LE
MENUCOMMAND.FORMAT_CONV2_UTF_8
MENUCOMMAND.FORMAT_DOS_437
MENUCOMMAND.FORMAT_DOS_720
MENUCOMMAND.FORMAT_DOS_737
MENUCOMMAND.FORMAT_DOS_775
MENUCOMMAND.FORMAT_DOS_850
MENUCOMMAND.FORMAT_DOS_852
MENUCOMMAND.FORMAT_DOS_855
MENUCOMMAND.FORMAT_DOS_857
MENUCOMMAND.FORMAT_DOS_858
MENUCOMMAND.FORMAT_DOS_860
MENUCOMMAND.FORMAT_DOS_861
MENUCOMMAND.FORMAT_DOS_862
MENUCOMMAND.FORMAT_DOS_863
MENUCOMMAND.FORMAT_DOS_865
MENUCOMMAND.FORMAT_DOS_866
MENUCOMMAND.FORMAT_DOS_869
MENUCOMMAND.FORMAT_ENCODE
MENUCOMMAND.FORMAT_ENCODE_END
MENUCOMMAND.FORMAT_EUC_KR
MENUCOMMAND.FORMAT_GB2312
MENUCOMMAND.FORMAT_ISO_8859_1
MENUCOMMAND.FORMAT_ISO_8859_10
MENUCOMMAND.FORMAT_ISO_8859_11
MENUCOMMAND.FORMAT_ISO_8859_13
MENUCOMMAND.FORMAT_ISO_8859_14
MENUCOMMAND.FORMAT_ISO_8859_15
MENUCOMMAND.FORMAT_ISO_8859_16
MENUCOMMAND.FORMAT_ISO_8859_2
MENUCOMMAND.FORMAT_ISO_8859_3
MENUCOMMAND.FORMAT_ISO_8859_4
MENUCOMMAND.FORMAT_ISO_8859_5
MENUCOMMAND.FORMAT_ISO_8859_6
MENUCOMMAND.FORMAT_ISO_8859_7
MENUCOMMAND.FORMAT_ISO_8859_8
MENUCOMMAND.FORMAT_ISO_8859_9
MENUCOMMAND.FORMAT_KOI8R_CYRILLIC
MENUCOMMAND.FORMAT_KOI8U_CYRILLIC
MENUCOMMAND.FORMAT_KOREAN_WIN
MENUCOMMAND.FORMAT_MAC_CYRILLIC
MENUCOMMAND.FORMAT_SHIFT_JIS
MENUCOMMAND.FORMAT_TIS_620
MENUCOMMAND.FORMAT_TODOS
MENUCOMMAND.FORMAT_TOMAC
MENUCOMMAND.FORMAT_TOUNIX
MENUCOMMAND.FORMAT_UCS_2BE
MENUCOMMAND.FORMAT_UCS_2LE
MENUCOMMAND.FORMAT_UTF_8
MENUCOMMAND.FORMAT_WIN_1250
MENUCOMMAND.FORMAT_WIN_1251
MENUCOMMAND.FORMAT_WIN_1252
MENUCOMMAND.FORMAT_WIN_1253
MENUCOMMAND.FORMAT_WIN_1254
MENUCOMMAND.FORMAT_WIN_1255
MENUCOMMAND.FORMAT_WIN_1256
MENUCOMMAND.FORMAT_WIN_1257
MENUCOMMAND.FORMAT_WIN_1258
MENUCOMMAND.FORUM
MENUCOMMAND.HELP
MENUCOMMAND.HOMESWEETHOME
MENUCOMMAND.LANGSTYLE_CONFIG_DLG
MENUCOMMAND.LANG_ADA
MENUCOMMAND.LANG_ASCII
MENUCOMMAND.LANG_ASM
MENUCOMMAND.LANG_ASP
MENUCOMMAND.LANG_AU3
MENUCOMMAND.LANG_BASH
MENUCOMMAND.LANG_BATCH
MENUCOMMAND.LANG_C
MENUCOMMAND.LANG_CAML
MENUCOMMAND.LANG_CMAKE
MENUCOMMAND.LANG_COBOL
MENUCOMMAND.LANG_CPP
MENUCOMMAND.LANG_CS
MENUCOMMAND.LANG_CSS
MENUCOMMAND.LANG_D
MENUCOMMAND.LANG_DIFF
MENUCOMMAND.LANG_EXTERNAL
MENUCOMMAND.LANG_EXTERNAL_LIMIT
MENUCOMMAND.LANG_FLASH
MENUCOMMAND.LANG_FORTRAN
MENUCOMMAND.LANG_GUI4CLI
MENUCOMMAND.LANG_HASKELL
MENUCOMMAND.LANG_HTML
MENUCOMMAND.LANG_INI
MENUCOMMAND.LANG_INNO
MENUCOMMAND.LANG_JAVA
MENUCOMMAND.LANG_JS
MENUCOMMAND.LANG_JSP
MENUCOMMAND.LANG_KIX
MENUCOMMAND.LANG_LISP
MENUCOMMAND.LANG_LUA
MENUCOMMAND.LANG_MAKEFILE
MENUCOMMAND.LANG_MATLAB
MENUCOMMAND.LANG_NSIS
MENUCOMMAND.LANG_OBJC
MENUCOMMAND.LANG_PASCAL
MENUCOMMAND.LANG_PERL
MENUCOMMAND.LANG_PHP
MENUCOMMAND.LANG_POWERSHELL
MENUCOMMAND.LANG_PROPS
MENUCOMMAND.LANG_PS
MENUCOMMAND.LANG_PYTHON
MENUCOMMAND.LANG_R
MENUCOMMAND.LANG_RC
MENUCOMMAND.LANG_RUBY
MENUCOMMAND.LANG_SCHEME
MENUCOMMAND.LANG_SMALLTALK
MENUCOMMAND.LANG_SQL
MENUCOMMAND.LANG_TCL
MENUCOMMAND.LANG_TEX
MENUCOMMAND.LANG_TEXT
MENUCOMMAND.LANG_USER
MENUCOMMAND.LANG_USER_LIMIT
MENUCOMMAND.LANG_VB
MENUCOMMAND.LANG_VERILOG
MENUCOMMAND.LANG_VHDL
MENUCOMMAND.LANG_XML
MENUCOMMAND.LANG_YAML
MENUCOMMAND.MACRO_PLAYBACKRECORDEDMACRO
MENUCOMMAND.MACRO_RUNMULTIMACRODLG
MENUCOMMAND.MACRO_SAVECURRENTMACRO
MENUCOMMAND.MACRO_STARTRECORDINGMACRO
MENUCOMMAND.MACRO_STOPRECORDINGMACRO
MENUCOMMAND.ONLINEHELP
MENUCOMMAND.OPEN_ALL_RECENT_FILE
MENUCOMMAND.PLUGINSHOME
MENUCOMMAND.PROJECTPAGE
MENUCOMMAND.SEARCH_CLEARALLMARKS
MENUCOMMAND.SEARCH_CLEAR_BOOKMARKS
MENUCOMMAND.SEARCH_COPYMARKEDLINES
MENUCOMMAND.SEARCH_CUTMARKEDLINES
MENUCOMMAND.SEARCH_DELETEMARKEDLINES
MENUCOMMAND.SEARCH_FIND
MENUCOMMAND.SEARCH_FINDINCREMENT
MENUCOMMAND.SEARCH_FINDINFILES
MENUCOMMAND.SEARCH_FINDNEXT
MENUCOMMAND.SEARCH_FINDPREV
MENUCOMMAND.SEARCH_GONEXTMARKER1
MENUCOMMAND.SEARCH_GONEXTMARKER2
MENUCOMMAND.SEARCH_GONEXTMARKER3
MENUCOMMAND.SEARCH_GONEXTMARKER4
MENUCOMMAND.SEARCH_GONEXTMARKER5
MENUCOMMAND.SEARCH_GONEXTMARKER_DEF
MENUCOMMAND.SEARCH_GOPREVMARKER1
MENUCOMMAND.SEARCH_GOPREVMARKER2
MENUCOMMAND.SEARCH_GOPREVMARKER3
MENUCOMMAND.SEARCH_GOPREVMARKER4
MENUCOMMAND.SEARCH_GOPREVMARKER5
MENUCOMMAND.SEARCH_GOPREVMARKER_DEF
MENUCOMMAND.SEARCH_GOTOLINE
MENUCOMMAND.SEARCH_GOTOMATCHINGBRACE
MENUCOMMAND.SEARCH_GOTONEXTFOUND
MENUCOMMAND.SEARCH_GOTOPREVFOUND
MENUCOMMAND.SEARCH_MARKALLEXT1
MENUCOMMAND.SEARCH_MARKALLEXT2
MENUCOMMAND.SEARCH_MARKALLEXT3
MENUCOMMAND.SEARCH_MARKALLEXT4
MENUCOMMAND.SEARCH_MARKALLEXT5
MENUCOMMAND.SEARCH_NEXT_BOOKMARK
MENUCOMMAND.SEARCH_PASTEMARKEDLINES
MENUCOMMAND.SEARCH_PREV_BOOKMARK
MENUCOMMAND.SEARCH_REPLACE
MENUCOMMAND.SEARCH_SETANDFINDNEXT
MENUCOMMAND.SEARCH_SETANDFINDPREV
MENUCOMMAND.SEARCH_TOGGLE_BOOKMARK
MENUCOMMAND.SEARCH_UNMARKALLEXT1
MENUCOMMAND.SEARCH_UNMARKALLEXT2
MENUCOMMAND.SEARCH_UNMARKALLEXT3
MENUCOMMAND.SEARCH_UNMARKALLEXT4
MENUCOMMAND.SEARCH_UNMARKALLEXT5
MENUCOMMAND.SEARCH_VOLATILE_FINDNEXT
MENUCOMMAND.SEARCH_VOLATILE_FINDPREV
MENUCOMMAND.SETTING_AUTOCNBCHAR
MENUCOMMAND.SETTING_EDGE_SIZE
MENUCOMMAND.SETTING_HISTORY_SIZE
MENUCOMMAND.SETTING_IMPORTPLUGIN
MENUCOMMAND.SETTING_IMPORTSTYLETHEMS
MENUCOMMAND.SETTING_PREFERECE
MENUCOMMAND.SETTING_REMEMBER_LAST_SESSION
MENUCOMMAND.SETTING_SHORTCUT_MAPPER
MENUCOMMAND.SETTING_TAB_REPLCESPACE
MENUCOMMAND.SETTING_TAB_SIZE
MENUCOMMAND.SETTING_TRAYICON
MENUCOMMAND.SYSTRAYPOPUP_ACTIVATE
MENUCOMMAND.SYSTRAYPOPUP_CLOSE
MENUCOMMAND.SYSTRAYPOPUP_NEWDOC
MENUCOMMAND.SYSTRAYPOPUP_NEW_AND_PASTE
MENUCOMMAND.SYSTRAYPOPUP_OPENFILE
MENUCOMMAND.UPDATE_NPP
MENUCOMMAND.VIEW_ALL_CHARACTERS
MENUCOMMAND.VIEW_ALWAYSONTOP
MENUCOMMAND.VIEW_CLONE_TO_ANOTHER_VIEW
MENUCOMMAND.VIEW_CURLINE_HILITING
MENUCOMMAND.VIEW_DOCCHANGEMARGIN
MENUCOMMAND.VIEW_DRAWTABBAR_CLOSEBOTTUN
MENUCOMMAND.VIEW_DRAWTABBAR_DBCLK2CLOSE
MENUCOMMAND.VIEW_DRAWTABBAR_INACIVETAB
MENUCOMMAND.VIEW_DRAWTABBAR_MULTILINE
MENUCOMMAND.VIEW_DRAWTABBAR_TOPBAR
MENUCOMMAND.VIEW_DRAWTABBAR_VERTICAL
MENUCOMMAND.VIEW_EDGEBACKGROUND
MENUCOMMAND.VIEW_EDGELINE
MENUCOMMAND.VIEW_EDGENONE
MENUCOMMAND.VIEW_EOL
MENUCOMMAND.VIEW_FOLD
MENUCOMMAND.VIEW_FOLDERMAGIN
MENUCOMMAND.VIEW_FOLDERMAGIN_ARROW
MENUCOMMAND.VIEW_FOLDERMAGIN_BOX
MENUCOMMAND.VIEW_FOLDERMAGIN_CIRCLE
MENUCOMMAND.VIEW_FOLDERMAGIN_SIMPLE
MENUCOMMAND.VIEW_FOLD_1
MENUCOMMAND.VIEW_FOLD_2
MENUCOMMAND.VIEW_FOLD_3
MENUCOMMAND.VIEW_FOLD_4
MENUCOMMAND.VIEW_FOLD_5
MENUCOMMAND.VIEW_FOLD_6
MENUCOMMAND.VIEW_FOLD_7
MENUCOMMAND.VIEW_FOLD_8
MENUCOMMAND.VIEW_FOLD_CURRENT
MENUCOMMAND.VIEW_FULLSCREENTOGGLE
MENUCOMMAND.VIEW_GOTO_ANOTHER_VIEW
MENUCOMMAND.VIEW_GOTO_NEW_INSTANCE
MENUCOMMAND.VIEW_HIDELINES
MENUCOMMAND.VIEW_INDENT_GUIDE
MENUCOMMAND.VIEW_LINENUMBER
MENUCOMMAND.VIEW_LOAD_IN_NEW_INSTANCE
MENUCOMMAND.VIEW_LOCKTABBAR
MENUCOMMAND.VIEW_POSTIT
MENUCOMMAND.VIEW_REDUCETABBAR
MENUCOMMAND.VIEW_REFRESHTABAR
MENUCOMMAND.VIEW_SWITCHTO_OTHER_VIEW
MENUCOMMAND.VIEW_SYMBOLMARGIN
MENUCOMMAND.VIEW_SYNSCROLLH
MENUCOMMAND.VIEW_SYNSCROLLV
MENUCOMMAND.VIEW_TAB_SPACE
MENUCOMMAND.VIEW_TOGGLE_FOLDALL
MENUCOMMAND.VIEW_TOGGLE_UNFOLDALL
MENUCOMMAND.VIEW_TOOLBAR_ENLARGE
MENUCOMMAND.VIEW_TOOLBAR_REDUCE
MENUCOMMAND.VIEW_TOOLBAR_STANDARD
MENUCOMMAND.VIEW_UNFOLD
MENUCOMMAND.VIEW_UNFOLD_1
MENUCOMMAND.VIEW_UNFOLD_2
MENUCOMMAND.VIEW_UNFOLD_3
MENUCOMMAND.VIEW_UNFOLD_4
MENUCOMMAND.VIEW_UNFOLD_5
MENUCOMMAND.VIEW_UNFOLD_6
MENUCOMMAND.VIEW_UNFOLD_7
MENUCOMMAND.VIEW_UNFOLD_8
MENUCOMMAND.VIEW_UNFOLD_CURRENT
MENUCOMMAND.VIEW_USER_DLG
MENUCOMMAND.VIEW_WRAP
MENUCOMMAND.VIEW_WRAP_SYMBOL
MENUCOMMAND.VIEW_ZOOMIN
MENUCOMMAND.VIEW_ZOOMOUT
MENUCOMMAND.VIEW_ZOOMRESTORE
MENUCOMMAND.WIKIFAQ

CARETPOLICY

class CARETPOLICY
CARETPOLICY.SLOP
CARETPOLICY.STRICT
CARETPOLICY.JUMPS
CARETPOLICY.EVEN

CASEVISIBLE

class CASEVISIBLE
CASEVISIBLE.MIXED
CASEVISIBLE.UPPER
CASEVISIBLE.LOWER

FOLDFLAG

class FOLDFLAG
FOLDFLAG.LINEBEFORE_EXPANDED
FOLDFLAG.LINEBEFORE_CONTRACTED
FOLDFLAG.LINEAFTER_EXPANDED
FOLDFLAG.LINEAFTER_CONTRACTED
FOLDFLAG.LEVELNUMBERS

CARETSTYLE

class CARETSTYLE
CARETSTYLE.INVISIBLE
CARETSTYLE.LINE
CARETSTYLE.BLOCK

STATUS

class STATUS
STATUS.OK
STATUS.FAILURE
STATUS.BADALLOC

WRAPVISUALLOCATION

class WRAPVISUALLOCATION
WRAPVISUALLOCATION.DEFAULT
WRAPVISUALLOCATION.END_BY_TEXT
WRAPVISUALLOCATION.START_BY_TEXT

KEYS

class KEYS
KEYS.DOWN
KEYS.UP
KEYS.LEFT
KEYS.RIGHT
KEYS.HOME
KEYS.END
KEYS.PRIOR
KEYS.NEXT
KEYS.DELETE
KEYS.INSERT
KEYS.ESCAPE
KEYS.BACK
KEYS.TAB
KEYS.RETURN
KEYS.ADD
KEYS.SUBTRACT
KEYS.DIVIDE
KEYS.WIN
KEYS.RWIN
KEYS.MENU

KEYMOD

class KEYMOD
KEYMOD.NORM
KEYMOD.SHIFT
KEYMOD.CTRL
KEYMOD.ALT
KEYMOD.SUPER

ANNOTATIONVISIBLE

class ANNOTATIONVISIBLE
ANNOTATIONVISIBLE.HIDDEN
ANNOTATIONVISIBLE.STANDARD
ANNOTATIONVISIBLE.BOXED

CHARACTERSET

class CHARACTERSET
CHARACTERSET.ANSI
CHARACTERSET.DEFAULT
CHARACTERSET.BALTIC
CHARACTERSET.CHINESEBIG5
CHARACTERSET.EASTEUROPE
CHARACTERSET.GB2312
CHARACTERSET.GREEK
CHARACTERSET.HANGUL
CHARACTERSET.MAC
CHARACTERSET.OEM
CHARACTERSET.RUSSIAN
CHARACTERSET.CYRILLIC
CHARACTERSET.SHIFTJIS
CHARACTERSET.SYMBOL
CHARACTERSET.TURKISH
CHARACTERSET.JOHAB
CHARACTERSET.HEBREW
CHARACTERSET.ARABIC
CHARACTERSET.VIETNAMESE
CHARACTERSET.THAI
CHARACTERSET.8859_15

PRINTOPTION

class PRINTOPTION
PRINTOPTION.NORMAL
PRINTOPTION.INVERTLIGHT
PRINTOPTION.BLACKONWHITE
PRINTOPTION.COLOURONWHITE
PRINTOPTION.COLOURONWHITEDEFAULTBG

MARKERSYMBOL

class MARKERSYMBOL
MARKERSYMBOL.CIRCLE
MARKERSYMBOL.ROUNDRECT
MARKERSYMBOL.ARROW
MARKERSYMBOL.SMALLRECT
MARKERSYMBOL.SHORTARROW
MARKERSYMBOL.EMPTY
MARKERSYMBOL.ARROWDOWN
MARKERSYMBOL.MINUS
MARKERSYMBOL.PLUS
MARKERSYMBOL.VLINE
MARKERSYMBOL.LCORNER
MARKERSYMBOL.TCORNER
MARKERSYMBOL.BOXPLUS
MARKERSYMBOL.BOXPLUSCONNECTED
MARKERSYMBOL.BOXMINUS
MARKERSYMBOL.BOXMINUSCONNECTED
MARKERSYMBOL.LCORNERCURVE
MARKERSYMBOL.TCORNERCURVE
MARKERSYMBOL.CIRCLEPLUS
MARKERSYMBOL.CIRCLEPLUSCONNECTED
MARKERSYMBOL.CIRCLEMINUS
MARKERSYMBOL.CIRCLEMINUSCONNECTED
MARKERSYMBOL.BACKGROUND
MARKERSYMBOL.DOTDOTDOT
MARKERSYMBOL.ARROWS
MARKERSYMBOL.PIXMAP
MARKERSYMBOL.FULLRECT
MARKERSYMBOL.LEFTRECT
MARKERSYMBOL.AVAILABLE
MARKERSYMBOL.UNDERLINE
MARKERSYMBOL.CHARACTER

INDICATORSTYLE

class INDICATORSTYLE
INDICATORSTYLE.PLAIN
INDICATORSTYLE.SQUIGGLE
INDICATORSTYLE.TT
INDICATORSTYLE.DIAGONAL
INDICATORSTYLE.STRIKE
INDICATORSTYLE.HIDDEN
INDICATORSTYLE.BOX
INDICATORSTYLE.ROUNDBOX
INDICATORSTYLE.MAX
INDICATORSTYLE.CONTAINER

WRAPVISUALFLAG

class WRAPVISUALFLAG
WRAPVISUALFLAG.NONE
WRAPVISUALFLAG.END
WRAPVISUALFLAG.START

LEXER

class LEXER
LEXER.CONTAINER
LEXER.NULL
LEXER.PYTHON
LEXER.CPP
LEXER.HTML
LEXER.XML
LEXER.PERL
LEXER.SQL
LEXER.VB
LEXER.PROPERTIES
LEXER.ERRORLIST
LEXER.MAKEFILE
LEXER.BATCH
LEXER.XCODE
LEXER.LATEX
LEXER.LUA
LEXER.DIFF
LEXER.CONF
LEXER.PASCAL
LEXER.AVE
LEXER.ADA
LEXER.LISP
LEXER.RUBY
LEXER.EIFFEL
LEXER.EIFFELKW
LEXER.TCL
LEXER.NNCRONTAB
LEXER.BULLANT
LEXER.VBSCRIPT
LEXER.BAAN
LEXER.MATLAB
LEXER.SCRIPTOL
LEXER.ASM
LEXER.CPPNOCASE
LEXER.FORTRAN
LEXER.F77
LEXER.CSS
LEXER.POV
LEXER.LOUT
LEXER.ESCRIPT
LEXER.PS
LEXER.NSIS
LEXER.MMIXAL
LEXER.CLW
LEXER.CLWNOCASE
LEXER.LOT
LEXER.YAML
LEXER.TEX
LEXER.METAPOST
LEXER.POWERBASIC
LEXER.FORTH
LEXER.ERLANG
LEXER.OCTAVE
LEXER.MSSQL
LEXER.VERILOG
LEXER.KIX
LEXER.GUI4CLI
LEXER.SPECMAN
LEXER.AU3
LEXER.APDL
LEXER.BASH
LEXER.ASN1
LEXER.VHDL
LEXER.CAML
LEXER.BLITZBASIC
LEXER.PUREBASIC
LEXER.HASKELL
LEXER.PHPSCRIPT
LEXER.TADS3
LEXER.REBOL
LEXER.SMALLTALK
LEXER.FLAGSHIP
LEXER.CSOUND
LEXER.FREEBASIC
LEXER.INNOSETUP
LEXER.OPAL
LEXER.SPICE
LEXER.D
LEXER.CMAKE
LEXER.GAP
LEXER.PLM
LEXER.PROGRESS
LEXER.ABAQUS
LEXER.ASYMPTOTE
LEXER.R
LEXER.MAGIK
LEXER.POWERSHELL
LEXER.MYSQL
LEXER.PO
LEXER.TAL
LEXER.COBOL
LEXER.TACL
LEXER.SORCUS
LEXER.POWERPRO
LEXER.NIMROD
LEXER.SML
LEXER.MARKDOWN
LEXER.AUTOMATIC

CURSORSHAPE

class CURSORSHAPE
CURSORSHAPE.NORMAL
CURSORSHAPE.WAIT

MARGINTYPE

class MARGINTYPE
MARGINTYPE.SYMBOL
MARGINTYPE.NUMBER
MARGINTYPE.BACK
MARGINTYPE.FORE
MARGINTYPE.TEXT
MARGINTYPE.RTEXT

FINDOPTION

class FINDOPTION
FINDOPTION.WHOLEWORD
FINDOPTION.MATCHCASE
FINDOPTION.WORDSTART
FINDOPTION.REGEXP
FINDOPTION.POSIX

VIRTUALSPACE

class VIRTUALSPACE
VIRTUALSPACE.NONE
VIRTUALSPACE.RECTANGULARSELECTION
VIRTUALSPACE.USERACCESSIBLE

EDGEVISUALSTYLE

class EDGEVISUALSTYLE
EDGEVISUALSTYLE.NONE
EDGEVISUALSTYLE.LINE
EDGEVISUALSTYLE.BACKGROUND

WHITESPACE

class WHITESPACE
WHITESPACE.INVISIBLE
WHITESPACE.VISIBLEALWAYS
WHITESPACE.VISIBLEAFTERINDENT

MARKEROUTLINE

class MARKEROUTLINE
MARKEROUTLINE.FOLDEREND
MARKEROUTLINE.FOLDEROPENMID
MARKEROUTLINE.FOLDERMIDTAIL
MARKEROUTLINE.FOLDERTAIL
MARKEROUTLINE.FOLDERSUB
MARKEROUTLINE.FOLDER
MARKEROUTLINE.FOLDEROPEN

FOLDLEVEL

class FOLDLEVEL
FOLDLEVEL.BASE
FOLDLEVEL.WHITEFLAG
FOLDLEVEL.HEADERFLAG
FOLDLEVEL.NUMBERMASK

WRAPINDENTMODE

class WRAPINDENTMODE
WRAPINDENTMODE.FIXED
WRAPINDENTMODE.SAME
WRAPINDENTMODE.INDENT

LINECACHE

class LINECACHE
LINECACHE.NONE
LINECACHE.CARET
LINECACHE.PAGE
LINECACHE.DOCUMENT

MULTIPASTE

class MULTIPASTE
MULTIPASTE.ONCE
MULTIPASTE.EACH

STYLESCOMMON

class STYLESCOMMON
STYLESCOMMON.DEFAULT
STYLESCOMMON.LINENUMBER
STYLESCOMMON.BRACELIGHT
STYLESCOMMON.BRACEBAD
STYLESCOMMON.CONTROLCHAR
STYLESCOMMON.INDENTGUIDE
STYLESCOMMON.CALLTIP
STYLESCOMMON.LASTPREDEFINED
STYLESCOMMON.MAX

INDENTVIEW

class INDENTVIEW
INDENTVIEW.NONE
INDENTVIEW.REAL
INDENTVIEW.LOOKFORWARD
INDENTVIEW.LOOKBOTH

WRAP

class WRAP
WRAP.NONE
WRAP.WORD
WRAP.CHAR

SELECTIONMODE

class SELECTIONMODE
SELECTIONMODE.STREAM
SELECTIONMODE.RECTANGLE
SELECTIONMODE.LINES
SELECTIONMODE.THIN

FONTQUALITY

class FONTQUALITY
FONTQUALITY.QUALITY_MASK
FONTQUALITY.QUALITY_DEFAULT
FONTQUALITY.QUALITY_NON_ANTIALIASED
FONTQUALITY.QUALITY_ANTIALIASED
FONTQUALITY.QUALITY_LCD_OPTIMIZED

ENDOFLINE

class ENDOFLINE
ENDOFLINE.CRLF
ENDOFLINE.CR
ENDOFLINE.LF


  • PythonScript v0.7.0.0 documentation »

Interface for Other Plugins

For plugin authors, you can run Python scripts and expressions by calling Python Script remotely. For this we use the Notepad++ message NPPM_MSGTOPLUGIN.

I’ll give instructions for C / C++, other languages you’ll need to convert the interface to - any submissions for other languages are welcome!

First #include "PythonScript/NppPluginScript.h" from the PythonScriptinclude directory in the source archive. The following instructions are also contained in this file.

A struct is defined in this file called PythonScript_Exec. This struct has a few members as follows.:

struct PythonScript_Exec
{
        /// PythonScript_Exec structure version - must always be 1
        int structVersion;

        /// Python Script (for PYSCR_EXECSTATEMENT) or absolute filename (for PYSCR_EXECSCRIPT)
        TCHAR *script;

        /** HANDLE to an event created with CreateEvent.  This event is signalled (with SetEvent)
         *  when the script has completed.
         *  This can be NULL, in which case no event is signalled
         *
         *  Important: Do NOT wait on the handle on the thread that Notepad++ runs on
         *  (ie. the plugin default thread) unless you really know what you are doing :)
         *  It will almost certainly deadlock (as Scintilla or N++ may need to process a message)
         */

        HANDLE completedEvent;

        /** Flags for running the script
         *  Combination of PYSCRF_xxxxx constants
         */
        int flags;

        /** PythonScripts sets this to TRUE when the PythonScript plugin
         *  has successfully received the message.
         *  Note that a TRUE here does NOT mean the script has run, or ran without
         *  errors, merely that the script has been added to the queue to run
         *
         *  You should set this to FALSE initially, and check for TRUE when SendMessage() returns.
         */
        BOOL deliverySuccess;
};

There are two messages you can use - PYSCR_EXECSCRIPT and PYSCR_EXECSTATEMENT. For the first, you pass the absolute filename of the script you wish to run, the second, you pass the statement directly.

Here’s a sample of how to call NPPM_MSGTOPLUGIN.:

void callPython()
{
        PythonScript_Exec pse;
        pse.structVersion = 1;

        HANDLE completeEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

        pse.completedEvent = completeEvent;
        pse.deliverySuccess = FALSE;

        TCHAR script[] = _T("e:\\script_to_run.py");
        pse.script = script;
        pse.flags = PYSCRF_SYNC;

        TCHAR pluginName[] = _T("PythonScript.dll");
        CommunicationInfo commInfo;
        commInfo.internalMsg = PYSCR_EXECSCRIPT;
        commInfo.srcModuleName = _T("MyPlugin.dll");

        commInfo.info = reinterpret_cast<void*>(&pse);

        BOOL delivery = SendMessage(nppData._nppHandle, NPPM_MSGTOPLUGIN, reinterpret_cast<WPARAM>(pluginName), reinterpret_cast<LPARAM>(&commInfo));
        if (!delivery)
        {
                MessageBox(NULL, _T("Python Script not found"), _T("Msg2PluginTester"), 0);
        }

        if (pse.deliverySuccess)
        {
                MessageBox(NULL, _T("Delivery Success"), _T("Msg2PluginTester"), 0);
        }
        else
        {
                MessageBox(NULL, _T("Delivery FAILED!"), _T("Msg2PluginTester"), 0);
        }

        // Optionally now start a thread to wait for the completion
        CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)threadRun, (LPVOID)completeEvent, 0, NULL);
}
...

void threadRun(HANDLE waitEvent)
{
        WaitForSingleObject(waitEvent, INFINITE);
        MessageBox(NULL, _T("Finished!"), _T("I waited..."), 0);
}


Index

Symbols | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

Symbols

8859_15 (CHARACTERSET attribute)

A

ABAQUS (LEXER attribute)
ABORTRETRYIGNORE (MESSAGEBOXFLAGS attribute)
activateBufferID() (Notepad method)
activateFile() (Notepad method)
activateIndex() (Notepad method)
ADA (LEXER attribute)
ADD (KEYS attribute)
addRefDocument() (Editor method)
addSelection() (Editor method)
addStyledText() (Editor method)
addText() (Editor method)
addUndoAction() (Editor method)
allocate() (Editor method)
ALT (KEYMOD attribute)
annotationClearAll() (Editor method)
annotationGetLines() (Editor method)
annotationGetStyle() (Editor method)
annotationGetStyleOffset() (Editor method)
annotationGetStyles() (Editor method)
annotationGetText() (Editor method)
annotationGetVisible() (Editor method)
annotationSetStyle() (Editor method)
annotationSetStyleOffset() (Editor method)
annotationSetStyles() (Editor method)
annotationSetText() (Editor method)
annotationSetVisible() (Editor method)
ANNOTATIONVISIBLE (built-in class)
ANSI (BUFFERENCODING attribute)
(CHARACTERSET attribute)
APDL (LEXER attribute)
appendText() (Editor method)
ARABIC (CHARACTERSET attribute)
ARROW (MARKERSYMBOL attribute)
ARROWDOWN (MARKERSYMBOL attribute)
ARROWS (MARKERSYMBOL attribute)
ASM (LEXER attribute)
ASN1 (LEXER attribute)
assignCmdKey() (Editor method)
ASYMPTOTE (LEXER attribute)
AU3 (LEXER attribute)
autoCActive() (Editor method)
autoCCancel() (Editor method)
autoCComplete() (Editor method)
autoCGetAutoHide() (Editor method)
autoCGetCancelAtStart() (Editor method)
autoCGetChooseSingle() (Editor method)
autoCGetCurrent() (Editor method)
autoCGetCurrentText() (Editor method)
autoCGetDropRestOfWord() (Editor method)
autoCGetIgnoreCase() (Editor method)
autoCGetMaxHeight() (Editor method)
autoCGetMaxWidth() (Editor method)
autoCGetSeparator() (Editor method)
autoCGetTypeSeparator() (Editor method)
autoCPosStart() (Editor method)
autoCSelect() (Editor method)
autoCSetAutoHide() (Editor method)
autoCSetCancelAtStart() (Editor method)
autoCSetChooseSingle() (Editor method)
autoCSetDropRestOfWord() (Editor method)
autoCSetFillUps() (Editor method)
autoCSetIgnoreCase() (Editor method)
autoCSetMaxHeight() (Editor method)
autoCSetMaxWidth() (Editor method)
autoCSetSeparator() (Editor method)
autoCSetTypeSeparator() (Editor method)
autoCShow() (Editor method)
autoCStops() (Editor method)
AUTOMATIC (LEXER attribute)
AVAILABLE (MARKERSYMBOL attribute)
AVE (LEXER attribute)

B

BAAN (LEXER attribute)
BACK (KEYS attribute)
(MARGINTYPE attribute)
BACKGROUND (EDGEVISUALSTYLE attribute)
(MARKERSYMBOL attribute)
backTab() (Editor method)
BADALLOC (STATUS attribute)
BALTIC (CHARACTERSET attribute)
BASE (FOLDLEVEL attribute)
BASH (LEXER attribute)
BATCH (LEXER attribute)
beginUndoAction() (Editor method)
BLACKONWHITE (PRINTOPTION attribute)
BLITZBASIC (LEXER attribute)
BLOCK (CARETSTYLE attribute)
BOX (INDICATORSTYLE attribute)
BOXED (ANNOTATIONVISIBLE attribute)
BOXMINUS (MARKERSYMBOL attribute)
BOXMINUSCONNECTED (MARKERSYMBOL attribute)
BOXPLUS (MARKERSYMBOL attribute)
BOXPLUSCONNECTED (MARKERSYMBOL attribute)
BRACEBAD (STYLESCOMMON attribute)
braceBadLight() (Editor method)
braceHighlight() (Editor method)
BRACELIGHT (STYLESCOMMON attribute)
braceMatch() (Editor method)
BUFFERACTIVATED (NOTIFICATION attribute)
BUFFERENCODING (built-in class)
BULLANT (LEXER attribute)

C

callback() (Notepad method)
CALLTIP (STYLESCOMMON attribute)
callTipActive() (Editor method)
callTipCancel() (Editor method)
callTipPosStart() (Editor method)
callTipSetBack() (Editor method)
callTipSetFore() (Editor method)
callTipSetForeHlt() (Editor method)
callTipSetHlt() (Editor method)
callTipShow() (Editor method)
callTipUseStyle() (Editor method)
CAML (LEXER attribute)
cancel() (Editor method)
CANCELTRYCONTINUE (MESSAGEBOXFLAGS attribute)
canPaste() (Editor method)
canRedo() (Editor method)
canUndo() (Editor method)
CARET (LINECACHE attribute)
CARETPOLICY (built-in class)
CARETSTYLE (built-in class)
CASEVISIBLE (built-in class)
CHAR (WRAP attribute)
CHARACTER (MARKERSYMBOL attribute)
CHARACTERSET (built-in class)
charLeft() (Editor method)
charLeftExtend() (Editor method)
charLeftRectExtend() (Editor method)
charPositionFromPoint() (Editor method)
charPositionFromPointClose() (Editor method)
charRight() (Editor method)
charRightExtend() (Editor method)
charRightRectExtend() (Editor method)
CHINESEBIG5 (CHARACTERSET attribute)
chooseCaretX() (Editor method)
CIRCLE (MARKERSYMBOL attribute)
CIRCLEMINUS (MARKERSYMBOL attribute)
CIRCLEMINUSCONNECTED (MARKERSYMBOL attribute)
CIRCLEPLUS (MARKERSYMBOL attribute)
CIRCLEPLUSCONNECTED (MARKERSYMBOL attribute)
CLEAN_RECENT_FILE_LIST (MENUCOMMAND attribute)
clear() (Console method)
(Editor method)
clearAll() (Editor method)
clearAllCmdKeys() (Editor method)
clearCallbacks() (Editor method), [1], [2], [3]
(Notepad method), [1], [2], [3]
clearCmdKey() (Editor method)
clearDocumentStyle() (Editor method)
clearRegisteredImages() (Editor method)
clearSelections() (Editor method)
close() (Notepad method)
closeAll() (Notepad method)
closeAllButCurrent() (Notepad method)
CLW (LEXER attribute)
CLWNOCASE (LEXER attribute)
CMAKE (LEXER attribute)
COBOL (LEXER attribute)
colourise() (Editor method)
COLOURONWHITE (PRINTOPTION attribute)
COLOURONWHITEDEFAULTBG (PRINTOPTION attribute)
CONF (LEXER attribute)
Console (built-in class)
CONTAINER (INDICATORSTYLE attribute)
(LEXER attribute)
CONTROLCHAR (STYLESCOMMON attribute)
convertEOLs() (Editor method)
COOKIE (BUFFERENCODING attribute)
copy() (Editor method)
copyAllowLine() (Editor method)
copyRange() (Editor method)
copyText() (Editor method)
CPP (LEXER attribute)
CPPNOCASE (LEXER attribute)
CR (ENDOFLINE attribute)
createDocument() (Editor method)
createScintilla() (Notepad method)
CRLF (ENDOFLINE attribute)
CSOUND (LEXER attribute)
CSS (LEXER attribute)
CTRL (KEYMOD attribute)
CURPOS (STATUSBARSECTION attribute)
CURSORSHAPE (built-in class)
cut() (Editor method)
CYRILLIC (CHARACTERSET attribute)

D

D (LEXER attribute)
DEFAULT (CHARACTERSET attribute)
(STYLESCOMMON attribute)
(WRAPVISUALLOCATION attribute)
DEFBUTTON1 (MESSAGEBOXFLAGS attribute)
DEFBUTTON2 (MESSAGEBOXFLAGS attribute)
DEFBUTTON3 (MESSAGEBOXFLAGS attribute)
DEFBUTTON4 (MESSAGEBOXFLAGS attribute)
DELETE (KEYS attribute)
deleteBack() (Editor method)
deleteBackNotLine() (Editor method)
deleteLine() (Editor method)
delLineLeft() (Editor method)
delLineRight() (Editor method)
delWordLeft() (Editor method)
delWordRight() (Editor method)
delWordRightEnd() (Editor method)
destroyScintilla() (Notepad method)
DIAGONAL (INDICATORSTYLE attribute)
DIFF (LEXER attribute)
DIVIDE (KEYS attribute)
docLineFromVisible() (Editor method)
DOCSIZE (STATUSBARSECTION attribute)
DOCTYPE (STATUSBARSECTION attribute)
DOCUMENT (LINECACHE attribute)
documentEnd() (Editor method)
documentEndExtend() (Editor method)
documentStart() (Editor method)
documentStartExtend() (Editor method)
DOTDOTDOT (MARKERSYMBOL attribute)
DOWN (KEYS attribute)

E

EACH (MULTIPASTE attribute)
EASTEUROPE (CHARACTERSET attribute)
EDGEVISUALSTYLE (built-in class)
EDIT_AUTOCOMPLETE (MENUCOMMAND attribute)
EDIT_AUTOCOMPLETE_CURRENTFILE (MENUCOMMAND attribute)
EDIT_BLOCK_COMMENT (MENUCOMMAND attribute)
EDIT_BLOCK_COMMENT_SET (MENUCOMMAND attribute)
EDIT_BLOCK_UNCOMMENT (MENUCOMMAND attribute)
EDIT_CLEARREADONLY (MENUCOMMAND attribute)
EDIT_COLUMNMODE (MENUCOMMAND attribute)
EDIT_COPY (MENUCOMMAND attribute)
EDIT_CURRENTDIRTOCLIP (MENUCOMMAND attribute)
EDIT_CUT (MENUCOMMAND attribute)
EDIT_DELETE (MENUCOMMAND attribute)
EDIT_DUP_LINE (MENUCOMMAND attribute)
EDIT_FILENAMETOCLIP (MENUCOMMAND attribute)
EDIT_FULLPATHTOCLIP (MENUCOMMAND attribute)
EDIT_FUNCCALLTIP (MENUCOMMAND attribute)
EDIT_INS_TAB (MENUCOMMAND attribute)
EDIT_JOIN_LINES (MENUCOMMAND attribute)
EDIT_LINE_DOWN (MENUCOMMAND attribute)
EDIT_LINE_UP (MENUCOMMAND attribute)
EDIT_LOWERCASE (MENUCOMMAND attribute)
EDIT_LTR (MENUCOMMAND attribute)
EDIT_PASTE (MENUCOMMAND attribute)
EDIT_REDO (MENUCOMMAND attribute)
EDIT_RMV_TAB (MENUCOMMAND attribute)
EDIT_RTL (MENUCOMMAND attribute)
EDIT_SELECTALL (MENUCOMMAND attribute)
EDIT_SETREADONLY (MENUCOMMAND attribute)
EDIT_SPLIT_LINES (MENUCOMMAND attribute)
EDIT_STREAM_COMMENT (MENUCOMMAND attribute)
EDIT_TRANSPOSE_LINE (MENUCOMMAND attribute)
EDIT_TRIMTRAILING (MENUCOMMAND attribute)
EDIT_UNDO (MENUCOMMAND attribute)
EDIT_UPPERCASE (MENUCOMMAND attribute)
Editor (built-in class)
editor (Console attribute)
editToggleOvertype() (Editor method)
EIFFEL (LEXER attribute)
EIFFELKW (LEXER attribute)
EMPTY (MARKERSYMBOL attribute)
emptyUndoBuffer() (Editor method)
ENC8BIT (BUFFERENCODING attribute)
encodedFromUTF8() (Editor method)
END (KEYS attribute)
(WRAPVISUALFLAG attribute)
END_BY_TEXT (WRAPVISUALLOCATION attribute)
ENDOFLINE (built-in class)
endUndoAction() (Editor method)
ensureVisible() (Editor method)
ensureVisibleEnforcePolicy() (Editor method)
EOFFORMAT (STATUSBARSECTION attribute)
ERLANG (LEXER attribute)
ERRORLIST (LEXER attribute)
ESCAPE (KEYS attribute)
ESCRIPT (LEXER attribute)
EVEN (CARETPOLICY attribute)

F

F77 (LEXER attribute)
FAILURE (STATUS attribute)
FILE_CLOSE (MENUCOMMAND attribute)
FILE_CLOSEALL (MENUCOMMAND attribute)
FILE_CLOSEALL_BUT_CURRENT (MENUCOMMAND attribute)
FILE_DELETE (MENUCOMMAND attribute)
FILE_EXIT (MENUCOMMAND attribute)
FILE_LOADSESSION (MENUCOMMAND attribute)
FILE_NEW (MENUCOMMAND attribute)
FILE_OPEN (MENUCOMMAND attribute)
FILE_PRINT (MENUCOMMAND attribute)
FILE_PRINTNOW (MENUCOMMAND attribute)
FILE_RELOAD (MENUCOMMAND attribute)
FILE_RENAME (MENUCOMMAND attribute)
FILE_SAVE (MENUCOMMAND attribute)
FILE_SAVEALL (MENUCOMMAND attribute)
FILE_SAVEAS (MENUCOMMAND attribute)
FILE_SAVECOPYAS (MENUCOMMAND attribute)
FILE_SAVESESSION (MENUCOMMAND attribute)
FILEBEFORECLOSE (NOTIFICATION attribute)
FILEBEFORELOAD (NOTIFICATION attribute)
FILEBEFOREOPEN (NOTIFICATION attribute)
FILEBEFORESAVE (NOTIFICATION attribute)
FILECLOSED (NOTIFICATION attribute)
FILELOADFAILED (NOTIFICATION attribute)
FILEOPENED (NOTIFICATION attribute)
FILESAVED (NOTIFICATION attribute)
findColumn() (Editor method)
FINDOPTION (built-in class)
findText() (Editor method)
FIXED (WRAPINDENTMODE attribute)
FLAGSHIP (LEXER attribute)
FOCUS_ON_FOUND_RESULTS (MENUCOMMAND attribute)
FOLDER (MARKEROUTLINE attribute)
FOLDEREND (MARKEROUTLINE attribute)
FOLDERMIDTAIL (MARKEROUTLINE attribute)
FOLDEROPEN (MARKEROUTLINE attribute)
FOLDEROPENMID (MARKEROUTLINE attribute)
FOLDERSUB (MARKEROUTLINE attribute)
FOLDERTAIL (MARKEROUTLINE attribute)
FOLDFLAG (built-in class)
FOLDLEVEL (built-in class)
FONTQUALITY (built-in class)
FORE (MARGINTYPE attribute)
forEachLine() (Editor method)
FORMAT_ANSI (MENUCOMMAND attribute)
FORMAT_AS_UTF_8 (MENUCOMMAND attribute)
FORMAT_BIG5 (MENUCOMMAND attribute)
FORMAT_CONV2_ANSI (MENUCOMMAND attribute)
FORMAT_CONV2_AS_UTF_8 (MENUCOMMAND attribute)
FORMAT_CONV2_UCS_2BE (MENUCOMMAND attribute)
FORMAT_CONV2_UCS_2LE (MENUCOMMAND attribute)
FORMAT_CONV2_UTF_8 (MENUCOMMAND attribute)
FORMAT_DOS_437 (MENUCOMMAND attribute)
FORMAT_DOS_720 (MENUCOMMAND attribute)
FORMAT_DOS_737 (MENUCOMMAND attribute)
FORMAT_DOS_775 (MENUCOMMAND attribute)
FORMAT_DOS_850 (MENUCOMMAND attribute)
FORMAT_DOS_852 (MENUCOMMAND attribute)
FORMAT_DOS_855 (MENUCOMMAND attribute)
FORMAT_DOS_857 (MENUCOMMAND attribute)
FORMAT_DOS_858 (MENUCOMMAND attribute)
FORMAT_DOS_860 (MENUCOMMAND attribute)
FORMAT_DOS_861 (MENUCOMMAND attribute)
FORMAT_DOS_862 (MENUCOMMAND attribute)
FORMAT_DOS_863 (MENUCOMMAND attribute)
FORMAT_DOS_865 (MENUCOMMAND attribute)
FORMAT_DOS_866 (MENUCOMMAND attribute)
FORMAT_DOS_869 (MENUCOMMAND attribute)
FORMAT_ENCODE (MENUCOMMAND attribute)
FORMAT_ENCODE_END (MENUCOMMAND attribute)
FORMAT_EUC_KR (MENUCOMMAND attribute)
FORMAT_GB2312 (MENUCOMMAND attribute)
FORMAT_ISO_8859_1 (MENUCOMMAND attribute)
FORMAT_ISO_8859_10 (MENUCOMMAND attribute)
FORMAT_ISO_8859_11 (MENUCOMMAND attribute)
FORMAT_ISO_8859_13 (MENUCOMMAND attribute)
FORMAT_ISO_8859_14 (MENUCOMMAND attribute)
FORMAT_ISO_8859_15 (MENUCOMMAND attribute)
FORMAT_ISO_8859_16 (MENUCOMMAND attribute)
FORMAT_ISO_8859_2 (MENUCOMMAND attribute)
FORMAT_ISO_8859_3 (MENUCOMMAND attribute)
FORMAT_ISO_8859_4 (MENUCOMMAND attribute)
FORMAT_ISO_8859_5 (MENUCOMMAND attribute)
FORMAT_ISO_8859_6 (MENUCOMMAND attribute)
FORMAT_ISO_8859_7 (MENUCOMMAND attribute)
FORMAT_ISO_8859_8 (MENUCOMMAND attribute)
FORMAT_ISO_8859_9 (MENUCOMMAND attribute)
FORMAT_KOI8R_CYRILLIC (MENUCOMMAND attribute)
FORMAT_KOI8U_CYRILLIC (MENUCOMMAND attribute)
FORMAT_KOREAN_WIN (MENUCOMMAND attribute)
FORMAT_MAC_CYRILLIC (MENUCOMMAND attribute)
FORMAT_SHIFT_JIS (MENUCOMMAND attribute)
FORMAT_TIS_620 (MENUCOMMAND attribute)
FORMAT_TODOS (MENUCOMMAND attribute)
FORMAT_TOMAC (MENUCOMMAND attribute)
FORMAT_TOUNIX (MENUCOMMAND attribute)
FORMAT_UCS_2BE (MENUCOMMAND attribute)
FORMAT_UCS_2LE (MENUCOMMAND attribute)
FORMAT_UTF_8 (MENUCOMMAND attribute)
FORMAT_WIN_1250 (MENUCOMMAND attribute)
FORMAT_WIN_1251 (MENUCOMMAND attribute)
FORMAT_WIN_1252 (MENUCOMMAND attribute)
FORMAT_WIN_1253 (MENUCOMMAND attribute)
FORMAT_WIN_1254 (MENUCOMMAND attribute)
FORMAT_WIN_1255 (MENUCOMMAND attribute)
FORMAT_WIN_1256 (MENUCOMMAND attribute)
FORMAT_WIN_1257 (MENUCOMMAND attribute)
FORMAT_WIN_1258 (MENUCOMMAND attribute)
FORMATTYPE (built-in class)
formFeed() (Editor method)
FORTH (LEXER attribute)
FORTRAN (LEXER attribute)
FORUM (MENUCOMMAND attribute)
FREEBASIC (LEXER attribute)
FULLRECT (MARKERSYMBOL attribute)

G

GAP (LEXER attribute)
GB2312 (CHARACTERSET attribute)
getAdditionalCaretFore() (Editor method)
getAdditionalCaretsBlink() (Editor method)
getAdditionalCaretsVisible() (Editor method)
getAdditionalSelAlpha() (Editor method)
getAdditionalSelectionTyping() (Editor method)
getAnchor() (Editor method)
getBackSpaceUnIndents() (Editor method)
getBufferedDraw() (Editor method)
getCaretFore() (Editor method)
getCaretLineBack() (Editor method)
getCaretLineBackAlpha() (Editor method)
getCaretLineVisible() (Editor method)
getCaretPeriod() (Editor method)
getCaretSticky() (Editor method)
getCaretStyle() (Editor method)
getCaretWidth() (Editor method)
getCharacterPointer() (Editor method)
getCharAt() (Editor method)
getCodePage() (Editor method)
getColumn() (Editor method)
getCommandLine() (Notepad method)
getControlCharSymbol() (Editor method)
getCurLine() (Editor method)
getCurrentBufferID() (Notepad method)
getCurrentDocIndex() (Notepad method)
getCurrentFilename() (Notepad method)
getCurrentLang() (Notepad method)
getCurrentPos() (Editor method)
getCurrentView() (Notepad method)
getCursor() (Editor method)
getDirectFunction() (Editor method)
getDirectPointer() (Editor method)
getDocPointer() (Editor method)
getEdgeColour() (Editor method)
getEdgeColumn() (Editor method)
getEdgeMode() (Editor method)
getEncoding() (Notepad method)
getEndAtLastLine() (Editor method)
getEndStyled() (Editor method)
getEOLMode() (Editor method)
getExtraAscent() (Editor method)
getExtraDescent() (Editor method)
getFiles() (Notepad method)
getFirstVisibleLine() (Editor method)
getFocus() (Editor method)
getFoldExpanded() (Editor method)
getFoldLevel() (Editor method)
getFoldParent() (Editor method)
getFontQuality() (Editor method)
getFormatType() (Notepad method)
getHighlightGuide() (Editor method)
getHotspotActiveBack() (Editor method)
getHotspotActiveFore() (Editor method)
getHotspotActiveUnderline() (Editor method)
getHotspotSingleLine() (Editor method)
getHScrollBar() (Editor method)
getIndent() (Editor method)
getIndentationGuides() (Editor method)
getIndicatorCurrent() (Editor method)
getIndicatorValue() (Editor method)
getKeysUnicode() (Editor method)
getLangType() (Notepad method)
getLastChild() (Editor method)
getLayoutCache() (Editor method)
getLength() (Editor method)
getLexer() (Editor method)
getLexerLanguage() (Editor method)
getLine() (Editor method)
getLineCount() (Editor method)
getLineEndPosition() (Editor method)
getLineIndentation() (Editor method)
getLineIndentPosition() (Editor method)
getLineSelEndPosition() (Editor method)
getLineSelStartPosition() (Editor method)
getLineState() (Editor method)
getLineVisible() (Editor method)
getMainSelection() (Editor method)
getMarginLeft() (Editor method)
getMarginMaskN() (Editor method)
getMarginRight() (Editor method)
getMarginSensitiveN() (Editor method)
getMarginTypeN() (Editor method)
getMarginWidthN() (Editor method)
getMaxLineState() (Editor method)
getModEventMask() (Editor method)
getModify() (Editor method)
getMouseDownCaptures() (Editor method)
getMouseDwellTime() (Editor method)
getMultiPaste() (Editor method)
getMultipleSelection() (Editor method)
getNppDir() (Notepad method)
getOvertype() (Editor method)
getPasteConvertEndings() (Editor method)
getPluginConfigDir() (Notepad method)
getPluginMenuHandle() (Notepad method)
getPositionCache() (Editor method)
getPrintColourMode() (Editor method)
getPrintMagnification() (Editor method)
getPrintWrapMode() (Editor method)
getProperty() (Editor method)
getPropertyExpanded() (Editor method)
getPropertyInt() (Editor method)
getReadOnly() (Editor method)
getRectangularSelectionAnchor() (Editor method)
getRectangularSelectionAnchorVirtualSpace() (Editor method)
getRectangularSelectionCaret() (Editor method)
getRectangularSelectionCaretVirtualSpace() (Editor method)
getRectangularSelectionModifier() (Editor method)
getScrollWidth() (Editor method)
getScrollWidthTracking() (Editor method)
getSearchFlags() (Editor method)
getSelAlpha() (Editor method)
getSelectionEnd() (Editor method)
getSelectionMode() (Editor method)
getSelectionNAnchor() (Editor method)
getSelectionNAnchorVirtualSpace() (Editor method)
getSelectionNCaret() (Editor method)
getSelectionNCaretVirtualSpace() (Editor method)
getSelectionNEnd() (Editor method)
getSelectionNStart() (Editor method)
getSelections() (Editor method)
getSelectionStart() (Editor method)
getSelEOLFilled() (Editor method)
getSelText() (Editor method)
getStatus() (Editor method)
getStyleAt() (Editor method)
getStyleBits() (Editor method)
getStyleBitsNeeded() (Editor method)
getStyledText() (Editor method)
getTabIndents() (Editor method)
getTabWidth() (Editor method)
getTag() (Editor method)
getTargetEnd() (Editor method)
getTargetStart() (Editor method)
getText() (Editor method)
getTextLength() (Editor method)
getTextRange() (Editor method)
getTwoPhaseDraw() (Editor method)
getUndoCollection() (Editor method)
getUsePalette() (Editor method)
getUserCharSelection() (Editor method)
getUserLineSelection() (Editor method)
getUseTabs() (Editor method)
getVersion() (Notepad method)
getViewEOL() (Editor method)
getViewWS() (Editor method)
getVirtualSpaceOptions() (Editor method)
getVScrollBar() (Editor method)
getWhitespaceSize() (Editor method)
getWrapIndentMode() (Editor method)
getWrapMode() (Editor method)
getWrapStartIndent() (Editor method)
getWrapVisualFlags() (Editor method)
getWrapVisualFlagsLocation() (Editor method)
getXOffset() (Editor method)
getZoom() (Editor method)
gotoLine() (Editor method)
gotoPos() (Editor method)
grabFocus() (Editor method)
GREEK (CHARACTERSET attribute)
GUI4CLI (LEXER attribute)

H

HANGUL (CHARACTERSET attribute)
HASKELL (LEXER attribute)
HEADERFLAG (FOLDLEVEL attribute)
HEBREW (CHARACTERSET attribute)
HELP (MENUCOMMAND attribute)
HIDDEN (ANNOTATIONVISIBLE attribute)
(INDICATORSTYLE attribute)
hide() (Console method)
hideLines() (Editor method)
hideSelection() (Editor method)
hideTabBar() (Notepad method)
HOME (KEYS attribute)
home() (Editor method)
homeDisplay() (Editor method)
homeDisplayExtend() (Editor method)
homeExtend() (Editor method)
homeRectExtend() (Editor method)
HOMESWEETHOME (MENUCOMMAND attribute)
homeWrap() (Editor method)
homeWrapExtend() (Editor method)
HTML (LEXER attribute)

I

ICONASTERISK (MESSAGEBOXFLAGS attribute)
ICONERROR (MESSAGEBOXFLAGS attribute)
ICONEXCLAMATION (MESSAGEBOXFLAGS attribute)
ICONHAND (MESSAGEBOXFLAGS attribute)
ICONINFORMATION (MESSAGEBOXFLAGS attribute)
ICONQUESTION (MESSAGEBOXFLAGS attribute)
ICONSTOP (MESSAGEBOXFLAGS attribute)
ICONWARNING (MESSAGEBOXFLAGS attribute)
INDENT (WRAPINDENTMODE attribute)
INDENTGUIDE (STYLESCOMMON attribute)
INDENTVIEW (built-in class)
indicatorAllOnFor() (Editor method)
indicatorClearRange() (Editor method)
indicatorEnd() (Editor method)
indicatorFillRange() (Editor method)
indicatorStart() (Editor method)
INDICATORSTYLE (built-in class)
indicatorValueAt() (Editor method)
indicGetAlpha() (Editor method)
indicGetFore() (Editor method)
indicGetStyle() (Editor method)
indicGetUnder() (Editor method)
indicSetAlpha() (Editor method)
indicSetFore() (Editor method)
indicSetStyle() (Editor method)
indicSetUnder() (Editor method)
INNOSETUP (LEXER attribute)
INSERT (KEYS attribute)
insertText() (Editor method)
INVERTLIGHT (PRINTOPTION attribute)
INVISIBLE (CARETSTYLE attribute)
(WHITESPACE attribute)

J

JOHAB (CHARACTERSET attribute)
JUMPS (CARETPOLICY attribute)

K

KEYMOD (built-in class)
KEYS (built-in class)
KIX (LEXER attribute)

L

LANG_ADA (MENUCOMMAND attribute)
LANG_ASCII (MENUCOMMAND attribute)
LANG_ASM (MENUCOMMAND attribute)
LANG_ASP (MENUCOMMAND attribute)
LANG_AU3 (MENUCOMMAND attribute)
LANG_BASH (MENUCOMMAND attribute)
LANG_BATCH (MENUCOMMAND attribute)
LANG_C (MENUCOMMAND attribute)
LANG_CAML (MENUCOMMAND attribute)
LANG_CMAKE (MENUCOMMAND attribute)
LANG_COBOL (MENUCOMMAND attribute)
LANG_CPP (MENUCOMMAND attribute)
LANG_CS (MENUCOMMAND attribute)
LANG_CSS (MENUCOMMAND attribute)
LANG_D (MENUCOMMAND attribute)
LANG_DIFF (MENUCOMMAND attribute)
LANG_EXTERNAL (MENUCOMMAND attribute)
LANG_EXTERNAL_LIMIT (MENUCOMMAND attribute)
LANG_FLASH (MENUCOMMAND attribute)
LANG_FORTRAN (MENUCOMMAND attribute)
LANG_GUI4CLI (MENUCOMMAND attribute)
LANG_HASKELL (MENUCOMMAND attribute)
LANG_HTML (MENUCOMMAND attribute)
LANG_INI (MENUCOMMAND attribute)
LANG_INNO (MENUCOMMAND attribute)
LANG_JAVA (MENUCOMMAND attribute)
LANG_JS (MENUCOMMAND attribute)
LANG_JSP (MENUCOMMAND attribute)
LANG_KIX (MENUCOMMAND attribute)
LANG_LISP (MENUCOMMAND attribute)
LANG_LUA (MENUCOMMAND attribute)
LANG_MAKEFILE (MENUCOMMAND attribute)
LANG_MATLAB (MENUCOMMAND attribute)
LANG_NSIS (MENUCOMMAND attribute)
LANG_OBJC (MENUCOMMAND attribute)
LANG_PASCAL (MENUCOMMAND attribute)
LANG_PERL (MENUCOMMAND attribute)
LANG_PHP (MENUCOMMAND attribute)
LANG_POWERSHELL (MENUCOMMAND attribute)
LANG_PROPS (MENUCOMMAND attribute)
LANG_PS (MENUCOMMAND attribute)
LANG_PYTHON (MENUCOMMAND attribute)
LANG_R (MENUCOMMAND attribute)
LANG_RC (MENUCOMMAND attribute)
LANG_RUBY (MENUCOMMAND attribute)
LANG_SCHEME (MENUCOMMAND attribute)
LANG_SMALLTALK (MENUCOMMAND attribute)
LANG_SQL (MENUCOMMAND attribute)
LANG_TCL (MENUCOMMAND attribute)
LANG_TEX (MENUCOMMAND attribute)
LANG_TEXT (MENUCOMMAND attribute)
LANG_USER (MENUCOMMAND attribute)
LANG_USER_LIMIT (MENUCOMMAND attribute)
LANG_VB (MENUCOMMAND attribute)
LANG_VERILOG (MENUCOMMAND attribute)
LANG_VHDL (MENUCOMMAND attribute)
LANG_XML (MENUCOMMAND attribute)
LANG_YAML (MENUCOMMAND attribute)
LANGCHANGED (NOTIFICATION attribute)
LANGSTYLE_CONFIG_DLG (MENUCOMMAND attribute)
LASTPREDEFINED (STYLESCOMMON attribute)
LATEX (LEXER attribute)
LCORNER (MARKERSYMBOL attribute)
LCORNERCURVE (MARKERSYMBOL attribute)
LEFT (KEYS attribute)
LEFTRECT (MARKERSYMBOL attribute)
LEVELNUMBERS (FOLDFLAG attribute)
LEXER (built-in class)
LF (ENDOFLINE attribute)
LINE (CARETSTYLE attribute)
(EDGEVISUALSTYLE attribute)
LINEAFTER_CONTRACTED (FOLDFLAG attribute)
LINEAFTER_EXPANDED (FOLDFLAG attribute)
LINEBEFORE_CONTRACTED (FOLDFLAG attribute)
LINEBEFORE_EXPANDED (FOLDFLAG attribute)
LINECACHE (built-in class)
lineCopy() (Editor method)
lineCut() (Editor method)
lineDelete() (Editor method)
lineDown() (Editor method)
lineDownExtend() (Editor method)
lineDownRectExtend() (Editor method)
lineDuplicate() (Editor method)
lineEnd() (Editor method)
lineEndDisplay() (Editor method)
lineEndDisplayExtend() (Editor method)
lineEndExtend() (Editor method)
lineEndRectExtend() (Editor method)
lineEndWrap() (Editor method)
lineEndWrapExtend() (Editor method)
lineFromPosition() (Editor method)
lineLength() (Editor method)
LINENUMBER (STYLESCOMMON attribute)
LINES (SELECTIONMODE attribute)
lineScroll() (Editor method)
lineScrollDown() (Editor method)
lineScrollUp() (Editor method)
linesJoin() (Editor method)
linesOnScreen() (Editor method)
linesSplit() (Editor method)
lineTranspose() (Editor method)
lineUp() (Editor method)
lineUpExtend() (Editor method)
lineUpRectExtend() (Editor method)
LISP (LEXER attribute)
loadLexerLibrary() (Editor method)
LOOKBOTH (INDENTVIEW attribute)
LOOKFORWARD (INDENTVIEW attribute)
LOT (LEXER attribute)
LOUT (LEXER attribute)
LOWER (CASEVISIBLE attribute)
lowerCase() (Editor method)
LUA (LEXER attribute)

M

MAC (CHARACTERSET attribute)
(FORMATTYPE attribute)
MACRO_PLAYBACKRECORDEDMACRO (MENUCOMMAND attribute)
MACRO_RUNMULTIMACRODLG (MENUCOMMAND attribute)
MACRO_SAVECURRENTMACRO (MENUCOMMAND attribute)
MACRO_STARTRECORDINGMACRO (MENUCOMMAND attribute)
MACRO_STOPRECORDINGMACRO (MENUCOMMAND attribute)
MAGIK (LEXER attribute)
MAKEFILE (LEXER attribute)
marginGetStyle() (Editor method)
marginGetStyleOffset() (Editor method)
marginGetStyles() (Editor method)
marginGetText() (Editor method)
marginSetStyle() (Editor method)
marginSetStyleOffset() (Editor method)
marginSetStyles() (Editor method)
marginSetText() (Editor method)
marginTextClearAll() (Editor method)
MARGINTYPE (built-in class)
MARKDOWN (LEXER attribute)
markerAdd() (Editor method)
markerAddSet() (Editor method)
markerDefine() (Editor method)
markerDefinePixmap() (Editor method)
markerDelete() (Editor method)
markerDeleteAll() (Editor method)
markerDeleteHandle() (Editor method)
markerGet() (Editor method)
markerLineFromHandle() (Editor method)
markerNext() (Editor method)
MARKEROUTLINE (built-in class)
markerPrevious() (Editor method)
markerSetAlpha() (Editor method)
markerSetBack() (Editor method)
markerSetFore() (Editor method)
MARKERSYMBOL (built-in class)
markerSymbolDefined() (Editor method)
MATCHCASE (FINDOPTION attribute)
MATLAB (LEXER attribute)
MAX (INDICATORSTYLE attribute)
(STYLESCOMMON attribute)
MENU (KEYS attribute)
MENUCOMMAND (built-in class)
menuCommand() (Notepad method)
messageBox() (Notepad method)
MESSAGEBOXFLAGS (built-in class)
METAPOST (LEXER attribute)
MINUS (MARKERSYMBOL attribute)
MIXED (CASEVISIBLE attribute)
MMIXAL (LEXER attribute)
moveCaretInsideView() (Editor method)
MSSQL (LEXER attribute)
MULTIPASTE (built-in class)
MYSQL (LEXER attribute)

N

new() (Notepad method)
newLine() (Editor method)
NEXT (KEYS attribute)
NIMROD (LEXER attribute)
NNCRONTAB (LEXER attribute)
NONE (EDGEVISUALSTYLE attribute)
(INDENTVIEW attribute)
(LINECACHE attribute)
(VIRTUALSPACE attribute)
(WRAP attribute)
(WRAPVISUALFLAG attribute)
NORM (KEYMOD attribute)
NORMAL (CURSORSHAPE attribute)
(PRINTOPTION attribute)
Notepad (built-in class)
NOTIFICATION (built-in class)
NSIS (LEXER attribute)
NULL (LEXER attribute)
null() (Editor method)
NUMBER (MARGINTYPE attribute)
NUMBERMASK (FOLDLEVEL attribute)

O

OCTAVE (LEXER attribute)
OEM (CHARACTERSET attribute)
OK (MESSAGEBOXFLAGS attribute)
(STATUS attribute)
OKCANCEL (MESSAGEBOXFLAGS attribute)
ONCE (MULTIPASTE attribute)
ONLINEHELP (MENUCOMMAND attribute)
OPAL (LEXER attribute)
open() (Notepad method)
OPEN_ALL_RECENT_FILE (MENUCOMMAND attribute)

P

PAGE (LINECACHE attribute)
pageDown() (Editor method)
pageDownExtend() (Editor method)
pageDownRectExtend() (Editor method)
pageUp() (Editor method)
pageUpExtend() (Editor method)
pageUpRectExtend() (Editor method)
paraDown() (Editor method)
paraDownExtend() (Editor method)
paraUp() (Editor method)
paraUpExtend() (Editor method)
PASCAL (LEXER attribute)
paste() (Editor method)
PERL (LEXER attribute)
PHPSCRIPT (LEXER attribute)
PIXMAP (MARKERSYMBOL attribute)
PLAIN (INDICATORSTYLE attribute)
PLM (LEXER attribute)
PLUGINSHOME (MENUCOMMAND attribute)
PLUS (MARKERSYMBOL attribute)
PO (LEXER attribute)
pointXFromPosition() (Editor method)
pointYFromPosition() (Editor method)
positionAfter() (Editor method)
positionBefore() (Editor method)
positionFromLine() (Editor method)
positionFromPoint() (Editor method)
positionFromPointClose() (Editor method)
POSIX (FINDOPTION attribute)
POV (LEXER attribute)
POWERBASIC (LEXER attribute)
POWERPRO (LEXER attribute)
POWERSHELL (LEXER attribute)
PRINTOPTION (built-in class)
PRIOR (KEYS attribute)
PROGRESS (LEXER attribute)
PROJECTPAGE (MENUCOMMAND attribute)
prompt() (Notepad method)
PROPERTIES (LEXER attribute)
PS (LEXER attribute)
PUREBASIC (LEXER attribute)
pymlreplace() (Editor method)
pymlsearch() (Editor method)
pyreplace() (Editor method)
pysearch() (Editor method)
PYTHON (LEXER attribute)

Q

QUALITY_ANTIALIASED (FONTQUALITY attribute)
QUALITY_DEFAULT (FONTQUALITY attribute)
QUALITY_LCD_OPTIMIZED (FONTQUALITY attribute)
QUALITY_MASK (FONTQUALITY attribute)
QUALITY_NON_ANTIALIASED (FONTQUALITY attribute)

R

R (LEXER attribute)
READONLYCHANGED (NOTIFICATION attribute)
READY (NOTIFICATION attribute)
REAL (INDENTVIEW attribute)
REBOL (LEXER attribute)
RECTANGLE (SELECTIONMODE attribute)
RECTANGULARSELECTION (VIRTUALSPACE attribute)
redo() (Editor method)
REGEXP (FINDOPTION attribute)
registerImage() (Editor method)
releaseDocument() (Editor method)
reloadBuffer() (Notepad method)
reloadCurrentDocument() (Notepad method)
reloadFile() (Notepad method)
replace() (Editor method)
replaceLine() (Editor method)
replaceSel() (Editor method)
replaceTarget() (Editor method)
replaceTargetRE() (Editor method)
replaceWholeLine() (Editor method)
rereplace() (Editor method)
RESULTABORT (MESSAGEBOXFLAGS attribute)
RESULTCANCEL (MESSAGEBOXFLAGS attribute)
RESULTCONTINUE (MESSAGEBOXFLAGS attribute)
RESULTIGNORE (MESSAGEBOXFLAGS attribute)
RESULTNO (MESSAGEBOXFLAGS attribute)
RESULTOK (MESSAGEBOXFLAGS attribute)
RESULTRETRY (MESSAGEBOXFLAGS attribute)
RESULTTRYAGAIN (MESSAGEBOXFLAGS attribute)
RESULTYES (MESSAGEBOXFLAGS attribute)
RETRYCANCEL (MESSAGEBOXFLAGS attribute)
RETURN (KEYS attribute)
RIGHT (KEYS attribute)
rotateSelection() (Editor method)
ROUNDBOX (INDICATORSTYLE attribute)
ROUNDRECT (MARKERSYMBOL attribute)
RTEXT (MARGINTYPE attribute)
RUBY (LEXER attribute)
run() (Console method)
runMenuCommand() (Notepad method)
runPluginCommand() (Notepad method)
RUSSIAN (CHARACTERSET attribute)
RWIN (KEYS attribute)

S

SAME (WRAPINDENTMODE attribute)
save() (Notepad method)
saveAllFiles() (Notepad method)
saveAs() (Notepad method)
saveAsCopy() (Notepad method)
saveCurrentSession() (Notepad method)
saveSession() (Notepad method)
SCRIPTOL (LEXER attribute)
scrollCaret() (Editor method)
SEARCH_CLEAR_BOOKMARKS (MENUCOMMAND attribute)
SEARCH_CLEARALLMARKS (MENUCOMMAND attribute)
SEARCH_COPYMARKEDLINES (MENUCOMMAND attribute)
SEARCH_CUTMARKEDLINES (MENUCOMMAND attribute)
SEARCH_DELETEMARKEDLINES (MENUCOMMAND attribute)
SEARCH_FIND (MENUCOMMAND attribute)
SEARCH_FINDINCREMENT (MENUCOMMAND attribute)
SEARCH_FINDINFILES (MENUCOMMAND attribute)
SEARCH_FINDNEXT (MENUCOMMAND attribute)
SEARCH_FINDPREV (MENUCOMMAND attribute)
SEARCH_GONEXTMARKER1 (MENUCOMMAND attribute)
SEARCH_GONEXTMARKER2 (MENUCOMMAND attribute)
SEARCH_GONEXTMARKER3 (MENUCOMMAND attribute)
SEARCH_GONEXTMARKER4 (MENUCOMMAND attribute)
SEARCH_GONEXTMARKER5 (MENUCOMMAND attribute)
SEARCH_GONEXTMARKER_DEF (MENUCOMMAND attribute)
SEARCH_GOPREVMARKER1 (MENUCOMMAND attribute)
SEARCH_GOPREVMARKER2 (MENUCOMMAND attribute)
SEARCH_GOPREVMARKER3 (MENUCOMMAND attribute)
SEARCH_GOPREVMARKER4 (MENUCOMMAND attribute)
SEARCH_GOPREVMARKER5 (MENUCOMMAND attribute)
SEARCH_GOPREVMARKER_DEF (MENUCOMMAND attribute)
SEARCH_GOTOLINE (MENUCOMMAND attribute)
SEARCH_GOTOMATCHINGBRACE (MENUCOMMAND attribute)
SEARCH_GOTONEXTFOUND (MENUCOMMAND attribute)
SEARCH_GOTOPREVFOUND (MENUCOMMAND attribute)
SEARCH_MARKALLEXT1 (MENUCOMMAND attribute)
SEARCH_MARKALLEXT2 (MENUCOMMAND attribute)
SEARCH_MARKALLEXT3 (MENUCOMMAND attribute)
SEARCH_MARKALLEXT4 (MENUCOMMAND attribute)
SEARCH_MARKALLEXT5 (MENUCOMMAND attribute)
SEARCH_NEXT_BOOKMARK (MENUCOMMAND attribute)
SEARCH_PASTEMARKEDLINES (MENUCOMMAND attribute)
SEARCH_PREV_BOOKMARK (MENUCOMMAND attribute)
SEARCH_REPLACE (MENUCOMMAND attribute)
SEARCH_SETANDFINDNEXT (MENUCOMMAND attribute)
SEARCH_SETANDFINDPREV (MENUCOMMAND attribute)
SEARCH_TOGGLE_BOOKMARK (MENUCOMMAND attribute)
SEARCH_UNMARKALLEXT1 (MENUCOMMAND attribute)
SEARCH_UNMARKALLEXT2 (MENUCOMMAND attribute)
SEARCH_UNMARKALLEXT3 (MENUCOMMAND attribute)
SEARCH_UNMARKALLEXT4 (MENUCOMMAND attribute)
SEARCH_UNMARKALLEXT5 (MENUCOMMAND attribute)
SEARCH_VOLATILE_FINDNEXT (MENUCOMMAND attribute)
SEARCH_VOLATILE_FINDPREV (MENUCOMMAND attribute)
searchAnchor() (Editor method)
searchInTarget() (Editor method)
searchNext() (Editor method)
searchPrev() (Editor method)
selectAll() (Editor method)
selectionDuplicate() (Editor method)
selectionIsRectangle() (Editor method)
SELECTIONMODE (built-in class)
setAdditionalCaretFore() (Editor method)
setAdditionalCaretsBlink() (Editor method)
setAdditionalCaretsVisible() (Editor method)
setAdditionalSelAlpha() (Editor method)
setAdditionalSelBack() (Editor method)
setAdditionalSelectionTyping() (Editor method)
setAdditionalSelFore() (Editor method)
setAnchor() (Editor method)
setBackSpaceUnIndents() (Editor method)
setBufferedDraw() (Editor method)
setCaretFore() (Editor method)
setCaretLineBack() (Editor method)
setCaretLineBackAlpha() (Editor method)
setCaretLineVisible() (Editor method)
setCaretPeriod() (Editor method)
setCaretSticky() (Editor method)
setCaretStyle() (Editor method)
setCaretWidth() (Editor method)
setCharsDefault() (Editor method)
setCodePage() (Editor method)
setControlCharSymbol() (Editor method)
setCurrentLang() (Notepad method)
setCurrentPos() (Editor method)
setCursor() (Editor method)
setDocPointer() (Editor method)
setEdgeColour() (Editor method)
setEdgeColumn() (Editor method)
setEdgeMode() (Editor method)
setEndAtLastLine() (Editor method)
setEOLMode() (Editor method)
setExtraAscent() (Editor method)
setExtraDescent() (Editor method)
setFirstVisibleLine() (Editor method)
setFocus() (Editor method)
setFoldExpanded() (Editor method)
setFoldFlags() (Editor method)
setFoldLevel() (Editor method)
setFoldMarginColour() (Editor method)
setFoldMarginHiColour() (Editor method)
setFontQuality() (Editor method)
setFormatType() (Notepad method)
setHighlightGuide() (Editor method)
setHotspotActiveBack() (Editor method)
setHotspotActiveFore() (Editor method)
setHotspotActiveUnderline() (Editor method)
setHotspotSingleLine() (Editor method)
setHScrollBar() (Editor method)
setIndent() (Editor method)
setIndentationGuides() (Editor method)
setIndicatorCurrent() (Editor method)
setIndicatorValue() (Editor method)
setKeysUnicode() (Editor method)
setKeyWords() (Editor method)
setLangType() (Notepad method)
setLayoutCache() (Editor method)
setLengthForEncode() (Editor method)
setLexer() (Editor method)
setLexerLanguage() (Editor method)
setLineIndentation() (Editor method)
setLineState() (Editor method)
setMainSelection() (Editor method)
setMarginLeft() (Editor method)
setMarginMaskN() (Editor method)
setMarginRight() (Editor method)
setMarginSensitiveN() (Editor method)
setMarginTypeN() (Editor method)
setMarginWidthN() (Editor method)
setModEventMask() (Editor method)
setMouseDownCaptures() (Editor method)
setMouseDwellTime() (Editor method)
setMultiPaste() (Editor method)
setMultipleSelection() (Editor method)
setOvertype() (Editor method)
setPasteConvertEndings() (Editor method)
setPositionCache() (Editor method)
setPrintColourMode() (Editor method)
setPrintMagnification() (Editor method)
setPrintWrapMode() (Editor method)
setProperty() (Editor method)
setReadOnly() (Editor method)
setRectangularSelectionAnchor() (Editor method)
setRectangularSelectionAnchorVirtualSpace() (Editor method)
setRectangularSelectionCaret() (Editor method)
setRectangularSelectionCaretVirtualSpace() (Editor method)
setRectangularSelectionModifier() (Editor method)
setSavePoint() (Editor method)
setScrollWidth() (Editor method)
setScrollWidthTracking() (Editor method)
setSearchFlags() (Editor method)
setSel() (Editor method)
setSelAlpha() (Editor method)
setSelBack() (Editor method)
setSelection() (Editor method)
setSelectionEnd() (Editor method)
setSelectionMode() (Editor method)
setSelectionNAnchor() (Editor method)
setSelectionNAnchorVirtualSpace() (Editor method)
setSelectionNCaret() (Editor method)
setSelectionNCaretVirtualSpace() (Editor method)
setSelectionNEnd() (Editor method)
setSelectionNStart() (Editor method)
setSelectionStart() (Editor method)
setSelEOLFilled() (Editor method)
setSelFore() (Editor method)
setStatus() (Editor method)
setStatusBar() (Notepad method)
setStyleBits() (Editor method)
setStyling() (Editor method)
setStylingEx() (Editor method)
setTabIndents() (Editor method)
setTabWidth() (Editor method)
setTarget() (Editor method)
setTargetEnd() (Editor method)
setTargetStart() (Editor method)
setText() (Editor method)
SETTING_AUTOCNBCHAR (MENUCOMMAND attribute)
SETTING_EDGE_SIZE (MENUCOMMAND attribute)
SETTING_HISTORY_SIZE (MENUCOMMAND attribute)
SETTING_IMPORTPLUGIN (MENUCOMMAND attribute)
SETTING_IMPORTSTYLETHEMS (MENUCOMMAND attribute)
SETTING_PREFERECE (MENUCOMMAND attribute)
SETTING_REMEMBER_LAST_SESSION (MENUCOMMAND attribute)
SETTING_SHORTCUT_MAPPER (MENUCOMMAND attribute)
SETTING_TAB_REPLCESPACE (MENUCOMMAND attribute)
SETTING_TAB_SIZE (MENUCOMMAND attribute)
SETTING_TRAYICON (MENUCOMMAND attribute)
setTwoPhaseDraw() (Editor method)
setUndoCollection() (Editor method)
setUsePalette() (Editor method)
setUseTabs() (Editor method)
setViewEOL() (Editor method)
setViewWS() (Editor method)
setVirtualSpaceOptions() (Editor method)
setVisiblePolicy() (Editor method)
setVScrollBar() (Editor method)
setWhitespaceBack() (Editor method)
setWhitespaceChars() (Editor method)
setWhitespaceFore() (Editor method)
setWhitespaceSize() (Editor method)
setWordChars() (Editor method)
setWrapIndentMode() (Editor method)
setWrapMode() (Editor method)
setWrapStartIndent() (Editor method)
setWrapVisualFlags() (Editor method)
setWrapVisualFlagsLocation() (Editor method)
setXCaretPolicy() (Editor method)
setXOffset() (Editor method)
setYCaretPolicy() (Editor method)
setZoom() (Editor method)
SHIFT (KEYMOD attribute)
SHIFTJIS (CHARACTERSET attribute)
SHORTARROW (MARKERSYMBOL attribute)
SHORTCUTREMAPPED (NOTIFICATION attribute)
show() (Console method)
showLines() (Editor method)
showTabBar() (Notepad method)
SHUTDOWN (NOTIFICATION attribute)
SLOP (CARETPOLICY attribute)
SMALLRECT (MARKERSYMBOL attribute)
SMALLTALK (LEXER attribute)
SML (LEXER attribute)
SORCUS (LEXER attribute)
SPECMAN (LEXER attribute)
SPICE (LEXER attribute)
SQL (LEXER attribute)
SQUIGGLE (INDICATORSTYLE attribute)
STANDARD (ANNOTATIONVISIBLE attribute)
START (WRAPVISUALFLAG attribute)
START_BY_TEXT (WRAPVISUALLOCATION attribute)
startRecord() (Editor method)
startStyling() (Editor method)
STATUS (built-in class)
STATUSBARSECTION (built-in class)
stopRecord() (Editor method)
STREAM (SELECTIONMODE attribute)
STRICT (CARETPOLICY attribute)
STRIKE (INDICATORSTYLE attribute)
stutteredPageDown() (Editor method)
stutteredPageDownExtend() (Editor method)
stutteredPageUp() (Editor method)
stutteredPageUpExtend() (Editor method)
styleClearAll() (Editor method)
styleGetBack() (Editor method)
styleGetBold() (Editor method)
styleGetCase() (Editor method)
styleGetChangeable() (Editor method)
styleGetCharacterSet() (Editor method)
styleGetEOLFilled() (Editor method)
styleGetFont() (Editor method)
styleGetFore() (Editor method)
styleGetHotSpot() (Editor method)
styleGetItalic() (Editor method)
styleGetSize() (Editor method)
styleGetUnderline() (Editor method)
styleGetVisible() (Editor method)
styleResetDefault() (Editor method)
STYLESCOMMON (built-in class)
styleSetBack() (Editor method)
styleSetBold() (Editor method)
styleSetCase() (Editor method)
styleSetChangeable() (Editor method)
styleSetCharacterSet() (Editor method)
styleSetEOLFilled() (Editor method)
styleSetFont() (Editor method)
styleSetFore() (Editor method)
styleSetHotSpot() (Editor method)
styleSetItalic() (Editor method)
styleSetSize() (Editor method)
styleSetUnderline() (Editor method)
styleSetVisible() (Editor method)
SUBTRACT (KEYS attribute)
SUPER (KEYMOD attribute)
swapMainAnchorCaret() (Editor method)
SYMBOL (CHARACTERSET attribute)
(MARGINTYPE attribute)
SYSTRAYPOPUP_ACTIVATE (MENUCOMMAND attribute)
SYSTRAYPOPUP_CLOSE (MENUCOMMAND attribute)
SYSTRAYPOPUP_NEW_AND_PASTE (MENUCOMMAND attribute)
SYSTRAYPOPUP_NEWDOC (MENUCOMMAND attribute)
SYSTRAYPOPUP_OPENFILE (MENUCOMMAND attribute)

T

TAB (KEYS attribute)
tab() (Editor method)
TACL (LEXER attribute)
TADS3 (LEXER attribute)
TAL (LEXER attribute)
targetAsUTF8() (Editor method)
targetFromSelection() (Editor method)
TBMODIFICATION (NOTIFICATION attribute)
TCL (LEXER attribute)
TCORNER (MARKERSYMBOL attribute)
TCORNERCURVE (MARKERSYMBOL attribute)
TEX (LEXER attribute)
TEXT (MARGINTYPE attribute)
textHeight() (Editor method)
textWidth() (Editor method)
THAI (CHARACTERSET attribute)
THIN (SELECTIONMODE attribute)
toggleCaretSticky() (Editor method)
toggleFold() (Editor method)
TT (INDICATORSTYLE attribute)
TURKISH (CHARACTERSET attribute)
TYPINGMODE (STATUSBARSECTION attribute)

U

UCS2BE (BUFFERENCODING attribute)
UCS2BE_NOBOM (BUFFERENCODING attribute)
UCS2LE (BUFFERENCODING attribute)
UCS2LE_NOBOM (BUFFERENCODING attribute)
UNDERLINE (MARKERSYMBOL attribute)
undo() (Editor method)
UNICODETYPE (STATUSBARSECTION attribute)
UNIX (FORMATTYPE attribute)
UP (KEYS attribute)
UPDATE_NPP (MENUCOMMAND attribute)
UPPER (CASEVISIBLE attribute)
upperCase() (Editor method)
usePopUp() (Editor method)
USERACCESSIBLE (VIRTUALSPACE attribute)
userListShow() (Editor method)
UTF8 (BUFFERENCODING attribute)

V

VB (LEXER attribute)
VBSCRIPT (LEXER attribute)
vCHome() (Editor method)
vCHomeExtend() (Editor method)
vCHomeRectExtend() (Editor method)
vCHomeWrap() (Editor method)
vCHomeWrapExtend() (Editor method)
VERILOG (LEXER attribute)
VHDL (LEXER attribute)
VIETNAMESE (CHARACTERSET attribute)
VIEW_ALL_CHARACTERS (MENUCOMMAND attribute)
VIEW_ALWAYSONTOP (MENUCOMMAND attribute)
VIEW_CLONE_TO_ANOTHER_VIEW (MENUCOMMAND attribute)
VIEW_CURLINE_HILITING (MENUCOMMAND attribute)
VIEW_DOCCHANGEMARGIN (MENUCOMMAND attribute)
VIEW_DRAWTABBAR_CLOSEBOTTUN (MENUCOMMAND attribute)
VIEW_DRAWTABBAR_DBCLK2CLOSE (MENUCOMMAND attribute)
VIEW_DRAWTABBAR_INACIVETAB (MENUCOMMAND attribute)
VIEW_DRAWTABBAR_MULTILINE (MENUCOMMAND attribute)
VIEW_DRAWTABBAR_TOPBAR (MENUCOMMAND attribute)
VIEW_DRAWTABBAR_VERTICAL (MENUCOMMAND attribute)
VIEW_EDGEBACKGROUND (MENUCOMMAND attribute)
VIEW_EDGELINE (MENUCOMMAND attribute)
VIEW_EDGENONE (MENUCOMMAND attribute)
VIEW_EOL (MENUCOMMAND attribute)
VIEW_FOLD (MENUCOMMAND attribute)
VIEW_FOLD_1 (MENUCOMMAND attribute)
VIEW_FOLD_2 (MENUCOMMAND attribute)
VIEW_FOLD_3 (MENUCOMMAND attribute)
VIEW_FOLD_4 (MENUCOMMAND attribute)
VIEW_FOLD_5 (MENUCOMMAND attribute)
VIEW_FOLD_6 (MENUCOMMAND attribute)
VIEW_FOLD_7 (MENUCOMMAND attribute)
VIEW_FOLD_8 (MENUCOMMAND attribute)
VIEW_FOLD_CURRENT (MENUCOMMAND attribute)
VIEW_FOLDERMAGIN (MENUCOMMAND attribute)
VIEW_FOLDERMAGIN_ARROW (MENUCOMMAND attribute)
VIEW_FOLDERMAGIN_BOX (MENUCOMMAND attribute)
VIEW_FOLDERMAGIN_CIRCLE (MENUCOMMAND attribute)
VIEW_FOLDERMAGIN_SIMPLE (MENUCOMMAND attribute)
VIEW_FULLSCREENTOGGLE (MENUCOMMAND attribute)
VIEW_GOTO_ANOTHER_VIEW (MENUCOMMAND attribute)
VIEW_GOTO_NEW_INSTANCE (MENUCOMMAND attribute)
VIEW_HIDELINES (MENUCOMMAND attribute)
VIEW_INDENT_GUIDE (MENUCOMMAND attribute)
VIEW_LINENUMBER (MENUCOMMAND attribute)
VIEW_LOAD_IN_NEW_INSTANCE (MENUCOMMAND attribute)
VIEW_LOCKTABBAR (MENUCOMMAND attribute)
VIEW_POSTIT (MENUCOMMAND attribute)
VIEW_REDUCETABBAR (MENUCOMMAND attribute)
VIEW_REFRESHTABAR (MENUCOMMAND attribute)
VIEW_SWITCHTO_OTHER_VIEW (MENUCOMMAND attribute)
VIEW_SYMBOLMARGIN (MENUCOMMAND attribute)
VIEW_SYNSCROLLH (MENUCOMMAND attribute)
VIEW_SYNSCROLLV (MENUCOMMAND attribute)
VIEW_TAB_SPACE (MENUCOMMAND attribute)
VIEW_TOGGLE_FOLDALL (MENUCOMMAND attribute)
VIEW_TOGGLE_UNFOLDALL (MENUCOMMAND attribute)
VIEW_TOOLBAR_ENLARGE (MENUCOMMAND attribute)
VIEW_TOOLBAR_REDUCE (MENUCOMMAND attribute)
VIEW_TOOLBAR_STANDARD (MENUCOMMAND attribute)
VIEW_UNFOLD (MENUCOMMAND attribute)
VIEW_UNFOLD_1 (MENUCOMMAND attribute)
VIEW_UNFOLD_2 (MENUCOMMAND attribute)
VIEW_UNFOLD_3 (MENUCOMMAND attribute)
VIEW_UNFOLD_4 (MENUCOMMAND attribute)
VIEW_UNFOLD_5 (MENUCOMMAND attribute)
VIEW_UNFOLD_6 (MENUCOMMAND attribute)
VIEW_UNFOLD_7 (MENUCOMMAND attribute)
VIEW_UNFOLD_8 (MENUCOMMAND attribute)
VIEW_UNFOLD_CURRENT (MENUCOMMAND attribute)
VIEW_USER_DLG (MENUCOMMAND attribute)
VIEW_WRAP (MENUCOMMAND attribute)
VIEW_WRAP_SYMBOL (MENUCOMMAND attribute)
VIEW_ZOOMIN (MENUCOMMAND attribute)
VIEW_ZOOMOUT (MENUCOMMAND attribute)
VIEW_ZOOMRESTORE (MENUCOMMAND attribute)
VIRTUALSPACE (built-in class)
VISIBLEAFTERINDENT (WHITESPACE attribute)
VISIBLEALWAYS (WHITESPACE attribute)
visibleFromDocLine() (Editor method)
VLINE (MARKERSYMBOL attribute)

W

WAIT (CURSORSHAPE attribute)
WHITEFLAG (FOLDLEVEL attribute)
WHITESPACE (built-in class)
WHOLEWORD (FINDOPTION attribute)
WIKIFAQ (MENUCOMMAND attribute)
WIN (FORMATTYPE attribute)
(KEYS attribute)
WORD (WRAP attribute)
wordEndPosition() (Editor method)
wordLeft() (Editor method)
wordLeftEnd() (Editor method)
wordLeftEndExtend() (Editor method)
wordLeftExtend() (Editor method)
wordPartLeft() (Editor method)
wordPartLeftExtend() (Editor method)
wordPartRight() (Editor method)
wordPartRightExtend() (Editor method)
wordRight() (Editor method)
wordRightEnd() (Editor method)
wordRightEndExtend() (Editor method)
wordRightExtend() (Editor method)
WORDSTART (FINDOPTION attribute)
wordStartPosition() (Editor method)
WORDSTYLESUPDATED (NOTIFICATION attribute)
WRAP (built-in class)
wrapCount() (Editor method)
WRAPINDENTMODE (built-in class)
WRAPVISUALFLAG (built-in class)
WRAPVISUALLOCATION (built-in class)
write() (Console method)
writeError() (Console method)

X

XCODE (LEXER attribute)
XML (LEXER attribute)

Y

YAML (LEXER attribute)
YESNO (MESSAGEBOXFLAGS attribute)
YESNOCANCEL (MESSAGEBOXFLAGS attribute)

Z

zoomIn() (Editor method)
zoomOut() (Editor method)


<no title>

  • index
  • PythonScript v0.7.0.0 documentation »
© Copyright 2010, Dave Brotherstone. Created using Sphinx 1.0.