#include "stdafx.h"

#include "ScintillaWrapper.h"

#include "Scintilla.h"

#include "GILManager.h"

namespace NppPythonScript

{

// Helper class

class PythonCompatibleStrBuffer

{

public:

inline explicit PythonCompatibleStrBuffer(size_t length) :

m_bufferLen(length + 1),

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+1) : 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)

{

DEBUG_TRACE(L"ScintillaWrapper::AddText\n");

std::string s = getStringFromObject(text);

return callScintilla(SCI_ADDTEXT, s.size(), reinterpret_cast<LPARAM>(s.c_str()));

}

/** Add array of cells to document.

*/

int ScintillaWrapper::AddStyledText(ScintillaCells c)

{

DEBUG_TRACE(L"ScintillaWrapper::AddStyledText\n");

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

}

/** Insert string at a position.

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::InsertText\n");

std::string stringtext = getStringFromObject(text);

callScintilla(SCI_INSERTTEXT, pos, reinterpret_cast<LPARAM>(stringtext.c_str()));

}

/** Delete all text in the document.

*/

void ScintillaWrapper::ClearAll()

{

DEBUG_TRACE(L"ScintillaWrapper::ClearAll\n");

callScintilla(SCI_CLEARALL);

}

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

*/

void ScintillaWrapper::DeleteRange(int pos, int deleteLength)

{

DEBUG_TRACE(L"ScintillaWrapper::DeleteRange\n");

callScintilla(SCI_DELETERANGE, pos, deleteLength);

}

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

*/

void ScintillaWrapper::ClearDocumentStyle()

{

DEBUG_TRACE(L"ScintillaWrapper::ClearDocumentStyle\n");

callScintilla(SCI_CLEARDOCUMENTSTYLE);

}

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

*/

int ScintillaWrapper::GetLength()

{

DEBUG_TRACE(L"ScintillaWrapper::GetLength\n");

return callScintilla(SCI_GETLENGTH);

}

/** Returns the character byte at the position.

*/

int ScintillaWrapper::GetCharAt(int pos)

{

DEBUG_TRACE(L"ScintillaWrapper::GetCharAt\n");

return callScintilla(SCI_GETCHARAT, pos);

}

/** Returns the position of the caret.

*/

int ScintillaWrapper::GetCurrentPos()

{

DEBUG_TRACE(L"ScintillaWrapper::GetCurrentPos\n");

return callScintilla(SCI_GETCURRENTPOS);

}

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

*/

int ScintillaWrapper::GetAnchor()

{

DEBUG_TRACE(L"ScintillaWrapper::GetAnchor\n");

return callScintilla(SCI_GETANCHOR);

}

/** Returns the style byte at the position.

*/

int ScintillaWrapper::GetStyleAt(int pos)

{

DEBUG_TRACE(L"ScintillaWrapper::GetStyleAt\n");

return callScintilla(SCI_GETSTYLEAT, pos);

}

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

*/

void ScintillaWrapper::Redo()

{

DEBUG_TRACE(L"ScintillaWrapper::Redo\n");

callScintilla(SCI_REDO);

}

/** Choose between collecting actions into the undo

* history and discarding them.

*/

void ScintillaWrapper::SetUndoCollection(bool collectUndo)

{

DEBUG_TRACE(L"ScintillaWrapper::SetUndoCollection\n");

callScintilla(SCI_SETUNDOCOLLECTION, collectUndo);

}

/** Select all the text in the document.

*/

void ScintillaWrapper::SelectAll()

{

DEBUG_TRACE(L"ScintillaWrapper::SelectAll\n");

callScintilla(SCI_SELECTALL);

}

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

* at which the document was saved.

*/

void ScintillaWrapper::SetSavePoint()

{

DEBUG_TRACE(L"ScintillaWrapper::SetSavePoint\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::GetStyledText\n");

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

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

{

DEBUG_TRACE(L"ScintillaWrapper::CanRedo\n");

return 0 != (callScintilla(SCI_CANREDO));

}

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

*/

int ScintillaWrapper::MarkerLineFromHandle(int handle)

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerLineFromHandle\n");

return callScintilla(SCI_MARKERLINEFROMHANDLE, handle);

}

