#include "stdafx.h"

#include "ScintillaWrapper.h"

#include "Scintilla.h"

// Helper class

class PythonCompatibleStrBuffer

{

public:

inline explicit PythonCompatibleStrBuffer(size_t length) :

m_bufferLen(length),

m_bufferPtr(new char[m_bufferLen])

{

if (m_bufferPtr && m_bufferLen > 0) m_bufferPtr[m_bufferLen-1] = '\0';

}

inline explicit PythonCompatibleStrBuffer(int length) :

m_bufferLen(length>=0?(size_t)length:0),

m_bufferPtr(new char[m_bufferLen])

{

if (m_bufferPtr && m_bufferLen > 0) m_bufferPtr[m_bufferLen-1] = '\0';

}

inline ~PythonCompatibleStrBuffer() { delete [] m_bufferPtr; }

inline char* operator*() { return m_bufferPtr; }

inline const char* c_str() const { return m_bufferPtr; }

inline size_t size() const { return m_bufferLen; }

private:

PythonCompatibleStrBuffer(); // default constructor disabled

PythonCompatibleStrBuffer(const PythonCompatibleStrBuffer&); // copy constructor disabled

PythonCompatibleStrBuffer& operator = (const PythonCompatibleStrBuffer&); // Disable assignment operator disabled

size_t m_bufferLen;

char* m_bufferPtr;

};

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

*/

int ScintillaWrapper::AddText(boost::python::object text)

{

const char *raw = boost::python::extract<const char *>(text.attr("__str__")());

return callScintilla(SCI_ADDTEXT, _len(text), reinterpret_cast<LPARAM>(raw));

}

/** Add array of cells to document.

*/

int ScintillaWrapper::AddStyledText(ScintillaCells c)

{

return callScintilla(SCI_ADDSTYLEDTEXT, c.length(), reinterpret_cast<LPARAM>(c.cells()));

}

/** Insert string at a position.

*/

void ScintillaWrapper::InsertText(int pos, boost::python::str text)

{

callScintilla(SCI_INSERTTEXT, pos, reinterpret_cast<LPARAM>(static_cast<const char*>(boost::python::extract<const char *>(text))));

}

/** Delete all text in the document.

*/

void ScintillaWrapper::ClearAll()

{

callScintilla(SCI_CLEARALL);

}

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

*/

void ScintillaWrapper::ClearDocumentStyle()

{

callScintilla(SCI_CLEARDOCUMENTSTYLE);

}

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

*/

int ScintillaWrapper::GetLength()

{

return callScintilla(SCI_GETLENGTH);

}

/** Returns the character byte at the position.

*/

int ScintillaWrapper::GetCharAt(int pos)

{

return callScintilla(SCI_GETCHARAT, pos);

}

/** Returns the position of the caret.

*/

int ScintillaWrapper::GetCurrentPos()

{

return callScintilla(SCI_GETCURRENTPOS);

}

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

*/

int ScintillaWrapper::GetAnchor()

{

return callScintilla(SCI_GETANCHOR);

}

/** Returns the style byte at the position.

*/

int ScintillaWrapper::GetStyleAt(int pos)

{

return callScintilla(SCI_GETSTYLEAT, pos);

}

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

*/

void ScintillaWrapper::Redo()

{

callScintilla(SCI_REDO);

}

/** Choose between collecting actions into the undo

* history and discarding them.

*/

void ScintillaWrapper::SetUndoCollection(bool collectUndo)

{

callScintilla(SCI_SETUNDOCOLLECTION, collectUndo);

}

/** Select all the text in the document.

*/

void ScintillaWrapper::SelectAll()

{

callScintilla(SCI_SELECTALL);

}

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

* at which the document was saved.

*/

void ScintillaWrapper::SetSavePoint()

{

callScintilla(SCI_SETSAVEPOINT);

}

/** Retrieve a buffer of cells.

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

*/

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

