//Auto-generated by kalyptus. DO NOT EDIT.
namespace QScintilla {

	using System;
	using Qyoto;
	using System.Collections.Generic;

	/// <remarks> See <see cref="IQsciScintillaSignals"></see> for signals emitted by QsciScintilla
	/// </remarks>

	[SmokeClass("QsciScintilla")]
	public class QsciScintilla : QsciScintillaBase, IDisposable {
 		protected QsciScintilla(Type dummy) : base((Type) null) {}
		protected new void CreateProxy() {
			interceptor = new SmokeInvocation(typeof(QsciScintilla), this);
		}
		private static SmokeInvocation staticInterceptor = null;
		static QsciScintilla() {
			staticInterceptor = new SmokeInvocation(typeof(QsciScintilla), null);
		}
		public enum AutoCompletionSource {
			AcsNone = 0,
			AcsAll = 1,
			AcsDocument = 2,
			AcsAPIs = 3,
		}
		public enum BraceMatch {
			NoBraceMatch = 0,
			StrictBraceMatch = 1,
			SloppyBraceMatch = 2,
		}
		public enum CallTipsStyle {
			CallTipsNone = 0,
			CallTipsNoContext = 1,
			CallTipsNoAutoCompletionContext = 2,
			CallTipsContext = 3,
		}
		public enum EdgeMode {
			EdgeNone = EDGE_NONE,
			EdgeLine = EDGE_LINE,
			EdgeBackground = EDGE_BACKGROUND,
		}
		public enum EolMode {
			EolWindows = SC_EOL_CRLF,
			EolUnix = SC_EOL_LF,
			EolMac = SC_EOL_CR,
		}
		public enum FoldStyle {
			NoFoldStyle = 0,
			PlainFoldStyle = 1,
			CircledFoldStyle = 2,
			BoxedFoldStyle = 3,
			CircledTreeFoldStyle = 4,
			BoxedTreeFoldStyle = 5,
		}
		public enum MarkerSymbol {
			Circle = SC_MARK_CIRCLE,
			Rectangle = SC_MARK_ROUNDRECT,
			RightTriangle = SC_MARK_ARROW,
			SmallRectangle = SC_MARK_SMALLRECT,
			RightArrow = SC_MARK_SHORTARROW,
			Invisible = SC_MARK_EMPTY,
			DownTriangle = SC_MARK_ARROWDOWN,
			Minus = SC_MARK_MINUS,
			Plus = SC_MARK_PLUS,
			VerticalLine = SC_MARK_VLINE,
			BottomLeftCorner = SC_MARK_LCORNER,
			LeftSideSplitter = SC_MARK_TCORNER,
			BoxedPlus = SC_MARK_BOXPLUS,
			BoxedPlusConnected = SC_MARK_BOXPLUSCONNECTED,
			BoxedMinus = SC_MARK_BOXMINUS,
			BoxedMinusConnected = SC_MARK_BOXMINUSCONNECTED,
			RoundedBottomLeftCorner = SC_MARK_LCORNERCURVE,
			LeftSideRoundedSplitter = SC_MARK_TCORNERCURVE,
			CircledPlus = SC_MARK_CIRCLEPLUS,
			CircledPlusConnected = SC_MARK_CIRCLEPLUSCONNECTED,
			CircledMinus = SC_MARK_CIRCLEMINUS,
			CircledMinusConnected = SC_MARK_CIRCLEMINUSCONNECTED,
			Background = SC_MARK_BACKGROUND,
			ThreeDots = SC_MARK_DOTDOTDOT,
			ThreeRightArrows = SC_MARK_ARROWS,
		}
		public enum WhitespaceVisibility {
			WsInvisible = SCWS_INVISIBLE,
			WsVisible = SCWS_VISIBLEALWAYS,
			WsVisibleAfterIndent = SCWS_VISIBLEAFTERINDENT,
		}
		public enum WrapMode {
			WrapNone = SC_WRAP_NONE,
			WrapWord = SC_WRAP_WORD,
			WrapCharacter = SC_WRAP_CHAR,
		}
		public enum WrapVisualFlag {
			WrapFlagNone = 0,
			WrapFlagByText = 1,
			WrapFlagByBorder = 2,
		}
		public const int AiMaintain = 0x01;
		public const int AiOpening = 0x02;
		public const int AiClosing = 0x04;