/** Delete a marker.

*/

void ScintillaWrapper::MarkerDeleteHandle(int handle)

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerDeleteHandle\n");

callScintilla(SCI_MARKERDELETEHANDLE, handle);

}

/** Is undo history being collected?

*/

bool ScintillaWrapper::GetUndoCollection()

{

DEBUG_TRACE(L"ScintillaWrapper::GetUndoCollection\n");

return 0 != (callScintilla(SCI_GETUNDOCOLLECTION));

}

/** Are white space characters currently visible?

* Returns one of SCWS_* constants.

*/

int ScintillaWrapper::GetViewWS()

{

DEBUG_TRACE(L"ScintillaWrapper::GetViewWS\n");

return callScintilla(SCI_GETVIEWWS);

}

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

*/

void ScintillaWrapper::SetViewWS(int viewWS)

{

DEBUG_TRACE(L"ScintillaWrapper::SetViewWS\n");

callScintilla(SCI_SETVIEWWS, viewWS);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::PositionFromPoint\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::PositionFromPointClose\n");

return callScintilla(SCI_POSITIONFROMPOINTCLOSE, x, y);

}

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

*/

void ScintillaWrapper::GotoLine(int line)

{

DEBUG_TRACE(L"ScintillaWrapper::GotoLine\n");

callScintilla(SCI_GOTOLINE, line);

}

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

*/

void ScintillaWrapper::GotoPos(int pos)

{

DEBUG_TRACE(L"ScintillaWrapper::GotoPos\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::SetAnchor\n");

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

{

DEBUG_TRACE(L"ScintillaWrapper::GetCurLine\n");

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

{

DEBUG_TRACE(L"ScintillaWrapper::GetEndStyled\n");

return callScintilla(SCI_GETENDSTYLED);

}

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

*/

void ScintillaWrapper::ConvertEOLs(int eolMode)

{

DEBUG_TRACE(L"ScintillaWrapper::ConvertEOLs\n");

callScintilla(SCI_CONVERTEOLS, eolMode);

}

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

*/

int ScintillaWrapper::GetEOLMode()

{

DEBUG_TRACE(L"ScintillaWrapper::GetEOLMode\n");

return callScintilla(SCI_GETEOLMODE);

}

/** Set the current end of line mode.

*/

void ScintillaWrapper::SetEOLMode(int eolMode)

{

DEBUG_TRACE(L"ScintillaWrapper::SetEOLMode\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::StartStyling\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::SetStyling\n");

callScintilla(SCI_SETSTYLING, length, style);

}

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

*/

bool ScintillaWrapper::GetBufferedDraw()

{

DEBUG_TRACE(L"ScintillaWrapper::GetBufferedDraw\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::SetBufferedDraw\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::SetTabWidth\n");

callScintilla(SCI_SETTABWIDTH, tabWidth);

}

/** Retrieve the visible size of a tab.

*/

int ScintillaWrapper::GetTabWidth()

{

DEBUG_TRACE(L"ScintillaWrapper::GetTabWidth\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::SetCodePage\n");

callScintilla(SCI_SETCODEPAGE, codePage);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerDefine\n");

callScintilla(SCI_MARKERDEFINE, markerNumber, markerSymbol);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerSetFore\n");

COLORREF rgbfore = MAKECOLOUR(fore);

callScintilla(SCI_MARKERSETFORE, markerNumber, static_cast<LPARAM>(rgbfore));

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerSetBack\n");

COLORREF rgbback = MAKECOLOUR(back);

callScintilla(SCI_MARKERSETBACK, markerNumber, static_cast<LPARAM>(rgbback));

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerSetBackSelected\n");

COLORREF rgbback = MAKECOLOUR(back);

callScintilla(SCI_MARKERSETBACKSELECTED, markerNumber, static_cast<LPARAM>(rgbback));

}

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

*/

void ScintillaWrapper::MarkerEnableHighlight(bool enabled)

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerEnableHighlight\n");

callScintilla(SCI_MARKERENABLEHIGHLIGHT, enabled);

}

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

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerAdd\n");

return callScintilla(SCI_MARKERADD, line, markerNumber);

}

