#ifndef _SCINTILLAWRAPPER_H

#define _SCINTILLAWRAPPER_H

#ifndef _SCINTILLACELL_H

#include "ScintillaCells.h"

#endif

#ifndef _PYPRODUCER_H

#include "PyProducerConsumer.h"

#endif

#ifndef REPLACER_20140209_H

#include "Replacer.h"

#endif

#ifndef CALLBACKEXECARGS_20140217_H

#include "CallbackExecArgs.h"

#endif

#include "MutexHolder.h"

#include "GILManager.h"

struct SCNotification;

#define COLOUR_RED(x) (x & 0x0000FF)

#define COLOUR_GREEN(x) ((x & 0x00FF00) >> 8)

#define COLOUR_BLUE(x) ((x & 0xFF0000) >> 16)

#define MAKECOLOUR(x) RGB(boost::python::extract<int>(x[0]),boost::python::extract<int>(x[1]),boost::python::extract<int>(x[2]))

struct out_of_bounds_exception : public std::exception

{

const char * what() const throw() { return "Out of bounds exception"; }

};

namespace NppPythonScript

{

void translateOutOfBounds(out_of_bounds_exception const& e);

class Match;

class ReplaceEntry;

class ScintillaCallback;

// Function that throws a notsupported exception, with the message about the method being deprecated

boost::python::object deprecated_replace_function(boost::python::tuple args, boost::python::dict kwargs);

class ScintillaWrapper : public PyProducerConsumer<CallbackExecArgs>

{

public:

explicit ScintillaWrapper(HWND handle, HWND notepadHandle);

virtual ~ScintillaWrapper();

void setHandle(const HWND handle) { m_handle = handle; };

HWND getHandle() { return m_handle; };

void invalidateHandle() { m_handle = NULL; };

void notify(SCNotification *notifyCode);

bool addSyncCallback(PyObject* callback, boost::python::list events);

bool addAsyncCallback(PyObject *callback, boost::python::list events);

bool addCallbackImpl(PyObject *callback, boost::python::list events, bool isAsync);

void clearAllCallbacks();

void clearCallbackFunction(PyObject* callback);

void clearCallbackEvents(boost::python::list events);

void clearCallback(PyObject* callback, boost::python::list events);

/* Helper functions

* These functions are designed to make life easier for scripting,

* but don't perform any "magic"

*/

void forEachLine(PyObject* function);

void deleteLine(int lineNumber);

void replaceLine(int lineNumber, boost::python::object newContents);

void replaceWholeLine(int lineNumber, boost::python::object newContents);

boost::python::tuple getUserLineSelection();

boost::python::tuple getUserCharSelection();

void setTarget(int start, int end);

/** Returns the flag to be combined with the re flag constants, in order to set the

* re anchors to treat the document as a whole, a not per line. ie. ^ matches the start of the document,

* and $ matches the end. Default is ^ matches start of line, $ the end.

*/

static int getWholeDocFlag() { return python_re_flag_wholedoc; }

void replacePlain(boost::python::object searchStr, boost::python::object replaceStr);

void replacePlainFlags(boost::python::object searchStr, boost::python::object replaceStr, int flags);

void replacePlainFlagsStart(boost::python::object searchStr, boost::python::object replaceStr, int flags, int startPosition);

void replacePlainFlagsStartEnd(boost::python::object searchStr, boost::python::object replaceStr, int flags, int startPosition, int endPosition);

void replacePlainFlagsStartEndMaxCount(boost::python::object searchStr, boost::python::object replaceStr, int flags, int startPosition, int endPosition, int maxCount);

void replaceRegex(boost::python::object searchStr, boost::python::object replaceStr);

void replaceRegexFlags(boost::python::object searchStr, boost::python::object replaceStr, int flags);

void replaceRegexFlagsStart(boost::python::object searchStr, boost::python::object replaceStr, int flags, int start);

void replaceRegexFlagsStartEnd(boost::python::object searchStr, boost::python::object replaceStr, int flags, int start, int end);

void replaceRegexFlagsStartEndMaxCount(boost::python::object searchStr, boost::python::object replaceStr, int flags, int start, int end, int maxCount);

void replaceImpl(boost::python::object searchStr, boost::python::object replaceStr, int count, python_re_flags flags, int startPosition, int endPosition);

void searchPlain(boost::python::object searchStr, boost::python::object matchFunction);

void searchPlainFlags(boost::python::object searchStr, boost::python::object matchFunction, int flags);

void searchPlainFlagsStart(boost::python::object searchStr, boost::python::object matchFunction, int flags, int startPosition);

void searchPlainFlagsStartEnd(boost::python::object searchStr, boost::python::object matchFunction, int flags, int startPosition, int endPosition);

void searchPlainFlagsStartEndCount(boost::python::object searchStr, boost::python::object matchFunction, int flags, int startPosition, int endPosition, int maxCount);

void searchRegex(boost::python::object searchStr, boost::python::object matchFunction);

void searchRegexFlags(boost::python::object searchStr, boost::python::object matchFunction, int flags);

void searchRegexFlagsStart(boost::python::object searchStr, boost::python::object matchFunction, int flags, int startPosition);

void searchRegexFlagsStartEnd(boost::python::object searchStr, boost::python::object matchFunction, int flags, int startPosition, int endPosition);

void searchRegexFlagsStartEndCount(boost::python::object searchStr, boost::python::object matchFunction, int flags, int startPosition, int endPosition, int maxCount);

void searchPlainImpl(boost::python::object searchStr, boost::python::object matchFunction, int maxCount, int flags, int startPosition, int endPosition);

void searchImpl(boost::python::object searchStr, boost::python::object matchFunction, int maxCount, python_re_flags flags, int startPosition, int endPosition);

//static const int RE_INCLUDELINEENDINGS = 65536;

/*

void pyreplace(boost::python::object searchExp, boost::python::object replaceStr, boost::python::object count, boost::python::object flags, boost::python::object startLine, boost::python::object endLine);

void pyreplaceNoFlagsNoCount(boost::python::object searchExp, boost::python::object replaceStr)

{ pyreplace(searchExp, replaceStr, boost::python::object(0), boost::python::object(0), boost::python::object(), boost::python::object()); };

void pyreplaceNoFlags(boost::python::object searchExp, boost::python::object replaceStr, boost::python::object count)

{ pyreplace(searchExp, replaceStr, count, boost::python::object(0), boost::python::object(), boost::python::object()); };

void pyreplaceNoStartEnd(boost::python::object searchExp, boost::python::object replaceStr, boost::python::object count, boost::python::object flags)

{ pyreplace(searchExp, replaceStr, count, flags, boost::python::object(), boost::python::object()); };

void pyreplaceNoEnd(boost::python::object searchExp, boost::python::object replaceStr, boost::python::object count, boost::python::object flags, boost::python::object startLine)

{ pyreplace(searchExp, replaceStr, count, flags, startLine, boost::python::object()); };

void pymlreplace(boost::python::object searchExp, boost::python::object replaceStr, boost::python::object count, boost::python::object flags, boost::python::object startPosition, boost::python::object endPosition);

void pymlreplaceNoFlagsNoCount(boost::python::object searchExp, boost::python::object replaceStr)

{ pymlreplace(searchExp, replaceStr, boost::python::object(0), boost::python::object(0), boost::python::object(), boost::python::object()); };

void pymlreplaceNoFlags(boost::python::object searchExp, boost::python::object replaceStr, boost::python::object count)

{ pymlreplace(searchExp, replaceStr, count, boost::python::object(0), boost::python::object(), boost::python::object()); };

void pymlreplaceNoStartEnd(boost::python::object searchExp, boost::python::object replaceStr, boost::python::object count, boost::python::object flags)

{ pymlreplace(searchExp, replaceStr, count, flags, boost::python::object(), boost::python::object()); };

void pymlreplaceNoEnd(boost::python::object searchExp, boost::python::object replaceStr, boost::python::object count, boost::python::object flags, boost::python::object startPosition)

{ pymlreplace(searchExp, replaceStr, count, flags, startPosition, boost::python::object()); };

void pysearch(boost::python::object searchExp, boost::python::object callback, boost::python::object flags, boost::python::object startLine, boost::python::object endLine);

void pysearchNoFlags(boost::python::object searchExp, boost::python::object callback)

{ pysearch(searchExp, callback, boost::python::object(0), boost::python::object(), boost::python::object()); };

void pysearchNoStartEnd(boost::python::object searchExp, boost::python::object callback, boost::python::object flags)

{ pysearch(searchExp, callback, flags, boost::python::object(), boost::python::object()); };

void pysearchNoEnd(boost::python::object searchExp, boost::python::object callback, boost::python::object flags, boost::python::object startLine)

{ pysearch(searchExp, callback, flags, startLine, boost::python::object()); };

void pymlsearch(boost::python::object searchExp, boost::python::object callback, boost::python::object flags, boost::python::object startPosition, boost::python::object endPosition);

void pymlsearchNoFlags(boost::python::object searchExp, boost::python::object callback)

{ pymlsearch(searchExp, callback, boost::python::object(0), boost::python::object(), boost::python::object()); };

void pymlsearchNoStartEnd(boost::python::object searchExp, boost::python::object callback, boost::python::object flags)

{ pymlsearch(searchExp, callback, flags, boost::python::object(), boost::python::object()); };

void pymlsearchNoEnd(boost::python::object searchExp, boost::python::object callback, boost::python::object flags, boost::python::object startPosition)

{ pymlsearch(searchExp, callback, flags, startPosition, boost::python::object()); };

*/

boost::python::str getWord(boost::python::object position, boost::python::object useOnlyWordChars);

boost::python::str getWordNoFlags(boost::python::object position)

{ return getWord(position, boost::python::object(true)); };

boost::python::str getCurrentWord()

{ return getWord(boost::python::object(), boost::python::object(true)); };

// This "normal" Scintilla function has been implemented manually, as it returns a pointer, which we can convert to a string

boost::python::str GetCharacterPointer();

// This "normal" Scintilla function has been implemented manually, as it returns a pointer, which we can convert to a string

boost::python::str GetRangePointer(int position, int length);

/** This helper function gets a std::string from the given object.

* If the object is a unicode string, it converts the string to UTF-8.

* If it's an object, it calls the __str__ method to convert the object to a string

*/

std::string getStringFromObject(boost::python::object o);

/* ++Autogenerated ---------------------------------------------------- */

/** Add text to the document at current position.

*/

intptr_t AddText(boost::python::object text);

/** Add array of cells to document.

*/

intptr_t AddStyledText(ScintillaCells c);

/** Insert string at a position.

*/

void InsertText(int pos, boost::python::object text);

/** Change the text that is being inserted in response to SC_MOD_INSERTCHECK

*/

intptr_t ChangeInsertion(boost::python::object text);

/** Delete all text in the document.

*/

void ClearAll();

/** Delete a range of text in the document.

*/

void DeleteRange(int pos, int deleteLength);

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

*/

void ClearDocumentStyle();

/** Returns the number of bytes in the document.

*/

intptr_t GetLength();

/** Returns the character byte at the position.

*/

intptr_t GetCharAt(int pos);

/** Returns the position of the caret.

*/

intptr_t GetCurrentPos();

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

*/

intptr_t GetAnchor();

/** Returns the style byte at the position.

*/

intptr_t GetStyleAt(int pos);

/** Redoes the next action on the undo history.

*/

void Redo();

/** Choose between collecting actions into the undo

* history and discarding them.

*/

void SetUndoCollection(bool collectUndo);

/** Select all the text in the document.

*/

void SelectAll();

/** Remember the current position in the undo history as the position

* at which the document was saved.

*/

void SetSavePoint();

/** Retrieve a buffer of cells.

* Returns the number of bytes in the buffer not including terminating NULs.

*/

boost::python::tuple GetStyledText(int start, int end);

/** Are there any redoable actions in the undo history?

*/

bool CanRedo();

/** Retrieve the line number at which a particular marker is located.

*/

intptr_t MarkerLineFromHandle(int handle);

/** Delete a marker.

*/

void MarkerDeleteHandle(int handle);

/** Is undo history being collected?

*/

bool GetUndoCollection();

/** Are white space characters currently visible?

* Returns one of SCWS_* constants.

*/

intptr_t GetViewWS();

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

*/

void SetViewWS(int viewWS);

/** Find the position from a point within the window.

*/

intptr_t PositionFromPoint(int x, int y);

/** Find the position from a point within the window but return

* INVALID_POSITION if not close to text.

*/

intptr_t PositionFromPointClose(int x, int y);

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

*/

void GotoLine(int line);

/** Set caret to a position and ensure it is visible.

*/

void GotoPos(int pos);

/** Set the selection anchor to a position. The anchor is the opposite

* end of the selection from the caret.

*/

void SetAnchor(int posAnchor);

/** Retrieve the text of the line containing the caret.

* Returns the index of the caret on the line.

* Result is NUL-terminated.

*/

boost::python::str GetCurLine();

/** Retrieve the position of the last correctly styled character.

*/

intptr_t GetEndStyled();

/** Convert all line endings in the document to one mode.

*/

void ConvertEOLs(int eolMode);

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

*/

intptr_t GetEOLMode();

/** Set the current end of line mode.

*/

void SetEOLMode(int eolMode);

/** Set the current styling position to pos and the styling mask to mask.

* The styling mask can be used to protect some bits in each styling byte from modification.

*/

void StartStyling(int pos, int mask);

/** Change style from current styling position for length characters to a style

* and move the current styling position to after this newly styled segment.

*/

void SetStyling(int length, int style);

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

*/

bool GetBufferedDraw();

/** If drawing is buffered then each line of text is drawn into a bitmap buffer

* before drawing it to the screen to avoid flicker.

*/

void SetBufferedDraw(bool buffered);

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

*/

void SetTabWidth(int tabWidth);

/** Retrieve the visible size of a tab.

*/

intptr_t GetTabWidth();

/** Clear explicit tabstops on a line.

*/

void ClearTabStops(int line);

/** Add an explicit tab stop for a line.

*/

void AddTabStop(int line, int x);

/** Find the next explicit tab stop position on a line after a position.

*/

intptr_t GetNextTabStop(int line, int x);

/** Set the code page used to interpret the bytes of the document as characters.

* The SC_CP_UTF8 value can be used to enter Unicode mode.

*/

void SetCodePage(int codePage);

/** Is the IME displayed in a winow or inline?

*/

intptr_t GetIMEInteraction();

/** Choose to display the the IME in a winow or inline.

*/

void SetIMEInteraction(int imeInteraction);

/** Set the symbol used for a particular marker number.

*/

void MarkerDefine(int markerNumber, int markerSymbol);

/** Set the foreground colour used for a particular marker number.

*/

void MarkerSetFore(int markerNumber, boost::python::tuple fore);

/** Set the background colour used for a particular marker number.

*/

void MarkerSetBack(int markerNumber, boost::python::tuple back);

/** Set the background colour used for a particular marker number when its folding block is selected.

*/

void MarkerSetBackSelected(int markerNumber, boost::python::tuple back);

/** Enable/disable highlight for current folding bloc (smallest one that contains the caret)

*/

void MarkerEnableHighlight(bool enabled);

/** Add a marker to a line, returning an ID which can be used to find or delete the marker.

*/

intptr_t MarkerAdd(int line, int markerNumber);

/** Delete a marker from a line.

*/

void MarkerDelete(int line, int markerNumber);

/** Delete all markers with a particular number from all lines.

*/

void MarkerDeleteAll(int markerNumber);

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

*/

intptr_t MarkerGet(int line);

/** Find the next line at or after lineStart that includes a marker in mask.

* Return -1 when no more lines.

*/

intptr_t MarkerNext(int lineStart, int markerMask);

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

*/

intptr_t MarkerPrevious(int lineStart, int markerMask);

/** Define a marker from a pixmap.

*/

void MarkerDefinePixmap(int markerNumber, boost::python::object pixmap);

/** Add a set of markers to a line.

*/

void MarkerAddSet(int line, int set);

/** Set the alpha used for a marker that is drawn in the text area, not the margin.

*/

void MarkerSetAlpha(int markerNumber, int alpha);

/** Set a margin to be either numeric or symbolic.

*/

void SetMarginTypeN(int margin, int marginType);

/** Retrieve the type of a margin.

*/

intptr_t GetMarginTypeN(int margin);

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

*/

void SetMarginWidthN(int margin, int pixelWidth);

/** Retrieve the width of a margin in pixels.

*/

intptr_t GetMarginWidthN(int margin);

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

*/

void SetMarginMaskN(int margin, int mask);

/** Retrieve the marker mask of a margin.

*/

intptr_t GetMarginMaskN(int margin);

/** Make a margin sensitive or insensitive to mouse clicks.

*/

void SetMarginSensitiveN(int margin, bool sensitive);

/** Retrieve the mouse click sensitivity of a margin.

*/

bool GetMarginSensitiveN(int margin);

/** Set the cursor shown when the mouse is inside a margin.

*/

void SetMarginCursorN(int margin, int cursor);

/** Retrieve the cursor shown in a margin.

*/

intptr_t GetMarginCursorN(int margin);

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

*/

void StyleClearAll();

/** Set the foreground colour of a style.

*/

void StyleSetFore(int style, boost::python::tuple fore);

/** Set the background colour of a style.

*/

void StyleSetBack(int style, boost::python::tuple back);

/** Set a style to be bold or not.

*/

void StyleSetBold(int style, bool bold);

/** Set a style to be italic or not.

*/

void StyleSetItalic(int style, bool italic);

/** Set the size of characters of a style.

*/

void StyleSetSize(int style, int sizePoints);

/** Set the font of a style.

*/

void StyleSetFont(int style, boost::python::object fontName);

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

*/

void StyleSetEOLFilled(int style, bool filled);

/** Reset the default style to its state at startup

*/

void StyleResetDefault();

/** Set a style to be underlined or not.

*/

void StyleSetUnderline(int style, bool underline);

/** Get the foreground colour of a style.

*/

boost::python::tuple StyleGetFore(int style);

/** Get the background colour of a style.

*/

boost::python::tuple StyleGetBack(int style);

/** Get is a style bold or not.

*/

bool StyleGetBold(int style);

/** Get is a style italic or not.

*/

bool StyleGetItalic(int style);

/** Get the size of characters of a style.

*/

intptr_t StyleGetSize(int style);

/** Get the font of a style.

* Returns the length of the fontName

* Result is NUL-terminated.

*/

boost::python::str StyleGetFont(int style);

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

*/

bool StyleGetEOLFilled(int style);

/** Get is a style underlined or not.

*/

bool StyleGetUnderline(int style);

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

*/

intptr_t StyleGetCase(int style);

/** Get the character get of the font in a style.

*/

intptr_t StyleGetCharacterSet(int style);

/** Get is a style visible or not.

*/

bool StyleGetVisible(int style);

/** Get is a style changeable or not (read only).

* Experimental feature, currently buggy.

*/

bool StyleGetChangeable(int style);

/** Get is a style a hotspot or not.

*/

bool StyleGetHotSpot(int style);

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

*/

void StyleSetCase(int style, int caseForce);

/** Set the size of characters of a style. Size is in points multiplied by 100.

*/

void StyleSetSizeFractional(int style, int caseForce);

/** Get the size of characters of a style in points multiplied by 100

*/

intptr_t StyleGetSizeFractional(int style);

/** Set the weight of characters of a style.

*/

void StyleSetWeight(int style, int weight);

/** Get the weight of characters of a style.

*/

intptr_t StyleGetWeight(int style);

/** Set the character set of the font in a style.

*/

void StyleSetCharacterSet(int style, int characterSet);

/** Set a style to be a hotspot or not.

*/

void StyleSetHotSpot(int style, bool hotspot);

/** Set the foreground colour of the main and additional selections and whether to use this setting.

*/

void SetSelFore(bool useSetting, boost::python::tuple fore);

/** Set the background colour of the main and additional selections and whether to use this setting.

*/

void SetSelBack(bool useSetting, boost::python::tuple back);

/** Get the alpha of the selection.

*/

intptr_t GetSelAlpha();

/** Set the alpha of the selection.

*/

void SetSelAlpha(int alpha);

/** Is the selection end of line filled?

*/

bool GetSelEOLFilled();

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

*/

void SetSelEOLFilled(bool filled);

/** Set the foreground colour of the caret.

*/

void SetCaretFore(boost::python::tuple fore);

/** When key+modifier combination km is pressed perform msg.

*/

void AssignCmdKey(int km, int msg);

/** When key+modifier combination km is pressed do nothing.

*/

void ClearCmdKey(int km);

/** Drop all key mappings.

*/

void ClearAllCmdKeys();

/** Set the styles for a segment of the document.

*/

intptr_t SetStylingEx(boost::python::object styles);

/** Set a style to be visible or not.

*/

void StyleSetVisible(int style, bool visible);

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

*/

intptr_t GetCaretPeriod();

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

*/

void SetCaretPeriod(int periodMilliseconds);

/** Set the set of characters making up words for when moving or selecting by word.

* First sets defaults like SetCharsDefault.

*/

void SetWordChars(boost::python::object characters);

/** Get the set of characters making up words for when moving or selecting by word.

* Returns the number of characters

*/

boost::python::str GetWordChars();

/** Start a sequence of actions that is undone and redone as a unit.

* May be nested.

*/

void BeginUndoAction();

/** End a sequence of actions that is undone and redone as a unit.

*/

void EndUndoAction();

/** Set an indicator to plain, squiggle or TT.

*/

void IndicSetStyle(int indic, int style);

/** Retrieve the style of an indicator.

*/

intptr_t IndicGetStyle(int indic);

/** Set the foreground colour of an indicator.

*/

void IndicSetFore(int indic, boost::python::tuple fore);

/** Retrieve the foreground colour of an indicator.

*/

boost::python::tuple IndicGetFore(int indic);

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

*/

void IndicSetUnder(int indic, bool under);

/** Retrieve whether indicator drawn under or over text.

*/

bool IndicGetUnder(int indic);

/** Set a hover indicator to plain, squiggle or TT.

*/

void IndicSetHoverStyle(int indic, int style);

/** Retrieve the hover style of an indicator.

*/

intptr_t IndicGetHoverStyle(int indic);

/** Set the foreground hover colour of an indicator.

*/

void IndicSetHoverFore(int indic, boost::python::tuple fore);

/** Retrieve the foreground hover colour of an indicator.

*/

boost::python::tuple IndicGetHoverFore(int indic);

/** Set the attributes of an indicator.

*/

void IndicSetFlags(int indic, int flags);

/** Retrieve the attributes of an indicator.

*/

intptr_t IndicGetFlags(int indic);

/** Set the foreground colour of all whitespace and whether to use this setting.

*/

void SetWhitespaceFore(bool useSetting, boost::python::tuple fore);

/** Set the background colour of all whitespace and whether to use this setting.

*/

void SetWhitespaceBack(bool useSetting, boost::python::tuple back);

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

*/

void SetWhitespaceSize(int size);

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

*/

intptr_t GetWhitespaceSize();

/** Divide each styling byte into lexical class bits (default: 5) and indicator

* bits (default: 3). If a lexer requires more than 32 lexical states, then this

* is used to expand the possible states.

*/

void SetStyleBits(int bits);

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

*/

intptr_t GetStyleBits();

/** Used to hold extra styling information for each line.

*/

void SetLineState(int line, int state);

/** Retrieve the extra styling information for a line.

*/

intptr_t GetLineState(int line);

/** Retrieve the last line number that has line state.

*/

intptr_t GetMaxLineState();

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

*/

bool GetCaretLineVisible();

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

*/

void SetCaretLineVisible(bool show);

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

*/

boost::python::tuple GetCaretLineBack();

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

*/

void SetCaretLineBack(boost::python::tuple back);

/** Set a style to be changeable or not (read only).

* Experimental feature, currently buggy.

*/

void StyleSetChangeable(int style, bool changeable);

/** Display a auto-completion list.

* The lenEntered parameter indicates how many characters before

* the caret should be used to provide context.

*/

void AutoCShow(int lenEntered, boost::python::object itemList);

/** Remove the auto-completion list from the screen.

*/

void AutoCCancel();

/** Is there an auto-completion list visible?

*/

bool AutoCActive();

/** Retrieve the position of the caret when the auto-completion list was displayed.

*/

intptr_t AutoCPosStart();

/** User has selected an item so remove the list and insert the selection.

*/

void AutoCComplete();

/** Define a set of character that when typed cancel the auto-completion list.

*/

void AutoCStops(boost::python::object characterSet);

/** Change the separator character in the string setting up an auto-completion list.

* Default is space but can be changed if items contain space.

*/

void AutoCSetSeparator(int separatorCharacter);

/** Retrieve the auto-completion list separator character.

*/

intptr_t AutoCGetSeparator();

/** Select the item in the auto-completion list that starts with a string.

*/

void AutoCSelect(boost::python::object text);

/** Should the auto-completion list be cancelled if the user backspaces to a

* position before where the box was created.

*/

void AutoCSetCancelAtStart(bool cancel);

/** Retrieve whether auto-completion cancelled by backspacing before start.

*/

bool AutoCGetCancelAtStart();

/** Define a set of characters that when typed will cause the autocompletion to

* choose the selected item.

*/

void AutoCSetFillUps(boost::python::object characterSet);

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

*/

void AutoCSetChooseSingle(bool chooseSingle);

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

*/

bool AutoCGetChooseSingle();

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

*/

void AutoCSetIgnoreCase(bool ignoreCase);

/** Retrieve state of ignore case flag.

*/

bool AutoCGetIgnoreCase();

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

*/

void UserListShow(int listType, boost::python::object itemList);

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

*/

void AutoCSetAutoHide(bool autoHide);

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

*/

bool AutoCGetAutoHide();

/** Set whether or not autocompletion deletes any word characters

* after the inserted text upon completion.

*/

void AutoCSetDropRestOfWord(bool dropRestOfWord);

/** Retrieve whether or not autocompletion deletes any word characters

* after the inserted text upon completion.

*/

bool AutoCGetDropRestOfWord();

/** Register an XPM image for use in autocompletion lists.

*/

void RegisterImage(int type, boost::python::object xpmData);

/** Clear all the registered XPM images.

*/

void ClearRegisteredImages();

/** Retrieve the auto-completion list type-separator character.

*/

intptr_t AutoCGetTypeSeparator();

/** Change the type-separator character in the string setting up an auto-completion list.

* Default is '?' but can be changed if items contain '?'.

*/

void AutoCSetTypeSeparator(int separatorCharacter);

/** Set the maximum width, in characters, of auto-completion and user lists.

* Set to 0 to autosize to fit longest item, which is the default.

*/

void AutoCSetMaxWidth(int characterCount);

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

*/

intptr_t AutoCGetMaxWidth();

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

* The default is 5 rows.

*/

void AutoCSetMaxHeight(int rowCount);

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

*/

intptr_t AutoCGetMaxHeight();

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

*/

void SetIndent(int indentSize);

/** Retrieve indentation size.

*/

intptr_t GetIndent();

/** Indentation will only use space characters if useTabs is false, otherwise

* it will use a combination of tabs and spaces.

*/

void SetUseTabs(bool useTabs);

/** Retrieve whether tabs will be used in indentation.

*/

bool GetUseTabs();

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

*/

void SetLineIndentation(int line, int indentSize);

/** Retrieve the number of columns that a line is indented.

*/

intptr_t GetLineIndentation(int line);

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

*/

intptr_t GetLineIndentPosition(int line);

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

*/

intptr_t GetColumn(int pos);

/** Count characters between two positions.

*/

intptr_t CountCharacters(int startPos, int endPos);

/** Show or hide the horizontal scroll bar.

*/

void SetHScrollBar(bool show);

/** Is the horizontal scroll bar visible?

*/

bool GetHScrollBar();

/** Show or hide indentation guides.

*/

void SetIndentationGuides(int indentView);

/** Are the indentation guides visible?

*/

intptr_t GetIndentationGuides();

/** Set the highlighted indentation guide column.

* 0 = no highlighted guide.

*/

void SetHighlightGuide(int column);

/** Get the highlighted indentation guide column.

*/

intptr_t GetHighlightGuide();

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

*/

intptr_t GetLineEndPosition(int line);

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

*/

intptr_t GetCodePage();

/** Get the foreground colour of the caret.

*/

boost::python::tuple GetCaretFore();

/** In read-only mode?

*/

bool GetReadOnly();

/** Sets the position of the caret.

*/

void SetCurrentPos(int pos);

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

*/

void SetSelectionStart(int pos);

/** Returns the position at the start of the selection.

*/

intptr_t GetSelectionStart();

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

*/

void SetSelectionEnd(int pos);

/** Returns the position at the end of the selection.

*/

intptr_t GetSelectionEnd();

/** Set caret to a position, while removing any existing selection.

*/

void SetEmptySelection(int pos);

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

*/