#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(boost::python::object callback, boost::python::list events);

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

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

void clearAllCallbacks();

void clearCallbackFunction(boost::python::object callback);

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

void clearCallback(boost::python::object 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(intptr_t start, intptr_t 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);

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

/** Flash the editor by reversing foreground and background colours

*/

void flash() { flashMilliseconds(50); }

void flashMilliseconds(int milliseconds);

/* ++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(Sci_Position 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(Sci_Position start, Sci_Position lengthDelete);

/** 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(Sci_Position 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(Sci_Position pos);

/** Returns the unsigned style byte at the position.

*/

intptr_t GetStyleIndexAt(Sci_Position 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(Sci_PositionCR start, Sci_PositionCR 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 markerHandle);

/** Delete a marker.

*/

void MarkerDeleteHandle(int markerHandle);

/** Retrieve marker handles of a line

*/

intptr_t MarkerHandleFromLine(intptr_t line, int which);

/** Retrieve marker number of a marker handle

*/

intptr_t MarkerNumberFromLine(intptr_t line, int which);

/** Is undo history being collected?

*/

bool GetUndoCollection();

/** Are white space characters currently visible?

* Returns one of SCWS_* constants.

*/

int GetViewWS();

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

*/

void SetViewWS(int viewWS);

/** Retrieve the current tab draw mode.

* Returns one of SCTD_* constants.

*/

int GetTabDrawMode();

/** Set how tabs are drawn when visible.

*/

void SetTabDrawMode(int tabDrawMode);

/** 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(intptr_t line);

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

*/

void GotoPos(Sci_Position caret);

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

* end of the selection from the caret.

*/

void SetAnchor(Sci_Position anchor);

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

*/

int GetEOLMode();

/** Set the current end of line mode.

*/

void SetEOLMode(int eolMode);

/** Set the current styling position to start.

* The unused parameter is no longer used and should be set to 0.

*/

void StartStyling(Sci_Position start, int unused);

/** 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(Sci_Position 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();

/** Set the minimum visual width of a tab.

*/

void SetTabMinimumWidth(int pixels);

/** Get the minimum visual width of a tab.

*/

intptr_t GetTabMinimumWidth();

/** Clear explicit tabstops on a line.

*/

void ClearTabStops(intptr_t line);

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

*/

void AddTabStop(intptr_t line, int x);

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

*/

intptr_t GetNextTabStop(intptr_t 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);

/** Set the locale for displaying text.

*/

void SetFontLocale(boost::python::object localeName);

/** Get the locale for displaying text.

*/

boost::python::str GetFontLocale();

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

*/

int GetIMEInteraction();

/** Choose to display the IME in a window 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);

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

*/

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

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

*/

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

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

*/

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

/** Set the width of strokes used in .01 pixels so 50 = 1/2 pixel width.

*/

void MarkerSetStrokeWidth(int markerNumber, int hundredths);

/** Enable/disable highlight for current folding block (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(intptr_t line, int markerNumber);

/** Delete a marker from a line.

*/

void MarkerDelete(intptr_t 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(intptr_t line);

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

* Return -1 when no more lines.

*/

intptr_t MarkerNext(intptr_t lineStart, int markerMask);

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

*/

intptr_t MarkerPrevious(intptr_t 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(intptr_t line, int markerSet);

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

*/

void MarkerSetAlpha(int markerNumber, int alpha);

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

*/

int MarkerGetLayer(int markerNumber);

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

*/

void MarkerSetLayer(int markerNumber, int layer);

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

*/

void SetMarginTypeN(int margin, int marginType);

/** Retrieve the type of a margin.

*/

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

*/

int GetMarginCursorN(int margin);

/** Set the background colour of a margin. Only visible for SC_MARGIN_COLOUR.

*/

void SetMarginBackN(int margin, boost::python::tuple back);

/** Retrieve the background colour of a margin

*/

boost::python::tuple GetMarginBackN(int margin);

/** Allocate a non-standard number of margins.

*/

void SetMargins(int margins);

/** How many margins are there?.

*/

intptr_t GetMargins();

/** 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 eolFilled);

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

*/

int StyleGetCase(int style);

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

*/

int 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 caseVisible);

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

*/

void StyleSetSizeFractional(int style, int sizeHundredthPoints);

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

*/

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

/** Indicate that a style may be monospaced over ASCII graphics characters which enables optimizations.

*/

void StyleSetCheckMonospaced(int style, bool checkMonospaced);

/** Get whether a style may be monospaced.

*/

bool StyleGetCheckMonospaced(int style);

/** Set the colour of an element. Translucency (alpha) may or may not be significant

* and this may depend on the platform. The alpha byte should commonly be 0xff for opaque.

*/

void SetElementColour(int element, boost::python::tuple colourElement);

/** Get the colour of an element.

*/

boost::python::tuple GetElementColour(int element);

/** Use the default or platform-defined colour for an element.

*/

void ResetElementColour(int element);

/** Get whether an element has been set by SetElementColour.

* When false, a platform-defined or default colour is used.

*/

bool GetElementIsSet(int element);

/** Get whether an element supports translucency.

*/

bool GetElementAllowsTranslucent(int element);

/** Get the colour of an element.

*/

boost::python::tuple GetElementBaseColour(int element);

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

*/

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

/** Get the layer for drawing selections

*/

int GetSelectionLayer();

/** Set the layer for drawing selections: either opaquely on base layer or translucently over text

*/

void SetSelectionLayer(int layer);

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

*/

int GetCaretLineLayer();

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

*/

void SetCaretLineLayer(int layer);

/** Get only highlighting subline instead of whole line.

*/

bool GetCaretLineHighlightSubLine();

/** Set only highlighting subline instead of whole line.

*/

void SetCaretLineHighlightSubLine(bool subLine);

/** Set the foreground colour of the caret.

*/

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

/** When key+modifier combination keyDefinition is pressed perform sciCommand.

*/

void AssignCmdKey(int keyDefinition, int sciCommand);

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

*/

void ClearCmdKey(int keyDefinition);

/** 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();

/** Set the number of characters to have directly indexed categories

*/

void SetCharacterCategoryOptimization(int countCharacters);

/** Get the number of characters to have directly indexed categories

*/

intptr_t GetCharacterCategoryOptimization();

/** 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 indicator, int indicatorStyle);

/** Retrieve the style of an indicator.

*/

int IndicGetStyle(int indicator);

/** Set the foreground colour of an indicator.

*/

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

/** Retrieve the foreground colour of an indicator.

*/

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

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

*/

void IndicSetUnder(int indicator, bool under);

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

*/

bool IndicGetUnder(int indicator);

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

*/

void IndicSetHoverStyle(int indicator, int indicatorStyle);

/** Retrieve the hover style of an indicator.

*/

int IndicGetHoverStyle(int indicator);

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

*/

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

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

*/

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

/** Set the attributes of an indicator.

*/

void IndicSetFlags(int indicator, int flags);

/** Retrieve the attributes of an indicator.

*/

int IndicGetFlags(int indicator);

/** Set the stroke width of an indicator in hundredths of a pixel.

*/

void IndicSetStrokeWidth(int indicator, int hundredths);

/** Retrieve the stroke width of an indicator.

*/

intptr_t IndicGetStrokeWidth(int indicator);

/** 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();

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

*/

void SetLineState(intptr_t line, int state);

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

*/

intptr_t GetLineState(intptr_t 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);

/** Retrieve the caret line frame width.

* Width = 0 means this option is disabled.

*/

intptr_t GetCaretLineFrame();

/** Display the caret line framed.

* Set width != 0 to enable this option and width = 0 to disable it.

*/

void SetCaretLineFrame(int width);

/** 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 lengthEntered parameter indicates how many characters before

* the caret should be used to provide context.

*/

void AutoCShow(Sci_Position lengthEntered, 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 select);

/** 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 autocompletion options.

*/

void AutoCSetOptions(int options);

/** Retrieve autocompletion options.

*/

int AutoCGetOptions();

/** 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);