/** Delete a marker from a line.

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerDelete\n");

callScintilla(SCI_MARKERDELETE, line, markerNumber);

}

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

*/

void ScintillaWrapper::MarkerDeleteAll(int markerNumber)

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerDeleteAll\n");

callScintilla(SCI_MARKERDELETEALL, markerNumber);

}

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

*/

int ScintillaWrapper::MarkerGet(int line)

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerGet\n");

return callScintilla(SCI_MARKERGET, line);

}

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

* Return -1 when no more lines.

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerNext\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerPrevious\n");

return callScintilla(SCI_MARKERPREVIOUS, lineStart, markerMask);

}

/** Define a marker from a pixmap.

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerDefinePixmap\n");

std::string stringpixmap = getStringFromObject(pixmap);

callScintilla(SCI_MARKERDEFINEPIXMAP, markerNumber, reinterpret_cast<LPARAM>(stringpixmap.c_str()));

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerAddSet\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::MarkerSetAlpha\n");

callScintilla(SCI_MARKERSETALPHA, markerNumber, alpha);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::SetMarginTypeN\n");

callScintilla(SCI_SETMARGINTYPEN, margin, marginType);

}

/** Retrieve the type of a margin.

*/

int ScintillaWrapper::GetMarginTypeN(int margin)

{

DEBUG_TRACE(L"ScintillaWrapper::GetMarginTypeN\n");

return callScintilla(SCI_GETMARGINTYPEN, margin);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::SetMarginWidthN\n");

callScintilla(SCI_SETMARGINWIDTHN, margin, pixelWidth);

}

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

*/

int ScintillaWrapper::GetMarginWidthN(int margin)

{

DEBUG_TRACE(L"ScintillaWrapper::GetMarginWidthN\n");

return callScintilla(SCI_GETMARGINWIDTHN, margin);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::SetMarginMaskN\n");

callScintilla(SCI_SETMARGINMASKN, margin, mask);

}

/** Retrieve the marker mask of a margin.

*/

int ScintillaWrapper::GetMarginMaskN(int margin)

{

DEBUG_TRACE(L"ScintillaWrapper::GetMarginMaskN\n");

return callScintilla(SCI_GETMARGINMASKN, margin);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::SetMarginSensitiveN\n");

callScintilla(SCI_SETMARGINSENSITIVEN, margin, sensitive);

}

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

*/

bool ScintillaWrapper::GetMarginSensitiveN(int margin)

{

DEBUG_TRACE(L"ScintillaWrapper::GetMarginSensitiveN\n");

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

}

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

*/

void ScintillaWrapper::SetMarginCursorN(int margin, int cursor)

{

DEBUG_TRACE(L"ScintillaWrapper::SetMarginCursorN\n");

callScintilla(SCI_SETMARGINCURSORN, margin, cursor);

}

/** Retrieve the cursor shown in a margin.

*/

int ScintillaWrapper::GetMarginCursorN(int margin)

{

DEBUG_TRACE(L"ScintillaWrapper::GetMarginCursorN\n");

return callScintilla(SCI_GETMARGINCURSORN, margin);

}

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

*/

void ScintillaWrapper::StyleClearAll()

{

DEBUG_TRACE(L"ScintillaWrapper::StyleClearAll\n");

callScintilla(SCI_STYLECLEARALL);

}