{

Sci_TextRange src;

if (end < start)

{

int temp = start;

start = end;

end = temp;

}

src.chrg.cpMin = start;

src.chrg.cpMax = end;

src.lpstrText = new char[size_t(((end-start) * 2) + 2)];

callScintilla(SCI_GETSTYLEDTEXT, 0, reinterpret_cast<LPARAM>(&src));

boost::python::list styles;

PythonCompatibleStrBuffer result((end-start) + 1);

for(idx_t pos = 0; pos < result.size() - 1; pos++)

{

(*result)[pos] = src.lpstrText[pos * 2];

styles.append((int)(src.lpstrText[(pos * 2) + 1]));

}

boost::python::str resultStr(result.c_str());

delete [] src.lpstrText;

return boost::python::make_tuple(resultStr, styles);

}

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

*/

bool ScintillaWrapper::CanRedo()

{

return 0 != (callScintilla(SCI_CANREDO));

}

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

*/

int ScintillaWrapper::MarkerLineFromHandle(int handle)

{

return callScintilla(SCI_MARKERLINEFROMHANDLE, handle);

}

/** Delete a marker.

*/

void ScintillaWrapper::MarkerDeleteHandle(int handle)

{

callScintilla(SCI_MARKERDELETEHANDLE, handle);

}

/** Is undo history being collected?

*/

bool ScintillaWrapper::GetUndoCollection()

{

return 0 != (callScintilla(SCI_GETUNDOCOLLECTION));

}

/** Are white space characters currently visible?

* Returns one of SCWS_* constants.

*/

int ScintillaWrapper::GetViewWS()

{

return callScintilla(SCI_GETVIEWWS);

}

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

*/

void ScintillaWrapper::SetViewWS(int viewWS)

{

callScintilla(SCI_SETVIEWWS, viewWS);

}

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

*/

int ScintillaWrapper::PositionFromPoint(int x, int y)

{

return callScintilla(SCI_POSITIONFROMPOINT, x, y);

}

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

* INVALID_POSITION if not close to text.

*/

int ScintillaWrapper::PositionFromPointClose(int x, int y)

{

return callScintilla(SCI_POSITIONFROMPOINTCLOSE, x, y);

}

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

*/

void ScintillaWrapper::GotoLine(int line)

{

callScintilla(SCI_GOTOLINE, line);

}

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

*/

void ScintillaWrapper::GotoPos(int pos)

{

callScintilla(SCI_GOTOPOS, pos);

}

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

* end of the selection from the caret.

*/

void ScintillaWrapper::SetAnchor(int posAnchor)

{

callScintilla(SCI_SETANCHOR, posAnchor);

}

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

* Returns the index of the caret on the line.

*/

boost::python::str ScintillaWrapper::GetCurLine()

{

PythonCompatibleStrBuffer result(callScintilla(SCI_GETCURLINE) + 1);

// result.size() does not depend on the order of evaluation here

//lint -e{864}

callScintilla(SCI_GETCURLINE, result.size(), reinterpret_cast<LPARAM>(*result));

return boost::python::str(result.c_str());

}

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

*/

int ScintillaWrapper::GetEndStyled()

{

return callScintilla(SCI_GETENDSTYLED);

}

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

*/

void ScintillaWrapper::ConvertEOLs(int eolMode)

{

callScintilla(SCI_CONVERTEOLS, eolMode);

}

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

*/

int ScintillaWrapper::GetEOLMode()

{

return callScintilla(SCI_GETEOLMODE);

}

/** Set the current end of line mode.

*/

void ScintillaWrapper::SetEOLMode(int eolMode)

