#ifndef _SCINTILLAWRAPPER_H

#define _SCINTILLAWRAPPER_H

#include "stdafx.h"

#include "ScintillaNotifications.h"

#include "ScintillaCells.h"

#include "Enums.h"

#include "PyProducerConsumer.h"

#include <exception>

using namespace boost::python;

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

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

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

#define MAKECOLOUR(x) ((extract<int>(x[0])) | (extract<int>(x[1])) << 8 | (extract<int>(x[2])) << 16)

struct out_of_bounds_exception : std::exception

{

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

};

namespace PythonScript

{

void translateOutOfBounds(out_of_bounds_exception const& e);

}

struct CallbackExecArgs;

class ScintillaWrapper : public NppPythonScript::PyProducerConsumer<CallbackExecArgs*>

{

public:

ScintillaWrapper(HWND handle);

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

void clearAllCallbacks();

void clearCallbackFunction(PyObject* callback);

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

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

void consume(CallbackExecArgs *);

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

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

void replaceNoFlags(boost::python::object searchStr, boost::python::object replaceStr)

{ replace(searchStr, replaceStr, object()); };

void rereplace(boost::python::object searchExp, boost::python::object replaceStr, boost::python::object flags);

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

{ rereplace(searchExp, replaceStr, object()); };

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, object(0), object(0), object(), object()); };

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

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

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

{ pyreplace(searchExp, replaceStr, count, flags, object(), 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, 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, object(0), object(0), object(), object()); };

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

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

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

{ pymlreplace(searchExp, replaceStr, count, flags, object(), 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, 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, object(0), object(), object()); };

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

{ pysearch(searchExp, callback, flags, object(), object()); };

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

{ pysearch(searchExp, callback, flags, startLine, 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, object(0), object(), object()); };

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

{ pymlsearch(searchExp, callback, flags, object(), object()); };

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

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

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

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

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

boost::python::str ScintillaWrapper::getCurrentWord()

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

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

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

*/

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

/** Add array of cells to document.

*/

int AddStyledText(ScintillaCells c);

/** Insert string at a position.

*/

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

/** Delete all text in the document.

*/

void ClearAll();

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

*/

void ClearDocumentStyle();

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

*/

int GetLength();

/** Returns the character byte at the position.

*/

int GetCharAt(int pos);

/** Returns the position of the caret.

*/

int GetCurrentPos();

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

*/

int GetAnchor();

/** Returns the style byte at the position.

*/

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

*/

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

*/

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

*/

int PositionFromPoint(int x, int y);

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

* INVALID_POSITION if not close to text.

*/

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

*/

boost::python::str GetCurLine();

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

*/

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

*/

int 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 SetCodePage(int codePage);

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

* more colours. This may lead to ugly displays.

*/

void SetUsePalette(bool usePalette);

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

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

*/

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

*/

int MarkerGet(int line);

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

*/

int MarkerNext(int lineStart, int markerMask);

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

*/

int MarkerPrevious(int lineStart, int markerMask);

/** Define a marker from a pixmap.

*/

void MarkerDefinePixmap(int markerNumber, boost::python::str 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.

*/

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.

*/

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

*/

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

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

*/

int StyleGetSize(int style);

/** Get the font of a style.

* Returns the length of the fontName

*/

boost::python::str StyleGetFont();

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

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

*/

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

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

*/

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

*/

int 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::str characters);

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

*/

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

*/

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

*/

int GetStyleBits();

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

*/

void SetLineState(int line, int state);

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

*/

int GetLineState(int line);

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

*/

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

*/

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

*/

int AutoCGetSeparator();

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

*/

void AutoCSelect(boost::python::str 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::str 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::str 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::str xpmData);

/** Clear all the registered XPM images.

*/

void ClearRegisteredImages();

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

*/

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

*/

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

*/

int AutoCGetMaxHeight();

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

*/

void SetIndent(int indentSize);

/** Retrieve indentation size.

*/

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

*/

int GetLineIndentation(int line);

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

*/

int GetLineIndentPosition(int line);

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

*/

int GetColumn(int pos);

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

*/

int GetIndentationGuides();

/** Set the highlighted indentation guide column.

* 0 = no highlighted guide.

*/

void SetHighlightGuide(int column);

/** Get the highlighted indentation guide column.

*/

int GetHighlightGuide();

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

*/

int GetLineEndPosition(int line);

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

*/

int GetCodePage();

/** Get the foreground colour of the caret.

*/

boost::python::tuple GetCaretFore();

/** In palette mode?

*/

bool GetUsePalette();

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

*/

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

*/

int GetSelectionEnd();

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

*/

void SetPrintMagnification(int magnification);

/** Returns the print magnification.

*/

int GetPrintMagnification();

/** Modify colours when printing for clearer printed text.

*/

void SetPrintColourMode(int mode);

/** Returns the print colour mode.

*/

int GetPrintColourMode();

/** Find some text in the document.

*/

boost::python::object FindText(int flags, int start, int end, boost::python::object ft);

/** Retrieve the display line at the top of the display.

*/

int GetFirstVisibleLine();

/** Retrieve the contents of a line.

* Returns the length of the line.

*/

boost::python::str GetLine(int line);

/** Returns the number of lines in the document. There is always at least one.

*/

int GetLineCount();

/** Sets the size in pixels of the left margin.

*/

void SetMarginLeft(int pixelWidth);

/** Returns the size in pixels of the left margin.

*/

int GetMarginLeft();

/** Sets the size in pixels of the right margin.

*/

void SetMarginRight(int pixelWidth);

/** Returns the size in pixels of the right margin.

*/

int GetMarginRight();

/** Is the document different from when it was last saved?

*/

bool GetModify();

/** Select a range of text.

*/

void SetSel(int start, int end);

/** Retrieve the selected text.

* Return the length of the text.

*/

boost::python::str GetSelText();

/** Retrieve a range of text.

* Return the length of the text.

*/

boost::python::str GetTextRange(int start, int end);

/** Draw the selection in normal style or with selection highlighted.

*/

void HideSelection(bool normal);

/** Retrieve the x value of the point in the window where a position is displayed.

*/

int PointXFromPosition(int pos);

/** Retrieve the y value of the point in the window where a position is displayed.

*/

int PointYFromPosition(int pos);

/** Retrieve the line containing a position.

*/

int LineFromPosition(int pos);

/** Retrieve the position at the start of a line.

*/

int PositionFromLine(int line);

/** Scroll horizontally and vertically.

*/

void LineScroll(int columns, int lines);

/** Ensure the caret is visible.

*/

void ScrollCaret();

/** Replace the selected text with the argument text.

*/

void ReplaceSel(boost::python::str text);

/** Set to read only or read write.

*/

void SetReadOnly(bool readOnly);

/** Null operation.

*/

void Null();

/** Will a paste succeed?

*/

bool CanPaste();

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

*/

bool CanUndo();

/** Delete the undo history.

*/

void EmptyUndoBuffer();

/** Undo one action in the undo history.

*/

void Undo();

/** Cut the selection to the clipboard.

*/

void Cut();

/** Copy the selection to the clipboard.

*/

void Copy();

/** Paste the contents of the clipboard into the document replacing the selection.

*/

void Paste();

/** Clear the selection.

*/

void Clear();

/** Replace the contents of the document with the argument text.

*/

void SetText(boost::python::str text);

/** Retrieve all the text in the document.

* Returns number of characters retrieved.

*/

boost::python::str GetText();

/** Retrieve the number of characters in the document.

*/