/** Set the foreground colour of a style.

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetFore\n");

COLORREF rgbfore = MAKECOLOUR(fore);

callScintilla(SCI_STYLESETFORE, style, static_cast<LPARAM>(rgbfore));

}

/** Set the background colour of a style.

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetBack\n");

COLORREF rgbback = MAKECOLOUR(back);

callScintilla(SCI_STYLESETBACK, style, static_cast<LPARAM>(rgbback));

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetBold\n");

callScintilla(SCI_STYLESETBOLD, style, bold);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetItalic\n");

callScintilla(SCI_STYLESETITALIC, style, italic);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetSize\n");

callScintilla(SCI_STYLESETSIZE, style, sizePoints);

}

/** Set the font of a style.

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetFont\n");

std::string stringfontName = getStringFromObject(fontName);

callScintilla(SCI_STYLESETFONT, style, reinterpret_cast<LPARAM>(stringfontName.c_str()));

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetEOLFilled\n");

callScintilla(SCI_STYLESETEOLFILLED, style, filled);

}

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

*/

void ScintillaWrapper::StyleResetDefault()

{

DEBUG_TRACE(L"ScintillaWrapper::StyleResetDefault\n");

callScintilla(SCI_STYLERESETDEFAULT);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetUnderline\n");

callScintilla(SCI_STYLESETUNDERLINE, style, underline);

}

/** Get the foreground colour of a style.

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetFore\n");

int retVal = (int)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)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetBack\n");

int retVal = (int)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)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetBold\n");

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

}

/** Get is a style italic or not.

*/

bool ScintillaWrapper::StyleGetItalic(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetItalic\n");

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

}

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

*/

int ScintillaWrapper::StyleGetSize(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetSize\n");

return callScintilla(SCI_STYLEGETSIZE, style);

}

/** Get the font of a style.

* Returns the length of the fontName

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetFont\n");

PythonCompatibleStrBuffer result(callScintilla(SCI_STYLEGETFONT, style));

callScintilla(SCI_STYLEGETFONT, style, 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)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetEOLFilled\n");

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

}

/** Get is a style underlined or not.

*/

bool ScintillaWrapper::StyleGetUnderline(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetUnderline\n");

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

}

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

*/

int ScintillaWrapper::StyleGetCase(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetCase\n");

return callScintilla(SCI_STYLEGETCASE, style);

}

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

*/

int ScintillaWrapper::StyleGetCharacterSet(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetCharacterSet\n");

return callScintilla(SCI_STYLEGETCHARACTERSET, style);

}

/** Get is a style visible or not.

*/

bool ScintillaWrapper::StyleGetVisible(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetVisible\n");

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

}

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

* Experimental feature, currently buggy.

*/

bool ScintillaWrapper::StyleGetChangeable(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetChangeable\n");

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

}

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

*/

bool ScintillaWrapper::StyleGetHotSpot(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetHotSpot\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetCase\n");

callScintilla(SCI_STYLESETCASE, style, caseForce);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetSizeFractional\n");

callScintilla(SCI_STYLESETSIZEFRACTIONAL, style, caseForce);

}

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

*/

int ScintillaWrapper::StyleGetSizeFractional(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetSizeFractional\n");

return callScintilla(SCI_STYLEGETSIZEFRACTIONAL, style);

}

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

*/

void ScintillaWrapper::StyleSetWeight(int style, int weight)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetWeight\n");

callScintilla(SCI_STYLESETWEIGHT, style, weight);

}

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

*/

int ScintillaWrapper::StyleGetWeight(int style)

{

DEBUG_TRACE(L"ScintillaWrapper::StyleGetWeight\n");

return callScintilla(SCI_STYLEGETWEIGHT, style);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetCharacterSet\n");

callScintilla(SCI_STYLESETCHARACTERSET, style, characterSet);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetHotSpot\n");

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)

{

DEBUG_TRACE(L"ScintillaWrapper::SetSelFore\n");

COLORREF rgbfore = MAKECOLOUR(fore);

callScintilla(SCI_SETSELFORE, useSetting, static_cast<LPARAM>(rgbfore));

}

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

{

DEBUG_TRACE(L"ScintillaWrapper::SetSelBack\n");

COLORREF rgbback = MAKECOLOUR(back);

callScintilla(SCI_SETSELBACK, useSetting, static_cast<LPARAM>(rgbback));

}

/** Get the alpha of the selection.

*/

int ScintillaWrapper::GetSelAlpha()