		public QsciScintilla(QWidget parent) : this((Type) null) {
			CreateProxy();
			interceptor.Invoke("QsciScintilla#", "QsciScintilla(QWidget*)", typeof(void), typeof(QWidget), parent);
		}
		public QsciScintilla() : this((Type) null) {
			CreateProxy();
			interceptor.Invoke("QsciScintilla", "QsciScintilla()", typeof(void));
		}
		public bool AutoCompletionCaseSensitivity() {
			return (bool) interceptor.Invoke("autoCompletionCaseSensitivity", "autoCompletionCaseSensitivity() const", typeof(bool));
		}
		public bool AutoCompletionFillupsEnabled() {
			return (bool) interceptor.Invoke("autoCompletionFillupsEnabled", "autoCompletionFillupsEnabled() const", typeof(bool));
		}
		public bool AutoCompletionReplaceWord() {
			return (bool) interceptor.Invoke("autoCompletionReplaceWord", "autoCompletionReplaceWord() const", typeof(bool));
		}
		public bool AutoCompletionShowSingle() {
			return (bool) interceptor.Invoke("autoCompletionShowSingle", "autoCompletionShowSingle() const", typeof(bool));
		}
		public QsciScintilla.AutoCompletionSource autoCompletionSource() {
			return (QsciScintilla.AutoCompletionSource) interceptor.Invoke("autoCompletionSource", "autoCompletionSource() const", typeof(QsciScintilla.AutoCompletionSource));
		}
		public int AutoCompletionThreshold() {
			return (int) interceptor.Invoke("autoCompletionThreshold", "autoCompletionThreshold() const", typeof(int));
		}
		public bool AutoIndent() {
			return (bool) interceptor.Invoke("autoIndent", "autoIndent() const", typeof(bool));
		}
		public bool BackspaceUnindents() {
			return (bool) interceptor.Invoke("backspaceUnindents", "backspaceUnindents() const", typeof(bool));
		}
		public void BeginUndoAction() {
			interceptor.Invoke("beginUndoAction", "beginUndoAction()", typeof(void));
		}
		public QsciScintilla.BraceMatch BraceMatching() {
			return (QsciScintilla.BraceMatch) interceptor.Invoke("braceMatching", "braceMatching() const", typeof(QsciScintilla.BraceMatch));
		}
		public QsciScintilla.CallTipsStyle callTipsStyle() {
			return (QsciScintilla.CallTipsStyle) interceptor.Invoke("callTipsStyle", "callTipsStyle() const", typeof(QsciScintilla.CallTipsStyle));
		}
		public int CallTipsVisible() {
			return (int) interceptor.Invoke("callTipsVisible", "callTipsVisible() const", typeof(int));
		}
		public void CancelList() {
			interceptor.Invoke("cancelList", "cancelList()", typeof(void));
		}
		public bool CaseSensitive() {
			return (bool) interceptor.Invoke("caseSensitive", "caseSensitive() const", typeof(bool));
		}
		public void ClearRegisteredImages() {
			interceptor.Invoke("clearRegisteredImages", "clearRegisteredImages()", typeof(void));
		}
		public QColor Color() {
			return (QColor) interceptor.Invoke("color", "color() const", typeof(QColor));
		}
		public void ConvertEols(QsciScintilla.EolMode mode) {
			interceptor.Invoke("convertEols$", "convertEols(QsciScintilla::EolMode)", typeof(void), typeof(QsciScintilla.EolMode), mode);
		}
		public QsciDocument Document() {
			return (QsciDocument) interceptor.Invoke("document", "document() const", typeof(QsciDocument));
		}
		public void EndUndoAction() {
			interceptor.Invoke("endUndoAction", "endUndoAction()", typeof(void));
		}
		public QColor EdgeColor() {
			return (QColor) interceptor.Invoke("edgeColor", "edgeColor() const", typeof(QColor));
		}
		public int EdgeColumn() {
			return (int) interceptor.Invoke("edgeColumn", "edgeColumn() const", typeof(int));
		}
		public QsciScintilla.EdgeMode edgeMode() {
			return (QsciScintilla.EdgeMode) interceptor.Invoke("edgeMode", "edgeMode() const", typeof(QsciScintilla.EdgeMode));
		}
		public void SetFont(QFont f) {
			interceptor.Invoke("setFont#", "setFont(const QFont&)", typeof(void), typeof(QFont), f);
		}
		public QsciScintilla.EolMode eolMode() {
			return (QsciScintilla.EolMode) interceptor.Invoke("eolMode", "eolMode() const", typeof(QsciScintilla.EolMode));
		}
		public bool EolVisibility() {
			return (bool) interceptor.Invoke("eolVisibility", "eolVisibility() const", typeof(bool));
		}
		[SmokeMethod("findFirst(const QString&, bool, bool, bool, bool, bool, int, int, bool)")]
		public virtual bool FindFirst(string expr, bool re, bool cs, bool wo, bool wrap, bool forward, int line, int index, bool show) {
			return (bool) interceptor.Invoke("findFirst$$$$$$$$$", "findFirst(const QString&, bool, bool, bool, bool, bool, int, int, bool)", typeof(bool), typeof(string), expr, typeof(bool), re, typeof(bool), cs, typeof(bool), wo, typeof(bool), wrap, typeof(bool), forward, typeof(int), line, typeof(int), index, typeof(bool), show);
		}
		[SmokeMethod("findFirst(const QString&, bool, bool, bool, bool, bool, int, int)")]
		public virtual bool FindFirst(string expr, bool re, bool cs, bool wo, bool wrap, bool forward, int line, int index) {
			return (bool) interceptor.Invoke("findFirst$$$$$$$$", "findFirst(const QString&, bool, bool, bool, bool, bool, int, int)", typeof(bool), typeof(string), expr, typeof(bool), re, typeof(bool), cs, typeof(bool), wo, typeof(bool), wrap, typeof(bool), forward, typeof(int), line, typeof(int), index);
		}
		[SmokeMethod("findFirst(const QString&, bool, bool, bool, bool, bool, int)")]
		public virtual bool FindFirst(string expr, bool re, bool cs, bool wo, bool wrap, bool forward, int line) {
			return (bool) interceptor.Invoke("findFirst$$$$$$$", "findFirst(const QString&, bool, bool, bool, bool, bool, int)", typeof(bool), typeof(string), expr, typeof(bool), re, typeof(bool), cs, typeof(bool), wo, typeof(bool), wrap, typeof(bool), forward, typeof(int), line);
		}
		[SmokeMethod("findFirst(const QString&, bool, bool, bool, bool, bool)")]
		public virtual bool FindFirst(string expr, bool re, bool cs, bool wo, bool wrap, bool forward) {
			return (bool) interceptor.Invoke("findFirst$$$$$$", "findFirst(const QString&, bool, bool, bool, bool, bool)", typeof(bool), typeof(string), expr, typeof(bool), re, typeof(bool), cs, typeof(bool), wo, typeof(bool), wrap, typeof(bool), forward);
		}
		[SmokeMethod("findFirst(const QString&, bool, bool, bool, bool)")]
		public virtual bool FindFirst(string expr, bool re, bool cs, bool wo, bool wrap) {
			return (bool) interceptor.Invoke("findFirst$$$$$", "findFirst(const QString&, bool, bool, bool, bool)", typeof(bool), typeof(string), expr, typeof(bool), re, typeof(bool), cs, typeof(bool), wo, typeof(bool), wrap);
		}
		[SmokeMethod("findNext()")]
		public virtual bool FindNext() {
			return (bool) interceptor.Invoke("findNext", "findNext()", typeof(bool));
		}
		public int FirstVisibleLine() {
			return (int) interceptor.Invoke("firstVisibleLine", "firstVisibleLine() const", typeof(int));
		}
		public QsciScintilla.FoldStyle Folding() {
			return (QsciScintilla.FoldStyle) interceptor.Invoke("folding", "folding() const", typeof(QsciScintilla.FoldStyle));
		}
		public void GetCursorPosition(ref int line, ref int index) {
			StackItem[] stack = new StackItem[3];
			stack[1].s_int = line;
			stack[2].s_int = index;
			interceptor.Invoke("getCursorPosition$$", "getCursorPosition(int*, int*) const", stack);
			line = stack[1].s_int;
			index = stack[2].s_int;
			return;
		}
		public void GetSelection(ref int lineFrom, ref int indexFrom, ref int lineTo, ref int indexTo) {
			StackItem[] stack = new StackItem[5];
			stack[1].s_int = lineFrom;
			stack[2].s_int = indexFrom;
			stack[3].s_int = lineTo;
			stack[4].s_int = indexTo;
			interceptor.Invoke("getSelection$$$$", "getSelection(int*, int*, int*, int*) const", stack);
			lineFrom = stack[1].s_int;
			indexFrom = stack[2].s_int;
			lineTo = stack[3].s_int;
			indexTo = stack[4].s_int;
			return;
		}
		public bool HasSelectedText() {
			return (bool) interceptor.Invoke("hasSelectedText", "hasSelectedText() const", typeof(bool));
		}
		public int Indentation(int line) {
			return (int) interceptor.Invoke("indentation$", "indentation(int) const", typeof(int), typeof(int), line);
		}
		public bool IndentationGuides() {
			return (bool) interceptor.Invoke("indentationGuides", "indentationGuides() const", typeof(bool));
		}
		public bool IndentationsUseTabs() {
			return (bool) interceptor.Invoke("indentationsUseTabs", "indentationsUseTabs() const", typeof(bool));
		}
		public int IndentationWidth() {
			return (int) interceptor.Invoke("indentationWidth", "indentationWidth() const", typeof(int));
		}
		public bool IsCallTipActive() {
			return (bool) interceptor.Invoke("isCallTipActive", "isCallTipActive() const", typeof(bool));
		}
		public bool IsListActive() {
			return (bool) interceptor.Invoke("isListActive", "isListActive() const", typeof(bool));
		}
		public bool IsModified() {
			return (bool) interceptor.Invoke("isModified", "isModified() const", typeof(bool));
		}
		public bool IsReadOnly() {
			return (bool) interceptor.Invoke("isReadOnly", "isReadOnly() const", typeof(bool));
		}
		public bool IsRedoAvailable() {
			return (bool) interceptor.Invoke("isRedoAvailable", "isRedoAvailable() const", typeof(bool));
		}
		public bool IsUndoAvailable() {
			return (bool) interceptor.Invoke("isUndoAvailable", "isUndoAvailable() const", typeof(bool));
		}
		public bool IsUtf8() {
			return (bool) interceptor.Invoke("isUtf8", "isUtf8() const", typeof(bool));
		}
		public bool IsWordCharacter(char ch) {
			return (bool) interceptor.Invoke("isWordCharacter$", "isWordCharacter(char) const", typeof(bool), typeof(char), ch);
		}
		public int LineAt(QPoint pos) {
			return (int) interceptor.Invoke("lineAt#", "lineAt(const QPoint&) const", typeof(int), typeof(QPoint), pos);
		}
		public int LineLength(int line) {
			return (int) interceptor.Invoke("lineLength$", "lineLength(int) const", typeof(int), typeof(int), line);
		}
		public int Lines() {
			return (int) interceptor.Invoke("lines", "lines() const", typeof(int));
		}
		public int Length() {
			return (int) interceptor.Invoke("length", "length() const", typeof(int));
		}
		public QsciLexer Lexer() {
			return (QsciLexer) interceptor.Invoke("lexer", "lexer() const", typeof(QsciLexer));
		}
		public bool MarginLineNumbers(int margin) {
			return (bool) interceptor.Invoke("marginLineNumbers$", "marginLineNumbers(int) const", typeof(bool), typeof(int), margin);
		}
		public int MarginMarkerMask(int margin) {
			return (int) interceptor.Invoke("marginMarkerMask$", "marginMarkerMask(int) const", typeof(int), typeof(int), margin);
		}
		public bool MarginSensitivity(int margin) {
			return (bool) interceptor.Invoke("marginSensitivity$", "marginSensitivity(int) const", typeof(bool), typeof(int), margin);
		}
		public int MarginWidth(int margin) {
			return (int) interceptor.Invoke("marginWidth$", "marginWidth(int) const", typeof(int), typeof(int), margin);
		}
		public int MarkerDefine(QsciScintilla.MarkerSymbol sym, int mnr) {
			return (int) interceptor.Invoke("markerDefine$$", "markerDefine(QsciScintilla::MarkerSymbol, int)", typeof(int), typeof(QsciScintilla.MarkerSymbol), sym, typeof(int), mnr);
		}
		public int MarkerDefine(QsciScintilla.MarkerSymbol sym) {
			return (int) interceptor.Invoke("markerDefine$", "markerDefine(QsciScintilla::MarkerSymbol)", typeof(int), typeof(QsciScintilla.MarkerSymbol), sym);
		}
		public int MarkerDefine(char ch, int mnr) {
			return (int) interceptor.Invoke("markerDefine$$", "markerDefine(char, int)", typeof(int), typeof(char), ch, typeof(int), mnr);
		}
		public int MarkerDefine(char ch) {
			return (int) interceptor.Invoke("markerDefine$", "markerDefine(char)", typeof(int), typeof(char), ch);
		}
		public int MarkerDefine(QPixmap pm, int mnr) {
			return (int) interceptor.Invoke("markerDefine#$", "markerDefine(const QPixmap&, int)", typeof(int), typeof(QPixmap), pm, typeof(int), mnr);
		}
		public int MarkerDefine(QPixmap pm) {
			return (int) interceptor.Invoke("markerDefine#", "markerDefine(const QPixmap&)", typeof(int), typeof(QPixmap), pm);
		}
		public int MarkerAdd(int linenr, int mnr) {
			return (int) interceptor.Invoke("markerAdd$$", "markerAdd(int, int)", typeof(int), typeof(int), linenr, typeof(int), mnr);
		}
		public uint MarkersAtLine(int linenr) {
			return (uint) interceptor.Invoke("markersAtLine$", "markersAtLine(int) const", typeof(uint), typeof(int), linenr);
		}
		public void MarkerDelete(int linenr, int mnr) {
			interceptor.Invoke("markerDelete$$", "markerDelete(int, int)", typeof(void), typeof(int), linenr, typeof(int), mnr);
		}
		public void MarkerDelete(int linenr) {
			interceptor.Invoke("markerDelete$", "markerDelete(int)", typeof(void), typeof(int), linenr);
		}
		public void MarkerDeleteAll(int mnr) {
			interceptor.Invoke("markerDeleteAll$", "markerDeleteAll(int)", typeof(void), typeof(int), mnr);
		}
		public void MarkerDeleteAll() {
			interceptor.Invoke("markerDeleteAll", "markerDeleteAll()", typeof(void));
		}
		public void MarkerDeleteHandle(int mhandle) {
			interceptor.Invoke("markerDeleteHandle$", "markerDeleteHandle(int)", typeof(void), typeof(int), mhandle);
		}
		public int MarkerLine(int mhandle) {
			return (int) interceptor.Invoke("markerLine$", "markerLine(int) const", typeof(int), typeof(int), mhandle);
		}
		public int MarkerFindNext(int linenr, uint mask) {
			return (int) interceptor.Invoke("markerFindNext$$", "markerFindNext(int, unsigned) const", typeof(int), typeof(int), linenr, typeof(uint), mask);
		}
		public int MarkerFindPrevious(int linenr, uint mask) {
			return (int) interceptor.Invoke("markerFindPrevious$$", "markerFindPrevious(int, unsigned) const", typeof(int), typeof(int), linenr, typeof(uint), mask);
		}
		public QColor Paper() {
			return (QColor) interceptor.Invoke("paper", "paper() const", typeof(QColor));
		}
		[SmokeMethod("recolor(int, int)")]
		public virtual void Recolor(int start, int end) {
			interceptor.Invoke("recolor$$", "recolor(int, int)", typeof(void), typeof(int), start, typeof(int), end);
		}
		[SmokeMethod("recolor(int)")]
		public virtual void Recolor(int start) {
			interceptor.Invoke("recolor$", "recolor(int)", typeof(void), typeof(int), start);
		}
		[SmokeMethod("recolor()")]
		public virtual void Recolor() {
			interceptor.Invoke("recolor", "recolor()", typeof(void));
		}
		public void RegisterImage(int id, QPixmap pm) {
			interceptor.Invoke("registerImage$#", "registerImage(int, const QPixmap&)", typeof(void), typeof(int), id, typeof(QPixmap), pm);
		}
		[SmokeMethod("replace(const QString&)")]
		public virtual void Replace(string replaceStr) {
			interceptor.Invoke("replace$", "replace(const QString&)", typeof(void), typeof(string), replaceStr);
		}
		public void ResetFoldMarginColors() {
			interceptor.Invoke("resetFoldMarginColors", "resetFoldMarginColors()", typeof(void));
		}
		public void SetFoldMarginColors(QColor fore, QColor back) {
			interceptor.Invoke("setFoldMarginColors##", "setFoldMarginColors(const QColor&, const QColor&)", typeof(void), typeof(QColor), fore, typeof(QColor), back);
		}
		public void SetAutoCompletionFillupsEnabled(bool enabled) {
			interceptor.Invoke("setAutoCompletionFillupsEnabled$", "setAutoCompletionFillupsEnabled(bool)", typeof(void), typeof(bool), enabled);
		}
		public void SetAutoCompletionFillups(string fillups) {
			interceptor.Invoke("setAutoCompletionFillups$", "setAutoCompletionFillups(const char*)", typeof(void), typeof(string), fillups);
		}
		public void SetAutoCompletionWordSeparators(List<string> separators) {
			interceptor.Invoke("setAutoCompletionWordSeparators?", "setAutoCompletionWordSeparators(const QStringList&)", typeof(void), typeof(List<string>), separators);
		}
		public void SetCallTipsBackgroundColor(QColor col) {
			interceptor.Invoke("setCallTipsBackgroundColor#", "setCallTipsBackgroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetCallTipsForegroundColor(QColor col) {
			interceptor.Invoke("setCallTipsForegroundColor#", "setCallTipsForegroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetCallTipsHighlightColor(QColor col) {
			interceptor.Invoke("setCallTipsHighlightColor#", "setCallTipsHighlightColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetCallTipsStyle(QsciScintilla.CallTipsStyle style) {
			interceptor.Invoke("setCallTipsStyle$", "setCallTipsStyle(QsciScintilla::CallTipsStyle)", typeof(void), typeof(QsciScintilla.CallTipsStyle), style);
		}
		public void SetCallTipsVisible(int nr) {
			interceptor.Invoke("setCallTipsVisible$", "setCallTipsVisible(int)", typeof(void), typeof(int), nr);
		}
		public void SetDocument(QsciDocument document) {
			interceptor.Invoke("setDocument#", "setDocument(const QsciDocument&)", typeof(void), typeof(QsciDocument), document);
		}
		public void SetEdgeColor(QColor col) {
			interceptor.Invoke("setEdgeColor#", "setEdgeColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetEdgeColumn(int colnr) {
			interceptor.Invoke("setEdgeColumn$", "setEdgeColumn(int)", typeof(void), typeof(int), colnr);
		}
		public void SetEdgeMode(QsciScintilla.EdgeMode mode) {
			interceptor.Invoke("setEdgeMode$", "setEdgeMode(QsciScintilla::EdgeMode)", typeof(void), typeof(QsciScintilla.EdgeMode), mode);
		}
		public void SetMarkerBackgroundColor(QColor col, int mnr) {
			interceptor.Invoke("setMarkerBackgroundColor#$", "setMarkerBackgroundColor(const QColor&, int)", typeof(void), typeof(QColor), col, typeof(int), mnr);
		}
		public void SetMarkerBackgroundColor(QColor col) {
			interceptor.Invoke("setMarkerBackgroundColor#", "setMarkerBackgroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetMarkerForegroundColor(QColor col, int mnr) {
			interceptor.Invoke("setMarkerForegroundColor#$", "setMarkerForegroundColor(const QColor&, int)", typeof(void), typeof(QColor), col, typeof(int), mnr);
		}
		public void SetMarkerForegroundColor(QColor col) {
			interceptor.Invoke("setMarkerForegroundColor#", "setMarkerForegroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetMatchedBraceBackgroundColor(QColor col) {
			interceptor.Invoke("setMatchedBraceBackgroundColor#", "setMatchedBraceBackgroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetMatchedBraceForegroundColor(QColor col) {
			interceptor.Invoke("setMatchedBraceForegroundColor#", "setMatchedBraceForegroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetUnmatchedBraceBackgroundColor(QColor col) {
			interceptor.Invoke("setUnmatchedBraceBackgroundColor#", "setUnmatchedBraceBackgroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetUnmatchedBraceForegroundColor(QColor col) {
			interceptor.Invoke("setUnmatchedBraceForegroundColor#", "setUnmatchedBraceForegroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		public void SetWrapVisualFlags(QsciScintilla.WrapVisualFlag eflag, QsciScintilla.WrapVisualFlag sflag, int sindent) {
			interceptor.Invoke("setWrapVisualFlags$$$", "setWrapVisualFlags(QsciScintilla::WrapVisualFlag, QsciScintilla::WrapVisualFlag, int)", typeof(void), typeof(QsciScintilla.WrapVisualFlag), eflag, typeof(QsciScintilla.WrapVisualFlag), sflag, typeof(int), sindent);
		}
		public void SetWrapVisualFlags(QsciScintilla.WrapVisualFlag eflag, QsciScintilla.WrapVisualFlag sflag) {
			interceptor.Invoke("setWrapVisualFlags$$", "setWrapVisualFlags(QsciScintilla::WrapVisualFlag, QsciScintilla::WrapVisualFlag)", typeof(void), typeof(QsciScintilla.WrapVisualFlag), eflag, typeof(QsciScintilla.WrapVisualFlag), sflag);
		}
		public void SetWrapVisualFlags(QsciScintilla.WrapVisualFlag eflag) {
			interceptor.Invoke("setWrapVisualFlags$", "setWrapVisualFlags(QsciScintilla::WrapVisualFlag)", typeof(void), typeof(QsciScintilla.WrapVisualFlag), eflag);
		}
		public string SelectedText() {
			return (string) interceptor.Invoke("selectedText", "selectedText() const", typeof(string));
		}
		public bool SelectionToEol() {
			return (bool) interceptor.Invoke("selectionToEol", "selectionToEol() const", typeof(bool));
		}
		public void SetSelectionToEol(bool filled) {
			interceptor.Invoke("setSelectionToEol$", "setSelectionToEol(bool)", typeof(void), typeof(bool), filled);
		}
		public void ShowUserList(int id, List<string> list) {
			interceptor.Invoke("showUserList$?", "showUserList(int, const QStringList&)", typeof(void), typeof(int), id, typeof(List<string>), list);
		}
		public QsciCommandSet StandardCommands() {
			return (QsciCommandSet) interceptor.Invoke("standardCommands", "standardCommands() const", typeof(QsciCommandSet));
		}
		public bool TabIndents() {
			return (bool) interceptor.Invoke("tabIndents", "tabIndents() const", typeof(bool));
		}
		public int TabWidth() {
			return (int) interceptor.Invoke("tabWidth", "tabWidth() const", typeof(int));
		}
		public string Text() {
			return (string) interceptor.Invoke("text", "text() const", typeof(string));
		}
		public string Text(int line) {
			return (string) interceptor.Invoke("text$", "text(int) const", typeof(string), typeof(int), line);
		}
		public int TextHeight(int linenr) {
			return (int) interceptor.Invoke("textHeight$", "textHeight(int) const", typeof(int), typeof(int), linenr);
		}
		public QsciScintilla.WhitespaceVisibility whitespaceVisibility() {
			return (QsciScintilla.WhitespaceVisibility) interceptor.Invoke("whitespaceVisibility", "whitespaceVisibility() const", typeof(QsciScintilla.WhitespaceVisibility));
		}
		public string WordCharacters() {
			return (string) interceptor.Invoke("wordCharacters", "wordCharacters() const", typeof(string));
		}
		public QsciScintilla.WrapMode wrapMode() {
			return (QsciScintilla.WrapMode) interceptor.Invoke("wrapMode", "wrapMode() const", typeof(QsciScintilla.WrapMode));
		}
		[Q_SLOT("void append(const QString&)")]
		[SmokeMethod("append(const QString&)")]
		public virtual void Append(string text) {
			interceptor.Invoke("append$", "append(const QString&)", typeof(void), typeof(string), text);
		}
		[Q_SLOT("void autoCompleteFromAll()")]
		[SmokeMethod("autoCompleteFromAll()")]
		public virtual void AutoCompleteFromAll() {
			interceptor.Invoke("autoCompleteFromAll", "autoCompleteFromAll()", typeof(void));
		}
		[Q_SLOT("void autoCompleteFromAPIs()")]
		[SmokeMethod("autoCompleteFromAPIs()")]
		public virtual void AutoCompleteFromAPIs() {
			interceptor.Invoke("autoCompleteFromAPIs", "autoCompleteFromAPIs()", typeof(void));
		}
		[Q_SLOT("void autoCompleteFromDocument()")]
		[SmokeMethod("autoCompleteFromDocument()")]
		public virtual void AutoCompleteFromDocument() {
			interceptor.Invoke("autoCompleteFromDocument", "autoCompleteFromDocument()", typeof(void));
		}
		[Q_SLOT("void callTip()")]
		[SmokeMethod("callTip()")]
		public virtual void CallTip() {
			interceptor.Invoke("callTip", "callTip()", typeof(void));
		}
		[Q_SLOT("void clear()")]
		[SmokeMethod("clear()")]
		public virtual void Clear() {
			interceptor.Invoke("clear", "clear()", typeof(void));
		}
		[Q_SLOT("void copy()")]
		[SmokeMethod("copy()")]
		public virtual void Copy() {
			interceptor.Invoke("copy", "copy()", typeof(void));
		}
		[Q_SLOT("void cut()")]
		[SmokeMethod("cut()")]
		public virtual void Cut() {
			interceptor.Invoke("cut", "cut()", typeof(void));
		}
		[Q_SLOT("void ensureCursorVisible()")]
		[SmokeMethod("ensureCursorVisible()")]
		public virtual void EnsureCursorVisible() {
			interceptor.Invoke("ensureCursorVisible", "ensureCursorVisible()", typeof(void));
		}
		[Q_SLOT("void ensureLineVisible(int)")]
		[SmokeMethod("ensureLineVisible(int)")]
		public virtual void EnsureLineVisible(int line) {
			interceptor.Invoke("ensureLineVisible$", "ensureLineVisible(int)", typeof(void), typeof(int), line);
		}
		[Q_SLOT("void foldAll(bool)")]
		[SmokeMethod("foldAll(bool)")]
		public virtual void FoldAll(bool children) {
			interceptor.Invoke("foldAll$", "foldAll(bool)", typeof(void), typeof(bool), children);
		}
		[Q_SLOT("void foldAll()")]
		[SmokeMethod("foldAll()")]
		public virtual void FoldAll() {
			interceptor.Invoke("foldAll", "foldAll()", typeof(void));
		}
		[Q_SLOT("void foldLine(int)")]
		[SmokeMethod("foldLine(int)")]
		public virtual void FoldLine(int line) {
			interceptor.Invoke("foldLine$", "foldLine(int)", typeof(void), typeof(int), line);
		}
		[Q_SLOT("void indent(int)")]
		[SmokeMethod("indent(int)")]
		public virtual void Indent(int line) {
			interceptor.Invoke("indent$", "indent(int)", typeof(void), typeof(int), line);
		}
		[Q_SLOT("void insert(const QString&)")]
		[SmokeMethod("insert(const QString&)")]
		public virtual void Insert(string text) {
			interceptor.Invoke("insert$", "insert(const QString&)", typeof(void), typeof(string), text);
		}
		[Q_SLOT("void insertAt(const QString&, int, int)")]
		[SmokeMethod("insertAt(const QString&, int, int)")]
		public virtual void InsertAt(string text, int line, int index) {
			interceptor.Invoke("insertAt$$$", "insertAt(const QString&, int, int)", typeof(void), typeof(string), text, typeof(int), line, typeof(int), index);
		}
		[Q_SLOT("void moveToMatchingBrace()")]
		[SmokeMethod("moveToMatchingBrace()")]
		public virtual void MoveToMatchingBrace() {
			interceptor.Invoke("moveToMatchingBrace", "moveToMatchingBrace()", typeof(void));
		}
		[Q_SLOT("void paste()")]
		[SmokeMethod("paste()")]
		public virtual void Paste() {
			interceptor.Invoke("paste", "paste()", typeof(void));
		}
		[Q_SLOT("void redo()")]
		[SmokeMethod("redo()")]
		public virtual void Redo() {
			interceptor.Invoke("redo", "redo()", typeof(void));
		}
		[Q_SLOT("void removeSelectedText()")]
		[SmokeMethod("removeSelectedText()")]
		public virtual void RemoveSelectedText() {
			interceptor.Invoke("removeSelectedText", "removeSelectedText()", typeof(void));
		}
		[Q_SLOT("void resetSelectionBackgroundColor()")]
		[SmokeMethod("resetSelectionBackgroundColor()")]
		public virtual void ResetSelectionBackgroundColor() {
			interceptor.Invoke("resetSelectionBackgroundColor", "resetSelectionBackgroundColor()", typeof(void));
		}
		[Q_SLOT("void resetSelectionForegroundColor()")]
		[SmokeMethod("resetSelectionForegroundColor()")]
		public virtual void ResetSelectionForegroundColor() {
			interceptor.Invoke("resetSelectionForegroundColor", "resetSelectionForegroundColor()", typeof(void));
		}
		[Q_SLOT("void selectAll(bool)")]
		[SmokeMethod("selectAll(bool)")]
		public virtual void SelectAll(bool select) {
			interceptor.Invoke("selectAll$", "selectAll(bool)", typeof(void), typeof(bool), select);
		}
		[Q_SLOT("void selectAll()")]
		[SmokeMethod("selectAll()")]
		public virtual void SelectAll() {
			interceptor.Invoke("selectAll", "selectAll()", typeof(void));
		}
		[Q_SLOT("void selectToMatchingBrace()")]
		[SmokeMethod("selectToMatchingBrace()")]
		public virtual void SelectToMatchingBrace() {
			interceptor.Invoke("selectToMatchingBrace", "selectToMatchingBrace()", typeof(void));
		}
		[Q_SLOT("void setAutoCompletionCaseSensitivity(bool)")]
		[SmokeMethod("setAutoCompletionCaseSensitivity(bool)")]
		public virtual void SetAutoCompletionCaseSensitivity(bool cs) {
			interceptor.Invoke("setAutoCompletionCaseSensitivity$", "setAutoCompletionCaseSensitivity(bool)", typeof(void), typeof(bool), cs);
		}
		[Q_SLOT("void setAutoCompletionReplaceWord(bool)")]
		[SmokeMethod("setAutoCompletionReplaceWord(bool)")]
		public virtual void SetAutoCompletionReplaceWord(bool replace) {
			interceptor.Invoke("setAutoCompletionReplaceWord$", "setAutoCompletionReplaceWord(bool)", typeof(void), typeof(bool), replace);
		}
		[Q_SLOT("void setAutoCompletionShowSingle(bool)")]
		[SmokeMethod("setAutoCompletionShowSingle(bool)")]
		public virtual void SetAutoCompletionShowSingle(bool single) {
			interceptor.Invoke("setAutoCompletionShowSingle$", "setAutoCompletionShowSingle(bool)", typeof(void), typeof(bool), single);
		}
		[Q_SLOT("void setAutoCompletionSource(QsciScintilla::AutoCompletionSource)")]
		[SmokeMethod("setAutoCompletionSource(QsciScintilla::AutoCompletionSource)")]
		public virtual void SetAutoCompletionSource(QsciScintilla.AutoCompletionSource source) {
			interceptor.Invoke("setAutoCompletionSource$", "setAutoCompletionSource(QsciScintilla::AutoCompletionSource)", typeof(void), typeof(QsciScintilla.AutoCompletionSource), source);
		}
		[Q_SLOT("void setAutoCompletionThreshold(int)")]
		[SmokeMethod("setAutoCompletionThreshold(int)")]
		public virtual void SetAutoCompletionThreshold(int thresh) {
			interceptor.Invoke("setAutoCompletionThreshold$", "setAutoCompletionThreshold(int)", typeof(void), typeof(int), thresh);
		}
		[Q_SLOT("void setAutoIndent(bool)")]
		[SmokeMethod("setAutoIndent(bool)")]
		public virtual void SetAutoIndent(bool autoindent) {
			interceptor.Invoke("setAutoIndent$", "setAutoIndent(bool)", typeof(void), typeof(bool), autoindent);
		}
		[Q_SLOT("void setBraceMatching(QsciScintilla::BraceMatch)")]
		[SmokeMethod("setBraceMatching(QsciScintilla::BraceMatch)")]
		public virtual void SetBraceMatching(QsciScintilla.BraceMatch bm) {
			interceptor.Invoke("setBraceMatching$", "setBraceMatching(QsciScintilla::BraceMatch)", typeof(void), typeof(QsciScintilla.BraceMatch), bm);
		}
		[Q_SLOT("void setBackspaceUnindents(bool)")]
		[SmokeMethod("setBackspaceUnindents(bool)")]
		public virtual void SetBackspaceUnindents(bool unindent) {
			interceptor.Invoke("setBackspaceUnindents$", "setBackspaceUnindents(bool)", typeof(void), typeof(bool), unindent);
		}
		[Q_SLOT("void setCaretForegroundColor(const QColor&)")]
		[SmokeMethod("setCaretForegroundColor(const QColor&)")]
		public virtual void SetCaretForegroundColor(QColor col) {
			interceptor.Invoke("setCaretForegroundColor#", "setCaretForegroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		[Q_SLOT("void setCaretLineBackgroundColor(const QColor&)")]
		[SmokeMethod("setCaretLineBackgroundColor(const QColor&)")]
		public virtual void SetCaretLineBackgroundColor(QColor col) {
			interceptor.Invoke("setCaretLineBackgroundColor#", "setCaretLineBackgroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		[Q_SLOT("void setCaretLineVisible(bool)")]
		[SmokeMethod("setCaretLineVisible(bool)")]
		public virtual void SetCaretLineVisible(bool enable) {
			interceptor.Invoke("setCaretLineVisible$", "setCaretLineVisible(bool)", typeof(void), typeof(bool), enable);
		}
		[Q_SLOT("void setCaretWidth(int)")]
		[SmokeMethod("setCaretWidth(int)")]
		public virtual void SetCaretWidth(int width) {
			interceptor.Invoke("setCaretWidth$", "setCaretWidth(int)", typeof(void), typeof(int), width);
		}
		[Q_SLOT("void setColor(const QColor&)")]
		[SmokeMethod("setColor(const QColor&)")]
		public virtual void SetColor(QColor c) {
			interceptor.Invoke("setColor#", "setColor(const QColor&)", typeof(void), typeof(QColor), c);
		}
		[Q_SLOT("void setCursorPosition(int, int)")]
		[SmokeMethod("setCursorPosition(int, int)")]
		public virtual void SetCursorPosition(int line, int index) {
			interceptor.Invoke("setCursorPosition$$", "setCursorPosition(int, int)", typeof(void), typeof(int), line, typeof(int), index);
		}
		[Q_SLOT("void setEolMode(QsciScintilla::EolMode)")]
		[SmokeMethod("setEolMode(QsciScintilla::EolMode)")]
		public virtual void SetEolMode(QsciScintilla.EolMode mode) {
			interceptor.Invoke("setEolMode$", "setEolMode(QsciScintilla::EolMode)", typeof(void), typeof(QsciScintilla.EolMode), mode);
		}
		[Q_SLOT("void setEolVisibility(bool)")]
		[SmokeMethod("setEolVisibility(bool)")]
		public virtual void SetEolVisibility(bool visible) {
			interceptor.Invoke("setEolVisibility$", "setEolVisibility(bool)", typeof(void), typeof(bool), visible);
		}
		[Q_SLOT("void setFolding(QsciScintilla::FoldStyle)")]
		[SmokeMethod("setFolding(QsciScintilla::FoldStyle)")]
		public virtual void SetFolding(QsciScintilla.FoldStyle fold) {
			interceptor.Invoke("setFolding$", "setFolding(QsciScintilla::FoldStyle)", typeof(void), typeof(QsciScintilla.FoldStyle), fold);
		}
		[Q_SLOT("void setIndentation(int, int)")]
		[SmokeMethod("setIndentation(int, int)")]
		public virtual void SetIndentation(int line, int indentation) {
			interceptor.Invoke("setIndentation$$", "setIndentation(int, int)", typeof(void), typeof(int), line, typeof(int), indentation);
		}
		[Q_SLOT("void setIndentationGuides(bool)")]
		[SmokeMethod("setIndentationGuides(bool)")]
		public virtual void SetIndentationGuides(bool enable) {
			interceptor.Invoke("setIndentationGuides$", "setIndentationGuides(bool)", typeof(void), typeof(bool), enable);
		}
		[Q_SLOT("void setIndentationGuidesBackgroundColor(const QColor&)")]
		[SmokeMethod("setIndentationGuidesBackgroundColor(const QColor&)")]
		public virtual void SetIndentationGuidesBackgroundColor(QColor col) {
			interceptor.Invoke("setIndentationGuidesBackgroundColor#", "setIndentationGuidesBackgroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		[Q_SLOT("void setIndentationGuidesForegroundColor(const QColor&)")]
		[SmokeMethod("setIndentationGuidesForegroundColor(const QColor&)")]
		public virtual void SetIndentationGuidesForegroundColor(QColor col) {
			interceptor.Invoke("setIndentationGuidesForegroundColor#", "setIndentationGuidesForegroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		[Q_SLOT("void setIndentationsUseTabs(bool)")]
		[SmokeMethod("setIndentationsUseTabs(bool)")]
		public virtual void SetIndentationsUseTabs(bool tabs) {
			interceptor.Invoke("setIndentationsUseTabs$", "setIndentationsUseTabs(bool)", typeof(void), typeof(bool), tabs);
		}
		[Q_SLOT("void setIndentationWidth(int)")]
		[SmokeMethod("setIndentationWidth(int)")]
		public virtual void SetIndentationWidth(int width) {
			interceptor.Invoke("setIndentationWidth$", "setIndentationWidth(int)", typeof(void), typeof(int), width);
		}
		[Q_SLOT("void setLexer(QsciLexer*)")]
		[SmokeMethod("setLexer(QsciLexer*)")]
		public virtual void SetLexer(QsciLexer lexer) {
			interceptor.Invoke("setLexer#", "setLexer(QsciLexer*)", typeof(void), typeof(QsciLexer), lexer);
		}
		[Q_SLOT("void setLexer()")]
		[SmokeMethod("setLexer()")]
		public virtual void SetLexer() {
			interceptor.Invoke("setLexer", "setLexer()", typeof(void));
		}
		[Q_SLOT("void setMarginsBackgroundColor(const QColor&)")]
		[SmokeMethod("setMarginsBackgroundColor(const QColor&)")]
		public virtual void SetMarginsBackgroundColor(QColor col) {
			interceptor.Invoke("setMarginsBackgroundColor#", "setMarginsBackgroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		[Q_SLOT("void setMarginsFont(const QFont&)")]
		[SmokeMethod("setMarginsFont(const QFont&)")]
		public virtual void SetMarginsFont(QFont f) {
			interceptor.Invoke("setMarginsFont#", "setMarginsFont(const QFont&)", typeof(void), typeof(QFont), f);
		}
		[Q_SLOT("void setMarginsForegroundColor(const QColor&)")]
		[SmokeMethod("setMarginsForegroundColor(const QColor&)")]
		public virtual void SetMarginsForegroundColor(QColor col) {
			interceptor.Invoke("setMarginsForegroundColor#", "setMarginsForegroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		[Q_SLOT("void setMarginLineNumbers(int, bool)")]
		[SmokeMethod("setMarginLineNumbers(int, bool)")]
		public virtual void SetMarginLineNumbers(int margin, bool lnrs) {
			interceptor.Invoke("setMarginLineNumbers$$", "setMarginLineNumbers(int, bool)", typeof(void), typeof(int), margin, typeof(bool), lnrs);
		}
		[Q_SLOT("void setMarginMarkerMask(int, int)")]
		[SmokeMethod("setMarginMarkerMask(int, int)")]
		public virtual void SetMarginMarkerMask(int margin, int mask) {
			interceptor.Invoke("setMarginMarkerMask$$", "setMarginMarkerMask(int, int)", typeof(void), typeof(int), margin, typeof(int), mask);
		}
		[Q_SLOT("void setMarginSensitivity(int, bool)")]
		[SmokeMethod("setMarginSensitivity(int, bool)")]
		public virtual void SetMarginSensitivity(int margin, bool sens) {
			interceptor.Invoke("setMarginSensitivity$$", "setMarginSensitivity(int, bool)", typeof(void), typeof(int), margin, typeof(bool), sens);
		}
		[Q_SLOT("void setMarginWidth(int, int)")]
		[SmokeMethod("setMarginWidth(int, int)")]
		public virtual void SetMarginWidth(int margin, int width) {
			interceptor.Invoke("setMarginWidth$$", "setMarginWidth(int, int)", typeof(void), typeof(int), margin, typeof(int), width);
		}
		[Q_SLOT("void setMarginWidth(int, const QString&)")]
		[SmokeMethod("setMarginWidth(int, const QString&)")]
		public virtual void SetMarginWidth(int margin, string s) {
			interceptor.Invoke("setMarginWidth$$", "setMarginWidth(int, const QString&)", typeof(void), typeof(int), margin, typeof(string), s);
		}
		[Q_SLOT("void setModified(bool)")]
		[SmokeMethod("setModified(bool)")]
		public virtual void SetModified(bool m) {
			interceptor.Invoke("setModified$", "setModified(bool)", typeof(void), typeof(bool), m);
		}
		[Q_SLOT("void setPaper(const QColor&)")]
		[SmokeMethod("setPaper(const QColor&)")]
		public virtual void SetPaper(QColor c) {
			interceptor.Invoke("setPaper#", "setPaper(const QColor&)", typeof(void), typeof(QColor), c);
		}
		[Q_SLOT("void setReadOnly(bool)")]
		[SmokeMethod("setReadOnly(bool)")]
		public virtual void SetReadOnly(bool ro) {
			interceptor.Invoke("setReadOnly$", "setReadOnly(bool)", typeof(void), typeof(bool), ro);
		}
		[Q_SLOT("void setSelection(int, int, int, int)")]
		[SmokeMethod("setSelection(int, int, int, int)")]
		public virtual void SetSelection(int lineFrom, int indexFrom, int lineTo, int indexTo) {
			interceptor.Invoke("setSelection$$$$", "setSelection(int, int, int, int)", typeof(void), typeof(int), lineFrom, typeof(int), indexFrom, typeof(int), lineTo, typeof(int), indexTo);
		}
		[Q_SLOT("void setSelectionBackgroundColor(const QColor&)")]
		[SmokeMethod("setSelectionBackgroundColor(const QColor&)")]
		public virtual void SetSelectionBackgroundColor(QColor col) {
			interceptor.Invoke("setSelectionBackgroundColor#", "setSelectionBackgroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		[Q_SLOT("void setSelectionForegroundColor(const QColor&)")]
		[SmokeMethod("setSelectionForegroundColor(const QColor&)")]
		public virtual void SetSelectionForegroundColor(QColor col) {
			interceptor.Invoke("setSelectionForegroundColor#", "setSelectionForegroundColor(const QColor&)", typeof(void), typeof(QColor), col);
		}
		[Q_SLOT("void setTabIndents(bool)")]
		[SmokeMethod("setTabIndents(bool)")]
		public virtual void SetTabIndents(bool indent) {
			interceptor.Invoke("setTabIndents$", "setTabIndents(bool)", typeof(void), typeof(bool), indent);
		}
		[Q_SLOT("void setTabWidth(int)")]
		[SmokeMethod("setTabWidth(int)")]
		public virtual void SetTabWidth(int width) {
			interceptor.Invoke("setTabWidth$", "setTabWidth(int)", typeof(void), typeof(int), width);
		}
		[Q_SLOT("void setText(const QString&)")]
		[SmokeMethod("setText(const QString&)")]
		public virtual void SetText(string text) {
			interceptor.Invoke("setText$", "setText(const QString&)", typeof(void), typeof(string), text);
		}
		[Q_SLOT("void setUtf8(bool)")]
		[SmokeMethod("setUtf8(bool)")]
		public virtual void SetUtf8(bool cp) {
			interceptor.Invoke("setUtf8$", "setUtf8(bool)", typeof(void), typeof(bool), cp);
		}
		[Q_SLOT("void setWhitespaceVisibility(QsciScintilla::WhitespaceVisibility)")]
		[SmokeMethod("setWhitespaceVisibility(QsciScintilla::WhitespaceVisibility)")]
		public virtual void SetWhitespaceVisibility(QsciScintilla.WhitespaceVisibility mode) {
			interceptor.Invoke("setWhitespaceVisibility$", "setWhitespaceVisibility(QsciScintilla::WhitespaceVisibility)", typeof(void), typeof(QsciScintilla.WhitespaceVisibility), mode);
		}
		[Q_SLOT("void setWrapMode(QsciScintilla::WrapMode)")]
		[SmokeMethod("setWrapMode(QsciScintilla::WrapMode)")]
		public virtual void SetWrapMode(QsciScintilla.WrapMode mode) {
			interceptor.Invoke("setWrapMode$", "setWrapMode(QsciScintilla::WrapMode)", typeof(void), typeof(QsciScintilla.WrapMode), mode);
		}
		[Q_SLOT("void undo()")]
		[SmokeMethod("undo()")]
		public virtual void Undo() {
			interceptor.Invoke("undo", "undo()", typeof(void));
		}
		[Q_SLOT("void unindent(int)")]
		[SmokeMethod("unindent(int)")]
		public virtual void Unindent(int line) {
			interceptor.Invoke("unindent$", "unindent(int)", typeof(void), typeof(int), line);
		}
		[Q_SLOT("void zoomIn(int)")]
		[SmokeMethod("zoomIn(int)")]
		public virtual void ZoomIn(int range) {
			interceptor.Invoke("zoomIn$", "zoomIn(int)", typeof(void), typeof(int), range);
		}
		[Q_SLOT("void zoomIn()")]
		[SmokeMethod("zoomIn()")]
		public virtual void ZoomIn() {
			interceptor.Invoke("zoomIn", "zoomIn()", typeof(void));
		}
		[Q_SLOT("void zoomOut(int)")]
		[SmokeMethod("zoomOut(int)")]
		public virtual void ZoomOut(int range) {
			interceptor.Invoke("zoomOut$", "zoomOut(int)", typeof(void), typeof(int), range);
		}
		[Q_SLOT("void zoomOut()")]
		[SmokeMethod("zoomOut()")]
		public virtual void ZoomOut() {
			interceptor.Invoke("zoomOut", "zoomOut()", typeof(void));
		}
		[Q_SLOT("void zoomTo(int)")]
		[SmokeMethod("zoomTo(int)")]
		public virtual void ZoomTo(int size) {
			interceptor.Invoke("zoomTo$", "zoomTo(int)", typeof(void), typeof(int), size);
		}
		~QsciScintilla() {
			interceptor.Invoke("~QsciScintilla", "~QsciScintilla()", typeof(void));
		}
		public new void Dispose() {
			interceptor.Invoke("~QsciScintilla", "~QsciScintilla()", typeof(void));
		}
		public static new string Tr(string s, string c) {
			return (string) staticInterceptor.Invoke("tr$$", "tr(const char*, const char*)", typeof(string), typeof(string), s, typeof(string), c);
		}
		public static new string Tr(string s) {
			return (string) staticInterceptor.Invoke("tr$", "tr(const char*)", typeof(string), typeof(string), s);
		}
		protected new IQsciScintillaSignals Emit {
			get { return (IQsciScintillaSignals) Q_EMIT; }
		}
	}

	public interface IQsciScintillaSignals : IQsciScintillaBaseSignals {
		[Q_SIGNAL("void cursorPositionChanged(int, int)")]
		void CursorPositionChanged(int line, int pos);
		[Q_SIGNAL("void copyAvailable(bool)")]
		void CopyAvailable(bool yes);
		[Q_SIGNAL("void linesChanged()")]
		void LinesChanged();
		[Q_SIGNAL("void marginClicked(int, int, Qt::KeyboardModifiers)")]
		void MarginClicked(int margin, int line, uint state);
		[Q_SIGNAL("void modificationAttempted()")]
		void ModificationAttempted();
		[Q_SIGNAL("void modificationChanged(bool)")]
		void ModificationChanged(bool m);
		[Q_SIGNAL("void selectionChanged()")]
		void SelectionChanged();
		[Q_SIGNAL("void textChanged()")]
		void TextChanged();
		[Q_SIGNAL("void userListActivated(int, const QString&)")]
		void UserListActivated(int id, string arg2);
	}
}
