
#include "stdafx.h"
#include "NotepadPlusWrapper.h"
#include "ScintillaWrapper.h"

#include "NotepadPython.h"
#include "PythonConsole.h"
#include "MatchPython.h"
#include "enums.h"
#include "ArgumentException.h"
#include "GroupNotFoundException.h"
#include "NotAllowedInCallbackException.h"

namespace NppPythonScript
{

BOOST_PYTHON_MODULE(Npp)
{
	boost::python::docstring_options doc_options;
	doc_options.disable_signatures();
	doc_options.enable_py_signatures();

	//lint -e1793 While calling �Symbol�: Initializing the implicit object parameter �Type� (a non-const reference) with a non-lvalue
	// The class declaration is used as designed, but it messes up Lint.
	boost::python::register_exception_translator<out_of_bounds_exception>(&translateOutOfBounds);
	boost::python::register_exception_translator<ArgumentException>(&translateArgumentException);
	boost::python::register_exception_translator<GroupNotFoundException>(&translateGroupNotFoundException);
	boost::python::register_exception_translator<NotAllowedInCallbackException>(&translateNotAllowedInCallbackException);

	boost::python::class_<ScintillaWrapper, boost::shared_ptr<ScintillaWrapper>, boost::noncopyable >("Editor", boost::python::no_init)
		.add_property("hwnd", &ScintillaWrapper::hwnd)
		.def("write", &ScintillaWrapper::AddText, boost::python::args("text"), "Add text to the document at current position (alias for addText).")
		.def("callbackSync", &ScintillaWrapper::addSyncCallback, boost::python::args("callable", "listOfNotifications"), "Registers a callback to a Python function when a Scintilla event occurs. See also callback() to register an asynchronous callback. Callbacks are called synchronously with the event, so try not to perform too much work in the event handler.\nCertain operations cannot be performed in a synchronous callback.  setDocPointer, searchInTarget or findText calls are examples.  Scintilla doesn't allow recursively modifying the text, so you can't modify the text in a SCINTILLANOTIFICATION.MODIFIED callback - use a standard Asynchronous callback to do this.\ne.g. editor.callbackSync(my_function, [SCINTILLANOTIFICATION.CHARADDED])")
		.def("callback", &ScintillaWrapper::addAsyncCallback, boost::python::args("callable", "listOfNotifications"), "Registers a callback to call a Python function synchronously when a Scintilla event occurs. Events are queued up, and run in the order they arrive, one after the other, but asynchronously with the main GUI. See editor.callbackSync() to register a synchronous callback. e.g. editor.callback(my_function, [SCINTILLANOTIFICATION.CHARADDED])")
		.def("__getitem__", &ScintillaWrapper::GetLine, boost::python::args("line"), "Gets a line from the given (zero based) index")
		.def("__len__", &ScintillaWrapper::GetLength, "Gets the length (number of bytes) in the document")
		.def("forEachLine", &ScintillaWrapper::forEachLine, boost::python::args("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.\nThat way, if you delete the current line, you should return 0, so as to stay on the current physical line.\n\nUnder normal circumstances, you do not need to return anything from the function (i.e. None)\n(Helper function)")
		.def("deleteLine", &ScintillaWrapper::deleteLine, boost::python::args("line"), "Deletes the given (zero indexed) line number. (Helper function)")
		.def("replaceLine", &ScintillaWrapper::replaceLine, boost::python::args("line", "newContents"), "Replaces the given (zero indexed) line number with the given contents. (Helper function)\ne.g.\n   editor.replaceLine(3, \"New contents\"")
		.def("replaceWholeLine", &ScintillaWrapper::replaceWholeLine, boost::python::args("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). (Helper function)\ne.g.\n   editor.replaceWholeLine(3, \"New contents\\n\"")
		.def("setTarget", &ScintillaWrapper::setTarget, boost::python::args("start", "end"), "Sets the target start and end in one call. (Helper function)")
		.def("getUserLineSelection", &ScintillaWrapper::getUserLineSelection, "Gets the start and end (zero indexed) line numbers of the user selection, or the whole document if nothing is selected. (Helper function)")
		.def("getUserCharSelection", &ScintillaWrapper::getUserCharSelection, "Gets the start and end (zero indexed) byte numbers of the user selection, or the whole document if nothing is selected. (Helper function)")
		.def("clearCallbacks", &ScintillaWrapper::clearAllCallbacks, "Clears all callbacks")
		.def("clearCallbacks", &ScintillaWrapper::clearCallbackFunction, boost::python::args("callable"), "Clears all callbacks for a given function")
		.def("clearCallbacks", &ScintillaWrapper::clearCallbackEvents, boost::python::args("notificationList"), "Clears all callbacks for the given list of events")
		.def("clearCallbacks", &ScintillaWrapper::clearCallback, boost::python::args("callable", "notificationList"), "Clears the callback for the given callback function for the list of events")
		.def("flash", &ScintillaWrapper::flash, "Flash the editor by reversing the foreground and background colours briefly")
		.def("flash", &ScintillaWrapper::flashMilliseconds, boost::python::args("milliseconds"), "Flash the editor by reversing the foreground and background colours briefly")
		.add_static_property("WHOLEDOC", &ScintillaWrapper::getWholeDocFlag)
		.def("replace", &ScintillaWrapper::replacePlain, boost::python::args("search", "replace"), "Simple search and replace. Replace [search] with [replace]")
		.def("replace", &ScintillaWrapper::replacePlainFlags, boost::python::args("search", "replace", "flags"), "Simple search and replace. Replace 'search' with 'replace' using the given flags.\nFlags are from the re module, and only re.IGNORECASE has an effect. ")
		.def("replace", &ScintillaWrapper::replacePlainFlagsStart, boost::python::args("search", "replace", "flags", "startPosition"), "Simple search and replace. Replace 'search' with 'replace' using the given flags.\nFlags are from the re module, and only re.IGNORECASE has an effect. Starts from the given (binary) startPosition")
		.def("replace", &ScintillaWrapper::replacePlainFlagsStartEnd, boost::python::args("search", "replace", "flags", "startPosition", "endPosition"), "Simple search and replace. Replace 'search' with 'replace' using the given flags.\nFlags are from the re module, and only re.IGNORECASE has an effect. Starts from the given (binary) startPosition, and replaces until the endPosition has been reached.")
		.def("replace", &ScintillaWrapper::replacePlainFlagsStartEndMaxCount, boost::python::args("search", "replace", "flags", "startPosition", "endPosition", "maxCount"), "Simple search and replace. Replace 'search' with 'replace' using the given flags.\nFlags are from the re module, and only re.IGNORECASE has an effect. Starts from the given (binary) startPosition, replaces until either the endPosition has been reached, or the maxCount of replacements have been performed")
		.def("rereplace", &ScintillaWrapper::replaceRegex, boost::python::args("searchRegex", "replace"), "Regular expression search and replace. Replaces 'searchRegex' with 'replace'.  ^ and $ by default match the starts and end of the document.  Use additional flags (re.MULTILINE) to treat ^ and $ per line.\n"
		                                                                                                  "The 'replace' parameter can be a python function, that recieves an object similar to a re.Match object.\n"
																										  "So you can have a function like\n"
																										  "   def myIncrement(m):\n"
																										  "       return int(m.group(1)) + 1\n\n"
																										  "And call rereplace('([0-9]+)', myIncrement) and it will increment all the integers.")
		.def("rereplace", &ScintillaWrapper::replaceRegexFlags, boost::python::args("searchRegex", "replace", "flags"), "Regular expression search and replace. Replaces 'searchRegex' with 'replace'.  Flags are the flags from the python re module (re.IGNORECASE, re.MULTILINE, re.DOTALL), and can be ORed together.  ^ and $ by default match the starts and end of the document.  Use re.MULTILINE as the flags to treat ^ and $ per line.\n"
		                                                                                                  "The 'replace' parameter can be a python function, that recieves an object similar to a re.Match object.\n"
																										  "So you can have a function like\n"
																										  "   def myIncrement(m):\n"
																										  "       return int(m.group(1)) + 1\n\n"
																										  "And call rereplace('([0-9]+)', myIncrement) and it will increment all the integers.")
		.def("rereplace", &ScintillaWrapper::replaceRegexFlagsStart, boost::python::args("searchRegex", "replace", "flags", "startPosition"), "Regular expression search and replace. Replaces 'searchRegex' with 'replace'.  Flags are the flags from the python re module (re.IGNORECASE, re.MULTILINE, re.DOTALL), and can be ORed together.\n"
		                                                             "startPosition is the binary startPosition to start the search from. ^ and $ by default match the starts and end of the document.  Use re.MULTILINE as the flags to treat ^ and $ per line.\n"
		                                                                                                  "The 'replace' parameter can be a python function, that recieves an object similar to a re.Match object.\n"
																										  "So you can have a function like\n"
																										  "   def myIncrement(m):\n"
																										  "       return int(m.group(1)) + 1\n\n"
																										  "And call rereplace('([0-9]+)', myIncrement) and it will increment all the integers.")
		.def("rereplace", &ScintillaWrapper::replaceRegexFlagsStartEnd, boost::python::args("searchRegex", "replace", "flags", "startPosition", "endPosition"), "Regular expression search and replace. Replaces 'searchRegex' with 'replace'.  Flags are the flags from the python re module (re.IGNORECASE, re.MULTILINE, re.DOTALL), and can be ORed together.\n"
		                                                             "startPosition and endPosition are the binary position to start and end the search from.\n"
																	  "^ and $ by default match the starts and end of the document.  Use re.MULTILINE as the flags to treat ^ and $ per line.\n"
		                                                                                                  "The 'replace' parameter can be a python function, that recieves an object similar to a re.Match object.\n"
																										  "So you can have a function like\n"
																										  "   def myIncrement(m):\n"
																										  "       return int(m.group(1)) + 1\n\n"
																										  "And call rereplace('([0-9]+)', myIncrement) and it will increment all the integers.")

		.def("rereplace", &ScintillaWrapper::replaceRegexFlagsStartEndMaxCount, boost::python::args("searchRegex", "replace", "flags", "startPosition", "endPosition", "maxCount"), "Regular expression search and replace. Replaces 'searchRegex' with 'replace'.  Flags are the flags from the python re module (re.IGNORECASE, re.MULTILINE, re.DOTALL), and can be ORed together.\n"
		                                                             "startPosition and endPosition are the binary position to start and end the search from.\n"
                                                                     "maxCount is the maximum count of replacements to perform.\n"
																	  "^ and $ by default match the starts and end of the document.  Use re.MULTILINE as the flags to treat ^ and $ per line.\n"
		                                                                                                  "The 'replace' parameter can be a python function, that recieves an object similar to a re.Match object.\n"
																										  "So you can have a function like\n"
																										  "   def myIncrement(m):\n"
																										  "       return int(m.group(1)) + 1\n\n"
																										  "And call rereplace('([0-9]+)', myIncrement) and it will increment all the integers.")
		.def("getWord", &ScintillaWrapper::getWord, "getWord([position[, useOnlyWordChars]])\nGets the word at position.  If position is not given or None, the current caret position is used.\nuseOnlyWordChars is a bool that is passed to Scintilla - see Scintilla rules on what is match. If not given or None, it is assumed to be true.")
		.def("getWord", &ScintillaWrapper::getWordNoFlags, "getWord([position[, useOnlyWordChars]])\nGets the word at position.  If position is not given or None, the current caret position is used.\nuseOnlyWordChars is a bool that is passed to Scintilla - see Scintilla rules on what is match. If not given or None, it is assumed to be true.")
		.def("getWord", &ScintillaWrapper::getCurrentWord, "getWord([position[, useOnlyWordChars]])\nGets the word at position.  If position is not given or None, the current caret position is used.\nuseOnlyWordChars is a bool that is passed to Scintilla - see Scintilla rules on what is match. If not given or None, it is assumed to be true.")
		.def("getCurrentWord", &ScintillaWrapper::getCurrentWord, "getCurrentWord()\nAlias for getWord(), that gets the current word at the cursor.")
		.def("search", &ScintillaWrapper::searchPlain, boost::python::args("search", "handlerFunction"), "Searches the document for given search text, and calls the handlerFunction with each match. The handler function receives a single match parameter, which is similar to a re.MatchObject object")
		.def("search", &ScintillaWrapper::searchPlainFlags, boost::python::args("search", "handlerFunction", "flags"), "Searches the document for given search text, and calls the handlerFunction with each match. The handler function receives a single match parameter, which is similar to a re.MatchObject object. Flags are the flags from the re module, specifically only re.IGNORECASE has an effect here.")
		.def("search", &ScintillaWrapper::searchPlainFlagsStart, boost::python::args("search", "handlerFunction", "flags", "startPosition"), "Searches the document from the given startPosition for given search text, and calls the handlerFunction with each match. The handler function receives a single match parameter, which is similar to a re.MatchObject object. Flags are the flags from the re module, specifically only re.IGNORECASE has an effect here.")
		.def("search", &ScintillaWrapper::searchPlainFlagsStartEnd, boost::python::args("search", "handlerFunction", "flags", "startPosition", "endPosition"), "Searches the document from the given startPosition to the given endPosition for given search text, and calls the handlerFunction with each match. The handler function receives a single match parameter, which is similar to a re.MatchObject object. Flags are the flags from the re module, specifically only re.IGNORECASE has an effect here.")
		.def("search", &ScintillaWrapper::searchPlainFlagsStartEndCount, boost::python::args("search", "handlerFunction", "flags", "startPosition", "endPosition", "maxCount"), "Searches the document from the given startPosition to the given endPosition for given search text, and calls the handlerFunction with each match. The search ends when maxCount matches have been located.  The handler function receives a single match parameter, which is similar to a re.MatchObject object. Flags are the flags from the re module, specifically only re.IGNORECASE has an effect here.")
		.def("research", &ScintillaWrapper::searchRegex, boost::python::args("search", "handlerFunction"), "Searches the document for given search regular expression, and calls the handlerFunction with each match. The handler function receives a single match parameter, which is similar to a re.MatchObject object")
		.def("research", &ScintillaWrapper::searchRegexFlags, boost::python::args("search", "handlerFunction", "flags"), "Searches the document for given search regular expression, and calls the handlerFunction with each match. The handler function receives a single match parameter, which is similar to a re.MatchObject object. Flags are the flags from the re module, specifically only re.IGNORECASE has an effect here.")
		.def("research", &ScintillaWrapper::searchRegexFlagsStart, boost::python::args("search", "handlerFunction", "flags", "startPosition"), "Searches the document from the given startPosition for given search regular expression, and calls the handlerFunction with each match. The handler function receives a single match parameter, which is similar to a re.MatchObject object. Flags are the flags from the re module, specifically only re.IGNORECASE has an effect here.")
		.def("research", &ScintillaWrapper::searchRegexFlagsStartEnd, boost::python::args("search", "handlerFunction", "flags", "startPosition", "endPosition"), "Searches the document from the given startPosition to the given endPosition for given search regular expression, and calls the handlerFunction with each match. The handler function receives a single match parameter, which is similar to a re.MatchObject object. Flags are the flags from the re module, specifically only re.IGNORECASE has an effect here.")
		.def("research", &ScintillaWrapper::searchRegexFlagsStartEndCount, boost::python::args("search", "handlerFunction", "flags", "startPosition", "endPosition", "maxCount"), "Searches the document from the given startPosition to the given endPosition for given search regular expression, and calls the handlerFunction with each match. The search ends when maxCount matches have been located.  The handler function receives a single match parameter, which is similar to a re.MatchObject object. Flags are the flags from the re module, specifically only re.IGNORECASE has an effect here.")
		/* Between the autogenerated comments is, surprise, autogenerated
		 * Do not edit the contents between these comments,
		 * edit "CreateWrapper.py" instead, which does the generation
		 * from Scintilla.iface
		 */
		/* ++Autogenerated -------------------- */
		.def("addText", &ScintillaWrapper::AddText, boost::python::args("text"), "Add text to the document at current position.")
		.def("addStyledText", &ScintillaWrapper::AddStyledText, boost::python::args("c"), "Add array of cells to document.")
		.def("insertText", &ScintillaWrapper::InsertText, boost::python::args("pos", "text"), "Insert string at a position.")
		.def("changeInsertion", &ScintillaWrapper::ChangeInsertion, boost::python::args("text"), "Change the text that is being inserted in response to SC_MOD_INSERTCHECK")
		.def("clearAll", &ScintillaWrapper::ClearAll, "Delete all text in the document.")
		.def("deleteRange", &ScintillaWrapper::DeleteRange, boost::python::args("start", "lengthDelete"), "Delete a range of text in the document.")
		.def("clearDocumentStyle", &ScintillaWrapper::ClearDocumentStyle, "Set all style bytes to 0, remove all folding information.")
		.def("getLength", &ScintillaWrapper::GetLength, "Returns the number of bytes in the document.")
		.def("getCharAt", &ScintillaWrapper::GetCharAt, boost::python::args("pos"), "Returns the character byte at the position.")
		.def("getCurrentPos", &ScintillaWrapper::GetCurrentPos, "Returns the position of the caret.")
		.def("getAnchor", &ScintillaWrapper::GetAnchor, "Returns the position of the opposite end of the selection to the caret.")
		.def("getStyleAt", &ScintillaWrapper::GetStyleAt, boost::python::args("pos"), "Returns the style byte at the position.")
		.def("getStyleIndexAt", &ScintillaWrapper::GetStyleIndexAt, boost::python::args("pos"), "Returns the unsigned style byte at the position.")
		.def("redo", &ScintillaWrapper::Redo, "Redoes the next action on the undo history.")
		.def("setUndoCollection", &ScintillaWrapper::SetUndoCollection, boost::python::args("collectUndo"), "Choose between collecting actions into the undo\nhistory and discarding them.")
		.def("selectAll", &ScintillaWrapper::SelectAll, "Select all the text in the document.")
		.def("setSavePoint", &ScintillaWrapper::SetSavePoint, "Remember the current position in the undo history as the position\nat which the document was saved.")
		.def("getStyledText", &ScintillaWrapper::GetStyledText, boost::python::args("start", "end"), "Retrieve a buffer of cells.\nReturns the number of bytes in the buffer not including terminating NULs.")
		.def("getStyledTextFull", &ScintillaWrapper::GetStyledTextFull, boost::python::args("start", "end"), "Retrieve a buffer of cells that can be past 2GB.\nReturns the number of bytes in the buffer not including terminating NULs.")
		.def("canRedo", &ScintillaWrapper::CanRedo, "Are there any redoable actions in the undo history?")
		.def("markerLineFromHandle", &ScintillaWrapper::MarkerLineFromHandle, boost::python::args("markerHandle"), "Retrieve the line number at which a particular marker is located.")
		.def("markerDeleteHandle", &ScintillaWrapper::MarkerDeleteHandle, boost::python::args("markerHandle"), "Delete a marker.")
		.def("markerHandleFromLine", &ScintillaWrapper::MarkerHandleFromLine, boost::python::args("line", "which"), "Retrieve marker handles of a line")
		.def("markerNumberFromLine", &ScintillaWrapper::MarkerNumberFromLine, boost::python::args("line", "which"), "Retrieve marker number of a marker handle")
		.def("getUndoCollection", &ScintillaWrapper::GetUndoCollection, "Is undo history being collected?")
		.def("getViewWS", &ScintillaWrapper::GetViewWS, "Are white space characters currently visible?\nReturns one of SCWS_* constants.")
		.def("setViewWS", &ScintillaWrapper::SetViewWS, boost::python::args("viewWS"), "Make white space characters invisible, always visible or visible outside indentation.")
		.def("getTabDrawMode", &ScintillaWrapper::GetTabDrawMode, "Retrieve the current tab draw mode.\nReturns one of SCTD_* constants.")
		.def("setTabDrawMode", &ScintillaWrapper::SetTabDrawMode, boost::python::args("tabDrawMode"), "Set how tabs are drawn when visible.")
		.def("positionFromPoint", &ScintillaWrapper::PositionFromPoint, boost::python::args("x", "y"), "Find the position from a point within the window.")
		.def("positionFromPointClose", &ScintillaWrapper::PositionFromPointClose, boost::python::args("x", "y"), "Find the position from a point within the window but return\nINVALID_POSITION if not close to text.")
		.def("gotoLine", &ScintillaWrapper::GotoLine, boost::python::args("line"), "Set caret to start of a line and ensure it is visible.")
		.def("gotoPos", &ScintillaWrapper::GotoPos, boost::python::args("caret"), "Set caret to a position and ensure it is visible.")
		.def("setAnchor", &ScintillaWrapper::SetAnchor, boost::python::args("anchor"), "Set the selection anchor to a position. The anchor is the opposite\nend of the selection from the caret.")
		.def("getCurLine", &ScintillaWrapper::GetCurLine, "Retrieve the text of the line containing the caret.\nReturns the index of the caret on the line.\nResult is NUL-terminated.")
		.def("getEndStyled", &ScintillaWrapper::GetEndStyled, "Retrieve the position of the last correctly styled character.")
		.def("convertEOLs", &ScintillaWrapper::ConvertEOLs, boost::python::args("eolMode"), "Convert all line endings in the document to one mode.")
		.def("getEOLMode", &ScintillaWrapper::GetEOLMode, "Retrieve the current end of line mode - one of CRLF, CR, or LF.")
		.def("setEOLMode", &ScintillaWrapper::SetEOLMode, boost::python::args("eolMode"), "Set the current end of line mode.")
		.def("startStyling", &ScintillaWrapper::StartStyling, boost::python::args("start", "unused"), "Set the current styling position to start.\nThe unused parameter is no longer used and should be set to 0.")
		.def("setStyling", &ScintillaWrapper::SetStyling, boost::python::args("length", "style"), "Change style from current styling position for length characters to a style\nand move the current styling position to after this newly styled segment.")
		.def("getBufferedDraw", &ScintillaWrapper::GetBufferedDraw, "Is drawing done first into a buffer or direct to the screen?")
		.def("setBufferedDraw", &ScintillaWrapper::SetBufferedDraw, boost::python::args("buffered"), "If drawing is buffered then each line of text is drawn into a bitmap buffer\nbefore drawing it to the screen to avoid flicker.")
		.def("setTabWidth", &ScintillaWrapper::SetTabWidth, boost::python::args("tabWidth"), "Change the visible size of a tab to be a multiple of the width of a space character.")
		.def("getTabWidth", &ScintillaWrapper::GetTabWidth, "Retrieve the visible size of a tab.")
		.def("setTabMinimumWidth", &ScintillaWrapper::SetTabMinimumWidth, boost::python::args("pixels"), "Set the minimum visual width of a tab.")
		.def("getTabMinimumWidth", &ScintillaWrapper::GetTabMinimumWidth, "Get the minimum visual width of a tab.")
		.def("clearTabStops", &ScintillaWrapper::ClearTabStops, boost::python::args("line"), "Clear explicit tabstops on a line.")
		.def("addTabStop", &ScintillaWrapper::AddTabStop, boost::python::args("line", "x"), "Add an explicit tab stop for a line.")
		.def("getNextTabStop", &ScintillaWrapper::GetNextTabStop, boost::python::args("line", "x"), "Find the next explicit tab stop position on a line after a position.")
		.def("setCodePage", &ScintillaWrapper::SetCodePage, boost::python::args("codePage"), "Set the code page used to interpret the bytes of the document as characters.\nThe SC_CP_UTF8 value can be used to enter Unicode mode.")
		.def("setFontLocale", &ScintillaWrapper::SetFontLocale, boost::python::args("localeName"), "Set the locale for displaying text.")
		.def("getFontLocale", &ScintillaWrapper::GetFontLocale, "Get the locale for displaying text.")
		.def("getIMEInteraction", &ScintillaWrapper::GetIMEInteraction, "Is the IME displayed in a window or inline?")
		.def("setIMEInteraction", &ScintillaWrapper::SetIMEInteraction, boost::python::args("imeInteraction"), "Choose to display the IME in a window or inline.")
		.def("markerDefine", &ScintillaWrapper::MarkerDefine, boost::python::args("markerNumber", "markerSymbol"), "Set the symbol used for a particular marker number.")
		.def("markerSetFore", &ScintillaWrapper::MarkerSetFore, boost::python::args("markerNumber", "fore"), "Set the foreground colour used for a particular marker number.")
		.def("markerSetBack", &ScintillaWrapper::MarkerSetBack, boost::python::args("markerNumber", "back"), "Set the background colour used for a particular marker number.")
		.def("markerSetBackSelected", &ScintillaWrapper::MarkerSetBackSelected, boost::python::args("markerNumber", "back"), "Set the background colour used for a particular marker number when its folding block is selected.")
		.def("markerSetForeTranslucent", &ScintillaWrapper::MarkerSetForeTranslucent, boost::python::args("markerNumber", "fore"), "Set the foreground colour used for a particular marker number.")
		.def("markerSetBackTranslucent", &ScintillaWrapper::MarkerSetBackTranslucent, boost::python::args("markerNumber", "back"), "Set the background colour used for a particular marker number.")
		.def("markerSetBackSelectedTranslucent", &ScintillaWrapper::MarkerSetBackSelectedTranslucent, boost::python::args("markerNumber", "back"), "Set the background colour used for a particular marker number when its folding block is selected.")
		.def("markerSetStrokeWidth", &ScintillaWrapper::MarkerSetStrokeWidth, boost::python::args("markerNumber", "hundredths"), "Set the width of strokes used in .01 pixels so 50  = 1/2 pixel width.")
		.def("markerEnableHighlight", &ScintillaWrapper::MarkerEnableHighlight, boost::python::args("enabled"), "Enable/disable highlight for current folding block (smallest one that contains the caret)")
		.def("markerAdd", &ScintillaWrapper::MarkerAdd, boost::python::args("line", "markerNumber"), "Add a marker to a line, returning an ID which can be used to find or delete the marker.")
		.def("markerDelete", &ScintillaWrapper::MarkerDelete, boost::python::args("line", "markerNumber"), "Delete a marker from a line.")
		.def("markerDeleteAll", &ScintillaWrapper::MarkerDeleteAll, boost::python::args("markerNumber"), "Delete all markers with a particular number from all lines.")
		.def("markerGet", &ScintillaWrapper::MarkerGet, boost::python::args("line"), "Get a bit mask of all the markers set on a line.")
		.def("markerNext", &ScintillaWrapper::MarkerNext, boost::python::args("lineStart", "markerMask"), "Find the next line at or after lineStart that includes a marker in mask.\nReturn -1 when no more lines.")
		.def("markerPrevious", &ScintillaWrapper::MarkerPrevious, boost::python::args("lineStart", "markerMask"), "Find the previous line before lineStart that includes a marker in mask.")
		.def("markerDefinePixmap", &ScintillaWrapper::MarkerDefinePixmap, boost::python::args("markerNumber", "pixmap"), "Define a marker from a pixmap.")
		.def("markerAddSet", &ScintillaWrapper::MarkerAddSet, boost::python::args("line", "markerSet"), "Add a set of markers to a line.")
		.def("markerSetAlpha", &ScintillaWrapper::MarkerSetAlpha, boost::python::args("markerNumber", "alpha"), "Set the alpha used for a marker that is drawn in the text area, not the margin.")
		.def("markerGetLayer", &ScintillaWrapper::MarkerGetLayer, boost::python::args("markerNumber"), "Get the layer used for a marker that is drawn in the text area, not the margin.")
		.def("markerSetLayer", &ScintillaWrapper::MarkerSetLayer, boost::python::args("markerNumber", "layer"), "Set the layer used for a marker that is drawn in the text area, not the margin.")
		.def("setMarginTypeN", &ScintillaWrapper::SetMarginTypeN, boost::python::args("margin", "marginType"), "Set a margin to be either numeric or symbolic.")
		.def("getMarginTypeN", &ScintillaWrapper::GetMarginTypeN, boost::python::args("margin"), "Retrieve the type of a margin.")
		.def("setMarginWidthN", &ScintillaWrapper::SetMarginWidthN, boost::python::args("margin", "pixelWidth"), "Set the width of a margin to a width expressed in pixels.")
		.def("getMarginWidthN", &ScintillaWrapper::GetMarginWidthN, boost::python::args("margin"), "Retrieve the width of a margin in pixels.")
		.def("setMarginMaskN", &ScintillaWrapper::SetMarginMaskN, boost::python::args("margin", "mask"), "Set a mask that determines which markers are displayed in a margin.")
		.def("getMarginMaskN", &ScintillaWrapper::GetMarginMaskN, boost::python::args("margin"), "Retrieve the marker mask of a margin.")
		.def("setMarginSensitiveN", &ScintillaWrapper::SetMarginSensitiveN, boost::python::args("margin", "sensitive"), "Make a margin sensitive or insensitive to mouse clicks.")
		.def("getMarginSensitiveN", &ScintillaWrapper::GetMarginSensitiveN, boost::python::args("margin"), "Retrieve the mouse click sensitivity of a margin.")
		.def("setMarginCursorN", &ScintillaWrapper::SetMarginCursorN, boost::python::args("margin", "cursor"), "Set the cursor shown when the mouse is inside a margin.")
		.def("getMarginCursorN", &ScintillaWrapper::GetMarginCursorN, boost::python::args("margin"), "Retrieve the cursor shown in a margin.")
		.def("setMarginBackN", &ScintillaWrapper::SetMarginBackN, boost::python::args("margin", "back"), "Set the background colour of a margin. Only visible for SC_MARGIN_COLOUR.")
		.def("getMarginBackN", &ScintillaWrapper::GetMarginBackN, boost::python::args("margin"), "Retrieve the background colour of a margin")
		.def("setMargins", &ScintillaWrapper::SetMargins, boost::python::args("margins"), "Allocate a non-standard number of margins.")
		.def("getMargins", &ScintillaWrapper::GetMargins, "How many margins are there?.")
		.def("styleClearAll", &ScintillaWrapper::StyleClearAll, "Clear all the styles and make equivalent to the global default style.")
		.def("styleSetFore", &ScintillaWrapper::StyleSetFore, boost::python::args("style", "fore"), "Set the foreground colour of a style.")
		.def("styleSetBack", &ScintillaWrapper::StyleSetBack, boost::python::args("style", "back"), "Set the background colour of a style.")
		.def("styleSetBold", &ScintillaWrapper::StyleSetBold, boost::python::args("style", "bold"), "Set a style to be bold or not.")
		.def("styleSetItalic", &ScintillaWrapper::StyleSetItalic, boost::python::args("style", "italic"), "Set a style to be italic or not.")
		.def("styleSetSize", &ScintillaWrapper::StyleSetSize, boost::python::args("style", "sizePoints"), "Set the size of characters of a style.")
		.def("styleSetFont", &ScintillaWrapper::StyleSetFont, boost::python::args("style", "fontName"), "Set the font of a style.")
		.def("styleSetEOLFilled", &ScintillaWrapper::StyleSetEOLFilled, boost::python::args("style", "eolFilled"), "Set a style to have its end of line filled or not.")
		.def("styleResetDefault", &ScintillaWrapper::StyleResetDefault, "Reset the default style to its state at startup")
		.def("styleSetUnderline", &ScintillaWrapper::StyleSetUnderline, boost::python::args("style", "underline"), "Set a style to be underlined or not.")
		.def("styleGetFore", &ScintillaWrapper::StyleGetFore, boost::python::args("style"), "Get the foreground colour of a style.")
		.def("styleGetBack", &ScintillaWrapper::StyleGetBack, boost::python::args("style"), "Get the background colour of a style.")
		.def("styleGetBold", &ScintillaWrapper::StyleGetBold, boost::python::args("style"), "Get is a style bold or not.")
		.def("styleGetItalic", &ScintillaWrapper::StyleGetItalic, boost::python::args("style"), "Get is a style italic or not.")
		.def("styleGetSize", &ScintillaWrapper::StyleGetSize, boost::python::args("style"), "Get the size of characters of a style.")
		.def("styleGetFont", &ScintillaWrapper::StyleGetFont, boost::python::args("style"), "Get the font of a style.\nReturns the length of the fontName\nResult is NUL-terminated.")
		.def("styleGetEOLFilled", &ScintillaWrapper::StyleGetEOLFilled, boost::python::args("style"), "Get is a style to have its end of line filled or not.")
		.def("styleGetUnderline", &ScintillaWrapper::StyleGetUnderline, boost::python::args("style"), "Get is a style underlined or not.")
		.def("styleGetCase", &ScintillaWrapper::StyleGetCase, boost::python::args("style"), "Get is a style mixed case, or to force upper or lower case.")
		.def("styleGetCharacterSet", &ScintillaWrapper::StyleGetCharacterSet, boost::python::args("style"), "Get the character get of the font in a style.")
		.def("styleGetVisible", &ScintillaWrapper::StyleGetVisible, boost::python::args("style"), "Get is a style visible or not.")
		.def("styleGetChangeable", &ScintillaWrapper::StyleGetChangeable, boost::python::args("style"), "Get is a style changeable or not (read only).\nExperimental feature, currently buggy.")
		.def("styleGetHotSpot", &ScintillaWrapper::StyleGetHotSpot, boost::python::args("style"), "Get is a style a hotspot or not.")
		.def("styleSetCase", &ScintillaWrapper::StyleSetCase, boost::python::args("style", "caseVisible"), "Set a style to be mixed case, or to force upper or lower case.")
		.def("styleSetSizeFractional", &ScintillaWrapper::StyleSetSizeFractional, boost::python::args("style", "sizeHundredthPoints"), "Set the size of characters of a style. Size is in points multiplied by 100.")
		.def("styleGetSizeFractional", &ScintillaWrapper::StyleGetSizeFractional, boost::python::args("style"), "Get the size of characters of a style in points multiplied by 100")
		.def("styleSetWeight", &ScintillaWrapper::StyleSetWeight, boost::python::args("style", "weight"), "Set the weight of characters of a style.")
		.def("styleGetWeight", &ScintillaWrapper::StyleGetWeight, boost::python::args("style"), "Get the weight of characters of a style.")
		.def("styleSetCharacterSet", &ScintillaWrapper::StyleSetCharacterSet, boost::python::args("style", "characterSet"), "Set the character set of the font in a style.")
		.def("styleSetHotSpot", &ScintillaWrapper::StyleSetHotSpot, boost::python::args("style", "hotspot"), "Set a style to be a hotspot or not.")
		.def("styleSetCheckMonospaced", &ScintillaWrapper::StyleSetCheckMonospaced, boost::python::args("style", "checkMonospaced"), "Indicate that a style may be monospaced over ASCII graphics characters which enables optimizations.")
		.def("styleGetCheckMonospaced", &ScintillaWrapper::StyleGetCheckMonospaced, boost::python::args("style"), "Get whether a style may be monospaced.")
		.def("styleSetStretch", &ScintillaWrapper::StyleSetStretch, boost::python::args("style", "stretch"), "Set the stretch of characters of a style.")
		.def("styleGetStretch", &ScintillaWrapper::StyleGetStretch, boost::python::args("style"), "Get the stretch of characters of a style.")
		.def("styleSetInvisibleRepresentation", &ScintillaWrapper::StyleSetInvisibleRepresentation, boost::python::args("style", "representation"), "Set the invisible representation for a style.")
		.def("styleGetInvisibleRepresentation", &ScintillaWrapper::StyleGetInvisibleRepresentation, boost::python::args("style"), "Get the invisible representation for a style.")
		.def("setElementColour", &ScintillaWrapper::SetElementColour, boost::python::args("element", "colourElement"), "Set the colour of an element. Translucency (alpha) may or may not be significant\nand this may depend on the platform. The alpha byte should commonly be 0xff for opaque.")
		.def("getElementColour", &ScintillaWrapper::GetElementColour, boost::python::args("element"), "Get the colour of an element.")
		.def("resetElementColour", &ScintillaWrapper::ResetElementColour, boost::python::args("element"), "Use the default or platform-defined colour for an element.")
		.def("getElementIsSet", &ScintillaWrapper::GetElementIsSet, boost::python::args("element"), "Get whether an element has been set by SetElementColour.\nWhen false, a platform-defined or default colour is used.")
		.def("getElementAllowsTranslucent", &ScintillaWrapper::GetElementAllowsTranslucent, boost::python::args("element"), "Get whether an element supports translucency.")
		.def("getElementBaseColour", &ScintillaWrapper::GetElementBaseColour, boost::python::args("element"), "Get the colour of an element.")
		.def("setSelFore", &ScintillaWrapper::SetSelFore, boost::python::args("useSetting", "fore"), "Set the foreground colour of the main and additional selections and whether to use this setting.")
		.def("setSelBack", &ScintillaWrapper::SetSelBack, boost::python::args("useSetting", "back"), "Set the background colour of the main and additional selections and whether to use this setting.")
		.def("getSelAlpha", &ScintillaWrapper::GetSelAlpha, "Get the alpha of the selection.")
		.def("setSelAlpha", &ScintillaWrapper::SetSelAlpha, boost::python::args("alpha"), "Set the alpha of the selection.")
		.def("getSelEOLFilled", &ScintillaWrapper::GetSelEOLFilled, "Is the selection end of line filled?")
		.def("setSelEOLFilled", &ScintillaWrapper::SetSelEOLFilled, boost::python::args("filled"), "Set the selection to have its end of line filled or not.")
		.def("getSelectionLayer", &ScintillaWrapper::GetSelectionLayer, "Get the layer for drawing selections")
		.def("setSelectionLayer", &ScintillaWrapper::SetSelectionLayer, boost::python::args("layer"), "Set the layer for drawing selections: either opaquely on base layer or translucently over text")
		.def("getCaretLineLayer", &ScintillaWrapper::GetCaretLineLayer, "Get the layer of the background of the line containing the caret.")
		.def("setCaretLineLayer", &ScintillaWrapper::SetCaretLineLayer, boost::python::args("layer"), "Set the layer of the background of the line containing the caret.")
		.def("getCaretLineHighlightSubLine", &ScintillaWrapper::GetCaretLineHighlightSubLine, "Get only highlighting subline instead of whole line.")
		.def("setCaretLineHighlightSubLine", &ScintillaWrapper::SetCaretLineHighlightSubLine, boost::python::args("subLine"), "Set only highlighting subline instead of whole line.")
		.def("setCaretFore", &ScintillaWrapper::SetCaretFore, boost::python::args("fore"), "Set the foreground colour of the caret.")
		.def("assignCmdKey", &ScintillaWrapper::AssignCmdKey, boost::python::args("keyDefinition", "sciCommand"), "When key+modifier combination keyDefinition is pressed perform sciCommand.")
		.def("clearCmdKey", &ScintillaWrapper::ClearCmdKey, boost::python::args("keyDefinition"), "When key+modifier combination keyDefinition is pressed do nothing.")
		.def("clearAllCmdKeys", &ScintillaWrapper::ClearAllCmdKeys, "Drop all key mappings.")
		.def("setStylingEx", &ScintillaWrapper::SetStylingEx, boost::python::args("styles"), "Set the styles for a segment of the document.")
		.def("styleSetVisible", &ScintillaWrapper::StyleSetVisible, boost::python::args("style", "visible"), "Set a style to be visible or not.")
		.def("getCaretPeriod", &ScintillaWrapper::GetCaretPeriod, "Get the time in milliseconds that the caret is on and off.")
		.def("setCaretPeriod", &ScintillaWrapper::SetCaretPeriod, boost::python::args("periodMilliseconds"), "Get the time in milliseconds that the caret is on and off. 0 = steady on.")
		.def("setWordChars", &ScintillaWrapper::SetWordChars, boost::python::args("characters"), "Set the set of characters making up words for when moving or selecting by word.\nFirst sets defaults like SetCharsDefault.")
		.def("getWordChars", &ScintillaWrapper::GetWordChars, "Get the set of characters making up words for when moving or selecting by word.\nReturns the number of characters")
		.def("setCharacterCategoryOptimization", &ScintillaWrapper::SetCharacterCategoryOptimization, boost::python::args("countCharacters"), "Set the number of characters to have directly indexed categories")
		.def("getCharacterCategoryOptimization", &ScintillaWrapper::GetCharacterCategoryOptimization, "Get the number of characters to have directly indexed categories")
		.def("beginUndoAction", &ScintillaWrapper::BeginUndoAction, "Start a sequence of actions that is undone and redone as a unit.\nMay be nested.")
		.def("endUndoAction", &ScintillaWrapper::EndUndoAction, "End a sequence of actions that is undone and redone as a unit.")
		.def("getUndoSequence", &ScintillaWrapper::GetUndoSequence, "Is an undo sequence active?")
		.def("getUndoActions", &ScintillaWrapper::GetUndoActions, "How many undo actions are in the history?")
		.def("setUndoSavePoint", &ScintillaWrapper::SetUndoSavePoint, boost::python::args("action"), "Set action as the save point")
		.def("getUndoSavePoint", &ScintillaWrapper::GetUndoSavePoint, "Which action is the save point?")
		.def("setUndoDetach", &ScintillaWrapper::SetUndoDetach, boost::python::args("action"), "Set action as the detach point")
		.def("getUndoDetach", &ScintillaWrapper::GetUndoDetach, "Which action is the detach point?")
		.def("setUndoTentative", &ScintillaWrapper::SetUndoTentative, boost::python::args("action"), "Set action as the tentative point")
		.def("getUndoTentative", &ScintillaWrapper::GetUndoTentative, "Which action is the tentative point?")
		.def("setUndoCurrent", &ScintillaWrapper::SetUndoCurrent, boost::python::args("action"), "Set action as the current point")
		.def("getUndoCurrent", &ScintillaWrapper::GetUndoCurrent, "Which action is the current point?")
		.def("pushUndoActionType", &ScintillaWrapper::PushUndoActionType, boost::python::args("type", "pos"), "Push one action onto undo history with no text")
		.def("changeLastUndoActionText", &ScintillaWrapper::ChangeLastUndoActionText, boost::python::args("text"), "Set the text and length of the most recently pushed action")
		.def("getUndoActionType", &ScintillaWrapper::GetUndoActionType, boost::python::args("action"), "What is the type of an action?")
		.def("getUndoActionPosition", &ScintillaWrapper::GetUndoActionPosition, boost::python::args("action"), "What is the position of an action?")
		.def("getUndoActionText", &ScintillaWrapper::GetUndoActionText, boost::python::args("action"), "What is the text of an action?")
		.def("indicSetStyle", &ScintillaWrapper::IndicSetStyle, boost::python::args("indicator", "indicatorStyle"), "Set an indicator to plain, squiggle or TT.")
		.def("indicGetStyle", &ScintillaWrapper::IndicGetStyle, boost::python::args("indicator"), "Retrieve the style of an indicator.")
		.def("indicSetFore", &ScintillaWrapper::IndicSetFore, boost::python::args("indicator", "fore"), "Set the foreground colour of an indicator.")
		.def("indicGetFore", &ScintillaWrapper::IndicGetFore, boost::python::args("indicator"), "Retrieve the foreground colour of an indicator.")
		.def("indicSetUnder", &ScintillaWrapper::IndicSetUnder, boost::python::args("indicator", "under"), "Set an indicator to draw under text or over(default).")
		.def("indicGetUnder", &ScintillaWrapper::IndicGetUnder, boost::python::args("indicator"), "Retrieve whether indicator drawn under or over text.")
		.def("indicSetHoverStyle", &ScintillaWrapper::IndicSetHoverStyle, boost::python::args("indicator", "indicatorStyle"), "Set a hover indicator to plain, squiggle or TT.")
		.def("indicGetHoverStyle", &ScintillaWrapper::IndicGetHoverStyle, boost::python::args("indicator"), "Retrieve the hover style of an indicator.")
		.def("indicSetHoverFore", &ScintillaWrapper::IndicSetHoverFore, boost::python::args("indicator", "fore"), "Set the foreground hover colour of an indicator.")
		.def("indicGetHoverFore", &ScintillaWrapper::IndicGetHoverFore, boost::python::args("indicator"), "Retrieve the foreground hover colour of an indicator.")
		.def("indicSetFlags", &ScintillaWrapper::IndicSetFlags, boost::python::args("indicator", "flags"), "Set the attributes of an indicator.")
		.def("indicGetFlags", &ScintillaWrapper::IndicGetFlags, boost::python::args("indicator"), "Retrieve the attributes of an indicator.")
		.def("indicSetStrokeWidth", &ScintillaWrapper::IndicSetStrokeWidth, boost::python::args("indicator", "hundredths"), "Set the stroke width of an indicator in hundredths of a pixel.")
		.def("indicGetStrokeWidth", &ScintillaWrapper::IndicGetStrokeWidth, boost::python::args("indicator"), "Retrieve the stroke width of an indicator.")
		.def("setWhitespaceFore", &ScintillaWrapper::SetWhitespaceFore, boost::python::args("useSetting", "fore"), "Set the foreground colour of all whitespace and whether to use this setting.")
		.def("setWhitespaceBack", &ScintillaWrapper::SetWhitespaceBack, boost::python::args("useSetting", "back"), "Set the background colour of all whitespace and whether to use this setting.")
		.def("setWhitespaceSize", &ScintillaWrapper::SetWhitespaceSize, boost::python::args("size"), "Set the size of the dots used to mark space characters.")
		.def("getWhitespaceSize", &ScintillaWrapper::GetWhitespaceSize, "Get the size of the dots used to mark space characters.")
		.def("setLineState", &ScintillaWrapper::SetLineState, boost::python::args("line", "state"), "Used to hold extra styling information for each line.")
		.def("getLineState", &ScintillaWrapper::GetLineState, boost::python::args("line"), "Retrieve the extra styling information for a line.")
		.def("getMaxLineState", &ScintillaWrapper::GetMaxLineState, "Retrieve the last line number that has line state.")
		.def("getCaretLineVisible", &ScintillaWrapper::GetCaretLineVisible, "Is the background of the line containing the caret in a different colour?")
		.def("setCaretLineVisible", &ScintillaWrapper::SetCaretLineVisible, boost::python::args("show"), "Display the background of the line containing the caret in a different colour.")
		.def("getCaretLineBack", &ScintillaWrapper::GetCaretLineBack, "Get the colour of the background of the line containing the caret.")
		.def("setCaretLineBack", &ScintillaWrapper::SetCaretLineBack, boost::python::args("back"), "Set the colour of the background of the line containing the caret.")
		.def("getCaretLineFrame", &ScintillaWrapper::GetCaretLineFrame, "Retrieve the caret line frame width.\nWidth = 0 means this option is disabled.")
		.def("setCaretLineFrame", &ScintillaWrapper::SetCaretLineFrame, boost::python::args("width"), "Display the caret line framed.\nSet width != 0 to enable this option and width = 0 to disable it.")
		.def("styleSetChangeable", &ScintillaWrapper::StyleSetChangeable, boost::python::args("style", "changeable"), "Set a style to be changeable or not (read only).\nExperimental feature, currently buggy.")
		.def("autoCShow", &ScintillaWrapper::AutoCShow, boost::python::args("lengthEntered", "itemList"), "Display a auto-completion list.\nThe lengthEntered parameter indicates how many characters before\nthe caret should be used to provide context.")
		.def("autoCCancel", &ScintillaWrapper::AutoCCancel, "Remove the auto-completion list from the screen.")
		.def("autoCActive", &ScintillaWrapper::AutoCActive, "Is there an auto-completion list visible?")
		.def("autoCPosStart", &ScintillaWrapper::AutoCPosStart, "Retrieve the position of the caret when the auto-completion list was displayed.")
		.def("autoCComplete", &ScintillaWrapper::AutoCComplete, "User has selected an item so remove the list and insert the selection.")
		.def("autoCStops", &ScintillaWrapper::AutoCStops, boost::python::args("characterSet"), "Define a set of character that when typed cancel the auto-completion list.")
		.def("autoCSetSeparator", &ScintillaWrapper::AutoCSetSeparator, boost::python::args("separatorCharacter"), "Change the separator character in the string setting up an auto-completion list.\nDefault is space but can be changed if items contain space.")
		.def("autoCGetSeparator", &ScintillaWrapper::AutoCGetSeparator, "Retrieve the auto-completion list separator character.")
		.def("autoCSelect", &ScintillaWrapper::AutoCSelect, boost::python::args("select"), "Select the item in the auto-completion list that starts with a string.")
		.def("autoCSetCancelAtStart", &ScintillaWrapper::AutoCSetCancelAtStart, boost::python::args("cancel"), "Should the auto-completion list be cancelled if the user backspaces to a\nposition before where the box was created.")
		.def("autoCGetCancelAtStart", &ScintillaWrapper::AutoCGetCancelAtStart, "Retrieve whether auto-completion cancelled by backspacing before start.")
		.def("autoCSetFillUps", &ScintillaWrapper::AutoCSetFillUps, boost::python::args("characterSet"), "Define a set of characters that when typed will cause the autocompletion to\nchoose the selected item.")
		.def("autoCSetChooseSingle", &ScintillaWrapper::AutoCSetChooseSingle, boost::python::args("chooseSingle"), "Should a single item auto-completion list automatically choose the item.")
		.def("autoCGetChooseSingle", &ScintillaWrapper::AutoCGetChooseSingle, "Retrieve whether a single item auto-completion list automatically choose the item.")
		.def("autoCSetIgnoreCase", &ScintillaWrapper::AutoCSetIgnoreCase, boost::python::args("ignoreCase"), "Set whether case is significant when performing auto-completion searches.")
		.def("autoCGetIgnoreCase", &ScintillaWrapper::AutoCGetIgnoreCase, "Retrieve state of ignore case flag.")
		.def("userListShow", &ScintillaWrapper::UserListShow, boost::python::args("listType", "itemList"), "Display a list of strings and send notification when user chooses one.")
		.def("autoCSetAutoHide", &ScintillaWrapper::AutoCSetAutoHide, boost::python::args("autoHide"), "Set whether or not autocompletion is hidden automatically when nothing matches.")
		.def("autoCGetAutoHide", &ScintillaWrapper::AutoCGetAutoHide, "Retrieve whether or not autocompletion is hidden automatically when nothing matches.")
		.def("autoCSetOptions", &ScintillaWrapper::AutoCSetOptions, boost::python::args("options"), "Set autocompletion options.")
		.def("autoCGetOptions", &ScintillaWrapper::AutoCGetOptions, "Retrieve autocompletion options.")
		.def("autoCSetDropRestOfWord", &ScintillaWrapper::AutoCSetDropRestOfWord, boost::python::args("dropRestOfWord"), "Set whether or not autocompletion deletes any word characters\nafter the inserted text upon completion.")
		.def("autoCGetDropRestOfWord", &ScintillaWrapper::AutoCGetDropRestOfWord, "Retrieve whether or not autocompletion deletes any word characters\nafter the inserted text upon completion.")
		.def("registerImage", &ScintillaWrapper::RegisterImage, boost::python::args("type", "xpmData"), "Register an XPM image for use in autocompletion lists.")
		.def("clearRegisteredImages", &ScintillaWrapper::ClearRegisteredImages, "Clear all the registered XPM images.")
		.def("autoCGetTypeSeparator", &ScintillaWrapper::AutoCGetTypeSeparator, "Retrieve the auto-completion list type-separator character.")
		.def("autoCSetTypeSeparator", &ScintillaWrapper::AutoCSetTypeSeparator, boost::python::args("separatorCharacter"), "Change the type-separator character in the string setting up an auto-completion list.\nDefault is '?' but can be changed if items contain '?'.")
		.def("autoCSetMaxWidth", &ScintillaWrapper::AutoCSetMaxWidth, boost::python::args("characterCount"), "Set the maximum width, in characters, of auto-completion and user lists.\nSet to 0 to autosize to fit longest item, which is the default.")
		.def("autoCGetMaxWidth", &ScintillaWrapper::AutoCGetMaxWidth, "Get the maximum width, in characters, of auto-completion and user lists.")
		.def("autoCSetMaxHeight", &ScintillaWrapper::AutoCSetMaxHeight, boost::python::args("rowCount"), "Set the maximum height, in rows, of auto-completion and user lists.\nThe default is 5 rows.")
		.def("autoCGetMaxHeight", &ScintillaWrapper::AutoCGetMaxHeight, "Set the maximum height, in rows, of auto-completion and user lists.")
		.def("autoCSetStyle", &ScintillaWrapper::AutoCSetStyle, boost::python::args("style"), "Set the style number used for auto-completion and user lists fonts.")
		.def("autoCGetStyle", &ScintillaWrapper::AutoCGetStyle, "Get the style number used for auto-completion and user lists fonts.")
		.def("setIndent", &ScintillaWrapper::SetIndent, boost::python::args("indentSize"), "Set the number of spaces used for one level of indentation.")
		.def("getIndent", &ScintillaWrapper::GetIndent, "Retrieve indentation size.")
		.def("setUseTabs", &ScintillaWrapper::SetUseTabs, boost::python::args("useTabs"), "Indentation will only use space characters if useTabs is false, otherwise\nit will use a combination of tabs and spaces.")
		.def("getUseTabs", &ScintillaWrapper::GetUseTabs, "Retrieve whether tabs will be used in indentation.")
		.def("setLineIndentation", &ScintillaWrapper::SetLineIndentation, boost::python::args("line", "indentation"), "Change the indentation of a line to a number of columns.")
		.def("getLineIndentation", &ScintillaWrapper::GetLineIndentation, boost::python::args("line"), "Retrieve the number of columns that a line is indented.")
		.def("getLineIndentPosition", &ScintillaWrapper::GetLineIndentPosition, boost::python::args("line"), "Retrieve the position before the first non indentation character on a line.")
		.def("getColumn", &ScintillaWrapper::GetColumn, boost::python::args("pos"), "Retrieve the column number of a position, taking tab width into account.")
		.def("countCharacters", &ScintillaWrapper::CountCharacters, boost::python::args("start", "end"), "Count characters between two positions.")
		.def("countCodeUnits", &ScintillaWrapper::CountCodeUnits, boost::python::args("start", "end"), "Count code units between two positions.")
		.def("setHScrollBar", &ScintillaWrapper::SetHScrollBar, boost::python::args("visible"), "Show or hide the horizontal scroll bar.")
		.def("getHScrollBar", &ScintillaWrapper::GetHScrollBar, "Is the horizontal scroll bar visible?")
		.def("setIndentationGuides", &ScintillaWrapper::SetIndentationGuides, boost::python::args("indentView"), "Show or hide indentation guides.")
		.def("getIndentationGuides", &ScintillaWrapper::GetIndentationGuides, "Are the indentation guides visible?")
		.def("setHighlightGuide", &ScintillaWrapper::SetHighlightGuide, boost::python::args("column"), "Set the highlighted indentation guide column.\n0 = no highlighted guide.")
		.def("getHighlightGuide", &ScintillaWrapper::GetHighlightGuide, "Get the highlighted indentation guide column.")
		.def("getLineEndPosition", &ScintillaWrapper::GetLineEndPosition, boost::python::args("line"), "Get the position after the last visible characters on a line.")
		.def("getCodePage", &ScintillaWrapper::GetCodePage, "Get the code page used to interpret the bytes of the document as characters.")
		.def("getCaretFore", &ScintillaWrapper::GetCaretFore, "Get the foreground colour of the caret.")
		.def("getReadOnly", &ScintillaWrapper::GetReadOnly, "In read-only mode?")
		.def("setCurrentPos", &ScintillaWrapper::SetCurrentPos, boost::python::args("caret"), "Sets the position of the caret.")
		.def("setSelectionStart", &ScintillaWrapper::SetSelectionStart, boost::python::args("anchor"), "Sets the position that starts the selection - this becomes the anchor.")
		.def("getSelectionStart", &ScintillaWrapper::GetSelectionStart, "Returns the position at the start of the selection.")
		.def("setSelectionEnd", &ScintillaWrapper::SetSelectionEnd, boost::python::args("caret"), "Sets the position that ends the selection - this becomes the caret.")
		.def("getSelectionEnd", &ScintillaWrapper::GetSelectionEnd, "Returns the position at the end of the selection.")
		.def("setEmptySelection", &ScintillaWrapper::SetEmptySelection, boost::python::args("caret"), "Set caret to a position, while removing any existing selection.")
		.def("setPrintMagnification", &ScintillaWrapper::SetPrintMagnification, boost::python::args("magnification"), "Sets the print magnification added to the point size of each style for printing.")
		.def("getPrintMagnification", &ScintillaWrapper::GetPrintMagnification, "Returns the print magnification.")
		.def("setPrintColourMode", &ScintillaWrapper::SetPrintColourMode, boost::python::args("mode"), "Modify colours when printing for clearer printed text.")
		.def("getPrintColourMode", &ScintillaWrapper::GetPrintColourMode, "Returns the print colour mode.")
		.def("findText", &ScintillaWrapper::FindText, boost::python::args("searchFlags", "start", "end", "ft"), "Find some text in the document.")
		.def("findTextFull", &ScintillaWrapper::FindTextFull, boost::python::args("searchFlags", "start", "end", "ft"), "Find some text in the document.")
		.def("setChangeHistory", &ScintillaWrapper::SetChangeHistory, boost::python::args("changeHistory"), "Enable or disable change history.")
		.def("getChangeHistory", &ScintillaWrapper::GetChangeHistory, "Report change history status.")
		.def("getFirstVisibleLine", &ScintillaWrapper::GetFirstVisibleLine, "Retrieve the display line at the top of the display.")
		.def("getLine", &ScintillaWrapper::GetLine, boost::python::args("line"), "Retrieve the contents of a line.\nReturns the length of the line.")
		.def("getLineCount", &ScintillaWrapper::GetLineCount, "Returns the number of lines in the document. There is always at least one.")
		.def("allocateLines", &ScintillaWrapper::AllocateLines, boost::python::args("lines"), "Enlarge the number of lines allocated.")
		.def("setMarginLeft", &ScintillaWrapper::SetMarginLeft, boost::python::args("pixelWidth"), "Sets the size in pixels of the left margin.")
		.def("getMarginLeft", &ScintillaWrapper::GetMarginLeft, "Returns the size in pixels of the left margin.")
		.def("setMarginRight", &ScintillaWrapper::SetMarginRight, boost::python::args("pixelWidth"), "Sets the size in pixels of the right margin.")
		.def("getMarginRight", &ScintillaWrapper::GetMarginRight, "Returns the size in pixels of the right margin.")
		.def("getModify", &ScintillaWrapper::GetModify, "Is the document different from when it was last saved?")
		.def("setSel", &ScintillaWrapper::SetSel, boost::python::args("anchor", "caret"), "Select a range of text.")
		.def("getSelText", &ScintillaWrapper::GetSelText, "Retrieve the selected text.\nReturn the length of the text.\nResult is NUL-terminated.")
		.def("getTextRange", &ScintillaWrapper::GetTextRange, boost::python::args("start", "end"), "Retrieve a range of text.\nReturn the length of the text.")
		.def("getTextRangeFull", &ScintillaWrapper::GetTextRangeFull, boost::python::args("start", "end"), "Retrieve a range of text that can be past 2GB.\nReturn the length of the text.")
		.def("hideSelection", &ScintillaWrapper::HideSelection, boost::python::args("hide"), "Draw the selection either highlighted or in normal (non-highlighted) style.")
		.def("getSelectionHidden", &ScintillaWrapper::GetSelectionHidden, "")
		.def("pointXFromPosition", &ScintillaWrapper::PointXFromPosition, boost::python::args("pos"), "Retrieve the x value of the point in the window where a position is displayed.")
		.def("pointYFromPosition", &ScintillaWrapper::PointYFromPosition, boost::python::args("pos"), "Retrieve the y value of the point in the window where a position is displayed.")
		.def("lineFromPosition", &ScintillaWrapper::LineFromPosition, boost::python::args("pos"), "Retrieve the line containing a position.")
		.def("positionFromLine", &ScintillaWrapper::PositionFromLine, boost::python::args("line"), "Retrieve the position at the start of a line.")
		.def("lineScroll", &ScintillaWrapper::LineScroll, boost::python::args("columns", "lines"), "Scroll horizontally and vertically.")
		.def("scrollCaret", &ScintillaWrapper::ScrollCaret, "Ensure the caret is visible.")
		.def("scrollRange", &ScintillaWrapper::ScrollRange, boost::python::args("secondary", "primary"), "Scroll the argument positions and the range between them into view giving\npriority to the primary position then the secondary position.\nThis may be used to make a search match visible.")
		.def("replaceSel", &ScintillaWrapper::ReplaceSel, boost::python::args("text"), "Replace the selected text with the argument text.")
		.def("setReadOnly", &ScintillaWrapper::SetReadOnly, boost::python::args("readOnly"), "Set to read only or read write.")
		.def("null", &ScintillaWrapper::Null, "Null operation.")
		.def("canPaste", &ScintillaWrapper::CanPaste, "Will a paste succeed?")
		.def("canUndo", &ScintillaWrapper::CanUndo, "Are there any undoable actions in the undo history?")
		.def("emptyUndoBuffer", &ScintillaWrapper::EmptyUndoBuffer, "Delete the undo history.")
		.def("undo", &ScintillaWrapper::Undo, "Undo one action in the undo history.")
		.def("cut", &ScintillaWrapper::Cut, "Cut the selection to the clipboard.")
		.def("copy", &ScintillaWrapper::Copy, "Copy the selection to the clipboard.")
		.def("paste", &ScintillaWrapper::Paste, "Paste the contents of the clipboard into the document replacing the selection.")
		.def("clear", &ScintillaWrapper::Clear, "Clear the selection.")
		.def("setText", &ScintillaWrapper::SetText, boost::python::args("text"), "Replace the contents of the document with the argument text.")
		.def("getText", &ScintillaWrapper::GetText, "Retrieve all the text in the document.\nReturns number of characters retrieved.\nResult is NUL-terminated.")
		.def("getTextLength", &ScintillaWrapper::GetTextLength, "Retrieve the number of characters in the document.")
		.def("getDirectFunction", &ScintillaWrapper::GetDirectFunction, "Retrieve a pointer to a function that processes messages for this Scintilla.")
		.def("getDirectStatusFunction", &ScintillaWrapper::GetDirectStatusFunction, "Retrieve a pointer to a function that processes messages for this Scintilla and returns status.")
		.def("getDirectPointer", &ScintillaWrapper::GetDirectPointer, "Retrieve a pointer value to use as the first argument when calling\nthe function returned by GetDirectFunction.")
		.def("setOvertype", &ScintillaWrapper::SetOvertype, boost::python::args("overType"), "Set to overtype (true) or insert mode.")
		.def("getOvertype", &ScintillaWrapper::GetOvertype, "Returns true if overtype mode is active otherwise false is returned.")
		.def("setCaretWidth", &ScintillaWrapper::SetCaretWidth, boost::python::args("pixelWidth"), "Set the width of the insert mode caret.")
		.def("getCaretWidth", &ScintillaWrapper::GetCaretWidth, "Returns the width of the insert mode caret.")
		.def("setTargetStart", &ScintillaWrapper::SetTargetStart, boost::python::args("start"), "Sets the position that starts the target which is used for updating the\ndocument without affecting the scroll position.")
		.def("getTargetStart", &ScintillaWrapper::GetTargetStart, "Get the position that starts the target.")
		.def("setTargetStartVirtualSpace", &ScintillaWrapper::SetTargetStartVirtualSpace, boost::python::args("space"), "Sets the virtual space of the target start")
		.def("getTargetStartVirtualSpace", &ScintillaWrapper::GetTargetStartVirtualSpace, "Get the virtual space of the target start")
		.def("setTargetEnd", &ScintillaWrapper::SetTargetEnd, boost::python::args("end"), "Sets the position that ends the target which is used for updating the\ndocument without affecting the scroll position.")
		.def("getTargetEnd", &ScintillaWrapper::GetTargetEnd, "Get the position that ends the target.")
		.def("setTargetEndVirtualSpace", &ScintillaWrapper::SetTargetEndVirtualSpace, boost::python::args("space"), "Sets the virtual space of the target end")
		.def("getTargetEndVirtualSpace", &ScintillaWrapper::GetTargetEndVirtualSpace, "Get the virtual space of the target end")
		.def("setTargetRange", &ScintillaWrapper::SetTargetRange, boost::python::args("start", "end"), "Sets both the start and end of the target in one call.")
		.def("getTargetText", &ScintillaWrapper::GetTargetText, "Retrieve the text in the target.")
		.def("targetFromSelection", &ScintillaWrapper::TargetFromSelection, "Make the target range start and end be the same as the selection range start and end.")
		.def("targetWholeDocument", &ScintillaWrapper::TargetWholeDocument, "Sets the target to the whole document.")
		.def("replaceTarget", &ScintillaWrapper::ReplaceTarget, boost::python::args("text"), "Replace the target text with the argument text.\nText is counted so it can contain NULs.\nReturns the length of the replacement text.")
		.def("replaceTargetRE", &ScintillaWrapper::ReplaceTargetRE, boost::python::args("text"), "Replace the target text with the argument text after \\d processing.\nText is counted so it can contain NULs.\nLooks for \\d where d is between 1 and 9 and replaces these with the strings\nmatched in the last search operation which were surrounded by \\( and \\).\nReturns the length of the replacement text including any change\ncaused by processing the \\d patterns.")
		.def("replaceTargetMinimal", &ScintillaWrapper::ReplaceTargetMinimal, boost::python::args("text"), "Replace the target text with the argument text but ignore prefix and suffix that\nare the same as current.")
		.def("searchInTarget", &ScintillaWrapper::SearchInTarget, boost::python::args("text"), "Search for a counted string in the target and set the target to the found\nrange. Text is counted so it can contain NULs.\nReturns start of found range or -1 for failure in which case target is not moved.")
		.def("setSearchFlags", &ScintillaWrapper::SetSearchFlags, boost::python::args("searchFlags"), "Set the search flags used by SearchInTarget.")
		.def("getSearchFlags", &ScintillaWrapper::GetSearchFlags, "Get the search flags used by SearchInTarget.")
		.def("callTipShow", &ScintillaWrapper::CallTipShow, boost::python::args("pos", "definition"), "Show a call tip containing a definition near position pos.")
		.def("callTipCancel", &ScintillaWrapper::CallTipCancel, "Remove the call tip from the screen.")
		.def("callTipActive", &ScintillaWrapper::CallTipActive, "Is there an active call tip?")
		.def("callTipPosStart", &ScintillaWrapper::CallTipPosStart, "Retrieve the position where the caret was before displaying the call tip.")
		.def("callTipSetPosStart", &ScintillaWrapper::CallTipSetPosStart, boost::python::args("posStart"), "Set the start position in order to change when backspacing removes the calltip.")
		.def("callTipSetHlt", &ScintillaWrapper::CallTipSetHlt, boost::python::args("highlightStart", "highlightEnd"), "Highlight a segment of the definition.")
		.def("callTipSetBack", &ScintillaWrapper::CallTipSetBack, boost::python::args("back"), "Set the background colour for the call tip.")
		.def("callTipSetFore", &ScintillaWrapper::CallTipSetFore, boost::python::args("fore"), "Set the foreground colour for the call tip.")
		.def("callTipSetForeHlt", &ScintillaWrapper::CallTipSetForeHlt, boost::python::args("fore"), "Set the foreground colour for the highlighted part of the call tip.")
		.def("callTipUseStyle", &ScintillaWrapper::CallTipUseStyle, boost::python::args("tabSize"), "Enable use of STYLE_CALLTIP and set call tip tab size in pixels.")
		.def("callTipSetPosition", &ScintillaWrapper::CallTipSetPosition, boost::python::args("above"), "Set position of calltip, above or below text.")
		.def("visibleFromDocLine", &ScintillaWrapper::VisibleFromDocLine, boost::python::args("docLine"), "Find the display line of a document line taking hidden lines into account.")
		.def("docLineFromVisible", &ScintillaWrapper::DocLineFromVisible, boost::python::args("displayLine"), "Find the document line of a display line taking hidden lines into account.")
		.def("wrapCount", &ScintillaWrapper::WrapCount, boost::python::args("docLine"), "The number of display lines needed to wrap a document line")
		.def("setFoldLevel", &ScintillaWrapper::SetFoldLevel, boost::python::args("line", "level"), "Set the fold level of a line.\nThis encodes an integer level along with flags indicating whether the\nline is a header and whether it is effectively white space.")
		.def("getFoldLevel", &ScintillaWrapper::GetFoldLevel, boost::python::args("line"), "Retrieve the fold level of a line.")
		.def("getLastChild", &ScintillaWrapper::GetLastChild, boost::python::args("line", "level"), "Find the last child line of a header line.")
		.def("getFoldParent", &ScintillaWrapper::GetFoldParent, boost::python::args("line"), "Find the parent line of a child line.")
		.def("showLines", &ScintillaWrapper::ShowLines, boost::python::args("lineStart", "lineEnd"), "Make a range of lines visible.")
		.def("hideLines", &ScintillaWrapper::HideLines, boost::python::args("lineStart", "lineEnd"), "Make a range of lines invisible.")
		.def("getLineVisible", &ScintillaWrapper::GetLineVisible, boost::python::args("line"), "Is a line visible?")
		.def("getAllLinesVisible", &ScintillaWrapper::GetAllLinesVisible, "Are all lines visible?")
		.def("setFoldExpanded", &ScintillaWrapper::SetFoldExpanded, boost::python::args("line", "expanded"), "Show the children of a header line.")
		.def("getFoldExpanded", &ScintillaWrapper::GetFoldExpanded, boost::python::args("line"), "Is a header line expanded?")
		.def("toggleFold", &ScintillaWrapper::ToggleFold, boost::python::args("line"), "Switch a header line between expanded and contracted.")
		.def("toggleFoldShowText", &ScintillaWrapper::ToggleFoldShowText, boost::python::args("line", "text"), "Switch a header line between expanded and contracted and show some text after the line.")
		.def("foldDisplayTextSetStyle", &ScintillaWrapper::FoldDisplayTextSetStyle, boost::python::args("style"), "Set the style of fold display text.")
		.def("foldDisplayTextGetStyle", &ScintillaWrapper::FoldDisplayTextGetStyle, "Get the style of fold display text.")
		.def("setDefaultFoldDisplayText", &ScintillaWrapper::SetDefaultFoldDisplayText, boost::python::args("text"), "Set the default fold display text.")
		.def("getDefaultFoldDisplayText", &ScintillaWrapper::GetDefaultFoldDisplayText, "Get the default fold display text.")
		.def("foldLine", &ScintillaWrapper::FoldLine, boost::python::args("line", "action"), "Expand or contract a fold header.")
		.def("foldChildren", &ScintillaWrapper::FoldChildren, boost::python::args("line", "action"), "Expand or contract a fold header and its children.")
		.def("expandChildren", &ScintillaWrapper::ExpandChildren, boost::python::args("line", "level"), "Expand a fold header and all children. Use the level argument instead of the line's current level.")
		.def("foldAll", &ScintillaWrapper::FoldAll, boost::python::args("action"), "Expand or contract all fold headers.")
		.def("ensureVisible", &ScintillaWrapper::EnsureVisible, boost::python::args("line"), "Ensure a particular line is visible by expanding any header line hiding it.")
		.def("setAutomaticFold", &ScintillaWrapper::SetAutomaticFold, boost::python::args("automaticFold"), "Set automatic folding behaviours.")
		.def("getAutomaticFold", &ScintillaWrapper::GetAutomaticFold, "Get automatic folding behaviours.")
		.def("setFoldFlags", &ScintillaWrapper::SetFoldFlags, boost::python::args("flags"), "Set some style options for folding.")
		.def("ensureVisibleEnforcePolicy", &ScintillaWrapper::EnsureVisibleEnforcePolicy, boost::python::args("line"), "Ensure a particular line is visible by expanding any header line hiding it.\nUse the currently set visibility policy to determine which range to display.")
		.def("setTabIndents", &ScintillaWrapper::SetTabIndents, boost::python::args("tabIndents"), "Sets whether a tab pressed when caret is within indentation indents.")
		.def("getTabIndents", &ScintillaWrapper::GetTabIndents, "Does a tab pressed when caret is within indentation indent?")
		.def("setBackSpaceUnIndents", &ScintillaWrapper::SetBackSpaceUnIndents, boost::python::args("bsUnIndents"), "Sets whether a backspace pressed when caret is within indentation unindents.")
		.def("getBackSpaceUnIndents", &ScintillaWrapper::GetBackSpaceUnIndents, "Does a backspace pressed when caret is within indentation unindent?")
		.def("setMouseDwellTime", &ScintillaWrapper::SetMouseDwellTime, boost::python::args("periodMilliseconds"), "Sets the time the mouse must sit still to generate a mouse dwell event.")
		.def("getMouseDwellTime", &ScintillaWrapper::GetMouseDwellTime, "Retrieve the time the mouse must sit still to generate a mouse dwell event.")
		.def("wordStartPosition", &ScintillaWrapper::WordStartPosition, boost::python::args("pos", "onlyWordCharacters"), "Get position of start of word.")
		.def("wordEndPosition", &ScintillaWrapper::WordEndPosition, boost::python::args("pos", "onlyWordCharacters"), "Get position of end of word.")
		.def("isRangeWord", &ScintillaWrapper::IsRangeWord, boost::python::args("start", "end"), "Is the range start..end considered a word?")
		.def("setIdleStyling", &ScintillaWrapper::SetIdleStyling, boost::python::args("idleStyling"), "Sets limits to idle styling.")
		.def("getIdleStyling", &ScintillaWrapper::GetIdleStyling, "Retrieve the limits to idle styling.")
		.def("setWrapMode", &ScintillaWrapper::SetWrapMode, boost::python::args("wrapMode"), "Sets whether text is word wrapped.")
		.def("getWrapMode", &ScintillaWrapper::GetWrapMode, "Retrieve whether text is word wrapped.")
		.def("setWrapVisualFlags", &ScintillaWrapper::SetWrapVisualFlags, boost::python::args("wrapVisualFlags"), "Set the display mode of visual flags for wrapped lines.")
		.def("getWrapVisualFlags", &ScintillaWrapper::GetWrapVisualFlags, "Retrive the display mode of visual flags for wrapped lines.")
		.def("setWrapVisualFlagsLocation", &ScintillaWrapper::SetWrapVisualFlagsLocation, boost::python::args("wrapVisualFlagsLocation"), "Set the location of visual flags for wrapped lines.")
		.def("getWrapVisualFlagsLocation", &ScintillaWrapper::GetWrapVisualFlagsLocation, "Retrive the location of visual flags for wrapped lines.")
		.def("setWrapStartIndent", &ScintillaWrapper::SetWrapStartIndent, boost::python::args("indent"), "Set the start indent for wrapped lines.")
		.def("getWrapStartIndent", &ScintillaWrapper::GetWrapStartIndent, "Retrive the start indent for wrapped lines.")
		.def("setWrapIndentMode", &ScintillaWrapper::SetWrapIndentMode, boost::python::args("wrapIndentMode"), "Sets how wrapped sublines are placed. Default is fixed.")
		.def("getWrapIndentMode", &ScintillaWrapper::GetWrapIndentMode, "Retrieve how wrapped sublines are placed. Default is fixed.")
		.def("setLayoutCache", &ScintillaWrapper::SetLayoutCache, boost::python::args("cacheMode"), "Sets the degree of caching of layout information.")
		.def("getLayoutCache", &ScintillaWrapper::GetLayoutCache, "Retrieve the degree of caching of layout information.")
		.def("setScrollWidth", &ScintillaWrapper::SetScrollWidth, boost::python::args("pixelWidth"), "Sets the document width assumed for scrolling.")
		.def("getScrollWidth", &ScintillaWrapper::GetScrollWidth, "Retrieve the document width assumed for scrolling.")
		.def("setScrollWidthTracking", &ScintillaWrapper::SetScrollWidthTracking, boost::python::args("tracking"), "Sets whether the maximum width line displayed is used to set scroll width.")
		.def("getScrollWidthTracking", &ScintillaWrapper::GetScrollWidthTracking, "Retrieve whether the scroll width tracks wide lines.")
		.def("textWidth", &ScintillaWrapper::TextWidth, boost::python::args("style", "text"), "Measure the pixel width of some text in a particular style.\nNUL terminated text argument.\nDoes not handle tab or control characters.")
		.def("setEndAtLastLine", &ScintillaWrapper::SetEndAtLastLine, boost::python::args("endAtLastLine"), "Sets the scroll range so that maximum scroll position has\nthe last line at the bottom of the view (default).\nSetting this to false allows scrolling one page below the last line.")
		.def("getEndAtLastLine", &ScintillaWrapper::GetEndAtLastLine, "Retrieve whether the maximum scroll position has the last\nline at the bottom of the view.")
		.def("textHeight", &ScintillaWrapper::TextHeight, boost::python::args("line"), "Retrieve the height of a particular line of text in pixels.")
		.def("setVScrollBar", &ScintillaWrapper::SetVScrollBar, boost::python::args("visible"), "Show or hide the vertical scroll bar.")
		.def("getVScrollBar", &ScintillaWrapper::GetVScrollBar, "Is the vertical scroll bar visible?")
		.def("appendText", &ScintillaWrapper::AppendText, boost::python::args("text"), "Append a string to the end of the document without changing the selection.")
		.def("getPhasesDraw", &ScintillaWrapper::GetPhasesDraw, "How many phases is drawing done in?")
		.def("setPhasesDraw", &ScintillaWrapper::SetPhasesDraw, boost::python::args("phases"), "In one phase draw, text is drawn in a series of rectangular blocks with no overlap.\nIn two phase draw, text is drawn in a series of lines allowing runs to overlap horizontally.\nIn multiple phase draw, each element is drawn over the whole drawing area, allowing text\nto overlap from one line to the next.")
		.def("setFontQuality", &ScintillaWrapper::SetFontQuality, boost::python::args("fontQuality"), "Choose the quality level for text from the FontQuality enumeration.")
		.def("getFontQuality", &ScintillaWrapper::GetFontQuality, "Retrieve the quality level for text.")
		.def("setFirstVisibleLine", &ScintillaWrapper::SetFirstVisibleLine, boost::python::args("displayLine"), "Scroll so that a display line is at the top of the display.")
		.def("setMultiPaste", &ScintillaWrapper::SetMultiPaste, boost::python::args("multiPaste"), "Change the effect of pasting when there are multiple selections.")
		.def("getMultiPaste", &ScintillaWrapper::GetMultiPaste, "Retrieve the effect of pasting when there are multiple selections.")
		.def("getTag", &ScintillaWrapper::GetTag, boost::python::args("tagNumber"), "Retrieve the value of a tag from a regular expression search.\nResult is NUL-terminated.")
		.def("linesJoin", &ScintillaWrapper::LinesJoin, "Join the lines in the target.")
		.def("linesSplit", &ScintillaWrapper::LinesSplit, boost::python::args("pixelWidth"), "Split the lines in the target into lines that are less wide than pixelWidth\nwhere possible.")
		.def("setFoldMarginColour", &ScintillaWrapper::SetFoldMarginColour, boost::python::args("useSetting", "back"), "Set one of the colours used as a chequerboard pattern in the fold margin")
		.def("setFoldMarginHiColour", &ScintillaWrapper::SetFoldMarginHiColour, boost::python::args("useSetting", "fore"), "Set the other colour used as a chequerboard pattern in the fold margin")
		.def("setAccessibility", &ScintillaWrapper::SetAccessibility, boost::python::args("accessibility"), "Enable or disable accessibility.")
		.def("getAccessibility", &ScintillaWrapper::GetAccessibility, "Report accessibility status.")
		.def("lineDown", &ScintillaWrapper::LineDown, "Move caret down one line.")
		.def("lineDownExtend", &ScintillaWrapper::LineDownExtend, "Move caret down one line extending selection to new caret position.")
		.def("lineUp", &ScintillaWrapper::LineUp, "Move caret up one line.")
		.def("lineUpExtend", &ScintillaWrapper::LineUpExtend, "Move caret up one line extending selection to new caret position.")
		.def("charLeft", &ScintillaWrapper::CharLeft, "Move caret left one character.")
		.def("charLeftExtend", &ScintillaWrapper::CharLeftExtend, "Move caret left one character extending selection to new caret position.")
		.def("charRight", &ScintillaWrapper::CharRight, "Move caret right one character.")
		.def("charRightExtend", &ScintillaWrapper::CharRightExtend, "Move caret right one character extending selection to new caret position.")
		.def("wordLeft", &ScintillaWrapper::WordLeft, "Move caret left one word.")
		.def("wordLeftExtend", &ScintillaWrapper::WordLeftExtend, "Move caret left one word extending selection to new caret position.")
		.def("wordRight", &ScintillaWrapper::WordRight, "Move caret right one word.")
		.def("wordRightExtend", &ScintillaWrapper::WordRightExtend, "Move caret right one word extending selection to new caret position.")
		.def("home", &ScintillaWrapper::Home, "Move caret to first position on line.")
		.def("homeExtend", &ScintillaWrapper::HomeExtend, "Move caret to first position on line extending selection to new caret position.")
		.def("lineEnd", &ScintillaWrapper::LineEnd, "Move caret to last position on line.")
		.def("lineEndExtend", &ScintillaWrapper::LineEndExtend, "Move caret to last position on line extending selection to new caret position.")
		.def("documentStart", &ScintillaWrapper::DocumentStart, "Move caret to first position in document.")
		.def("documentStartExtend", &ScintillaWrapper::DocumentStartExtend, "Move caret to first position in document extending selection to new caret position.")
		.def("documentEnd", &ScintillaWrapper::DocumentEnd, "Move caret to last position in document.")
		.def("documentEndExtend", &ScintillaWrapper::DocumentEndExtend, "Move caret to last position in document extending selection to new caret position.")
		.def("pageUp", &ScintillaWrapper::PageUp, "Move caret one page up.")
		.def("pageUpExtend", &ScintillaWrapper::PageUpExtend, "Move caret one page up extending selection to new caret position.")
		.def("pageDown", &ScintillaWrapper::PageDown, "Move caret one page down.")
		.def("pageDownExtend", &ScintillaWrapper::PageDownExtend, "Move caret one page down extending selection to new caret position.")
		.def("editToggleOvertype", &ScintillaWrapper::EditToggleOvertype, "Switch from insert to overtype mode or the reverse.")
		.def("cancel", &ScintillaWrapper::Cancel, "Cancel any modes such as call tip or auto-completion list display.")
		.def("deleteBack", &ScintillaWrapper::DeleteBack, "Delete the selection or if no selection, the character before the caret.")
		.def("tab", &ScintillaWrapper::Tab, "If selection is empty or all on one line replace the selection with a tab character.\nIf more than one line selected, indent the lines.")
		.def("lineIndent", &ScintillaWrapper::LineIndent, "Indent the current and selected lines.")
		.def("backTab", &ScintillaWrapper::BackTab, "If selection is empty or all on one line dedent the line if caret is at start, else move caret.\nIf more than one line selected, dedent the lines.")
		.def("lineDedent", &ScintillaWrapper::LineDedent, "Dedent the current and selected lines.")
		.def("newLine", &ScintillaWrapper::NewLine, "Insert a new line, may use a CRLF, CR or LF depending on EOL mode.")
		.def("formFeed", &ScintillaWrapper::FormFeed, "Insert a Form Feed character.")
		.def("vCHome", &ScintillaWrapper::VCHome, "Move caret to before first visible character on line.\nIf already there move to first character on line.")
		.def("vCHomeExtend", &ScintillaWrapper::VCHomeExtend, "Like VCHome but extending selection to new caret position.")
		.def("zoomIn", &ScintillaWrapper::ZoomIn, "Magnify the displayed text by increasing the sizes by 1 point.")
		.def("zoomOut", &ScintillaWrapper::ZoomOut, "Make the displayed text smaller by decreasing the sizes by 1 point.")
		.def("delWordLeft", &ScintillaWrapper::DelWordLeft, "Delete the word to the left of the caret.")
		.def("delWordRight", &ScintillaWrapper::DelWordRight, "Delete the word to the right of the caret.")
		.def("delWordRightEnd", &ScintillaWrapper::DelWordRightEnd, "Delete the word to the right of the caret, but not the trailing non-word characters.")
		.def("lineCut", &ScintillaWrapper::LineCut, "Cut the line containing the caret.")
		.def("lineDelete", &ScintillaWrapper::LineDelete, "Delete the line containing the caret.")
		.def("lineTranspose", &ScintillaWrapper::LineTranspose, "Switch the current line with the previous.")
		.def("lineReverse", &ScintillaWrapper::LineReverse, "Reverse order of selected lines.")
		.def("lineDuplicate", &ScintillaWrapper::LineDuplicate, "Duplicate the current line.")
		.def("lowerCase", &ScintillaWrapper::LowerCase, "Transform the selection to lower case.")
		.def("upperCase", &ScintillaWrapper::UpperCase, "Transform the selection to upper case.")
		.def("lineScrollDown", &ScintillaWrapper::LineScrollDown, "Scroll the document down, keeping the caret visible.")
		.def("lineScrollUp", &ScintillaWrapper::LineScrollUp, "Scroll the document up, keeping the caret visible.")
		.def("deleteBackNotLine", &ScintillaWrapper::DeleteBackNotLine, "Delete the selection or if no selection, the character before the caret.\nWill not delete the character before at the start of a line.")
		.def("homeDisplay", &ScintillaWrapper::HomeDisplay, "Move caret to first position on display line.")
		.def("homeDisplayExtend", &ScintillaWrapper::HomeDisplayExtend, "Move caret to first position on display line extending selection to\nnew caret position.")
		.def("lineEndDisplay", &ScintillaWrapper::LineEndDisplay, "Move caret to last position on display line.")
		.def("lineEndDisplayExtend", &ScintillaWrapper::LineEndDisplayExtend, "Move caret to last position on display line extending selection to new\ncaret position.")
		.def("homeWrap", &ScintillaWrapper::HomeWrap, "Like Home but when word-wrap is enabled goes first to start of display line\nHomeDisplay, then to start of document line Home.")
		.def("homeWrapExtend", &ScintillaWrapper::HomeWrapExtend, "Like HomeExtend but when word-wrap is enabled extends first to start of display line\nHomeDisplayExtend, then to start of document line HomeExtend.")
		.def("lineEndWrap", &ScintillaWrapper::LineEndWrap, "Like LineEnd but when word-wrap is enabled goes first to end of display line\nLineEndDisplay, then to start of document line LineEnd.")
		.def("lineEndWrapExtend", &ScintillaWrapper::LineEndWrapExtend, "Like LineEndExtend but when word-wrap is enabled extends first to end of display line\nLineEndDisplayExtend, then to start of document line LineEndExtend.")
		.def("vCHomeWrap", &ScintillaWrapper::VCHomeWrap, "Like VCHome but when word-wrap is enabled goes first to start of display line\nVCHomeDisplay, then behaves like VCHome.")
		.def("vCHomeWrapExtend", &ScintillaWrapper::VCHomeWrapExtend, "Like VCHomeExtend but when word-wrap is enabled extends first to start of display line\nVCHomeDisplayExtend, then behaves like VCHomeExtend.")
		.def("lineCopy", &ScintillaWrapper::LineCopy, "Copy the line containing the caret.")
		.def("moveCaretInsideView", &ScintillaWrapper::MoveCaretInsideView, "Move the caret inside current view if it's not there already.")
		.def("lineLength", &ScintillaWrapper::LineLength, boost::python::args("line"), "How many characters are on a line, including end of line characters?")
		.def("braceHighlight", &ScintillaWrapper::BraceHighlight, boost::python::args("posA", "posB"), "Highlight the characters at two positions.")
		.def("braceHighlightIndicator", &ScintillaWrapper::BraceHighlightIndicator, boost::python::args("useSetting", "indicator"), "Use specified indicator to highlight matching braces instead of changing their style.")
		.def("braceBadLight", &ScintillaWrapper::BraceBadLight, boost::python::args("pos"), "Highlight the character at a position indicating there is no matching brace.")
		.def("braceBadLightIndicator", &ScintillaWrapper::BraceBadLightIndicator, boost::python::args("useSetting", "indicator"), "Use specified indicator to highlight non matching brace instead of changing its style.")
		.def("braceMatch", &ScintillaWrapper::BraceMatch, boost::python::args("pos", "maxReStyle"), "Find the position of a matching brace or INVALID_POSITION if no match.\nThe maxReStyle must be 0 for now. It may be defined in a future release.")
		.def("braceMatchNext", &ScintillaWrapper::BraceMatchNext, boost::python::args("pos", "startPos"), "Similar to BraceMatch, but matching starts at the explicit start position.")
		.def("getViewEOL", &ScintillaWrapper::GetViewEOL, "Are the end of line characters visible?")
		.def("setViewEOL", &ScintillaWrapper::SetViewEOL, boost::python::args("visible"), "Make the end of line characters visible or invisible.")
		.def("getDocPointer", &ScintillaWrapper::GetDocPointer, "Retrieve a pointer to the document object.")
		.def("setDocPointer", &ScintillaWrapper::SetDocPointer, boost::python::args("pointer"), "Change the document object used.")
		.def("setModEventMask", &ScintillaWrapper::SetModEventMask, boost::python::args("eventMask"), "Set which document modification events are sent to the container.")
		.def("getEdgeColumn", &ScintillaWrapper::GetEdgeColumn, "Retrieve the column number which text should be kept within.")
		.def("setEdgeColumn", &ScintillaWrapper::SetEdgeColumn, boost::python::args("column"), "Set the column number of the edge.\nIf text goes past the edge then it is highlighted.")
		.def("getEdgeMode", &ScintillaWrapper::GetEdgeMode, "Retrieve the edge highlight mode.")
		.def("setEdgeMode", &ScintillaWrapper::SetEdgeMode, boost::python::args("edgeMode"), "The edge may be displayed by a line (EDGE_LINE/EDGE_MULTILINE) or by highlighting text that\ngoes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).")
		.def("getEdgeColour", &ScintillaWrapper::GetEdgeColour, "Retrieve the colour used in edge indication.")
		.def("setEdgeColour", &ScintillaWrapper::SetEdgeColour, boost::python::args("edgeColour"), "Change the colour used in edge indication.")
		.def("multiEdgeAddLine", &ScintillaWrapper::MultiEdgeAddLine, boost::python::args("column", "edgeColour"), "Add a new vertical edge to the view.")
		.def("multiEdgeClearAll", &ScintillaWrapper::MultiEdgeClearAll, "Clear all vertical edges.")
		.def("getMultiEdgeColumn", &ScintillaWrapper::GetMultiEdgeColumn, boost::python::args("which"), "Get multi edge positions.")
		.def("searchAnchor", &ScintillaWrapper::SearchAnchor, "Sets the current caret position to be the search anchor.")
		.def("searchNext", &ScintillaWrapper::SearchNext, boost::python::args("searchFlags", "text"), "Find some text starting at the search anchor.\nDoes not ensure the selection is visible.")
		.def("searchPrev", &ScintillaWrapper::SearchPrev, boost::python::args("searchFlags", "text"), "Find some text starting at the search anchor and moving backwards.\nDoes not ensure the selection is visible.")
		.def("linesOnScreen", &ScintillaWrapper::LinesOnScreen, "Retrieves the number of lines completely visible.")
		.def("usePopUp", &ScintillaWrapper::UsePopUp, boost::python::args("popUpMode"), "Set whether a pop up menu is displayed automatically when the user presses\nthe wrong mouse button on certain areas.")
		.def("selectionIsRectangle", &ScintillaWrapper::SelectionIsRectangle, "Is the selection rectangular? The alternative is the more common stream selection.")
		.def("setZoom", &ScintillaWrapper::SetZoom, boost::python::args("zoomInPoints"), "Set the zoom level. This number of points is added to the size of all fonts.\nIt may be positive to magnify or negative to reduce.")
		.def("getZoom", &ScintillaWrapper::GetZoom, "Retrieve the zoom level.")
		.def("createDocument", &ScintillaWrapper::CreateDocument, boost::python::args("bytes", "documentOptions"), "Create a new document object.\nStarts with reference count of 1 and not selected into editor.")
		.def("addRefDocument", &ScintillaWrapper::AddRefDocument, boost::python::args("doc"), "Extend life of document.")
		.def("releaseDocument", &ScintillaWrapper::ReleaseDocument, boost::python::args("doc"), "Release a reference to the document, deleting document if it fades to black.")
		.def("getDocumentOptions", &ScintillaWrapper::GetDocumentOptions, "Get which document options are set.")
		.def("getModEventMask", &ScintillaWrapper::GetModEventMask, "Get which document modification events are sent to the container.")
		.def("setCommandEvents", &ScintillaWrapper::SetCommandEvents, boost::python::args("commandEvents"), "Set whether command events are sent to the container.")
		.def("getCommandEvents", &ScintillaWrapper::GetCommandEvents, "Get whether command events are sent to the container.")
		.def("setFocus", &ScintillaWrapper::SetFocus, boost::python::args("focus"), "Change internal focus flag.")
		.def("getFocus", &ScintillaWrapper::GetFocus, "Get internal focus flag.")
		.def("setStatus", &ScintillaWrapper::SetStatus, boost::python::args("status"), "Change error status - 0 = OK.")
		.def("getStatus", &ScintillaWrapper::GetStatus, "Get error status.")
		.def("setMouseDownCaptures", &ScintillaWrapper::SetMouseDownCaptures, boost::python::args("captures"), "Set whether the mouse is captured when its button is pressed.")
		.def("getMouseDownCaptures", &ScintillaWrapper::GetMouseDownCaptures, "Get whether mouse gets captured.")
		.def("setMouseWheelCaptures", &ScintillaWrapper::SetMouseWheelCaptures, boost::python::args("captures"), "Set whether the mouse wheel can be active outside the window.")
		.def("getMouseWheelCaptures", &ScintillaWrapper::GetMouseWheelCaptures, "Get whether mouse wheel can be active outside the window.")
		.def("setCursor", &ScintillaWrapper::SetCursor, boost::python::args("cursorType"), "Sets the cursor to one of the SC_CURSOR* values.")
		.def("getCursor", &ScintillaWrapper::GetCursor, "Get cursor type.")
		.def("setControlCharSymbol", &ScintillaWrapper::SetControlCharSymbol, boost::python::args("symbol"), "Change the way control characters are displayed:\nIf symbol is < 32, keep the drawn way, else, use the given character.")
		.def("getControlCharSymbol", &ScintillaWrapper::GetControlCharSymbol, "Get the way control characters are displayed.")
		.def("wordPartLeft", &ScintillaWrapper::WordPartLeft, "Move to the previous change in capitalisation.")
		.def("wordPartLeftExtend", &ScintillaWrapper::WordPartLeftExtend, "Move to the previous change in capitalisation extending selection\nto new caret position.")
		.def("wordPartRight", &ScintillaWrapper::WordPartRight, "Move to the change next in capitalisation.")
		.def("wordPartRightExtend", &ScintillaWrapper::WordPartRightExtend, "Move to the next change in capitalisation extending selection\nto new caret position.")
		.def("setVisiblePolicy", &ScintillaWrapper::SetVisiblePolicy, boost::python::args("visiblePolicy", "visibleSlop"), "Set the way the display area is determined when a particular line\nis to be moved to by Find, FindNext, GotoLine, etc.")
		.def("delLineLeft", &ScintillaWrapper::DelLineLeft, "Delete back from the current position to the start of the line.")
		.def("delLineRight", &ScintillaWrapper::DelLineRight, "Delete forwards from the current position to the end of the line.")
		.def("setXOffset", &ScintillaWrapper::SetXOffset, boost::python::args("xOffset"), "Set the xOffset (ie, horizontal scroll position).")
		.def("getXOffset", &ScintillaWrapper::GetXOffset, "Get the xOffset (ie, horizontal scroll position).")
		.def("chooseCaretX", &ScintillaWrapper::ChooseCaretX, "Set the last x chosen value to be the caret x position.")
		.def("grabFocus", &ScintillaWrapper::GrabFocus, "Set the focus to this Scintilla widget.")
		.def("setXCaretPolicy", &ScintillaWrapper::SetXCaretPolicy, boost::python::args("caretPolicy", "caretSlop"), "Set the way the caret is kept visible when going sideways.\nThe exclusion zone is given in pixels.")
		.def("setYCaretPolicy", &ScintillaWrapper::SetYCaretPolicy, boost::python::args("caretPolicy", "caretSlop"), "Set the way the line the caret is on is kept visible.\nThe exclusion zone is given in lines.")
		.def("setPrintWrapMode", &ScintillaWrapper::SetPrintWrapMode, boost::python::args("wrapMode"), "Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).")
		.def("getPrintWrapMode", &ScintillaWrapper::GetPrintWrapMode, "Is printing line wrapped?")
		.def("setHotspotActiveFore", &ScintillaWrapper::SetHotspotActiveFore, boost::python::args("useSetting", "fore"), "Set a fore colour for active hotspots.")
		.def("getHotspotActiveFore", &ScintillaWrapper::GetHotspotActiveFore, "Get the fore colour for active hotspots.")
		.def("setHotspotActiveBack", &ScintillaWrapper::SetHotspotActiveBack, boost::python::args("useSetting", "back"), "Set a back colour for active hotspots.")
		.def("getHotspotActiveBack", &ScintillaWrapper::GetHotspotActiveBack, "Get the back colour for active hotspots.")
		.def("setHotspotActiveUnderline", &ScintillaWrapper::SetHotspotActiveUnderline, boost::python::args("underline"), "Enable / Disable underlining active hotspots.")
		.def("getHotspotActiveUnderline", &ScintillaWrapper::GetHotspotActiveUnderline, "Get whether underlining for active hotspots.")
		.def("setHotspotSingleLine", &ScintillaWrapper::SetHotspotSingleLine, boost::python::args("singleLine"), "Limit hotspots to single line so hotspots on two lines don't merge.")
		.def("getHotspotSingleLine", &ScintillaWrapper::GetHotspotSingleLine, "Get the HotspotSingleLine property")
		.def("paraDown", &ScintillaWrapper::ParaDown, "Move caret down one paragraph (delimited by empty lines).")
		.def("paraDownExtend", &ScintillaWrapper::ParaDownExtend, "Extend selection down one paragraph (delimited by empty lines).")
		.def("paraUp", &ScintillaWrapper::ParaUp, "Move caret up one paragraph (delimited by empty lines).")
		.def("paraUpExtend", &ScintillaWrapper::ParaUpExtend, "Extend selection up one paragraph (delimited by empty lines).")
		.def("positionBefore", &ScintillaWrapper::PositionBefore, boost::python::args("pos"), "Given a valid document position, return the previous position taking code\npage into account. Returns 0 if passed 0.")
		.def("positionAfter", &ScintillaWrapper::PositionAfter, boost::python::args("pos"), "Given a valid document position, return the next position taking code\npage into account. Maximum value returned is the last position in the document.")
		.def("positionRelative", &ScintillaWrapper::PositionRelative, boost::python::args("pos", "relative"), "Given a valid document position, return a position that differs in a number\nof characters. Returned value is always between 0 and last position in document.")
		.def("positionRelativeCodeUnits", &ScintillaWrapper::PositionRelativeCodeUnits, boost::python::args("pos", "relative"), "Given a valid document position, return a position that differs in a number\nof UTF-16 code units. Returned value is always between 0 and last position in document.\nThe result may point half way (2 bytes) inside a non-BMP character.")
		.def("copyRange", &ScintillaWrapper::CopyRange, boost::python::args("start", "end"), "Copy a range of text to the clipboard. Positions are clipped into the document.")
		.def("copyText", &ScintillaWrapper::CopyText, boost::python::args("text"), "Copy argument text to the clipboard.")
		.def("setSelectionMode", &ScintillaWrapper::SetSelectionMode, boost::python::args("selectionMode"), "Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or\nby lines (SC_SEL_LINES).")
		.def("changeSelectionMode", &ScintillaWrapper::ChangeSelectionMode, boost::python::args("selectionMode"), "Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or\nby lines (SC_SEL_LINES) without changing MoveExtendsSelection.")
		.def("getSelectionMode", &ScintillaWrapper::GetSelectionMode, "Get the mode of the current selection.")
		.def("setMoveExtendsSelection", &ScintillaWrapper::SetMoveExtendsSelection, boost::python::args("moveExtendsSelection"), "Set whether or not regular caret moves will extend or reduce the selection.")
		.def("getMoveExtendsSelection", &ScintillaWrapper::GetMoveExtendsSelection, "Get whether or not regular caret moves will extend or reduce the selection.")
		.def("getLineSelStartPosition", &ScintillaWrapper::GetLineSelStartPosition, boost::python::args("line"), "Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line).")
		.def("getLineSelEndPosition", &ScintillaWrapper::GetLineSelEndPosition, boost::python::args("line"), "Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line).")
		.def("lineDownRectExtend", &ScintillaWrapper::LineDownRectExtend, "Move caret down one line, extending rectangular selection to new caret position.")
		.def("lineUpRectExtend", &ScintillaWrapper::LineUpRectExtend, "Move caret up one line, extending rectangular selection to new caret position.")
		.def("charLeftRectExtend", &ScintillaWrapper::CharLeftRectExtend, "Move caret left one character, extending rectangular selection to new caret position.")
		.def("charRightRectExtend", &ScintillaWrapper::CharRightRectExtend, "Move caret right one character, extending rectangular selection to new caret position.")
		.def("homeRectExtend", &ScintillaWrapper::HomeRectExtend, "Move caret to first position on line, extending rectangular selection to new caret position.")
		.def("vCHomeRectExtend", &ScintillaWrapper::VCHomeRectExtend, "Move caret to before first visible character on line.\nIf already there move to first character on line.\nIn either case, extend rectangular selection to new caret position.")
		.def("lineEndRectExtend", &ScintillaWrapper::LineEndRectExtend, "Move caret to last position on line, extending rectangular selection to new caret position.")
		.def("pageUpRectExtend", &ScintillaWrapper::PageUpRectExtend, "Move caret one page up, extending rectangular selection to new caret position.")
		.def("pageDownRectExtend", &ScintillaWrapper::PageDownRectExtend, "Move caret one page down, extending rectangular selection to new caret position.")
		.def("stutteredPageUp", &ScintillaWrapper::StutteredPageUp, "Move caret to top of page, or one page up if already at top of page.")
		.def("stutteredPageUpExtend", &ScintillaWrapper::StutteredPageUpExtend, "Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.")
		.def("stutteredPageDown", &ScintillaWrapper::StutteredPageDown, "Move caret to bottom of page, or one page down if already at bottom of page.")
		.def("stutteredPageDownExtend", &ScintillaWrapper::StutteredPageDownExtend, "Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.")
		.def("wordLeftEnd", &ScintillaWrapper::WordLeftEnd, "Move caret left one word, position cursor at end of word.")
		.def("wordLeftEndExtend", &ScintillaWrapper::WordLeftEndExtend, "Move caret left one word, position cursor at end of word, extending selection to new caret position.")
		.def("wordRightEnd", &ScintillaWrapper::WordRightEnd, "Move caret right one word, position cursor at end of word.")
		.def("wordRightEndExtend", &ScintillaWrapper::WordRightEndExtend, "Move caret right one word, position cursor at end of word, extending selection to new caret position.")
		.def("setWhitespaceChars", &ScintillaWrapper::SetWhitespaceChars, boost::python::args("characters"), "Set the set of characters making up whitespace for when moving or selecting by word.\nShould be called after SetWordChars.")
		.def("getWhitespaceChars", &ScintillaWrapper::GetWhitespaceChars, "Get the set of characters making up whitespace for when moving or selecting by word.")
		.def("setPunctuationChars", &ScintillaWrapper::SetPunctuationChars, boost::python::args("characters"), "Set the set of characters making up punctuation characters\nShould be called after SetWordChars.")
		.def("getPunctuationChars", &ScintillaWrapper::GetPunctuationChars, "Get the set of characters making up punctuation characters")
		.def("setCharsDefault", &ScintillaWrapper::SetCharsDefault, "Reset the set of characters for whitespace and word characters to the defaults.")
		.def("autoCGetCurrent", &ScintillaWrapper::AutoCGetCurrent, "Get currently selected item position in the auto-completion list")
		.def("autoCGetCurrentText", &ScintillaWrapper::AutoCGetCurrentText, "Get currently selected item text in the auto-completion list\nReturns the length of the item text\nResult is NUL-terminated.")
		.def("autoCSetCaseInsensitiveBehaviour", &ScintillaWrapper::AutoCSetCaseInsensitiveBehaviour, boost::python::args("behaviour"), "Set auto-completion case insensitive behaviour to either prefer case-sensitive matches or have no preference.")
		.def("autoCGetCaseInsensitiveBehaviour", &ScintillaWrapper::AutoCGetCaseInsensitiveBehaviour, "Get auto-completion case insensitive behaviour.")
		.def("autoCSetMulti", &ScintillaWrapper::AutoCSetMulti, boost::python::args("multi"), "Change the effect of autocompleting when there are multiple selections.")
		.def("autoCGetMulti", &ScintillaWrapper::AutoCGetMulti, "Retrieve the effect of autocompleting when there are multiple selections.")
		.def("autoCSetOrder", &ScintillaWrapper::AutoCSetOrder, boost::python::args("order"), "Set the way autocompletion lists are ordered.")
		.def("autoCGetOrder", &ScintillaWrapper::AutoCGetOrder, "Get the way autocompletion lists are ordered.")
		.def("allocate", &ScintillaWrapper::Allocate, boost::python::args("bytes"), "Enlarge the document to a particular size of text bytes.")
		.def("targetAsUTF8", &ScintillaWrapper::TargetAsUTF8, "Returns the target converted to UTF8.\nReturn the length in bytes.")
		.def("setLengthForEncode", &ScintillaWrapper::SetLengthForEncode, boost::python::args("bytes"), "Set the length of the utf8 argument for calling EncodedFromUTF8.\nSet to -1 and the string will be measured to the first nul.")
		.def("encodedFromUTF8", &ScintillaWrapper::EncodedFromUTF8, boost::python::args("utf8"), "Translates a UTF8 string into the document encoding.\nReturn the length of the result in bytes.\nOn error return 0.")
		.def("findColumn", &ScintillaWrapper::FindColumn, boost::python::args("line", "column"), "Find the position of a column on a line taking into account tabs and\nmulti-byte characters. If beyond end of line, return line end position.")
		.def("getCaretSticky", &ScintillaWrapper::GetCaretSticky, "Can the caret preferred x position only be changed by explicit movement commands?")
		.def("setCaretSticky", &ScintillaWrapper::SetCaretSticky, boost::python::args("useCaretStickyBehaviour"), "Stop the caret preferred x position changing when the user types.")
		.def("toggleCaretSticky", &ScintillaWrapper::ToggleCaretSticky, "Switch between sticky and non-sticky: meant to be bound to a key.")
		.def("setPasteConvertEndings", &ScintillaWrapper::SetPasteConvertEndings, boost::python::args("convert"), "Enable/Disable convert-on-paste for line endings")
		.def("getPasteConvertEndings", &ScintillaWrapper::GetPasteConvertEndings, "Get convert-on-paste setting")
		.def("replaceRectangular", &ScintillaWrapper::ReplaceRectangular, boost::python::args("text"), "Replace the selection with text like a rectangular paste.")
		.def("selectionDuplicate", &ScintillaWrapper::SelectionDuplicate, "Duplicate the selection. If selection empty duplicate the line containing the caret.")
		.def("setCaretLineBackAlpha", &ScintillaWrapper::SetCaretLineBackAlpha, boost::python::args("alpha"), "Set background alpha of the caret line.")
		.def("getCaretLineBackAlpha", &ScintillaWrapper::GetCaretLineBackAlpha, "Get the background alpha of the caret line.")
		.def("setCaretStyle", &ScintillaWrapper::SetCaretStyle, boost::python::args("caretStyle"), "Set the style of the caret to be drawn.")
		.def("getCaretStyle", &ScintillaWrapper::GetCaretStyle, "Returns the current style of the caret.")
		.def("setIndicatorCurrent", &ScintillaWrapper::SetIndicatorCurrent, boost::python::args("indicator"), "Set the indicator used for IndicatorFillRange and IndicatorClearRange")
		.def("getIndicatorCurrent", &ScintillaWrapper::GetIndicatorCurrent, "Get the current indicator")
		.def("setIndicatorValue", &ScintillaWrapper::SetIndicatorValue, boost::python::args("value"), "Set the value used for IndicatorFillRange")
		.def("getIndicatorValue", &ScintillaWrapper::GetIndicatorValue, "Get the current indicator value")
		.def("indicatorFillRange", &ScintillaWrapper::IndicatorFillRange, boost::python::args("start", "lengthFill"), "Turn a indicator on over a range.")
		.def("indicatorClearRange", &ScintillaWrapper::IndicatorClearRange, boost::python::args("start", "lengthClear"), "Turn a indicator off over a range.")
		.def("indicatorAllOnFor", &ScintillaWrapper::IndicatorAllOnFor, boost::python::args("pos"), "Are any indicators present at pos?")
		.def("indicatorValueAt", &ScintillaWrapper::IndicatorValueAt, boost::python::args("indicator", "pos"), "What value does a particular indicator have at a position?")
		.def("indicatorStart", &ScintillaWrapper::IndicatorStart, boost::python::args("indicator", "pos"), "Where does a particular indicator start?")
		.def("indicatorEnd", &ScintillaWrapper::IndicatorEnd, boost::python::args("indicator", "pos"), "Where does a particular indicator end?")
		.def("setPositionCache", &ScintillaWrapper::SetPositionCache, boost::python::args("size"), "Set number of entries in position cache")
		.def("getPositionCache", &ScintillaWrapper::GetPositionCache, "How many entries are allocated to the position cache?")
		.def("setLayoutThreads", &ScintillaWrapper::SetLayoutThreads, boost::python::args("threads"), "Set maximum number of threads used for layout")
		.def("getLayoutThreads", &ScintillaWrapper::GetLayoutThreads, "Get maximum number of threads used for layout")
		.def("copyAllowLine", &ScintillaWrapper::CopyAllowLine, "Copy the selection, if selection empty copy the line with the caret")
		.def("cutAllowLine", &ScintillaWrapper::CutAllowLine, "Cut the selection, if selection empty cut the line with the caret")
		.def("setCopySeparator", &ScintillaWrapper::SetCopySeparator, boost::python::args("separator"), "Set the string to separate parts when copying a multiple selection.")
		.def("getCopySeparator", &ScintillaWrapper::GetCopySeparator, "Get the string to separate parts when copying a multiple selection.")
		.def("getCharacterPointer", &ScintillaWrapper::GetCharacterPointer, "Compact the document buffer and return a read-only pointer to the\ncharacters in the document.")
		.def("getRangePointer", &ScintillaWrapper::GetRangePointer, boost::python::args("position", "rangeLength"), "Return a read-only pointer to a range of characters in the document.\nMay move the gap so that the range is contiguous, but will only move up\nto lengthRange bytes.")
		.def("getGapPosition", &ScintillaWrapper::GetGapPosition, "Return a position which, to avoid performance costs, should not be within\nthe range of a call to GetRangePointer.")
		.def("indicSetAlpha", &ScintillaWrapper::IndicSetAlpha, boost::python::args("indicator", "alpha"), "Set the alpha fill colour of the given indicator.")
		.def("indicGetAlpha", &ScintillaWrapper::IndicGetAlpha, boost::python::args("indicator"), "Get the alpha fill colour of the given indicator.")
		.def("indicSetOutlineAlpha", &ScintillaWrapper::IndicSetOutlineAlpha, boost::python::args("indicator", "alpha"), "Set the alpha outline colour of the given indicator.")
		.def("indicGetOutlineAlpha", &ScintillaWrapper::IndicGetOutlineAlpha, boost::python::args("indicator"), "Get the alpha outline colour of the given indicator.")
		.def("setExtraAscent", &ScintillaWrapper::SetExtraAscent, boost::python::args("extraAscent"), "Set extra ascent for each line")
		.def("getExtraAscent", &ScintillaWrapper::GetExtraAscent, "Get extra ascent for each line")
		.def("setExtraDescent", &ScintillaWrapper::SetExtraDescent, boost::python::args("extraDescent"), "Set extra descent for each line")
		.def("getExtraDescent", &ScintillaWrapper::GetExtraDescent, "Get extra descent for each line")
		.def("markerSymbolDefined", &ScintillaWrapper::MarkerSymbolDefined, boost::python::args("markerNumber"), "Which symbol was defined for markerNumber with MarkerDefine")
		.def("marginSetText", &ScintillaWrapper::MarginSetText, boost::python::args("line", "text"), "Set the text in the text margin for a line")
		.def("marginGetText", &ScintillaWrapper::MarginGetText, boost::python::args("line"), "Get the text in the text margin for a line")
		.def("marginSetStyle", &ScintillaWrapper::MarginSetStyle, boost::python::args("line", "style"), "Set the style number for the text margin for a line")
		.def("marginGetStyle", &ScintillaWrapper::MarginGetStyle, boost::python::args("line"), "Get the style number for the text margin for a line")
		.def("marginSetStyles", &ScintillaWrapper::MarginSetStyles, boost::python::args("line", "styles"), "Set the style in the text margin for a line")
		.def("marginGetStyles", &ScintillaWrapper::MarginGetStyles, boost::python::args("line"), "Get the styles in the text margin for a line")
		.def("marginTextClearAll", &ScintillaWrapper::MarginTextClearAll, "Clear the margin text on all lines")
		.def("marginSetStyleOffset", &ScintillaWrapper::MarginSetStyleOffset, boost::python::args("style"), "Get the start of the range of style numbers used for margin text")
		.def("marginGetStyleOffset", &ScintillaWrapper::MarginGetStyleOffset, "Get the start of the range of style numbers used for margin text")
		.def("setMarginOptions", &ScintillaWrapper::SetMarginOptions, boost::python::args("marginOptions"), "Set the margin options.")
		.def("getMarginOptions", &ScintillaWrapper::GetMarginOptions, "Get the margin options.")
		.def("annotationSetText", &ScintillaWrapper::AnnotationSetText, boost::python::args("line", "text"), "Set the annotation text for a line")
		.def("annotationGetText", &ScintillaWrapper::AnnotationGetText, boost::python::args("line"), "Get the annotation text for a line")
		.def("annotationSetStyle", &ScintillaWrapper::AnnotationSetStyle, boost::python::args("line", "style"), "Set the style number for the annotations for a line")
		.def("annotationGetStyle", &ScintillaWrapper::AnnotationGetStyle, boost::python::args("line"), "Get the style number for the annotations for a line")
		.def("annotationSetStyles", &ScintillaWrapper::AnnotationSetStyles, boost::python::args("line", "styles"), "Set the annotation styles for a line")
		.def("annotationGetStyles", &ScintillaWrapper::AnnotationGetStyles, boost::python::args("line"), "Get the annotation styles for a line")
		.def("annotationGetLines", &ScintillaWrapper::AnnotationGetLines, boost::python::args("line"), "Get the number of annotation lines for a line")
		.def("annotationClearAll", &ScintillaWrapper::AnnotationClearAll, "Clear the annotations from all lines")
		.def("annotationSetVisible", &ScintillaWrapper::AnnotationSetVisible, boost::python::args("visible"), "Set the visibility for the annotations for a view")
		.def("annotationGetVisible", &ScintillaWrapper::AnnotationGetVisible, "Get the visibility for the annotations for a view")
		.def("annotationSetStyleOffset", &ScintillaWrapper::AnnotationSetStyleOffset, boost::python::args("style"), "Get the start of the range of style numbers used for annotations")
		.def("annotationGetStyleOffset", &ScintillaWrapper::AnnotationGetStyleOffset, "Get the start of the range of style numbers used for annotations")
		.def("releaseAllExtendedStyles", &ScintillaWrapper::ReleaseAllExtendedStyles, "Release all extended (>255) style numbers")
		.def("allocateExtendedStyles", &ScintillaWrapper::AllocateExtendedStyles, boost::python::args("numberStyles"), "Allocate some extended (>255) style numbers and return the start of the range")
		.def("addUndoAction", &ScintillaWrapper::AddUndoAction, boost::python::args("token", "flags"), "Add a container action to the undo stack")
		.def("charPositionFromPoint", &ScintillaWrapper::CharPositionFromPoint, boost::python::args("x", "y"), "Find the position of a character from a point within the window.")
		.def("charPositionFromPointClose", &ScintillaWrapper::CharPositionFromPointClose, boost::python::args("x", "y"), "Find the position of a character from a point within the window.\nReturn INVALID_POSITION if not close to text.")
		.def("setMouseSelectionRectangularSwitch", &ScintillaWrapper::SetMouseSelectionRectangularSwitch, boost::python::args("mouseSelectionRectangularSwitch"), "Set whether switching to rectangular mode while selecting with the mouse is allowed.")
		.def("getMouseSelectionRectangularSwitch", &ScintillaWrapper::GetMouseSelectionRectangularSwitch, "Whether switching to rectangular mode while selecting with the mouse is allowed.")
		.def("setMultipleSelection", &ScintillaWrapper::SetMultipleSelection, boost::python::args("multipleSelection"), "Set whether multiple selections can be made")
		.def("getMultipleSelection", &ScintillaWrapper::GetMultipleSelection, "Whether multiple selections can be made")
		.def("setAdditionalSelectionTyping", &ScintillaWrapper::SetAdditionalSelectionTyping, boost::python::args("additionalSelectionTyping"), "Set whether typing can be performed into multiple selections")
		.def("getAdditionalSelectionTyping", &ScintillaWrapper::GetAdditionalSelectionTyping, "Whether typing can be performed into multiple selections")
		.def("setAdditionalCaretsBlink", &ScintillaWrapper::SetAdditionalCaretsBlink, boost::python::args("additionalCaretsBlink"), "Set whether additional carets will blink")
		.def("getAdditionalCaretsBlink", &ScintillaWrapper::GetAdditionalCaretsBlink, "Whether additional carets will blink")
		.def("setAdditionalCaretsVisible", &ScintillaWrapper::SetAdditionalCaretsVisible, boost::python::args("additionalCaretsVisible"), "Set whether additional carets are visible")
		.def("getAdditionalCaretsVisible", &ScintillaWrapper::GetAdditionalCaretsVisible, "Whether additional carets are visible")
		.def("getSelections", &ScintillaWrapper::GetSelections, "How many selections are there?")
		.def("getSelectionEmpty", &ScintillaWrapper::GetSelectionEmpty, "Is every selected range empty?")
		.def("clearSelections", &ScintillaWrapper::ClearSelections, "Clear selections to a single empty stream selection")
		.def("setSelection", &ScintillaWrapper::SetSelection, boost::python::args("caret", "anchor"), "Set a simple selection")
		.def("addSelection", &ScintillaWrapper::AddSelection, boost::python::args("caret", "anchor"), "Add a selection")
		.def("selectionFromPoint", &ScintillaWrapper::SelectionFromPoint, boost::python::args("x", "y"), "Find the selection index for a point. -1 when not at a selection.")
		.def("dropSelectionN", &ScintillaWrapper::DropSelectionN, boost::python::args("selection"), "Drop one selection")
		.def("setMainSelection", &ScintillaWrapper::SetMainSelection, boost::python::args("selection"), "Set the main selection")
		.def("getMainSelection", &ScintillaWrapper::GetMainSelection, "Which selection is the main selection")
		.def("setSelectionNCaret", &ScintillaWrapper::SetSelectionNCaret, boost::python::args("selection", "caret"), "Set the caret position of the nth selection.")
		.def("getSelectionNCaret", &ScintillaWrapper::GetSelectionNCaret, boost::python::args("selection"), "Return the caret position of the nth selection.")
		.def("setSelectionNAnchor", &ScintillaWrapper::SetSelectionNAnchor, boost::python::args("selection", "anchor"), "Set the anchor position of the nth selection.")
		.def("getSelectionNAnchor", &ScintillaWrapper::GetSelectionNAnchor, boost::python::args("selection"), "Return the anchor position of the nth selection.")
		.def("setSelectionNCaretVirtualSpace", &ScintillaWrapper::SetSelectionNCaretVirtualSpace, boost::python::args("selection", "space"), "Set the virtual space of the caret of the nth selection.")
		.def("getSelectionNCaretVirtualSpace", &ScintillaWrapper::GetSelectionNCaretVirtualSpace, boost::python::args("selection"), "Return the virtual space of the caret of the nth selection.")
		.def("setSelectionNAnchorVirtualSpace", &ScintillaWrapper::SetSelectionNAnchorVirtualSpace, boost::python::args("selection", "space"), "Set the virtual space of the anchor of the nth selection.")
		.def("getSelectionNAnchorVirtualSpace", &ScintillaWrapper::GetSelectionNAnchorVirtualSpace, boost::python::args("selection"), "Return the virtual space of the anchor of the nth selection.")
		.def("setSelectionNStart", &ScintillaWrapper::SetSelectionNStart, boost::python::args("selection", "anchor"), "Sets the position that starts the selection - this becomes the anchor.")
		.def("getSelectionNStart", &ScintillaWrapper::GetSelectionNStart, boost::python::args("selection"), "Returns the position at the start of the selection.")
		.def("getSelectionNStartVirtualSpace", &ScintillaWrapper::GetSelectionNStartVirtualSpace, boost::python::args("selection"), "Returns the virtual space at the start of the selection.")
		.def("setSelectionNEnd", &ScintillaWrapper::SetSelectionNEnd, boost::python::args("selection", "caret"), "Sets the position that ends the selection - this becomes the currentPosition.")
		.def("getSelectionNEndVirtualSpace", &ScintillaWrapper::GetSelectionNEndVirtualSpace, boost::python::args("selection"), "Returns the virtual space at the end of the selection.")
		.def("getSelectionNEnd", &ScintillaWrapper::GetSelectionNEnd, boost::python::args("selection"), "Returns the position at the end of the selection.")
		.def("setRectangularSelectionCaret", &ScintillaWrapper::SetRectangularSelectionCaret, boost::python::args("caret"), "Set the caret position of the rectangular selection.")
		.def("getRectangularSelectionCaret", &ScintillaWrapper::GetRectangularSelectionCaret, "Return the caret position of the rectangular selection.")
		.def("setRectangularSelectionAnchor", &ScintillaWrapper::SetRectangularSelectionAnchor, boost::python::args("anchor"), "Set the anchor position of the rectangular selection.")
		.def("getRectangularSelectionAnchor", &ScintillaWrapper::GetRectangularSelectionAnchor, "Return the anchor position of the rectangular selection.")
		.def("setRectangularSelectionCaretVirtualSpace", &ScintillaWrapper::SetRectangularSelectionCaretVirtualSpace, boost::python::args("space"), "Set the virtual space of the caret of the rectangular selection.")
		.def("getRectangularSelectionCaretVirtualSpace", &ScintillaWrapper::GetRectangularSelectionCaretVirtualSpace, "Return the virtual space of the caret of the rectangular selection.")
		.def("setRectangularSelectionAnchorVirtualSpace", &ScintillaWrapper::SetRectangularSelectionAnchorVirtualSpace, boost::python::args("space"), "Set the virtual space of the anchor of the rectangular selection.")
		.def("getRectangularSelectionAnchorVirtualSpace", &ScintillaWrapper::GetRectangularSelectionAnchorVirtualSpace, "Return the virtual space of the anchor of the rectangular selection.")
		.def("setVirtualSpaceOptions", &ScintillaWrapper::SetVirtualSpaceOptions, boost::python::args("virtualSpaceOptions"), "Set options for virtual space behaviour.")
		.def("getVirtualSpaceOptions", &ScintillaWrapper::GetVirtualSpaceOptions, "Return options for virtual space behaviour.")
		.def("setRectangularSelectionModifier", &ScintillaWrapper::SetRectangularSelectionModifier, boost::python::args("modifier"), "On GTK, allow selecting the modifier key to use for mouse-based\nrectangular selection. Often the window manager requires Alt+Mouse Drag\nfor moving windows.\nValid values are SCMOD_CTRL(default), SCMOD_ALT, or SCMOD_SUPER.")
		.def("getRectangularSelectionModifier", &ScintillaWrapper::GetRectangularSelectionModifier, "Get the modifier key used for rectangular selection.")
		.def("setAdditionalSelFore", &ScintillaWrapper::SetAdditionalSelFore, boost::python::args("fore"), "Set the foreground colour of additional selections.\nMust have previously called SetSelFore with non-zero first argument for this to have an effect.")
		.def("setAdditionalSelBack", &ScintillaWrapper::SetAdditionalSelBack, boost::python::args("back"), "Set the background colour of additional selections.\nMust have previously called SetSelBack with non-zero first argument for this to have an effect.")
		.def("setAdditionalSelAlpha", &ScintillaWrapper::SetAdditionalSelAlpha, boost::python::args("alpha"), "Set the alpha of the selection.")
		.def("getAdditionalSelAlpha", &ScintillaWrapper::GetAdditionalSelAlpha, "Get the alpha of the selection.")
		.def("setAdditionalCaretFore", &ScintillaWrapper::SetAdditionalCaretFore, boost::python::args("fore"), "Set the foreground colour of additional carets.")
		.def("getAdditionalCaretFore", &ScintillaWrapper::GetAdditionalCaretFore, "Get the foreground colour of additional carets.")
		.def("rotateSelection", &ScintillaWrapper::RotateSelection, "Set the main selection to the next selection.")
		.def("swapMainAnchorCaret", &ScintillaWrapper::SwapMainAnchorCaret, "Swap that caret and anchor of the main selection.")
		.def("multipleSelectAddNext", &ScintillaWrapper::MultipleSelectAddNext, "Add the next occurrence of the main selection to the set of selections as main.\nIf the current selection is empty then select word around caret.")
		.def("multipleSelectAddEach", &ScintillaWrapper::MultipleSelectAddEach, "Add each occurrence of the main selection in the target to the set of selections.\nIf the current selection is empty then select word around caret.")
		.def("changeLexerState", &ScintillaWrapper::ChangeLexerState, boost::python::args("start", "end"), "Indicate that the internal state of a lexer has changed over a range and therefore\nthere may be a need to redraw.")
		.def("contractedFoldNext", &ScintillaWrapper::ContractedFoldNext, boost::python::args("lineStart"), "Find the next line at or after lineStart that is a contracted fold header line.\nReturn -1 when no more lines.")
		.def("verticalCentreCaret", &ScintillaWrapper::VerticalCentreCaret, "Centre current line in window.")
		.def("moveSelectedLinesUp", &ScintillaWrapper::MoveSelectedLinesUp, "Move the selected lines up one line, shifting the line above after the selection")
		.def("moveSelectedLinesDown", &ScintillaWrapper::MoveSelectedLinesDown, "Move the selected lines down one line, shifting the line below before the selection")
		.def("setIdentifier", &ScintillaWrapper::SetIdentifier, boost::python::args("identifier"), "Set the identifier reported as idFrom in notification messages.")
		.def("getIdentifier", &ScintillaWrapper::GetIdentifier, "Get the identifier.")
		.def("rGBAImageSetWidth", &ScintillaWrapper::RGBAImageSetWidth, boost::python::args("width"), "Set the width for future RGBA image data.")
		.def("rGBAImageSetHeight", &ScintillaWrapper::RGBAImageSetHeight, boost::python::args("height"), "Set the height for future RGBA image data.")
		.def("rGBAImageSetScale", &ScintillaWrapper::RGBAImageSetScale, boost::python::args("scalePercent"), "Set the scale factor in percent for future RGBA image data.")
		.def("markerDefineRGBAImage", &ScintillaWrapper::MarkerDefineRGBAImage, boost::python::args("markerNumber", "pixels"), "Define a marker from RGBA data.\nIt has the width and height from RGBAImageSetWidth/Height")
		.def("registerRGBAImage", &ScintillaWrapper::RegisterRGBAImage, boost::python::args("type", "pixels"), "Register an RGBA image for use in autocompletion lists.\nIt has the width and height from RGBAImageSetWidth/Height")
		.def("scrollToStart", &ScintillaWrapper::ScrollToStart, "Scroll to start of document.")
		.def("scrollToEnd", &ScintillaWrapper::ScrollToEnd, "Scroll to end of document.")
		.def("setTechnology", &ScintillaWrapper::SetTechnology, boost::python::args("technology"), "Set the technology used.")
		.def("getTechnology", &ScintillaWrapper::GetTechnology, "Get the tech.")
		.def("createLoader", &ScintillaWrapper::CreateLoader, boost::python::args("bytes", "documentOptions"), "Create an ILoader*.")
		.def("findIndicatorShow", &ScintillaWrapper::FindIndicatorShow, boost::python::args("start", "end"), "On macOS, show a find indicator.")
		.def("findIndicatorFlash", &ScintillaWrapper::FindIndicatorFlash, boost::python::args("start", "end"), "On macOS, flash a find indicator, then fade out.")
		.def("findIndicatorHide", &ScintillaWrapper::FindIndicatorHide, "On macOS, hide the find indicator.")
		.def("vCHomeDisplay", &ScintillaWrapper::VCHomeDisplay, "Move caret to before first visible character on display line.\nIf already there move to first character on display line.")
		.def("vCHomeDisplayExtend", &ScintillaWrapper::VCHomeDisplayExtend, "Like VCHomeDisplay but extending selection to new caret position.")
		.def("getCaretLineVisibleAlways", &ScintillaWrapper::GetCaretLineVisibleAlways, "Is the caret line always visible?")
		.def("setCaretLineVisibleAlways", &ScintillaWrapper::SetCaretLineVisibleAlways, boost::python::args("alwaysVisible"), "Sets the caret line to always visible.")
		.def("setLineEndTypesAllowed", &ScintillaWrapper::SetLineEndTypesAllowed, boost::python::args("lineEndBitSet"), "Set the line end types that the application wants to use. May not be used if incompatible with lexer or encoding.")
		.def("getLineEndTypesAllowed", &ScintillaWrapper::GetLineEndTypesAllowed, "Get the line end types currently allowed.")
		.def("getLineEndTypesActive", &ScintillaWrapper::GetLineEndTypesActive, "Get the line end types currently recognised. May be a subset of the allowed types due to lexer limitation.")
		.def("setRepresentation", &ScintillaWrapper::SetRepresentation, boost::python::args("encodedCharacter", "representation"), "Set the way a character is drawn.")
		.def("getRepresentation", &ScintillaWrapper::GetRepresentation, boost::python::args("encodedCharacter"), "Get the way a character is drawn.\nResult is NUL-terminated.")
		.def("clearRepresentation", &ScintillaWrapper::ClearRepresentation, boost::python::args("encodedCharacter"), "Remove a character representation.")
		.def("clearAllRepresentations", &ScintillaWrapper::ClearAllRepresentations, "Clear representations to default.")
		.def("setRepresentationAppearance", &ScintillaWrapper::SetRepresentationAppearance, boost::python::args("encodedCharacter", "appearance"), "Set the appearance of a representation.")
		.def("getRepresentationAppearance", &ScintillaWrapper::GetRepresentationAppearance, boost::python::args("encodedCharacter"), "Get the appearance of a representation.")
		.def("setRepresentationColour", &ScintillaWrapper::SetRepresentationColour, boost::python::args("encodedCharacter", "colour"), "Set the colour of a representation.")
		.def("getRepresentationColour", &ScintillaWrapper::GetRepresentationColour, boost::python::args("encodedCharacter"), "Get the colour of a representation.")
		.def("eOLAnnotationSetText", &ScintillaWrapper::EOLAnnotationSetText, boost::python::args("line", "text"), "Set the end of line annotation text for a line")
		.def("eOLAnnotationGetText", &ScintillaWrapper::EOLAnnotationGetText, boost::python::args("line"), "Get the end of line annotation text for a line")
		.def("eOLAnnotationSetStyle", &ScintillaWrapper::EOLAnnotationSetStyle, boost::python::args("line", "style"), "Set the style number for the end of line annotations for a line")
		.def("eOLAnnotationGetStyle", &ScintillaWrapper::EOLAnnotationGetStyle, boost::python::args("line"), "Get the style number for the end of line annotations for a line")
		.def("eOLAnnotationClearAll", &ScintillaWrapper::EOLAnnotationClearAll, "Clear the end of annotations from all lines")
		.def("eOLAnnotationSetVisible", &ScintillaWrapper::EOLAnnotationSetVisible, boost::python::args("visible"), "Set the visibility for the end of line annotations for a view")
		.def("eOLAnnotationGetVisible", &ScintillaWrapper::EOLAnnotationGetVisible, "Get the visibility for the end of line annotations for a view")
		.def("eOLAnnotationSetStyleOffset", &ScintillaWrapper::EOLAnnotationSetStyleOffset, boost::python::args("style"), "Get the start of the range of style numbers used for end of line annotations")
		.def("eOLAnnotationGetStyleOffset", &ScintillaWrapper::EOLAnnotationGetStyleOffset, "Get the start of the range of style numbers used for end of line annotations")
		.def("supportsFeature", &ScintillaWrapper::SupportsFeature, boost::python::args("feature"), "Get whether a feature is supported")
		.def("getLineCharacterIndex", &ScintillaWrapper::GetLineCharacterIndex, "Retrieve line character index state.")
		.def("allocateLineCharacterIndex", &ScintillaWrapper::AllocateLineCharacterIndex, boost::python::args("lineCharacterIndex"), "Request line character index be created or its use count increased.")
		.def("releaseLineCharacterIndex", &ScintillaWrapper::ReleaseLineCharacterIndex, boost::python::args("lineCharacterIndex"), "Decrease use count of line character index and remove if 0.")
		.def("lineFromIndexPosition", &ScintillaWrapper::LineFromIndexPosition, boost::python::args("pos", "lineCharacterIndex"), "Retrieve the document line containing a position measured in index units.")
		.def("indexPositionFromLine", &ScintillaWrapper::IndexPositionFromLine, boost::python::args("line", "lineCharacterIndex"), "Retrieve the position measured in index units at the start of a document line.")
		.def("startRecord", &ScintillaWrapper::StartRecord, "Start notifying the container of all key presses and commands.")
		.def("stopRecord", &ScintillaWrapper::StopRecord, "Stop notifying the container of all key presses and commands.")
		.def("getLexer", &ScintillaWrapper::GetLexer, "Retrieve the lexing language of the document.")
		.def("colourise", &ScintillaWrapper::Colourise, boost::python::args("start", "end"), "Colourise a segment of the document using the current lexing language.")
		.def("setProperty", &ScintillaWrapper::SetProperty, boost::python::args("key", "value"), "Set up a value that may be used by a lexer for some optional feature.")
		.def("setKeyWords", &ScintillaWrapper::SetKeyWords, boost::python::args("keyWordSet", "keyWords"), "Set up the key words used by the lexer.")
		.def("getProperty", &ScintillaWrapper::GetProperty, boost::python::args("key"), "Retrieve a \"property\" value previously set with SetProperty.\nResult is NUL-terminated.")
		.def("getPropertyExpanded", &ScintillaWrapper::GetPropertyExpanded, boost::python::args("key"), "Retrieve a \"property\" value previously set with SetProperty,\nwith \"$()\" variable replacement on returned buffer.\nResult is NUL-terminated.")
		.def("getPropertyInt", &ScintillaWrapper::GetPropertyInt, boost::python::args("key", "defaultValue"), "Retrieve a \"property\" value previously set with SetProperty,\ninterpreted as an int AFTER any \"$()\" variable replacement.")
		.def("getLexerLanguage", &ScintillaWrapper::GetLexerLanguage, "Retrieve the name of the lexer.\nReturn the length of the text.\nResult is NUL-terminated.")
		.def("privateLexerCall", &ScintillaWrapper::PrivateLexerCall, boost::python::args("operation", "pointer"), "For private communication between an application and a known lexer.")
		.def("propertyNames", &ScintillaWrapper::PropertyNames, "Retrieve a '\n' separated list of properties understood by the current lexer.\nResult is NUL-terminated.")
		.def("propertyType", &ScintillaWrapper::PropertyType, boost::python::args("name"), "Retrieve the type of a property.")
		.def("describeProperty", &ScintillaWrapper::DescribeProperty, boost::python::args("name"), "Describe a property.\nResult is NUL-terminated.")
		.def("describeKeyWordSets", &ScintillaWrapper::DescribeKeyWordSets, "Retrieve a '\n' separated list of descriptions of the keyword sets understood by the current lexer.\nResult is NUL-terminated.")
		.def("getLineEndTypesSupported", &ScintillaWrapper::GetLineEndTypesSupported, "Bit set of LineEndType enumeration for which line ends beyond the standard\nLF, CR, and CRLF are supported by the lexer.")
		.def("allocateSubStyles", &ScintillaWrapper::AllocateSubStyles, boost::python::args("styleBase", "numberStyles"), "Allocate a set of sub styles for a particular base style, returning start of range")
		.def("getSubStylesStart", &ScintillaWrapper::GetSubStylesStart, boost::python::args("styleBase"), "The starting style number for the sub styles associated with a base style")
		.def("getSubStylesLength", &ScintillaWrapper::GetSubStylesLength, boost::python::args("styleBase"), "The number of sub styles associated with a base style")
		.def("getStyleFromSubStyle", &ScintillaWrapper::GetStyleFromSubStyle, boost::python::args("subStyle"), "For a sub style, return the base style, else return the argument.")
		.def("getPrimaryStyleFromStyle", &ScintillaWrapper::GetPrimaryStyleFromStyle, boost::python::args("style"), "For a secondary style, return the primary style, else return the argument.")
		.def("freeSubStyles", &ScintillaWrapper::FreeSubStyles, "Free allocated sub styles")
		.def("setIdentifiers", &ScintillaWrapper::SetIdentifiers, boost::python::args("style", "identifiers"), "Set the identifiers that are shown in a particular style")
		.def("distanceToSecondaryStyles", &ScintillaWrapper::DistanceToSecondaryStyles, "Where styles are duplicated by a feature such as active/inactive code\nreturn the distance between the two types.")
		.def("getSubStyleBases", &ScintillaWrapper::GetSubStyleBases, "Get the set of base styles that can be extended with sub styles\nResult is NUL-terminated.")
		.def("getNamedStyles", &ScintillaWrapper::GetNamedStyles, "Retrieve the number of named styles for the lexer.")
		.def("nameOfStyle", &ScintillaWrapper::NameOfStyle, boost::python::args("style"), "Retrieve the name of a style.\nResult is NUL-terminated.")
		.def("tagsOfStyle", &ScintillaWrapper::TagsOfStyle, boost::python::args("style"), "Retrieve a ' ' separated list of style tags like \"literal quoted string\".\nResult is NUL-terminated.")
		.def("descriptionOfStyle", &ScintillaWrapper::DescriptionOfStyle, boost::python::args("style"), "Retrieve a description of a style.\nResult is NUL-terminated.")
		.def("setILexer", &ScintillaWrapper::SetILexer, boost::python::args("ilexer"), "Set the lexer from an ILexer*.")
		.def("getBidirectional", &ScintillaWrapper::GetBidirectional, "Retrieve bidirectional text display state.")
		.def("setBidirectional", &ScintillaWrapper::SetBidirectional, boost::python::args("bidirectional"), "Set bidirectional text display state.")
		/* --Autogenerated -------------------- */
		;
	//lint +e1793

	boost::python::class_<ScintillaCells>("Cell", boost::python::init<boost::python::str, boost::python::list>());

	export_enums();
	export_notepad();
	export_console();
	export_match();
}

//see https://github.com/TNG/boost-python-examples/blob/master/10-Embedding/embedding.cpp
#if PY_MAJOR_VERSION >= 3
#   define INIT_MODULE PyInit_Npp
extern "C" PyObject* INIT_MODULE();
#else
#   define INIT_MODULE initNpp
extern "C" void INIT_MODULE();
#endif

void preinitScintillaModule()
{
	PyImport_AppendInittab("Npp", INIT_MODULE);
}

void importScintilla(boost::shared_ptr<ScintillaWrapper> editor, boost::shared_ptr<ScintillaWrapper> editor1, boost::shared_ptr<ScintillaWrapper> editor2)
{
	// Get the __main__ module/namespace
	//object main_module(handle<>(borrowed(PyImport_AddModule("Npp"))));
	boost::python::object npp_module( (boost::python::handle<>(PyImport_ImportModule("Npp"))) );
	boost::python::object npp_namespace = npp_module.attr("__dict__");
	// Create an instance variable buffer in __main__ that points to the ScintillaWrapper instance
	npp_namespace["editor"] = editor;
	npp_namespace["editor1"] = editor1;
	npp_namespace["editor2"] = editor2;

	// Import our Scintilla object
	//	object main_module( (handle<>(PyImport_ImportModule("__main__"))) );
	//object main_namespace = main_module.attr("__dict__");
	// Add "Npp" to __main__
	//main_namespace["Npp"] = npp_module;


}

void importNotepad(boost::shared_ptr<NotepadPlusWrapper> instance)
{
	// Get the __main__ module/namespace
	//object main_module(handle<>(borrowed(PyImport_AddModule("Npp"))));
	boost::python::object npp_module( (boost::python::handle<>(PyImport_ImportModule("Npp"))) );
	boost::python::object main_namespace = npp_module.attr("__dict__");

	// Create an instance variable buffer in __main__ that points to the NotepadPlusWrapper instance
	main_namespace["notepad"] = instance;

}


void importConsole(boost::shared_ptr<PythonConsole> instance)
{
	// Get the __main__ module/namespace
	//object main_module(handle<>(borrowed(PyImport_AddModule("Npp"))));
	boost::python::object npp_module( (boost::python::handle<>(PyImport_ImportModule("Npp"))) );
	boost::python::object main_namespace = npp_module.attr("__dict__");

	// Create an instance variable buffer in __main__ that points to the PythonConsole instance
	main_namespace["console"] = instance;
}

}