{

DEBUG_TRACE(L"ScintillaWrapper::GetSelAlpha\n");

return callScintilla(SCI_GETSELALPHA);

}

/** Set the alpha of the selection.

*/

void ScintillaWrapper::SetSelAlpha(int alpha)

{

DEBUG_TRACE(L"ScintillaWrapper::SetSelAlpha\n");

callScintilla(SCI_SETSELALPHA, alpha);

}

/** Is the selection end of line filled?

*/

bool ScintillaWrapper::GetSelEOLFilled()

{

DEBUG_TRACE(L"ScintillaWrapper::GetSelEOLFilled\n");

return 0 != (callScintilla(SCI_GETSELEOLFILLED));

}

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

*/

void ScintillaWrapper::SetSelEOLFilled(bool filled)

{

DEBUG_TRACE(L"ScintillaWrapper::SetSelEOLFilled\n");

callScintilla(SCI_SETSELEOLFILLED, filled);

}

/** Set the foreground colour of the caret.

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::SetCaretFore\n");

COLORREF rgbfore = MAKECOLOUR(fore);

callScintilla(SCI_SETCARETFORE, static_cast<WPARAM>(rgbfore));

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::AssignCmdKey\n");

callScintilla(SCI_ASSIGNCMDKEY, km, msg);

}

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

*/

void ScintillaWrapper::ClearCmdKey(int km)

{

DEBUG_TRACE(L"ScintillaWrapper::ClearCmdKey\n");

callScintilla(SCI_CLEARCMDKEY, km);

}

/** Drop all key mappings.

*/

void ScintillaWrapper::ClearAllCmdKeys()

{

DEBUG_TRACE(L"ScintillaWrapper::ClearAllCmdKeys\n");

callScintilla(SCI_CLEARALLCMDKEYS);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::SetStylingEx\n");

std::string s = getStringFromObject(styles);

return callScintilla(SCI_SETSTYLINGEX, s.size(), reinterpret_cast<LPARAM>(s.c_str()));

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::StyleSetVisible\n");

callScintilla(SCI_STYLESETVISIBLE, style, visible);

}

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

*/

int ScintillaWrapper::GetCaretPeriod()

{

DEBUG_TRACE(L"ScintillaWrapper::GetCaretPeriod\n");

return callScintilla(SCI_GETCARETPERIOD);

}

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

*/

void ScintillaWrapper::SetCaretPeriod(int periodMilliseconds)

{

DEBUG_TRACE(L"ScintillaWrapper::SetCaretPeriod\n");

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::object characters)

{

DEBUG_TRACE(L"ScintillaWrapper::SetWordChars\n");

std::string stringcharacters = getStringFromObject(characters);

callScintilla(SCI_SETWORDCHARS, 0, reinterpret_cast<LPARAM>(stringcharacters.c_str()));

}

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

* Retuns the number of characters

*/

boost::python::str ScintillaWrapper::GetWordChars()

{

DEBUG_TRACE(L"ScintillaWrapper::GetWordChars\n");

PythonCompatibleStrBuffer result(callScintilla(SCI_GETWORDCHARS));

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

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

}

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

* May be nested.

*/

void ScintillaWrapper::BeginUndoAction()

{

DEBUG_TRACE(L"ScintillaWrapper::BeginUndoAction\n");

callScintilla(SCI_BEGINUNDOACTION);

}

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

*/

void ScintillaWrapper::EndUndoAction()

{

DEBUG_TRACE(L"ScintillaWrapper::EndUndoAction\n");

callScintilla(SCI_ENDUNDOACTION);

}

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

*/

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

{

DEBUG_TRACE(L"ScintillaWrapper::IndicSetStyle\n");

callScintilla(SCI_INDICSETSTYLE, indic, style);

}

/** Retrieve the style of an indicator.

*/

int ScintillaWrapper::IndicGetStyle(int indic)

{

DEBUG_TRACE(L"ScintillaWrapper::IndicGetStyle\n");

return callScintilla(SCI_INDICGETSTYLE, indic);

}