{

callScintilla(SCI_SETEOLMODE, 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 ScintillaWrapper::StartStyling(int pos, int mask)

{

callScintilla(SCI_STARTSTYLING, pos, 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 ScintillaWrapper::SetStyling(int length, int style)

{

callScintilla(SCI_SETSTYLING, length, style);

}

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

*/

bool ScintillaWrapper::GetBufferedDraw()

{

return 0 != (callScintilla(SCI_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 ScintillaWrapper::SetBufferedDraw(bool buffered)

{

callScintilla(SCI_SETBUFFEREDDRAW, buffered);

}

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

*/

void ScintillaWrapper::SetTabWidth(int tabWidth)

{

callScintilla(SCI_SETTABWIDTH, tabWidth);

}

/** Retrieve the visible size of a tab.

*/

int ScintillaWrapper::GetTabWidth()

{

return callScintilla(SCI_GETTABWIDTH);

}

/** 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 ScintillaWrapper::SetCodePage(int codePage)

{

callScintilla(SCI_SETCODEPAGE, codePage);

}

/** In palette mode, Scintilla uses the environment's palette calls to display

* more colours. This may lead to ugly displays.

*/

void ScintillaWrapper::SetUsePalette(bool usePalette)

{

callScintilla(SCI_SETUSEPALETTE, usePalette);

}

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

*/

void ScintillaWrapper::MarkerDefine(int markerNumber, int markerSymbol)

{

callScintilla(SCI_MARKERDEFINE, markerNumber, markerSymbol);

}

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

*/

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

{

callScintilla(SCI_MARKERSETFORE, markerNumber, MAKECOLOUR(fore));

}

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

*/

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

{

callScintilla(SCI_MARKERSETBACK, markerNumber, MAKECOLOUR(back));

}

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

*/

int ScintillaWrapper::MarkerAdd(int line, int markerNumber)

{

return callScintilla(SCI_MARKERADD, line, markerNumber);

}

/** Delete a marker from a line.

*/

void ScintillaWrapper::MarkerDelete(int line, int markerNumber)

{

callScintilla(SCI_MARKERDELETE, line, markerNumber);

}

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

*/

void ScintillaWrapper::MarkerDeleteAll(int markerNumber)

{

callScintilla(SCI_MARKERDELETEALL, markerNumber);

}

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

*/

int ScintillaWrapper::MarkerGet(int line)

{

return callScintilla(SCI_MARKERGET, line);

}

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

*/

int ScintillaWrapper::MarkerNext(int lineStart, int markerMask)

{

return callScintilla(SCI_MARKERNEXT, lineStart, markerMask);

}

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

*/

int ScintillaWrapper::MarkerPrevious(int lineStart, int markerMask)

{

return callScintilla(SCI_MARKERPREVIOUS, lineStart, markerMask);

}

/** Define a marker from a pixmap.

*/

void ScintillaWrapper::MarkerDefinePixmap(int markerNumber, boost::python::str pixmap)

{

callScintilla(SCI_MARKERDEFINEPIXMAP, markerNumber, reinterpret_cast<LPARAM>(static_cast<const char*>(boost::python::extract<const char *>(pixmap))));

}

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

*/

void ScintillaWrapper::MarkerAddSet(int line, int set)

{

callScintilla(SCI_MARKERADDSET, line, set);

}

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

*/

void ScintillaWrapper::MarkerSetAlpha(int markerNumber, int alpha)

{

callScintilla(SCI_MARKERSETALPHA, markerNumber, alpha);

}

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

*/

void ScintillaWrapper::SetMarginTypeN(int margin, int marginType)

{

callScintilla(SCI_SETMARGINTYPEN, margin, marginType);

}

/** Retrieve the type of a margin.

*/

int ScintillaWrapper::GetMarginTypeN(int margin)

{

return callScintilla(SCI_GETMARGINTYPEN, margin);

}

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

*/

void ScintillaWrapper::SetMarginWidthN(int margin, int pixelWidth)

{

callScintilla(SCI_SETMARGINWIDTHN, margin, pixelWidth);

}

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

*/

int ScintillaWrapper::GetMarginWidthN(int margin)

{

return callScintilla(SCI_GETMARGINWIDTHN, margin);

}

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

*/

void ScintillaWrapper::SetMarginMaskN(int margin, int mask)

{

callScintilla(SCI_SETMARGINMASKN, margin, mask);

}

/** Retrieve the marker mask of a margin.

*/

int ScintillaWrapper::GetMarginMaskN(int margin)

{

return callScintilla(SCI_GETMARGINMASKN, margin);

}

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

*/

void ScintillaWrapper::SetMarginSensitiveN(int margin, bool sensitive)

{

callScintilla(SCI_SETMARGINSENSITIVEN, margin, sensitive);

}

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

*/

bool ScintillaWrapper::GetMarginSensitiveN(int margin)

{

return 0 != (callScintilla(SCI_GETMARGINSENSITIVEN, margin));

}

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

*/

void ScintillaWrapper::StyleClearAll()

{

callScintilla(SCI_STYLECLEARALL);

}

/** Set the foreground colour of a style.

*/

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

{

callScintilla(SCI_STYLESETFORE, style, MAKECOLOUR(fore));

}

/** Set the background colour of a style.

*/

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

{

callScintilla(SCI_STYLESETBACK, style, MAKECOLOUR(back));

}

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

*/

void ScintillaWrapper::StyleSetBold(int style, bool bold)

{

callScintilla(SCI_STYLESETBOLD, style, bold);

}

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

*/

void ScintillaWrapper::StyleSetItalic(int style, bool italic)

{

callScintilla(SCI_STYLESETITALIC, style, italic);

}

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

*/

void ScintillaWrapper::StyleSetSize(int style, int sizePoints)

{

callScintilla(SCI_STYLESETSIZE, style, sizePoints);

}

/** Set the font of a style.

*/

void ScintillaWrapper::StyleSetFont(int style, boost::python::str fontName)

{

callScintilla(SCI_STYLESETFONT, style, reinterpret_cast<LPARAM>(static_cast<const char*>(boost::python::extract<const char *>(fontName))));

}

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

*/

void ScintillaWrapper::StyleSetEOLFilled(int style, bool filled)

{

callScintilla(SCI_STYLESETEOLFILLED, style, filled);

}

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

*/

void ScintillaWrapper::StyleResetDefault()

{

callScintilla(SCI_STYLERESETDEFAULT);

}

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

*/

void ScintillaWrapper::StyleSetUnderline(int style, bool underline)

{

callScintilla(SCI_STYLESETUNDERLINE, style, underline);

}

/** Get the foreground colour of a style.

*/

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

{

int retVal = callScintilla(callScintilla(SCI_STYLEGETFORE, style));

return boost::python::make_tuple(COLOUR_RED(retVal), COLOUR_GREEN(retVal), COLOUR_BLUE(retVal));

}

/** Get the background colour of a style.

*/

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

{

int retVal = callScintilla(callScintilla(SCI_STYLEGETBACK, style));

return boost::python::make_tuple(COLOUR_RED(retVal), COLOUR_GREEN(retVal), COLOUR_BLUE(retVal));

}

/** Get is a style bold or not.

*/

bool ScintillaWrapper::StyleGetBold(int style)

{

return 0 != (callScintilla(SCI_STYLEGETBOLD, style));

}

/** Get is a style italic or not.

*/

bool ScintillaWrapper::StyleGetItalic(int style)

{

return 0 != (callScintilla(SCI_STYLEGETITALIC, style));

}

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

*/

int ScintillaWrapper::StyleGetSize(int style)

{

return callScintilla(SCI_STYLEGETSIZE, style);

}

/** Get the font of a style.

* Returns the length of the fontName

*/

boost::python::str ScintillaWrapper::StyleGetFont()

{

PythonCompatibleStrBuffer result(callScintilla(SCI_STYLEGETFONT));

callScintilla(SCI_STYLEGETFONT, 0, reinterpret_cast<LPARAM>(*result));

return boost::python::str(result.c_str());

}

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

*/

bool ScintillaWrapper::StyleGetEOLFilled(int style)

{

return 0 != (callScintilla(SCI_STYLEGETEOLFILLED, style));

}

/** Get is a style underlined or not.

*/

bool ScintillaWrapper::StyleGetUnderline(int style)

{

return 0 != (callScintilla(SCI_STYLEGETUNDERLINE, style));

}

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

*/

int ScintillaWrapper::StyleGetCase(int style)

{

return callScintilla(SCI_STYLEGETCASE, style);

}

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

*/

int ScintillaWrapper::StyleGetCharacterSet(int style)

{

return callScintilla(SCI_STYLEGETCHARACTERSET, style);

}

/** Get is a style visible or not.

*/

bool ScintillaWrapper::StyleGetVisible(int style)

{

return 0 != (callScintilla(SCI_STYLEGETVISIBLE, style));

}

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

* Experimental feature, currently buggy.

*/

bool ScintillaWrapper::StyleGetChangeable(int style)

{

return 0 != (callScintilla(SCI_STYLEGETCHANGEABLE, style));

}

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

*/

bool ScintillaWrapper::StyleGetHotSpot(int style)

{

return 0 != (callScintilla(SCI_STYLEGETHOTSPOT, style));

}

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

*/

void ScintillaWrapper::StyleSetCase(int style, int caseForce)

{

callScintilla(SCI_STYLESETCASE, style, caseForce);

}

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

*/

void ScintillaWrapper::StyleSetCharacterSet(int style, int characterSet)

{

callScintilla(SCI_STYLESETCHARACTERSET, style, characterSet);

}

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

*/

void ScintillaWrapper::StyleSetHotSpot(int style, bool hotspot)

{

callScintilla(SCI_STYLESETHOTSPOT, style, hotspot);

}

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

*/

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

{

callScintilla(SCI_SETSELFORE, useSetting, MAKECOLOUR(fore));

}

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

*/

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

{

callScintilla(SCI_SETSELBACK, useSetting, MAKECOLOUR(back));

}

/** Get the alpha of the selection.

*/

int ScintillaWrapper::GetSelAlpha()

{

return callScintilla(SCI_GETSELALPHA);

}

/** Set the alpha of the selection.

*/

void ScintillaWrapper::SetSelAlpha(int alpha)

{

callScintilla(SCI_SETSELALPHA, alpha);

}

/** Is the selection end of line filled?

*/

bool ScintillaWrapper::GetSelEOLFilled()

{

return 0 != (callScintilla(SCI_GETSELEOLFILLED));

}

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

*/

void ScintillaWrapper::SetSelEOLFilled(bool filled)

{

callScintilla(SCI_SETSELEOLFILLED, filled);

}

/** Set the foreground colour of the caret.

*/

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

{

callScintilla(SCI_SETCARETFORE, MAKECOLOUR(fore));

}

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

*/

void ScintillaWrapper::AssignCmdKey(int km, int msg)

{

callScintilla(SCI_ASSIGNCMDKEY, km, msg);

}

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

*/

void ScintillaWrapper::ClearCmdKey(int km)

{

callScintilla(SCI_CLEARCMDKEY, km);

}

/** Drop all key mappings.

*/

void ScintillaWrapper::ClearAllCmdKeys()

{

callScintilla(SCI_CLEARALLCMDKEYS);

}

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

*/

int ScintillaWrapper::SetStylingEx(boost::python::object styles)

{

const char *raw = boost::python::extract<const char *>(styles.attr("__str__")());

return callScintilla(SCI_SETSTYLINGEX, _len(styles), reinterpret_cast<LPARAM>(raw));

}

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

*/

void ScintillaWrapper::StyleSetVisible(int style, bool visible)

{

callScintilla(SCI_STYLESETVISIBLE, style, visible);

}

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

*/

int ScintillaWrapper::GetCaretPeriod()

{

return callScintilla(SCI_GETCARETPERIOD);

}

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

*/

void ScintillaWrapper::SetCaretPeriod(int periodMilliseconds)

{

callScintilla(SCI_SETCARETPERIOD, periodMilliseconds);

}

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

* First sets defaults like SetCharsDefault.

*/

void ScintillaWrapper::SetWordChars(boost::python::str characters)

{

callScintilla(SCI_SETWORDCHARS, 0, reinterpret_cast<LPARAM>(static_cast<const char*>(boost::python::extract<const char *>(characters))));

}

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

* May be nested.

*/

void ScintillaWrapper::BeginUndoAction()

{

callScintilla(SCI_BEGINUNDOACTION);

}

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

*/

void ScintillaWrapper::EndUndoAction()

{

callScintilla(SCI_ENDUNDOACTION);

}

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

*/

void ScintillaWrapper::IndicSetStyle(int indic, int style)

{

callScintilla(SCI_INDICSETSTYLE, indic, style);

}

/** Retrieve the style of an indicator.

*/

int ScintillaWrapper::IndicGetStyle(int indic)

{

return callScintilla(SCI_INDICGETSTYLE, indic);

}

/** Set the foreground colour of an indicator.

*/

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

{

callScintilla(SCI_INDICSETFORE, indic, MAKECOLOUR(fore));

}

/** Retrieve the foreground colour of an indicator.

*/

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

{

int retVal = callScintilla(callScintilla(SCI_INDICGETFORE, indic));

return boost::python::make_tuple(COLOUR_RED(retVal), COLOUR_GREEN(retVal), COLOUR_BLUE(retVal));

}

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

*/

void ScintillaWrapper::IndicSetUnder(int indic, bool under)

{

callScintilla(SCI_INDICSETUNDER, indic, under);

}

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

*/

bool ScintillaWrapper::IndicGetUnder(int indic)

{

return 0 != (callScintilla(SCI_INDICGETUNDER, indic));

}

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

*/

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

{

callScintilla(SCI_SETWHITESPACEFORE, useSetting, MAKECOLOUR(fore));

}

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

*/

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

{

callScintilla(SCI_SETWHITESPACEBACK, useSetting, MAKECOLOUR(back));

}

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

*/

void ScintillaWrapper::SetWhitespaceSize(int size)

{

callScintilla(SCI_SETWHITESPACESIZE, size);

}

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

*/

int ScintillaWrapper::GetWhitespaceSize()

{

return callScintilla(SCI_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 ScintillaWrapper::SetStyleBits(int bits)

{

callScintilla(SCI_SETSTYLEBITS, bits);

}

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

*/

int ScintillaWrapper::GetStyleBits()

{

return callScintilla(SCI_GETSTYLEBITS);

}

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

*/

void ScintillaWrapper::SetLineState(int line, int state)

{

callScintilla(SCI_SETLINESTATE, line, state);

}

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

*/

int ScintillaWrapper::GetLineState(int line)

{

return callScintilla(SCI_GETLINESTATE, line);

}

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

*/

int ScintillaWrapper::GetMaxLineState()

{

return callScintilla(SCI_GETMAXLINESTATE);

}

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

*/

bool ScintillaWrapper::GetCaretLineVisible()

{

return 0 != (callScintilla(SCI_GETCARETLINEVISIBLE));

}

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

*/

void ScintillaWrapper::SetCaretLineVisible(bool show)

{

callScintilla(SCI_SETCARETLINEVISIBLE, show);

}

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

*/

boost::python::tuple ScintillaWrapper::GetCaretLineBack()

{

int retVal = callScintilla(callScintilla(SCI_GETCARETLINEBACK));

return boost::python::make_tuple(COLOUR_RED(retVal), COLOUR_GREEN(retVal), COLOUR_BLUE(retVal));

}

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

*/

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

{

callScintilla(SCI_SETCARETLINEBACK, MAKECOLOUR(back));

}

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

* Experimental feature, currently buggy.

*/

void ScintillaWrapper::StyleSetChangeable(int style, bool changeable)

{

callScintilla(SCI_STYLESETCHANGEABLE, style, changeable);

}

/** Display a auto-completion list.

* The lenEntered parameter indicates how many characters before

* the caret should be used to provide context.

*/

void ScintillaWrapper::AutoCShow(int lenEntered, boost::python::str itemList)

{

callScintilla(SCI_AUTOCSHOW, lenEntered, reinterpret_cast<LPARAM>(static_cast<const char*>(boost::python::extract<const char *>(itemList))));

}

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

*/

void ScintillaWrapper::AutoCCancel()

{

callScintilla(SCI_AUTOCCANCEL);

}

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

*/

bool ScintillaWrapper::AutoCActive()

{

return 0 != (callScintilla(SCI_AUTOCACTIVE));

}

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

*/

int ScintillaWrapper::AutoCPosStart()

{

return callScintilla(SCI_AUTOCPOSSTART);

}

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

*/

void ScintillaWrapper::AutoCComplete()

{

callScintilla(SCI_AUTOCCOMPLETE);

}

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

*/

void ScintillaWrapper::AutoCStops(boost::python::str characterSet)

{

callScintilla(SCI_AUTOCSTOPS, 0, reinterpret_cast<LPARAM>(static_cast<const char*>(boost::python::extract<const char *>(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 ScintillaWrapper::AutoCSetSeparator(int separatorCharacter)

{

callScintilla(SCI_AUTOCSETSEPARATOR, separatorCharacter);

}

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

*/

int ScintillaWrapper::AutoCGetSeparator()

{

return callScintilla(SCI_AUTOCGETSEPARATOR);

}

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

*/

void ScintillaWrapper::AutoCSelect(boost::python::str text)

{