Move ScintillaCall from SciTE project.

5 files changed, 4384 insertions, 10 deletions

diff --git a/call/ScintillaCall.cxx b/call/ScintillaCall.cxx
new file mode 100644
index 000000000..f9bffeb64
--- /dev/null
+++ b/call/ScintillaCall.cxx
@@ -0,0 +1,3317 @@
+// SciTE - Scintilla based Text Editor
+/** @file ScintillaCall.cxx
+ ** Interface to calling a Scintilla instance.
+ **/
+// Copyright 1998-2019 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+/* Most of this file is automatically generated from the Scintilla.iface interface definition
+ * file which contains any comments about the definitions. APIFacer.py does the generation. */
+
+#include <cstdint>
+
+#include <string>
+#include <string_view>
+
+#include "ScintillaTypes.h"
+#include "ScintillaMessages.h"
+#include "ScintillaCall.h"
+
+namespace Scintilla {
+
+ScintillaCall::ScintillaCall() noexcept : fn(nullptr), ptr(0), statusLastCall(Status::Ok) {
+}
+
+void ScintillaCall::SetFnPtr(FunctionDirect fn_, intptr_t ptr_) noexcept {
+	fn = fn_;
+	ptr = ptr_;
+}
+
+bool ScintillaCall::IsValid() const noexcept {
+	return fn && ptr;
+}
+
+intptr_t ScintillaCall::Call(Message msg, uintptr_t wParam, intptr_t lParam) {
+	if (!fn)
+		throw Failure(Status::Failure);
+	int status = 0;
+	const intptr_t retVal = fn(ptr, static_cast<unsigned int>(msg), wParam, lParam, &status);
+	statusLastCall = static_cast<Scintilla::Status>(status);
+	if (statusLastCall > Status::Ok && statusLastCall < Status::WarnStart)
+		throw Failure(statusLastCall);
+	return retVal;
+}
+
+intptr_t ScintillaCall::CallPointer(Message msg, uintptr_t wParam, void *s) {
+	return Call(msg, wParam, reinterpret_cast<intptr_t>(s));
+}
+
+intptr_t ScintillaCall::CallString(Message msg, uintptr_t wParam, const char *s) {
+	return Call(msg, wParam, reinterpret_cast<intptr_t>(s));
+}
+
+std::string ScintillaCall::CallReturnString(Message msg, uintptr_t wParam) {
+	size_t len = CallPointer(msg, wParam, nullptr);
+	if (len) {
+		std::string value(len, '\0');
+		CallPointer(msg, wParam, value.data());
+		return value;
+	} else {
+		return std::string();
+	}
+}
+
+// Common APIs made more structured and type-safe
+
+Position ScintillaCall::LineStart(Line line) {
+	return Call(Message::PositionFromLine, line);
+}
+
+Position ScintillaCall::LineEnd(Line line) {
+	return Call(Message::GetLineEndPosition, line);
+}
+
+Span ScintillaCall::SelectionSpan() {
+	return Span(
+		       Call(Message::GetSelectionStart),
+		       Call(Message::GetSelectionEnd));
+}
+
+Span ScintillaCall::TargetSpan() {
+	return Span(
+		       Call(Message::GetTargetStart),
+		       Call(Message::GetTargetEnd));
+}
+
+void ScintillaCall::SetTarget(Span span) {
+	Call(Message::SetTargetRange, span.start, span.end);
+}
+
+void ScintillaCall::ColouriseAll() {
+	Colourise(0, -1);
+}
+
+char ScintillaCall::CharacterAt(Position position) {
+	return static_cast<char>(Call(Message::GetCharAt, position));
+}
+
+int ScintillaCall::UnsignedStyleAt(Position position) {
+	// Returns signed value but easier to use as unsigned
+	return static_cast<unsigned char>(Call(Message::GetStyleAt, position));
+}
+
+std::string ScintillaCall::StringOfSpan(Span span) {
+	if (span.Length() == 0) {
+		return std::string();
+	} else {
+		std::string text(span.Length(), '\0');
+		SetTarget(span);
+		TargetText(text.data());
+		return text;
+	}
+}
+
+Position ScintillaCall::ReplaceTarget(std::string_view text) {
+	return ScintillaCall::CallString(Message::ReplaceTarget, text.length(), text.data());
+}
+
+Position ScintillaCall::ReplaceTargetRE(std::string_view text) {
+	return CallString(Message::ReplaceTargetRE, text.length(), text.data());
+}
+
+Position ScintillaCall::SearchInTarget(std::string_view text) {
+	return CallString(Message::SearchInTarget, text.length(), text.data());
+}
+
+Span ScintillaCall::SpanSearchInTarget(std::string_view text) {
+	const Position posFound = SearchInTarget(text);
+	if (posFound >= 0)
+		return Span(posFound, TargetEnd());
+	else
+		return Span(posFound, 0);
+}
+
+// Generated methods
+
+// ScintillaCall requires automatically generated casts as it is converting
+// specific types to/from generic arguments and return values of 'Call'.
+// Suppress Visual C++ Code Analysis warnings for these casts and pointer returns.
+// 26472 = Don't use a static_cast for arithmetic conversions.
+// 26487 = Don't return a pointer '*' that may be invalid (lifetime.4).
+// 26490 = Don't use reinterpret_cast.
+#if defined(_MSC_VER)
+#pragma warning(disable: 26472 26487 26490)
+#endif
+
+//++Autogenerated -- start of section automatically generated from Scintilla.iface
+void ScintillaCall::AddText(Position length, const char *text) {
+	CallString(Message::AddText, length, text);
+}
+
+void ScintillaCall::AddStyledText(Position length, const char *c) {
+	CallString(Message::AddStyledText, length, c);
+}
+
+void ScintillaCall::InsertText(Position pos, const char *text) {
+	CallString(Message::InsertText, pos, text);
+}
+
+void ScintillaCall::ChangeInsertion(Position length, const char *text) {
+	CallString(Message::ChangeInsertion, length, text);
+}
+
+void ScintillaCall::ClearAll() {
+	Call(Message::ClearAll);
+}
+
+void ScintillaCall::DeleteRange(Position start, Position lengthDelete) {
+	Call(Message::DeleteRange, start, lengthDelete);
+}
+
+void ScintillaCall::ClearDocumentStyle() {
+	Call(Message::ClearDocumentStyle);
+}
+
+Position ScintillaCall::Length() {
+	return Call(Message::GetLength);
+}
+
+int ScintillaCall::CharAt(Position pos) {
+	return static_cast<int>(Call(Message::GetCharAt, pos));
+}
+
+Position ScintillaCall::CurrentPos() {
+	return Call(Message::GetCurrentPos);
+}
+
+Position ScintillaCall::Anchor() {
+	return Call(Message::GetAnchor);
+}
+
+int ScintillaCall::StyleAt(Position pos) {
+	return static_cast<int>(Call(Message::GetStyleAt, pos));
+}
+
+void ScintillaCall::Redo() {
+	Call(Message::Redo);
+}
+
+void ScintillaCall::SetUndoCollection(bool collectUndo) {
+	Call(Message::SetUndoCollection, collectUndo);
+}
+
+void ScintillaCall::SelectAll() {
+	Call(Message::SelectAll);
+}
+
+void ScintillaCall::SetSavePoint() {
+	Call(Message::SetSavePoint);
+}
+
+Position ScintillaCall::GetStyledText(void *tr) {
+	return CallPointer(Message::GetStyledText, 0, tr);
+}
+
+bool ScintillaCall::CanRedo() {
+	return Call(Message::CanRedo);
+}
+
+Line ScintillaCall::MarkerLineFromHandle(int markerHandle) {
+	return Call(Message::MarkerLineFromHandle, markerHandle);
+}
+
+void ScintillaCall::MarkerDeleteHandle(int markerHandle) {
+	Call(Message::MarkerDeleteHandle, markerHandle);
+}
+
+int ScintillaCall::MarkerHandleFromLine(Line line, int which) {
+	return static_cast<int>(Call(Message::MarkerHandleFromLine, line, which));
+}
+
+int ScintillaCall::MarkerNumberFromLine(Line line, int which) {
+	return static_cast<int>(Call(Message::MarkerNumberFromLine, line, which));
+}
+
+bool ScintillaCall::UndoCollection() {
+	return Call(Message::GetUndoCollection);
+}
+
+WhiteSpace ScintillaCall::ViewWS() {
+	return static_cast<Scintilla::WhiteSpace>(Call(Message::GetViewWS));
+}
+
+void ScintillaCall::SetViewWS(Scintilla::WhiteSpace viewWS) {
+	Call(Message::SetViewWS, static_cast<uintptr_t>(viewWS));
+}
+
+TabDrawMode ScintillaCall::TabDrawMode() {
+	return static_cast<Scintilla::TabDrawMode>(Call(Message::GetTabDrawMode));
+}
+
+void ScintillaCall::SetTabDrawMode(Scintilla::TabDrawMode tabDrawMode) {
+	Call(Message::SetTabDrawMode, static_cast<uintptr_t>(tabDrawMode));
+}
+
+Position ScintillaCall::PositionFromPoint(int x, int y) {
+	return Call(Message::PositionFromPoint, x, y);
+}
+
+Position ScintillaCall::PositionFromPointClose(int x, int y) {
+	return Call(Message::PositionFromPointClose, x, y);
+}
+
+void ScintillaCall::GotoLine(Line line) {
+	Call(Message::GotoLine, line);
+}
+
+void ScintillaCall::GotoPos(Position caret) {
+	Call(Message::GotoPos, caret);
+}
+
+void ScintillaCall::SetAnchor(Position anchor) {
+	Call(Message::SetAnchor, anchor);
+}
+
+Position ScintillaCall::GetCurLine(Position length, char *text) {
+	return CallPointer(Message::GetCurLine, length, text);
+}
+
+std::string ScintillaCall::GetCurLine(Position length) {
+	return CallReturnString(Message::GetCurLine, length);
+}
+
+Position ScintillaCall::EndStyled() {
+	return Call(Message::GetEndStyled);
+}
+
+void ScintillaCall::ConvertEOLs(Scintilla::EndOfLine eolMode) {
+	Call(Message::ConvertEOLs, static_cast<uintptr_t>(eolMode));
+}
+
+EndOfLine ScintillaCall::EOLMode() {
+	return static_cast<Scintilla::EndOfLine>(Call(Message::GetEOLMode));
+}
+
+void ScintillaCall::SetEOLMode(Scintilla::EndOfLine eolMode) {
+	Call(Message::SetEOLMode, static_cast<uintptr_t>(eolMode));
+}
+
+void ScintillaCall::StartStyling(Position start, int unused) {
+	Call(Message::StartStyling, start, unused);
+}
+
+void ScintillaCall::SetStyling(Position length, int style) {
+	Call(Message::SetStyling, length, style);
+}
+
+bool ScintillaCall::BufferedDraw() {
+	return Call(Message::GetBufferedDraw);
+}
+
+void ScintillaCall::SetBufferedDraw(bool buffered) {
+	Call(Message::SetBufferedDraw, buffered);
+}
+
+void ScintillaCall::SetTabWidth(int tabWidth) {
+	Call(Message::SetTabWidth, tabWidth);
+}
+
+int ScintillaCall::TabWidth() {
+	return static_cast<int>(Call(Message::GetTabWidth));
+}
+
+void ScintillaCall::SetTabMinimumWidth(int pixels) {
+	Call(Message::SetTabMinimumWidth, pixels);
+}
+
+int ScintillaCall::TabMinimumWidth() {
+	return static_cast<int>(Call(Message::GetTabMinimumWidth));
+}
+
+void ScintillaCall::ClearTabStops(Line line) {
+	Call(Message::ClearTabStops, line);
+}
+
+void ScintillaCall::AddTabStop(Line line, int x) {
+	Call(Message::AddTabStop, line, x);
+}
+
+int ScintillaCall::GetNextTabStop(Line line, int x) {
+	return static_cast<int>(Call(Message::GetNextTabStop, line, x));
+}
+
+void ScintillaCall::SetCodePage(int codePage) {
+	Call(Message::SetCodePage, codePage);
+}
+
+void ScintillaCall::SetFontLocale(const char *localeName) {
+	CallString(Message::SetFontLocale, 0, localeName);
+}
+
+int ScintillaCall::FontLocale(char *localeName) {
+	return static_cast<int>(CallPointer(Message::GetFontLocale, 0, localeName));
+}
+
+std::string ScintillaCall::FontLocale() {
+	return CallReturnString(Message::GetFontLocale, 0);
+}
+
+IMEInteraction ScintillaCall::IMEInteraction() {
+	return static_cast<Scintilla::IMEInteraction>(Call(Message::GetIMEInteraction));
+}
+
+void ScintillaCall::SetIMEInteraction(Scintilla::IMEInteraction imeInteraction) {
+	Call(Message::SetIMEInteraction, static_cast<uintptr_t>(imeInteraction));
+}
+
+void ScintillaCall::MarkerDefine(int markerNumber, Scintilla::MarkerSymbol markerSymbol) {
+	Call(Message::MarkerDefine, markerNumber, static_cast<intptr_t>(markerSymbol));
+}
+
+void ScintillaCall::MarkerSetFore(int markerNumber, Colour fore) {
+	Call(Message::MarkerSetFore, markerNumber, fore);
+}
+
+void ScintillaCall::MarkerSetBack(int markerNumber, Colour back) {
+	Call(Message::MarkerSetBack, markerNumber, back);
+}
+
+void ScintillaCall::MarkerSetBackSelected(int markerNumber, Colour back) {
+	Call(Message::MarkerSetBackSelected, markerNumber, back);
+}
+
+void ScintillaCall::MarkerSetForeTranslucent(int markerNumber, ColourAlpha fore) {
+	Call(Message::MarkerSetForeTranslucent, markerNumber, fore);
+}
+
+void ScintillaCall::MarkerSetBackTranslucent(int markerNumber, ColourAlpha back) {
+	Call(Message::MarkerSetBackTranslucent, markerNumber, back);
+}
+
+void ScintillaCall::MarkerSetBackSelectedTranslucent(int markerNumber, ColourAlpha back) {
+	Call(Message::MarkerSetBackSelectedTranslucent, markerNumber, back);
+}
+
+void ScintillaCall::MarkerSetStrokeWidth(int markerNumber, int hundredths) {
+	Call(Message::MarkerSetStrokeWidth, markerNumber, hundredths);
+}
+
+void ScintillaCall::MarkerEnableHighlight(bool enabled) {
+	Call(Message::MarkerEnableHighlight, enabled);
+}
+
+int ScintillaCall::MarkerAdd(Line line, int markerNumber) {
+	return static_cast<int>(Call(Message::MarkerAdd, line, markerNumber));
+}
+
+void ScintillaCall::MarkerDelete(Line line, int markerNumber) {
+	Call(Message::MarkerDelete, line, markerNumber);
+}
+
+void ScintillaCall::MarkerDeleteAll(int markerNumber) {
+	Call(Message::MarkerDeleteAll, markerNumber);
+}
+
+int ScintillaCall::MarkerGet(Line line) {
+	return static_cast<int>(Call(Message::MarkerGet, line));
+}
+
+Line ScintillaCall::MarkerNext(Line lineStart, int markerMask) {
+	return Call(Message::MarkerNext, lineStart, markerMask);
+}
+
+Line ScintillaCall::MarkerPrevious(Line lineStart, int markerMask) {
+	return Call(Message::MarkerPrevious, lineStart, markerMask);
+}
+
+void ScintillaCall::MarkerDefinePixmap(int markerNumber, const char *pixmap) {
+	CallString(Message::MarkerDefinePixmap, markerNumber, pixmap);
+}
+
+void ScintillaCall::MarkerAddSet(Line line, int markerSet) {
+	Call(Message::MarkerAddSet, line, markerSet);
+}
+
+void ScintillaCall::MarkerSetAlpha(int markerNumber, Scintilla::Alpha alpha) {
+	Call(Message::MarkerSetAlpha, markerNumber, static_cast<intptr_t>(alpha));
+}
+
+Layer ScintillaCall::MarkerGetLayer(int markerNumber) {
+	return static_cast<Scintilla::Layer>(Call(Message::MarkerGetLayer, markerNumber));
+}
+
+void ScintillaCall::MarkerSetLayer(int markerNumber, Scintilla::Layer layer) {
+	Call(Message::MarkerSetLayer, markerNumber, static_cast<intptr_t>(layer));
+}
+
+void ScintillaCall::SetMarginTypeN(int margin, Scintilla::MarginType marginType) {
+	Call(Message::SetMarginTypeN, margin, static_cast<intptr_t>(marginType));
+}
+
+MarginType ScintillaCall::MarginTypeN(int margin) {
+	return static_cast<Scintilla::MarginType>(Call(Message::GetMarginTypeN, margin));
+}
+
+void ScintillaCall::SetMarginWidthN(int margin, int pixelWidth) {
+	Call(Message::SetMarginWidthN, margin, pixelWidth);
+}
+
+int ScintillaCall::MarginWidthN(int margin) {
+	return static_cast<int>(Call(Message::GetMarginWidthN, margin));
+}
+
+void ScintillaCall::SetMarginMaskN(int margin, int mask) {
+	Call(Message::SetMarginMaskN, margin, mask);
+}
+
+int ScintillaCall::MarginMaskN(int margin) {
+	return static_cast<int>(Call(Message::GetMarginMaskN, margin));
+}
+
+void ScintillaCall::SetMarginSensitiveN(int margin, bool sensitive) {
+	Call(Message::SetMarginSensitiveN, margin, sensitive);
+}
+
+bool ScintillaCall::MarginSensitiveN(int margin) {
+	return Call(Message::GetMarginSensitiveN, margin);
+}
+
+void ScintillaCall::SetMarginCursorN(int margin, Scintilla::CursorShape cursor) {
+	Call(Message::SetMarginCursorN, margin, static_cast<intptr_t>(cursor));
+}
+
+CursorShape ScintillaCall::MarginCursorN(int margin) {
+	return static_cast<Scintilla::CursorShape>(Call(Message::GetMarginCursorN, margin));
+}
+
+void ScintillaCall::SetMarginBackN(int margin, Colour back) {
+	Call(Message::SetMarginBackN, margin, back);
+}
+
+Colour ScintillaCall::MarginBackN(int margin) {
+	return static_cast<Colour>(Call(Message::GetMarginBackN, margin));
+}
+
+void ScintillaCall::SetMargins(int margins) {
+	Call(Message::SetMargins, margins);
+}
+
+int ScintillaCall::Margins() {
+	return static_cast<int>(Call(Message::GetMargins));
+}
+
+void ScintillaCall::StyleClearAll() {
+	Call(Message::StyleClearAll);
+}
+
+void ScintillaCall::StyleSetFore(int style, Colour fore) {
+	Call(Message::StyleSetFore, style, fore);
+}
+
+void ScintillaCall::StyleSetBack(int style, Colour back) {
+	Call(Message::StyleSetBack, style, back);
+}
+
+void ScintillaCall::StyleSetBold(int style, bool bold) {
+	Call(Message::StyleSetBold, style, bold);
+}
+
+void ScintillaCall::StyleSetItalic(int style, bool italic) {
+	Call(Message::StyleSetItalic, style, italic);
+}
+
+void ScintillaCall::StyleSetSize(int style, int sizePoints) {
+	Call(Message::StyleSetSize, style, sizePoints);
+}
+
+void ScintillaCall::StyleSetFont(int style, const char *fontName) {
+	CallString(Message::StyleSetFont, style, fontName);
+}
+
+void ScintillaCall::StyleSetEOLFilled(int style, bool eolFilled) {
+	Call(Message::StyleSetEOLFilled, style, eolFilled);
+}
+
+void ScintillaCall::StyleResetDefault() {
+	Call(Message::StyleResetDefault);
+}
+
+void ScintillaCall::StyleSetUnderline(int style, bool underline) {
+	Call(Message::StyleSetUnderline, style, underline);
+}
+
+Colour ScintillaCall::StyleGetFore(int style) {
+	return static_cast<Colour>(Call(Message::StyleGetFore, style));
+}
+
+Colour ScintillaCall::StyleGetBack(int style) {
+	return static_cast<Colour>(Call(Message::StyleGetBack, style));
+}
+
+bool ScintillaCall::StyleGetBold(int style) {
+	return Call(Message::StyleGetBold, style);
+}
+
+bool ScintillaCall::StyleGetItalic(int style) {
+	return Call(Message::StyleGetItalic, style);
+}
+
+int ScintillaCall::StyleGetSize(int style) {
+	return static_cast<int>(Call(Message::StyleGetSize, style));
+}
+
+int ScintillaCall::StyleGetFont(int style, char *fontName) {
+	return static_cast<int>(CallPointer(Message::StyleGetFont, style, fontName));
+}
+
+std::string ScintillaCall::StyleGetFont(int style) {
+	return CallReturnString(Message::StyleGetFont, style);
+}
+
+bool ScintillaCall::StyleGetEOLFilled(int style) {
+	return Call(Message::StyleGetEOLFilled, style);
+}
+
+bool ScintillaCall::StyleGetUnderline(int style) {
+	return Call(Message::StyleGetUnderline, style);
+}
+
+CaseVisible ScintillaCall::StyleGetCase(int style) {
+	return static_cast<Scintilla::CaseVisible>(Call(Message::StyleGetCase, style));
+}
+
+CharacterSet ScintillaCall::StyleGetCharacterSet(int style) {
+	return static_cast<Scintilla::CharacterSet>(Call(Message::StyleGetCharacterSet, style));
+}
+
+bool ScintillaCall::StyleGetVisible(int style) {
+	return Call(Message::StyleGetVisible, style);
+}
+
+bool ScintillaCall::StyleGetChangeable(int style) {
+	return Call(Message::StyleGetChangeable, style);
+}
+
+bool ScintillaCall::StyleGetHotSpot(int style) {
+	return Call(Message::StyleGetHotSpot, style);
+}
+
+void ScintillaCall::StyleSetCase(int style, Scintilla::CaseVisible caseVisible) {
+	Call(Message::StyleSetCase, style, static_cast<intptr_t>(caseVisible));
+}
+
+void ScintillaCall::StyleSetSizeFractional(int style, int sizeHundredthPoints) {
+	Call(Message::StyleSetSizeFractional, style, sizeHundredthPoints);
+}
+
+int ScintillaCall::StyleGetSizeFractional(int style) {
+	return static_cast<int>(Call(Message::StyleGetSizeFractional, style));
+}
+
+void ScintillaCall::StyleSetWeight(int style, Scintilla::FontWeight weight) {
+	Call(Message::StyleSetWeight, style, static_cast<intptr_t>(weight));
+}
+
+FontWeight ScintillaCall::StyleGetWeight(int style) {
+	return static_cast<Scintilla::FontWeight>(Call(Message::StyleGetWeight, style));
+}
+
+void ScintillaCall::StyleSetCharacterSet(int style, Scintilla::CharacterSet characterSet) {
+	Call(Message::StyleSetCharacterSet, style, static_cast<intptr_t>(characterSet));
+}
+
+void ScintillaCall::StyleSetHotSpot(int style, bool hotspot) {
+	Call(Message::StyleSetHotSpot, style, hotspot);
+}
+
+void ScintillaCall::SetElementColour(Scintilla::Element element, ColourAlpha colourElement) {
+	Call(Message::SetElementColour, static_cast<uintptr_t>(element), colourElement);
+}
+
+ColourAlpha ScintillaCall::ElementColour(Scintilla::Element element) {
+	return static_cast<ColourAlpha>(Call(Message::GetElementColour, static_cast<uintptr_t>(element)));
+}
+
+void ScintillaCall::ResetElementColour(Scintilla::Element element) {
+	Call(Message::ResetElementColour, static_cast<uintptr_t>(element));
+}
+
+bool ScintillaCall::ElementIsSet(Scintilla::Element element) {
+	return Call(Message::GetElementIsSet, static_cast<uintptr_t>(element));
+}
+
+bool ScintillaCall::ElementAllowsTranslucent(Scintilla::Element element) {
+	return Call(Message::GetElementAllowsTranslucent, static_cast<uintptr_t>(element));
+}
+
+ColourAlpha ScintillaCall::ElementBaseColour(Scintilla::Element element) {
+	return static_cast<ColourAlpha>(Call(Message::GetElementBaseColour, static_cast<uintptr_t>(element)));
+}
+
+void ScintillaCall::SetSelFore(bool useSetting, Colour fore) {
+	Call(Message::SetSelFore, useSetting, fore);
+}
+
+void ScintillaCall::SetSelBack(bool useSetting, Colour back) {
+	Call(Message::SetSelBack, useSetting, back);
+}
+
+Alpha ScintillaCall::SelAlpha() {
+	return static_cast<Scintilla::Alpha>(Call(Message::GetSelAlpha));
+}
+
+void ScintillaCall::SetSelAlpha(Scintilla::Alpha alpha) {
+	Call(Message::SetSelAlpha, static_cast<uintptr_t>(alpha));
+}
+
+bool ScintillaCall::SelEOLFilled() {
+	return Call(Message::GetSelEOLFilled);
+}
+
+void ScintillaCall::SetSelEOLFilled(bool filled) {
+	Call(Message::SetSelEOLFilled, filled);
+}
+
+Layer ScintillaCall::SelectionLayer() {
+	return static_cast<Scintilla::Layer>(Call(Message::GetSelectionLayer));
+}
+
+void ScintillaCall::SetSelectionLayer(Scintilla::Layer layer) {
+	Call(Message::SetSelectionLayer, static_cast<uintptr_t>(layer));
+}
+
+Layer ScintillaCall::CaretLineLayer() {
+	return static_cast<Scintilla::Layer>(Call(Message::GetCaretLineLayer));
+}
+
+void ScintillaCall::SetCaretLineLayer(Scintilla::Layer layer) {
+	Call(Message::SetCaretLineLayer, static_cast<uintptr_t>(layer));
+}
+
+void ScintillaCall::SetCaretFore(Colour fore) {
+	Call(Message::SetCaretFore, fore);
+}
+
+void ScintillaCall::AssignCmdKey(int keyDefinition, int sciCommand) {
+	Call(Message::AssignCmdKey, keyDefinition, sciCommand);
+}
+
+void ScintillaCall::ClearCmdKey(int keyDefinition) {
+	Call(Message::ClearCmdKey, keyDefinition);
+}
+
+void ScintillaCall::ClearAllCmdKeys() {
+	Call(Message::ClearAllCmdKeys);
+}
+
+void ScintillaCall::SetStylingEx(Position length, const char *styles) {
+	CallString(Message::SetStylingEx, length, styles);
+}
+
+void ScintillaCall::StyleSetVisible(int style, bool visible) {
+	Call(Message::StyleSetVisible, style, visible);
+}
+
+int ScintillaCall::CaretPeriod() {
+	return static_cast<int>(Call(Message::GetCaretPeriod));
+}
+
+void ScintillaCall::SetCaretPeriod(int periodMilliseconds) {
+	Call(Message::SetCaretPeriod, periodMilliseconds);
+}
+
+void ScintillaCall::SetWordChars(const char *characters) {
+	CallString(Message::SetWordChars, 0, characters);
+}
+
+int ScintillaCall::WordChars(char *characters) {
+	return static_cast<int>(CallPointer(Message::GetWordChars, 0, characters));
+}
+
+std::string ScintillaCall::WordChars() {
+	return CallReturnString(Message::GetWordChars, 0);
+}
+
+void ScintillaCall::SetCharacterCategoryOptimization(int countCharacters) {
+	Call(Message::SetCharacterCategoryOptimization, countCharacters);
+}
+
+int ScintillaCall::CharacterCategoryOptimization() {
+	return static_cast<int>(Call(Message::GetCharacterCategoryOptimization));
+}
+
+void ScintillaCall::BeginUndoAction() {
+	Call(Message::BeginUndoAction);
+}
+
+void ScintillaCall::EndUndoAction() {
+	Call(Message::EndUndoAction);
+}
+
+void ScintillaCall::IndicSetStyle(int indicator, Scintilla::IndicatorStyle indicatorStyle) {
+	Call(Message::IndicSetStyle, indicator, static_cast<intptr_t>(indicatorStyle));
+}
+
+IndicatorStyle ScintillaCall::IndicGetStyle(int indicator) {
+	return static_cast<Scintilla::IndicatorStyle>(Call(Message::IndicGetStyle, indicator));
+}
+
+void ScintillaCall::IndicSetFore(int indicator, Colour fore) {
+	Call(Message::IndicSetFore, indicator, fore);
+}
+
+Colour ScintillaCall::IndicGetFore(int indicator) {
+	return static_cast<Colour>(Call(Message::IndicGetFore, indicator));
+}
+
+void ScintillaCall::IndicSetUnder(int indicator, bool under) {
+	Call(Message::IndicSetUnder, indicator, under);
+}
+
+bool ScintillaCall::IndicGetUnder(int indicator) {
+	return Call(Message::IndicGetUnder, indicator);
+}
+
+void ScintillaCall::IndicSetHoverStyle(int indicator, Scintilla::IndicatorStyle indicatorStyle) {
+	Call(Message::IndicSetHoverStyle, indicator, static_cast<intptr_t>(indicatorStyle));
+}
+
+IndicatorStyle ScintillaCall::IndicGetHoverStyle(int indicator) {
+	return static_cast<Scintilla::IndicatorStyle>(Call(Message::IndicGetHoverStyle, indicator));
+}
+
+void ScintillaCall::IndicSetHoverFore(int indicator, Colour fore) {
+	Call(Message::IndicSetHoverFore, indicator, fore);
+}
+
+Colour ScintillaCall::IndicGetHoverFore(int indicator) {
+	return static_cast<Colour>(Call(Message::IndicGetHoverFore, indicator));
+}
+
+void ScintillaCall::IndicSetFlags(int indicator, Scintilla::IndicFlag flags) {
+	Call(Message::IndicSetFlags, indicator, static_cast<intptr_t>(flags));
+}
+
+IndicFlag ScintillaCall::IndicGetFlags(int indicator) {
+	return static_cast<Scintilla::IndicFlag>(Call(Message::IndicGetFlags, indicator));
+}
+
+void ScintillaCall::IndicSetStrokeWidth(int indicator, int hundredths) {
+	Call(Message::IndicSetStrokeWidth, indicator, hundredths);
+}
+
+int ScintillaCall::IndicGetStrokeWidth(int indicator) {
+	return static_cast<int>(Call(Message::IndicGetStrokeWidth, indicator));
+}
+
+void ScintillaCall::SetWhitespaceFore(bool useSetting, Colour fore) {
+	Call(Message::SetWhitespaceFore, useSetting, fore);
+}
+
+void ScintillaCall::SetWhitespaceBack(bool useSetting, Colour back) {
+	Call(Message::SetWhitespaceBack, useSetting, back);
+}
+
+void ScintillaCall::SetWhitespaceSize(int size) {
+	Call(Message::SetWhitespaceSize, size);
+}
+
+int ScintillaCall::WhitespaceSize() {
+	return static_cast<int>(Call(Message::GetWhitespaceSize));
+}
+
+void ScintillaCall::SetLineState(Line line, int state) {
+	Call(Message::SetLineState, line, state);
+}
+
+int ScintillaCall::LineState(Line line) {
+	return static_cast<int>(Call(Message::GetLineState, line));
+}
+
+int ScintillaCall::MaxLineState() {
+	return static_cast<int>(Call(Message::GetMaxLineState));
+}
+
+bool ScintillaCall::CaretLineVisible() {
+	return Call(Message::GetCaretLineVisible);
+}
+
+void ScintillaCall::SetCaretLineVisible(bool show) {
+	Call(Message::SetCaretLineVisible, show);
+}
+
+Colour ScintillaCall::CaretLineBack() {
+	return static_cast<Colour>(Call(Message::GetCaretLineBack));
+}
+
+void ScintillaCall::SetCaretLineBack(Colour back) {
+	Call(Message::SetCaretLineBack, back);
+}
+
+int ScintillaCall::CaretLineFrame() {
+	return static_cast<int>(Call(Message::GetCaretLineFrame));
+}
+
+void ScintillaCall::SetCaretLineFrame(int width) {
+	Call(Message::SetCaretLineFrame, width);
+}
+
+void ScintillaCall::StyleSetChangeable(int style, bool changeable) {
+	Call(Message::StyleSetChangeable, style, changeable);
+}
+
+void ScintillaCall::AutoCShow(Position lengthEntered, const char *itemList) {
+	CallString(Message::AutoCShow, lengthEntered, itemList);
+}
+
+void ScintillaCall::AutoCCancel() {
+	Call(Message::AutoCCancel);
+}
+
+bool ScintillaCall::AutoCActive() {
+	return Call(Message::AutoCActive);
+}
+
+Position ScintillaCall::AutoCPosStart() {
+	return Call(Message::AutoCPosStart);
+}
+
+void ScintillaCall::AutoCComplete() {
+	Call(Message::AutoCComplete);
+}
+
+void ScintillaCall::AutoCStops(const char *characterSet) {
+	CallString(Message::AutoCStops, 0, characterSet);
+}
+
+void ScintillaCall::AutoCSetSeparator(int separatorCharacter) {
+	Call(Message::AutoCSetSeparator, separatorCharacter);
+}
+
+int ScintillaCall::AutoCGetSeparator() {
+	return static_cast<int>(Call(Message::AutoCGetSeparator));
+}
+
+void ScintillaCall::AutoCSelect(const char *select) {
+	CallString(Message::AutoCSelect, 0, select);
+}
+
+void ScintillaCall::AutoCSetCancelAtStart(bool cancel) {
+	Call(Message::AutoCSetCancelAtStart, cancel);
+}
+
+bool ScintillaCall::AutoCGetCancelAtStart() {
+	return Call(Message::AutoCGetCancelAtStart);
+}
+
+void ScintillaCall::AutoCSetFillUps(const char *characterSet) {
+	CallString(Message::AutoCSetFillUps, 0, characterSet);
+}
+
+void ScintillaCall::AutoCSetChooseSingle(bool chooseSingle) {
+	Call(Message::AutoCSetChooseSingle, chooseSingle);
+}
+
+bool ScintillaCall::AutoCGetChooseSingle() {
+	return Call(Message::AutoCGetChooseSingle);
+}
+
+void ScintillaCall::AutoCSetIgnoreCase(bool ignoreCase) {
+	Call(Message::AutoCSetIgnoreCase, ignoreCase);
+}
+
+bool ScintillaCall::AutoCGetIgnoreCase() {
+	return Call(Message::AutoCGetIgnoreCase);
+}
+
+void ScintillaCall::UserListShow(int listType, const char *itemList) {
+	CallString(Message::UserListShow, listType, itemList);
+}
+
+void ScintillaCall::AutoCSetAutoHide(bool autoHide) {
+	Call(Message::AutoCSetAutoHide, autoHide);
+}
+
+bool ScintillaCall::AutoCGetAutoHide() {
+	return Call(Message::AutoCGetAutoHide);
+}
+
+void ScintillaCall::AutoCSetDropRestOfWord(bool dropRestOfWord) {
+	Call(Message::AutoCSetDropRestOfWord, dropRestOfWord);
+}
+
+bool ScintillaCall::AutoCGetDropRestOfWord() {
+	return Call(Message::AutoCGetDropRestOfWord);
+}
+
+void ScintillaCall::RegisterImage(int type, const char *xpmData) {
+	CallString(Message::RegisterImage, type, xpmData);
+}
+
+void ScintillaCall::ClearRegisteredImages() {
+	Call(Message::ClearRegisteredImages);
+}
+
+int ScintillaCall::AutoCGetTypeSeparator() {
+	return static_cast<int>(Call(Message::AutoCGetTypeSeparator));
+}
+
+void ScintillaCall::AutoCSetTypeSeparator(int separatorCharacter) {
+	Call(Message::AutoCSetTypeSeparator, separatorCharacter);
+}
+
+void ScintillaCall::AutoCSetMaxWidth(int characterCount) {
+	Call(Message::AutoCSetMaxWidth, characterCount);
+}
+
+int ScintillaCall::AutoCGetMaxWidth() {
+	return static_cast<int>(Call(Message::AutoCGetMaxWidth));
+}
+
+void ScintillaCall::AutoCSetMaxHeight(int rowCount) {
+	Call(Message::AutoCSetMaxHeight, rowCount);
+}
+
+int ScintillaCall::AutoCGetMaxHeight() {
+	return static_cast<int>(Call(Message::AutoCGetMaxHeight));
+}
+
+void ScintillaCall::SetIndent(int indentSize) {
+	Call(Message::SetIndent, indentSize);
+}
+
+int ScintillaCall::Indent() {
+	return static_cast<int>(Call(Message::GetIndent));
+}
+
+void ScintillaCall::SetUseTabs(bool useTabs) {
+	Call(Message::SetUseTabs, useTabs);
+}
+
+bool ScintillaCall::UseTabs() {
+	return Call(Message::GetUseTabs);
+}
+
+void ScintillaCall::SetLineIndentation(Line line, int indentation) {
+	Call(Message::SetLineIndentation, line, indentation);
+}
+
+int ScintillaCall::LineIndentation(Line line) {
+	return static_cast<int>(Call(Message::GetLineIndentation, line));
+}
+
+Position ScintillaCall::LineIndentPosition(Line line) {
+	return Call(Message::GetLineIndentPosition, line);
+}
+
+Position ScintillaCall::Column(Position pos) {
+	return Call(Message::GetColumn, pos);
+}
+
+Position ScintillaCall::CountCharacters(Position start, Position end) {
+	return Call(Message::CountCharacters, start, end);
+}
+
+Position ScintillaCall::CountCodeUnits(Position start, Position end) {
+	return Call(Message::CountCodeUnits, start, end);
+}
+
+void ScintillaCall::SetHScrollBar(bool visible) {
+	Call(Message::SetHScrollBar, visible);
+}
+
+bool ScintillaCall::HScrollBar() {
+	return Call(Message::GetHScrollBar);
+}
+
+void ScintillaCall::SetIndentationGuides(Scintilla::IndentView indentView) {
+	Call(Message::SetIndentationGuides, static_cast<uintptr_t>(indentView));
+}
+
+IndentView ScintillaCall::IndentationGuides() {
+	return static_cast<Scintilla::IndentView>(Call(Message::GetIndentationGuides));
+}
+
+void ScintillaCall::SetHighlightGuide(Position column) {
+	Call(Message::SetHighlightGuide, column);
+}
+
+Position ScintillaCall::HighlightGuide() {
+	return Call(Message::GetHighlightGuide);
+}
+
+Position ScintillaCall::LineEndPosition(Line line) {
+	return Call(Message::GetLineEndPosition, line);
+}
+
+int ScintillaCall::CodePage() {
+	return static_cast<int>(Call(Message::GetCodePage));
+}
+
+Colour ScintillaCall::CaretFore() {
+	return static_cast<Colour>(Call(Message::GetCaretFore));
+}
+
+bool ScintillaCall::ReadOnly() {
+	return Call(Message::GetReadOnly);
+}
+
+void ScintillaCall::SetCurrentPos(Position caret) {
+	Call(Message::SetCurrentPos, caret);
+}
+
+void ScintillaCall::SetSelectionStart(Position anchor) {
+	Call(Message::SetSelectionStart, anchor);
+}
+
+Position ScintillaCall::SelectionStart() {
+	return Call(Message::GetSelectionStart);
+}
+
+void ScintillaCall::SetSelectionEnd(Position caret) {
+	Call(Message::SetSelectionEnd, caret);
+}
+
+Position ScintillaCall::SelectionEnd() {
+	return Call(Message::GetSelectionEnd);
+}
+
+void ScintillaCall::SetEmptySelection(Position caret) {
+	Call(Message::SetEmptySelection, caret);
+}
+
+void ScintillaCall::SetPrintMagnification(int magnification) {
+	Call(Message::SetPrintMagnification, magnification);
+}
+
+int ScintillaCall::PrintMagnification() {
+	return static_cast<int>(Call(Message::GetPrintMagnification));
+}
+
+void ScintillaCall::SetPrintColourMode(Scintilla::PrintOption mode) {
+	Call(Message::SetPrintColourMode, static_cast<uintptr_t>(mode));
+}
+
+PrintOption ScintillaCall::PrintColourMode() {
+	return static_cast<Scintilla::PrintOption>(Call(Message::GetPrintColourMode));
+}
+
+Position ScintillaCall::FindText(Scintilla::FindOption searchFlags, void *ft) {
+	return CallPointer(Message::FindText, static_cast<uintptr_t>(searchFlags), ft);
+}
+
+Position ScintillaCall::FormatRange(bool draw, void *fr) {
+	return CallPointer(Message::FormatRange, draw, fr);
+}
+
+Line ScintillaCall::FirstVisibleLine() {
+	return Call(Message::GetFirstVisibleLine);
+}
+
+Position ScintillaCall::GetLine(Line line, char *text) {
+	return CallPointer(Message::GetLine, line, text);
+}
+
+std::string ScintillaCall::GetLine(Line line) {
+	return CallReturnString(Message::GetLine, line);
+}
+
+Line ScintillaCall::LineCount() {
+	return Call(Message::GetLineCount);
+}
+
+void ScintillaCall::SetMarginLeft(int pixelWidth) {
+	Call(Message::SetMarginLeft, 0, pixelWidth);
+}
+
+int ScintillaCall::MarginLeft() {
+	return static_cast<int>(Call(Message::GetMarginLeft));
+}
+
+void ScintillaCall::SetMarginRight(int pixelWidth) {
+	Call(Message::SetMarginRight, 0, pixelWidth);
+}
+
+int ScintillaCall::MarginRight() {
+	return static_cast<int>(Call(Message::GetMarginRight));
+}
+
+bool ScintillaCall::Modify() {
+	return Call(Message::GetModify);
+}
+
+void ScintillaCall::SetSel(Position anchor, Position caret) {
+	Call(Message::SetSel, anchor, caret);
+}
+
+Position ScintillaCall::GetSelText(char *text) {
+	return CallPointer(Message::GetSelText, 0, text);
+}
+
+std::string ScintillaCall::GetSelText() {
+	return CallReturnString(Message::GetSelText, 0);
+}
+
+Position ScintillaCall::GetTextRange(void *tr) {
+	return CallPointer(Message::GetTextRange, 0, tr);
+}
+
+void ScintillaCall::HideSelection(bool hide) {
+	Call(Message::HideSelection, hide);
+}
+
+int ScintillaCall::PointXFromPosition(Position pos) {
+	return static_cast<int>(Call(Message::PointXFromPosition, 0, pos));
+}
+
+int ScintillaCall::PointYFromPosition(Position pos) {
+	return static_cast<int>(Call(Message::PointYFromPosition, 0, pos));
+}
+
+Line ScintillaCall::LineFromPosition(Position pos) {
+	return Call(Message::LineFromPosition, pos);
+}
+
+Position ScintillaCall::PositionFromLine(Line line) {
+	return Call(Message::PositionFromLine, line);
+}
+
+void ScintillaCall::LineScroll(Position columns, Line lines) {
+	Call(Message::LineScroll, columns, lines);
+}
+
+void ScintillaCall::ScrollCaret() {
+	Call(Message::ScrollCaret);
+}
+
+void ScintillaCall::ScrollRange(Position secondary, Position primary) {
+	Call(Message::ScrollRange, secondary, primary);
+}
+
+void ScintillaCall::ReplaceSel(const char *text) {
+	CallString(Message::ReplaceSel, 0, text);
+}
+
+void ScintillaCall::SetReadOnly(bool readOnly) {
+	Call(Message::SetReadOnly, readOnly);
+}
+
+void ScintillaCall::Null() {
+	Call(Message::Null);
+}
+
+bool ScintillaCall::CanPaste() {
+	return Call(Message::CanPaste);
+}
+
+bool ScintillaCall::CanUndo() {
+	return Call(Message::CanUndo);
+}
+
+void ScintillaCall::EmptyUndoBuffer() {
+	Call(Message::EmptyUndoBuffer);
+}
+
+void ScintillaCall::Undo() {
+	Call(Message::Undo);
+}
+
+void ScintillaCall::Cut() {
+	Call(Message::Cut);
+}
+
+void ScintillaCall::Copy() {
+	Call(Message::Copy);
+}
+
+void ScintillaCall::Paste() {
+	Call(Message::Paste);
+}
+
+void ScintillaCall::Clear() {
+	Call(Message::Clear);
+}
+
+void ScintillaCall::SetText(const char *text) {
+	CallString(Message::SetText, 0, text);
+}
+
+Position ScintillaCall::GetText(Position length, char *text) {
+	return CallPointer(Message::GetText, length, text);
+}
+
+std::string ScintillaCall::GetText(Position length) {
+	return CallReturnString(Message::GetText, length);
+}
+
+Position ScintillaCall::TextLength() {
+	return Call(Message::GetTextLength);
+}
+
+void *ScintillaCall::DirectFunction() {
+	return reinterpret_cast<void *>(Call(Message::GetDirectFunction));
+}
+
+void *ScintillaCall::DirectStatusFunction() {
+	return reinterpret_cast<void *>(Call(Message::GetDirectStatusFunction));
+}
+
+void *ScintillaCall::DirectPointer() {
+	return reinterpret_cast<void *>(Call(Message::GetDirectPointer));
+}
+
+void ScintillaCall::SetOvertype(bool overType) {
+	Call(Message::SetOvertype, overType);
+}
+
+bool ScintillaCall::Overtype() {
+	return Call(Message::GetOvertype);
+}
+
+void ScintillaCall::SetCaretWidth(int pixelWidth) {
+	Call(Message::SetCaretWidth, pixelWidth);
+}
+
+int ScintillaCall::CaretWidth() {
+	return static_cast<int>(Call(Message::GetCaretWidth));
+}
+
+void ScintillaCall::SetTargetStart(Position start) {
+	Call(Message::SetTargetStart, start);
+}
+
+Position ScintillaCall::TargetStart() {
+	return Call(Message::GetTargetStart);
+}
+
+void ScintillaCall::SetTargetStartVirtualSpace(Position space) {
+	Call(Message::SetTargetStartVirtualSpace, space);
+}
+
+Position ScintillaCall::TargetStartVirtualSpace() {
+	return Call(Message::GetTargetStartVirtualSpace);
+}
+
+void ScintillaCall::SetTargetEnd(Position end) {
+	Call(Message::SetTargetEnd, end);
+}
+
+Position ScintillaCall::TargetEnd() {
+	return Call(Message::GetTargetEnd);
+}
+
+void ScintillaCall::SetTargetEndVirtualSpace(Position space) {
+	Call(Message::SetTargetEndVirtualSpace, space);
+}
+
+Position ScintillaCall::TargetEndVirtualSpace() {
+	return Call(Message::GetTargetEndVirtualSpace);
+}
+
+void ScintillaCall::SetTargetRange(Position start, Position end) {
+	Call(Message::SetTargetRange, start, end);
+}
+
+Position ScintillaCall::TargetText(char *text) {
+	return CallPointer(Message::GetTargetText, 0, text);
+}
+
+std::string ScintillaCall::TargetText() {
+	return CallReturnString(Message::GetTargetText, 0);
+}
+
+void ScintillaCall::TargetFromSelection() {
+	Call(Message::TargetFromSelection);
+}
+
+void ScintillaCall::TargetWholeDocument() {
+	Call(Message::TargetWholeDocument);
+}
+
+Position ScintillaCall::ReplaceTarget(Position length, const char *text) {
+	return CallString(Message::ReplaceTarget, length, text);
+}
+
+Position ScintillaCall::ReplaceTargetRE(Position length, const char *text) {
+	return CallString(Message::ReplaceTargetRE, length, text);
+}
+
+Position ScintillaCall::SearchInTarget(Position length, const char *text) {
+	return CallString(Message::SearchInTarget, length, text);
+}
+
+void ScintillaCall::SetSearchFlags(Scintilla::FindOption searchFlags) {
+	Call(Message::SetSearchFlags, static_cast<uintptr_t>(searchFlags));
+}
+
+FindOption ScintillaCall::SearchFlags() {
+	return static_cast<Scintilla::FindOption>(Call(Message::GetSearchFlags));
+}
+
+void ScintillaCall::CallTipShow(Position pos, const char *definition) {
+	CallString(Message::CallTipShow, pos, definition);
+}
+
+void ScintillaCall::CallTipCancel() {
+	Call(Message::CallTipCancel);
+}
+
+bool ScintillaCall::CallTipActive() {
+	return Call(Message::CallTipActive);
+}
+
+Position ScintillaCall::CallTipPosStart() {
+	return Call(Message::CallTipPosStart);
+}
+
+void ScintillaCall::CallTipSetPosStart(Position posStart) {
+	Call(Message::CallTipSetPosStart, posStart);
+}
+
+void ScintillaCall::CallTipSetHlt(Position highlightStart, Position highlightEnd) {
+	Call(Message::CallTipSetHlt, highlightStart, highlightEnd);
+}
+
+void ScintillaCall::CallTipSetBack(Colour back) {
+	Call(Message::CallTipSetBack, back);
+}
+
+void ScintillaCall::CallTipSetFore(Colour fore) {
+	Call(Message::CallTipSetFore, fore);
+}
+
+void ScintillaCall::CallTipSetForeHlt(Colour fore) {
+	Call(Message::CallTipSetForeHlt, fore);
+}
+
+void ScintillaCall::CallTipUseStyle(int tabSize) {
+	Call(Message::CallTipUseStyle, tabSize);
+}
+
+void ScintillaCall::CallTipSetPosition(bool above) {
+	Call(Message::CallTipSetPosition, above);
+}
+
+Line ScintillaCall::VisibleFromDocLine(Line docLine) {
+	return Call(Message::VisibleFromDocLine, docLine);
+}
+
+Line ScintillaCall::DocLineFromVisible(Line displayLine) {
+	return Call(Message::DocLineFromVisible, displayLine);
+}
+
+Line ScintillaCall::WrapCount(Line docLine) {
+	return Call(Message::WrapCount, docLine);
+}
+
+void ScintillaCall::SetFoldLevel(Line line, Scintilla::FoldLevel level) {
+	Call(Message::SetFoldLevel, line, static_cast<intptr_t>(level));
+}
+
+FoldLevel ScintillaCall::FoldLevel(Line line) {
+	return static_cast<Scintilla::FoldLevel>(Call(Message::GetFoldLevel, line));
+}
+
+Line ScintillaCall::LastChild(Line line, Scintilla::FoldLevel level) {
+	return Call(Message::GetLastChild, line, static_cast<intptr_t>(level));
+}
+
+Line ScintillaCall::FoldParent(Line line) {
+	return Call(Message::GetFoldParent, line);
+}
+
+void ScintillaCall::ShowLines(Line lineStart, Line lineEnd) {
+	Call(Message::ShowLines, lineStart, lineEnd);
+}
+
+void ScintillaCall::HideLines(Line lineStart, Line lineEnd) {
+	Call(Message::HideLines, lineStart, lineEnd);
+}
+
+bool ScintillaCall::LineVisible(Line line) {
+	return Call(Message::GetLineVisible, line);
+}
+
+bool ScintillaCall::AllLinesVisible() {
+	return Call(Message::GetAllLinesVisible);
+}
+
+void ScintillaCall::SetFoldExpanded(Line line, bool expanded) {
+	Call(Message::SetFoldExpanded, line, expanded);
+}
+
+bool ScintillaCall::FoldExpanded(Line line) {
+	return Call(Message::GetFoldExpanded, line);
+}
+
+void ScintillaCall::ToggleFold(Line line) {
+	Call(Message::ToggleFold, line);
+}
+
+void ScintillaCall::ToggleFoldShowText(Line line, const char *text) {
+	CallString(Message::ToggleFoldShowText, line, text);
+}
+
+void ScintillaCall::FoldDisplayTextSetStyle(Scintilla::FoldDisplayTextStyle style) {
+	Call(Message::FoldDisplayTextSetStyle, static_cast<uintptr_t>(style));
+}
+
+FoldDisplayTextStyle ScintillaCall::FoldDisplayTextGetStyle() {
+	return static_cast<Scintilla::FoldDisplayTextStyle>(Call(Message::FoldDisplayTextGetStyle));
+}
+
+void ScintillaCall::SetDefaultFoldDisplayText(const char *text) {
+	CallString(Message::SetDefaultFoldDisplayText, 0, text);
+}
+
+int ScintillaCall::GetDefaultFoldDisplayText(char *text) {
+	return static_cast<int>(CallPointer(Message::GetDefaultFoldDisplayText, 0, text));
+}
+
+std::string ScintillaCall::GetDefaultFoldDisplayText() {
+	return CallReturnString(Message::GetDefaultFoldDisplayText, 0);
+}
+
+void ScintillaCall::FoldLine(Line line, Scintilla::FoldAction action) {
+	Call(Message::FoldLine, line, static_cast<intptr_t>(action));
+}
+
+void ScintillaCall::FoldChildren(Line line, Scintilla::FoldAction action) {
+	Call(Message::FoldChildren, line, static_cast<intptr_t>(action));
+}
+
+void ScintillaCall::ExpandChildren(Line line, Scintilla::FoldLevel level) {
+	Call(Message::ExpandChildren, line, static_cast<intptr_t>(level));
+}
+
+void ScintillaCall::FoldAll(Scintilla::FoldAction action) {
+	Call(Message::FoldAll, static_cast<uintptr_t>(action));
+}
+
+void ScintillaCall::EnsureVisible(Line line) {
+	Call(Message::EnsureVisible, line);
+}
+
+void ScintillaCall::SetAutomaticFold(Scintilla::AutomaticFold automaticFold) {
+	Call(Message::SetAutomaticFold, static_cast<uintptr_t>(automaticFold));
+}
+
+AutomaticFold ScintillaCall::AutomaticFold() {
+	return static_cast<Scintilla::AutomaticFold>(Call(Message::GetAutomaticFold));
+}
+
+void ScintillaCall::SetFoldFlags(Scintilla::FoldFlag flags) {
+	Call(Message::SetFoldFlags, static_cast<uintptr_t>(flags));
+}
+
+void ScintillaCall::EnsureVisibleEnforcePolicy(Line line) {
+	Call(Message::EnsureVisibleEnforcePolicy, line);
+}
+
+void ScintillaCall::SetTabIndents(bool tabIndents) {
+	Call(Message::SetTabIndents, tabIndents);
+}
+
+bool ScintillaCall::TabIndents() {
+	return Call(Message::GetTabIndents);
+}
+
+void ScintillaCall::SetBackSpaceUnIndents(bool bsUnIndents) {
+	Call(Message::SetBackSpaceUnIndents, bsUnIndents);
+}
+
+bool ScintillaCall::BackSpaceUnIndents() {
+	return Call(Message::GetBackSpaceUnIndents);
+}
+
+void ScintillaCall::SetMouseDwellTime(int periodMilliseconds) {
+	Call(Message::SetMouseDwellTime, periodMilliseconds);
+}
+
+int ScintillaCall::MouseDwellTime() {
+	return static_cast<int>(Call(Message::GetMouseDwellTime));
+}
+
+Position ScintillaCall::WordStartPosition(Position pos, bool onlyWordCharacters) {
+	return Call(Message::WordStartPosition, pos, onlyWordCharacters);
+}
+
+Position ScintillaCall::WordEndPosition(Position pos, bool onlyWordCharacters) {
+	return Call(Message::WordEndPosition, pos, onlyWordCharacters);
+}
+
+bool ScintillaCall::IsRangeWord(Position start, Position end) {
+	return Call(Message::IsRangeWord, start, end);
+}
+
+void ScintillaCall::SetIdleStyling(Scintilla::IdleStyling idleStyling) {
+	Call(Message::SetIdleStyling, static_cast<uintptr_t>(idleStyling));
+}
+
+IdleStyling ScintillaCall::IdleStyling() {
+	return static_cast<Scintilla::IdleStyling>(Call(Message::GetIdleStyling));
+}
+
+void ScintillaCall::SetWrapMode(Scintilla::Wrap wrapMode) {
+	Call(Message::SetWrapMode, static_cast<uintptr_t>(wrapMode));
+}
+
+Wrap ScintillaCall::WrapMode() {
+	return static_cast<Scintilla::Wrap>(Call(Message::GetWrapMode));
+}
+
+void ScintillaCall::SetWrapVisualFlags(Scintilla::WrapVisualFlag wrapVisualFlags) {
+	Call(Message::SetWrapVisualFlags, static_cast<uintptr_t>(wrapVisualFlags));
+}
+
+WrapVisualFlag ScintillaCall::WrapVisualFlags() {
+	return static_cast<Scintilla::WrapVisualFlag>(Call(Message::GetWrapVisualFlags));
+}
+
+void ScintillaCall::SetWrapVisualFlagsLocation(Scintilla::WrapVisualLocation wrapVisualFlagsLocation) {
+	Call(Message::SetWrapVisualFlagsLocation, static_cast<uintptr_t>(wrapVisualFlagsLocation));
+}
+
+WrapVisualLocation ScintillaCall::WrapVisualFlagsLocation() {
+	return static_cast<Scintilla::WrapVisualLocation>(Call(Message::GetWrapVisualFlagsLocation));
+}
+
+void ScintillaCall::SetWrapStartIndent(int indent) {
+	Call(Message::SetWrapStartIndent, indent);
+}
+
+int ScintillaCall::WrapStartIndent() {
+	return static_cast<int>(Call(Message::GetWrapStartIndent));
+}
+
+void ScintillaCall::SetWrapIndentMode(Scintilla::WrapIndentMode wrapIndentMode) {
+	Call(Message::SetWrapIndentMode, static_cast<uintptr_t>(wrapIndentMode));
+}
+
+WrapIndentMode ScintillaCall::WrapIndentMode() {
+	return static_cast<Scintilla::WrapIndentMode>(Call(Message::GetWrapIndentMode));
+}
+
+void ScintillaCall::SetLayoutCache(Scintilla::LineCache cacheMode) {
+	Call(Message::SetLayoutCache, static_cast<uintptr_t>(cacheMode));
+}
+
+LineCache ScintillaCall::LayoutCache() {
+	return static_cast<Scintilla::LineCache>(Call(Message::GetLayoutCache));
+}
+
+void ScintillaCall::SetScrollWidth(int pixelWidth) {
+	Call(Message::SetScrollWidth, pixelWidth);
+}
+
+int ScintillaCall::ScrollWidth() {
+	return static_cast<int>(Call(Message::GetScrollWidth));
+}
+
+void ScintillaCall::SetScrollWidthTracking(bool tracking) {
+	Call(Message::SetScrollWidthTracking, tracking);
+}
+
+bool ScintillaCall::ScrollWidthTracking() {
+	return Call(Message::GetScrollWidthTracking);
+}
+
+int ScintillaCall::TextWidth(int style, const char *text) {
+	return static_cast<int>(CallString(Message::TextWidth, style, text));
+}
+
+void ScintillaCall::SetEndAtLastLine(bool endAtLastLine) {
+	Call(Message::SetEndAtLastLine, endAtLastLine);
+}
+
+bool ScintillaCall::EndAtLastLine() {
+	return Call(Message::GetEndAtLastLine);
+}
+
+int ScintillaCall::TextHeight(Line line) {
+	return static_cast<int>(Call(Message::TextHeight, line));
+}
+
+void ScintillaCall::SetVScrollBar(bool visible) {
+	Call(Message::SetVScrollBar, visible);
+}
+
+bool ScintillaCall::VScrollBar() {
+	return Call(Message::GetVScrollBar);
+}
+
+void ScintillaCall::AppendText(Position length, const char *text) {
+	CallString(Message::AppendText, length, text);
+}
+
+PhasesDraw ScintillaCall::PhasesDraw() {
+	return static_cast<Scintilla::PhasesDraw>(Call(Message::GetPhasesDraw));
+}
+
+void ScintillaCall::SetPhasesDraw(Scintilla::PhasesDraw phases) {
+	Call(Message::SetPhasesDraw, static_cast<uintptr_t>(phases));
+}
+
+void ScintillaCall::SetFontQuality(Scintilla::FontQuality fontQuality) {
+	Call(Message::SetFontQuality, static_cast<uintptr_t>(fontQuality));
+}
+
+FontQuality ScintillaCall::FontQuality() {
+	return static_cast<Scintilla::FontQuality>(Call(Message::GetFontQuality));
+}
+
+void ScintillaCall::SetFirstVisibleLine(Line displayLine) {
+	Call(Message::SetFirstVisibleLine, displayLine);
+}
+
+void ScintillaCall::SetMultiPaste(Scintilla::MultiPaste multiPaste) {
+	Call(Message::SetMultiPaste, static_cast<uintptr_t>(multiPaste));
+}
+
+MultiPaste ScintillaCall::MultiPaste() {
+	return static_cast<Scintilla::MultiPaste>(Call(Message::GetMultiPaste));
+}
+
+int ScintillaCall::Tag(int tagNumber, char *tagValue) {
+	return static_cast<int>(CallPointer(Message::GetTag, tagNumber, tagValue));
+}
+
+std::string ScintillaCall::Tag(int tagNumber) {
+	return CallReturnString(Message::GetTag, tagNumber);
+}
+
+void ScintillaCall::LinesJoin() {
+	Call(Message::LinesJoin);
+}
+
+void ScintillaCall::LinesSplit(int pixelWidth) {
+	Call(Message::LinesSplit, pixelWidth);
+}
+
+void ScintillaCall::SetFoldMarginColour(bool useSetting, Colour back) {
+	Call(Message::SetFoldMarginColour, useSetting, back);
+}
+
+void ScintillaCall::SetFoldMarginHiColour(bool useSetting, Colour fore) {
+	Call(Message::SetFoldMarginHiColour, useSetting, fore);
+}
+
+void ScintillaCall::SetAccessibility(Scintilla::Accessibility accessibility) {
+	Call(Message::SetAccessibility, static_cast<uintptr_t>(accessibility));
+}
+
+Accessibility ScintillaCall::Accessibility() {
+	return static_cast<Scintilla::Accessibility>(Call(Message::GetAccessibility));
+}
+
+void ScintillaCall::LineDown() {
+	Call(Message::LineDown);
+}
+
+void ScintillaCall::LineDownExtend() {
+	Call(Message::LineDownExtend);
+}
+
+void ScintillaCall::LineUp() {
+	Call(Message::LineUp);
+}
+
+void ScintillaCall::LineUpExtend() {
+	Call(Message::LineUpExtend);
+}
+
+void ScintillaCall::CharLeft() {
+	Call(Message::CharLeft);
+}
+
+void ScintillaCall::CharLeftExtend() {
+	Call(Message::CharLeftExtend);
+}
+
+void ScintillaCall::CharRight() {
+	Call(Message::CharRight);
+}
+
+void ScintillaCall::CharRightExtend() {
+	Call(Message::CharRightExtend);
+}
+
+void ScintillaCall::WordLeft() {
+	Call(Message::WordLeft);
+}
+
+void ScintillaCall::WordLeftExtend() {
+	Call(Message::WordLeftExtend);
+}
+
+void ScintillaCall::WordRight() {
+	Call(Message::WordRight);
+}
+
+void ScintillaCall::WordRightExtend() {
+	Call(Message::WordRightExtend);
+}
+
+void ScintillaCall::Home() {
+	Call(Message::Home);
+}
+
+void ScintillaCall::HomeExtend() {
+	Call(Message::HomeExtend);
+}
+
+void ScintillaCall::LineEnd() {
+	Call(Message::LineEnd);
+}
+
+void ScintillaCall::LineEndExtend() {
+	Call(Message::LineEndExtend);
+}
+
+void ScintillaCall::DocumentStart() {
+	Call(Message::DocumentStart);
+}
+
+void ScintillaCall::DocumentStartExtend() {
+	Call(Message::DocumentStartExtend);
+}
+
+void ScintillaCall::DocumentEnd() {
+	Call(Message::DocumentEnd);
+}
+
+void ScintillaCall::DocumentEndExtend() {
+	Call(Message::DocumentEndExtend);
+}
+
+void ScintillaCall::PageUp() {
+	Call(Message::PageUp);
+}
+
+void ScintillaCall::PageUpExtend() {
+	Call(Message::PageUpExtend);
+}
+
+void ScintillaCall::PageDown() {
+	Call(Message::PageDown);
+}
+
+void ScintillaCall::PageDownExtend() {
+	Call(Message::PageDownExtend);
+}
+
+void ScintillaCall::EditToggleOvertype() {
+	Call(Message::EditToggleOvertype);
+}
+
+void ScintillaCall::Cancel() {
+	Call(Message::Cancel);
+}
+
+void ScintillaCall::DeleteBack() {
+	Call(Message::DeleteBack);
+}
+
+void ScintillaCall::Tab() {
+	Call(Message::Tab);
+}
+
+void ScintillaCall::BackTab() {
+	Call(Message::BackTab);
+}
+
+void ScintillaCall::NewLine() {
+	Call(Message::NewLine);
+}
+
+void ScintillaCall::FormFeed() {
+	Call(Message::FormFeed);
+}
+
+void ScintillaCall::VCHome() {
+	Call(Message::VCHome);
+}
+
+void ScintillaCall::VCHomeExtend() {
+	Call(Message::VCHomeExtend);
+}
+
+void ScintillaCall::ZoomIn() {
+	Call(Message::ZoomIn);
+}
+
+void ScintillaCall::ZoomOut() {
+	Call(Message::ZoomOut);
+}
+
+void ScintillaCall::DelWordLeft() {
+	Call(Message::DelWordLeft);
+}
+
+void ScintillaCall::DelWordRight() {
+	Call(Message::DelWordRight);
+}
+
+void ScintillaCall::DelWordRightEnd() {
+	Call(Message::DelWordRightEnd);
+}
+
+void ScintillaCall::LineCut() {
+	Call(Message::LineCut);
+}
+
+void ScintillaCall::LineDelete() {
+	Call(Message::LineDelete);
+}
+
+void ScintillaCall::LineTranspose() {
+	Call(Message::LineTranspose);
+}
+
+void ScintillaCall::LineReverse() {
+	Call(Message::LineReverse);
+}
+
+void ScintillaCall::LineDuplicate() {
+	Call(Message::LineDuplicate);
+}
+
+void ScintillaCall::LowerCase() {
+	Call(Message::LowerCase);
+}
+
+void ScintillaCall::UpperCase() {
+	Call(Message::UpperCase);
+}
+
+void ScintillaCall::LineScrollDown() {
+	Call(Message::LineScrollDown);
+}
+
+void ScintillaCall::LineScrollUp() {
+	Call(Message::LineScrollUp);
+}
+
+void ScintillaCall::DeleteBackNotLine() {
+	Call(Message::DeleteBackNotLine);
+}
+
+void ScintillaCall::HomeDisplay() {
+	Call(Message::HomeDisplay);
+}
+
+void ScintillaCall::HomeDisplayExtend() {
+	Call(Message::HomeDisplayExtend);
+}
+
+void ScintillaCall::LineEndDisplay() {
+	Call(Message::LineEndDisplay);
+}
+
+void ScintillaCall::LineEndDisplayExtend() {
+	Call(Message::LineEndDisplayExtend);
+}
+
+void ScintillaCall::HomeWrap() {
+	Call(Message::HomeWrap);
+}
+
+void ScintillaCall::HomeWrapExtend() {
+	Call(Message::HomeWrapExtend);
+}
+
+void ScintillaCall::LineEndWrap() {
+	Call(Message::LineEndWrap);
+}
+
+void ScintillaCall::LineEndWrapExtend() {
+	Call(Message::LineEndWrapExtend);
+}
+
+void ScintillaCall::VCHomeWrap() {
+	Call(Message::VCHomeWrap);
+}
+
+void ScintillaCall::VCHomeWrapExtend() {
+	Call(Message::VCHomeWrapExtend);
+}
+
+void ScintillaCall::LineCopy() {
+	Call(Message::LineCopy);
+}
+
+void ScintillaCall::MoveCaretInsideView() {
+	Call(Message::MoveCaretInsideView);
+}
+
+Position ScintillaCall::LineLength(Line line) {
+	return Call(Message::LineLength, line);
+}
+
+void ScintillaCall::BraceHighlight(Position posA, Position posB) {
+	Call(Message::BraceHighlight, posA, posB);
+}
+
+void ScintillaCall::BraceHighlightIndicator(bool useSetting, int indicator) {
+	Call(Message::BraceHighlightIndicator, useSetting, indicator);
+}
+
+void ScintillaCall::BraceBadLight(Position pos) {
+	Call(Message::BraceBadLight, pos);
+}
+
+void ScintillaCall::BraceBadLightIndicator(bool useSetting, int indicator) {
+	Call(Message::BraceBadLightIndicator, useSetting, indicator);
+}
+
+Position ScintillaCall::BraceMatch(Position pos, int maxReStyle) {
+	return Call(Message::BraceMatch, pos, maxReStyle);
+}
+
+Position ScintillaCall::BraceMatchNext(Position pos, Position startPos) {
+	return Call(Message::BraceMatchNext, pos, startPos);
+}
+
+bool ScintillaCall::ViewEOL() {
+	return Call(Message::GetViewEOL);
+}
+
+void ScintillaCall::SetViewEOL(bool visible) {
+	Call(Message::SetViewEOL, visible);
+}
+
+void *ScintillaCall::DocPointer() {
+	return reinterpret_cast<void *>(Call(Message::GetDocPointer));
+}
+
+void ScintillaCall::SetDocPointer(void *doc) {
+	CallPointer(Message::SetDocPointer, 0, doc);
+}
+
+void ScintillaCall::SetModEventMask(Scintilla::ModificationFlags eventMask) {
+	Call(Message::SetModEventMask, static_cast<uintptr_t>(eventMask));
+}
+
+Position ScintillaCall::EdgeColumn() {
+	return Call(Message::GetEdgeColumn);
+}
+
+void ScintillaCall::SetEdgeColumn(Position column) {
+	Call(Message::SetEdgeColumn, column);
+}
+
+EdgeVisualStyle ScintillaCall::EdgeMode() {
+	return static_cast<Scintilla::EdgeVisualStyle>(Call(Message::GetEdgeMode));
+}
+
+void ScintillaCall::SetEdgeMode(Scintilla::EdgeVisualStyle edgeMode) {
+	Call(Message::SetEdgeMode, static_cast<uintptr_t>(edgeMode));
+}
+
+Colour ScintillaCall::EdgeColour() {
+	return static_cast<Colour>(Call(Message::GetEdgeColour));
+}
+
+void ScintillaCall::SetEdgeColour(Colour edgeColour) {
+	Call(Message::SetEdgeColour, edgeColour);
+}
+
+void ScintillaCall::MultiEdgeAddLine(Position column, Colour edgeColour) {
+	Call(Message::MultiEdgeAddLine, column, edgeColour);
+}
+
+void ScintillaCall::MultiEdgeClearAll() {
+	Call(Message::MultiEdgeClearAll);
+}
+
+Position ScintillaCall::MultiEdgeColumn(int which) {
+	return Call(Message::GetMultiEdgeColumn, which);
+}
+
+void ScintillaCall::SearchAnchor() {
+	Call(Message::SearchAnchor);
+}
+
+Position ScintillaCall::SearchNext(Scintilla::FindOption searchFlags, const char *text) {
+	return CallString(Message::SearchNext, static_cast<uintptr_t>(searchFlags), text);
+}
+
+Position ScintillaCall::SearchPrev(Scintilla::FindOption searchFlags, const char *text) {
+	return CallString(Message::SearchPrev, static_cast<uintptr_t>(searchFlags), text);
+}
+
+Line ScintillaCall::LinesOnScreen() {
+	return Call(Message::LinesOnScreen);
+}
+
+void ScintillaCall::UsePopUp(Scintilla::PopUp popUpMode) {
+	Call(Message::UsePopUp, static_cast<uintptr_t>(popUpMode));
+}
+
+bool ScintillaCall::SelectionIsRectangle() {
+	return Call(Message::SelectionIsRectangle);
+}
+
+void ScintillaCall::SetZoom(int zoomInPoints) {
+	Call(Message::SetZoom, zoomInPoints);
+}
+
+int ScintillaCall::Zoom() {
+	return static_cast<int>(Call(Message::GetZoom));
+}
+
+void *ScintillaCall::CreateDocument(Position bytes, Scintilla::DocumentOption documentOptions) {
+	return reinterpret_cast<void *>(Call(Message::CreateDocument, bytes, static_cast<intptr_t>(documentOptions)));
+}
+
+void ScintillaCall::AddRefDocument(void *doc) {
+	CallPointer(Message::AddRefDocument, 0, doc);
+}
+
+void ScintillaCall::ReleaseDocument(void *doc) {
+	CallPointer(Message::ReleaseDocument, 0, doc);
+}
+
+DocumentOption ScintillaCall::DocumentOptions() {
+	return static_cast<Scintilla::DocumentOption>(Call(Message::GetDocumentOptions));
+}
+
+ModificationFlags ScintillaCall::ModEventMask() {
+	return static_cast<Scintilla::ModificationFlags>(Call(Message::GetModEventMask));
+}
+
+void ScintillaCall::SetCommandEvents(bool commandEvents) {
+	Call(Message::SetCommandEvents, commandEvents);
+}
+
+bool ScintillaCall::CommandEvents() {
+	return Call(Message::GetCommandEvents);
+}
+
+void ScintillaCall::SetFocus(bool focus) {
+	Call(Message::SetFocus, focus);
+}
+
+bool ScintillaCall::Focus() {
+	return Call(Message::GetFocus);
+}
+
+void ScintillaCall::SetStatus(Scintilla::Status status) {
+	Call(Message::SetStatus, static_cast<uintptr_t>(status));
+}
+
+Status ScintillaCall::Status() {
+	return static_cast<Scintilla::Status>(Call(Message::GetStatus));
+}
+
+void ScintillaCall::SetMouseDownCaptures(bool captures) {
+	Call(Message::SetMouseDownCaptures, captures);
+}
+
+bool ScintillaCall::MouseDownCaptures() {
+	return Call(Message::GetMouseDownCaptures);
+}
+
+void ScintillaCall::SetMouseWheelCaptures(bool captures) {
+	Call(Message::SetMouseWheelCaptures, captures);
+}
+
+bool ScintillaCall::MouseWheelCaptures() {
+	return Call(Message::GetMouseWheelCaptures);
+}
+
+void ScintillaCall::SetCursor(Scintilla::CursorShape cursorType) {
+	Call(Message::SetCursor, static_cast<uintptr_t>(cursorType));
+}
+
+CursorShape ScintillaCall::Cursor() {
+	return static_cast<Scintilla::CursorShape>(Call(Message::GetCursor));
+}
+
+void ScintillaCall::SetControlCharSymbol(int symbol) {
+	Call(Message::SetControlCharSymbol, symbol);
+}
+
+int ScintillaCall::ControlCharSymbol() {
+	return static_cast<int>(Call(Message::GetControlCharSymbol));
+}
+
+void ScintillaCall::WordPartLeft() {
+	Call(Message::WordPartLeft);
+}
+
+void ScintillaCall::WordPartLeftExtend() {
+	Call(Message::WordPartLeftExtend);
+}
+
+void ScintillaCall::WordPartRight() {
+	Call(Message::WordPartRight);
+}
+
+void ScintillaCall::WordPartRightExtend() {
+	Call(Message::WordPartRightExtend);
+}
+
+void ScintillaCall::SetVisiblePolicy(Scintilla::VisiblePolicy visiblePolicy, int visibleSlop) {
+	Call(Message::SetVisiblePolicy, static_cast<uintptr_t>(visiblePolicy), visibleSlop);
+}
+
+void ScintillaCall::DelLineLeft() {
+	Call(Message::DelLineLeft);
+}
+
+void ScintillaCall::DelLineRight() {
+	Call(Message::DelLineRight);
+}
+
+void ScintillaCall::SetXOffset(int xOffset) {
+	Call(Message::SetXOffset, xOffset);
+}
+
+int ScintillaCall::XOffset() {
+	return static_cast<int>(Call(Message::GetXOffset));
+}
+
+void ScintillaCall::ChooseCaretX() {
+	Call(Message::ChooseCaretX);
+}
+
+void ScintillaCall::GrabFocus() {
+	Call(Message::GrabFocus);
+}
+
+void ScintillaCall::SetXCaretPolicy(Scintilla::CaretPolicy caretPolicy, int caretSlop) {
+	Call(Message::SetXCaretPolicy, static_cast<uintptr_t>(caretPolicy), caretSlop);
+}
+
+void ScintillaCall::SetYCaretPolicy(Scintilla::CaretPolicy caretPolicy, int caretSlop) {
+	Call(Message::SetYCaretPolicy, static_cast<uintptr_t>(caretPolicy), caretSlop);
+}
+
+void ScintillaCall::SetPrintWrapMode(Scintilla::Wrap wrapMode) {
+	Call(Message::SetPrintWrapMode, static_cast<uintptr_t>(wrapMode));
+}
+
+Wrap ScintillaCall::PrintWrapMode() {
+	return static_cast<Scintilla::Wrap>(Call(Message::GetPrintWrapMode));
+}
+
+void ScintillaCall::SetHotspotActiveFore(bool useSetting, Colour fore) {
+	Call(Message::SetHotspotActiveFore, useSetting, fore);
+}
+
+Colour ScintillaCall::HotspotActiveFore() {
+	return static_cast<Colour>(Call(Message::GetHotspotActiveFore));
+}
+
+void ScintillaCall::SetHotspotActiveBack(bool useSetting, Colour back) {
+	Call(Message::SetHotspotActiveBack, useSetting, back);
+}
+
+Colour ScintillaCall::HotspotActiveBack() {
+	return static_cast<Colour>(Call(Message::GetHotspotActiveBack));
+}
+
+void ScintillaCall::SetHotspotActiveUnderline(bool underline) {
+	Call(Message::SetHotspotActiveUnderline, underline);
+}
+
+bool ScintillaCall::HotspotActiveUnderline() {
+	return Call(Message::GetHotspotActiveUnderline);
+}
+
+void ScintillaCall::SetHotspotSingleLine(bool singleLine) {
+	Call(Message::SetHotspotSingleLine, singleLine);
+}
+
+bool ScintillaCall::HotspotSingleLine() {
+	return Call(Message::GetHotspotSingleLine);
+}
+
+void ScintillaCall::ParaDown() {
+	Call(Message::ParaDown);
+}
+
+void ScintillaCall::ParaDownExtend() {
+	Call(Message::ParaDownExtend);
+}
+
+void ScintillaCall::ParaUp() {
+	Call(Message::ParaUp);
+}
+
+void ScintillaCall::ParaUpExtend() {
+	Call(Message::ParaUpExtend);
+}
+
+Position ScintillaCall::PositionBefore(Position pos) {
+	return Call(Message::PositionBefore, pos);
+}
+
+Position ScintillaCall::PositionAfter(Position pos) {
+	return Call(Message::PositionAfter, pos);
+}
+
+Position ScintillaCall::PositionRelative(Position pos, Position relative) {
+	return Call(Message::PositionRelative, pos, relative);
+}
+
+Position ScintillaCall::PositionRelativeCodeUnits(Position pos, Position relative) {
+	return Call(Message::PositionRelativeCodeUnits, pos, relative);
+}
+
+void ScintillaCall::CopyRange(Position start, Position end) {
+	Call(Message::CopyRange, start, end);
+}
+
+void ScintillaCall::CopyText(Position length, const char *text) {
+	CallString(Message::CopyText, length, text);
+}
+
+void ScintillaCall::SetSelectionMode(Scintilla::SelectionMode selectionMode) {
+	Call(Message::SetSelectionMode, static_cast<uintptr_t>(selectionMode));
+}
+
+SelectionMode ScintillaCall::SelectionMode() {
+	return static_cast<Scintilla::SelectionMode>(Call(Message::GetSelectionMode));
+}
+
+bool ScintillaCall::MoveExtendsSelection() {
+	return Call(Message::GetMoveExtendsSelection);
+}
+
+Position ScintillaCall::GetLineSelStartPosition(Line line) {
+	return Call(Message::GetLineSelStartPosition, line);
+}
+
+Position ScintillaCall::GetLineSelEndPosition(Line line) {
+	return Call(Message::GetLineSelEndPosition, line);
+}
+
+void ScintillaCall::LineDownRectExtend() {
+	Call(Message::LineDownRectExtend);
+}
+
+void ScintillaCall::LineUpRectExtend() {
+	Call(Message::LineUpRectExtend);
+}
+
+void ScintillaCall::CharLeftRectExtend() {
+	Call(Message::CharLeftRectExtend);
+}
+
+void ScintillaCall::CharRightRectExtend() {
+	Call(Message::CharRightRectExtend);
+}
+
+void ScintillaCall::HomeRectExtend() {
+	Call(Message::HomeRectExtend);
+}
+
+void ScintillaCall::VCHomeRectExtend() {
+	Call(Message::VCHomeRectExtend);
+}
+
+void ScintillaCall::LineEndRectExtend() {
+	Call(Message::LineEndRectExtend);
+}
+
+void ScintillaCall::PageUpRectExtend() {
+	Call(Message::PageUpRectExtend);
+}
+
+void ScintillaCall::PageDownRectExtend() {
+	Call(Message::PageDownRectExtend);
+}
+
+void ScintillaCall::StutteredPageUp() {
+	Call(Message::StutteredPageUp);
+}
+
+void ScintillaCall::StutteredPageUpExtend() {
+	Call(Message::StutteredPageUpExtend);
+}
+
+void ScintillaCall::StutteredPageDown() {
+	Call(Message::StutteredPageDown);
+}
+
+void ScintillaCall::StutteredPageDownExtend() {
+	Call(Message::StutteredPageDownExtend);
+}
+
+void ScintillaCall::WordLeftEnd() {
+	Call(Message::WordLeftEnd);
+}
+
+void ScintillaCall::WordLeftEndExtend() {
+	Call(Message::WordLeftEndExtend);
+}
+
+void ScintillaCall::WordRightEnd() {
+	Call(Message::WordRightEnd);
+}
+
+void ScintillaCall::WordRightEndExtend() {
+	Call(Message::WordRightEndExtend);
+}
+
+void ScintillaCall::SetWhitespaceChars(const char *characters) {
+	CallString(Message::SetWhitespaceChars, 0, characters);
+}
+
+int ScintillaCall::WhitespaceChars(char *characters) {
+	return static_cast<int>(CallPointer(Message::GetWhitespaceChars, 0, characters));
+}
+
+std::string ScintillaCall::WhitespaceChars() {
+	return CallReturnString(Message::GetWhitespaceChars, 0);
+}
+
+void ScintillaCall::SetPunctuationChars(const char *characters) {
+	CallString(Message::SetPunctuationChars, 0, characters);
+}
+
+int ScintillaCall::PunctuationChars(char *characters) {
+	return static_cast<int>(CallPointer(Message::GetPunctuationChars, 0, characters));
+}
+
+std::string ScintillaCall::PunctuationChars() {
+	return CallReturnString(Message::GetPunctuationChars, 0);
+}
+
+void ScintillaCall::SetCharsDefault() {
+	Call(Message::SetCharsDefault);
+}
+
+int ScintillaCall::AutoCGetCurrent() {
+	return static_cast<int>(Call(Message::AutoCGetCurrent));
+}
+
+int ScintillaCall::AutoCGetCurrentText(char *text) {
+	return static_cast<int>(CallPointer(Message::AutoCGetCurrentText, 0, text));
+}
+
+std::string ScintillaCall::AutoCGetCurrentText() {
+	return CallReturnString(Message::AutoCGetCurrentText, 0);
+}
+
+void ScintillaCall::AutoCSetCaseInsensitiveBehaviour(Scintilla::CaseInsensitiveBehaviour behaviour) {
+	Call(Message::AutoCSetCaseInsensitiveBehaviour, static_cast<uintptr_t>(behaviour));
+}
+
+CaseInsensitiveBehaviour ScintillaCall::AutoCGetCaseInsensitiveBehaviour() {
+	return static_cast<Scintilla::CaseInsensitiveBehaviour>(Call(Message::AutoCGetCaseInsensitiveBehaviour));
+}
+
+void ScintillaCall::AutoCSetMulti(Scintilla::MultiAutoComplete multi) {
+	Call(Message::AutoCSetMulti, static_cast<uintptr_t>(multi));
+}
+
+MultiAutoComplete ScintillaCall::AutoCGetMulti() {
+	return static_cast<Scintilla::MultiAutoComplete>(Call(Message::AutoCGetMulti));
+}
+
+void ScintillaCall::AutoCSetOrder(Scintilla::Ordering order) {
+	Call(Message::AutoCSetOrder, static_cast<uintptr_t>(order));
+}
+
+Ordering ScintillaCall::AutoCGetOrder() {
+	return static_cast<Scintilla::Ordering>(Call(Message::AutoCGetOrder));
+}
+
+void ScintillaCall::Allocate(Position bytes) {
+	Call(Message::Allocate, bytes);
+}
+
+Position ScintillaCall::TargetAsUTF8(char *s) {
+	return CallPointer(Message::TargetAsUTF8, 0, s);
+}
+
+std::string ScintillaCall::TargetAsUTF8() {
+	return CallReturnString(Message::TargetAsUTF8, 0);
+}
+
+void ScintillaCall::SetLengthForEncode(Position bytes) {
+	Call(Message::SetLengthForEncode, bytes);
+}
+
+Position ScintillaCall::EncodedFromUTF8(const char *utf8, char *encoded) {
+	return CallPointer(Message::EncodedFromUTF8, reinterpret_cast<uintptr_t>(utf8), encoded);
+}
+
+std::string ScintillaCall::EncodedFromUTF8(const char *utf8) {
+	return CallReturnString(Message::EncodedFromUTF8, reinterpret_cast<uintptr_t>(utf8));
+}
+
+Position ScintillaCall::FindColumn(Line line, Position column) {
+	return Call(Message::FindColumn, line, column);
+}
+
+CaretSticky ScintillaCall::CaretSticky() {
+	return static_cast<Scintilla::CaretSticky>(Call(Message::GetCaretSticky));
+}
+
+void ScintillaCall::SetCaretSticky(Scintilla::CaretSticky useCaretStickyBehaviour) {
+	Call(Message::SetCaretSticky, static_cast<uintptr_t>(useCaretStickyBehaviour));
+}
+
+void ScintillaCall::ToggleCaretSticky() {
+	Call(Message::ToggleCaretSticky);
+}
+
+void ScintillaCall::SetPasteConvertEndings(bool convert) {
+	Call(Message::SetPasteConvertEndings, convert);
+}
+
+bool ScintillaCall::PasteConvertEndings() {
+	return Call(Message::GetPasteConvertEndings);
+}
+
+void ScintillaCall::ReplaceRectangular(Position length, const char *text) {
+	CallString(Message::ReplaceRectangular, length, text);
+}
+
+void ScintillaCall::SelectionDuplicate() {
+	Call(Message::SelectionDuplicate);
+}
+
+void ScintillaCall::SetCaretLineBackAlpha(Scintilla::Alpha alpha) {
+	Call(Message::SetCaretLineBackAlpha, static_cast<uintptr_t>(alpha));
+}
+
+Alpha ScintillaCall::CaretLineBackAlpha() {
+	return static_cast<Scintilla::Alpha>(Call(Message::GetCaretLineBackAlpha));
+}
+
+void ScintillaCall::SetCaretStyle(Scintilla::CaretStyle caretStyle) {
+	Call(Message::SetCaretStyle, static_cast<uintptr_t>(caretStyle));
+}
+
+CaretStyle ScintillaCall::CaretStyle() {
+	return static_cast<Scintilla::CaretStyle>(Call(Message::GetCaretStyle));
+}
+
+void ScintillaCall::SetIndicatorCurrent(int indicator) {
+	Call(Message::SetIndicatorCurrent, indicator);
+}
+
+int ScintillaCall::IndicatorCurrent() {
+	return static_cast<int>(Call(Message::GetIndicatorCurrent));
+}
+
+void ScintillaCall::SetIndicatorValue(int value) {
+	Call(Message::SetIndicatorValue, value);
+}
+
+int ScintillaCall::IndicatorValue() {
+	return static_cast<int>(Call(Message::GetIndicatorValue));
+}
+
+void ScintillaCall::IndicatorFillRange(Position start, Position lengthFill) {
+	Call(Message::IndicatorFillRange, start, lengthFill);
+}
+
+void ScintillaCall::IndicatorClearRange(Position start, Position lengthClear) {
+	Call(Message::IndicatorClearRange, start, lengthClear);
+}
+
+int ScintillaCall::IndicatorAllOnFor(Position pos) {
+	return static_cast<int>(Call(Message::IndicatorAllOnFor, pos));
+}
+
+int ScintillaCall::IndicatorValueAt(int indicator, Position pos) {
+	return static_cast<int>(Call(Message::IndicatorValueAt, indicator, pos));
+}
+
+Position ScintillaCall::IndicatorStart(int indicator, Position pos) {
+	return Call(Message::IndicatorStart, indicator, pos);
+}
+
+Position ScintillaCall::IndicatorEnd(int indicator, Position pos) {
+	return Call(Message::IndicatorEnd, indicator, pos);
+}
+
+void ScintillaCall::SetPositionCache(int size) {
+	Call(Message::SetPositionCache, size);
+}
+
+int ScintillaCall::PositionCache() {
+	return static_cast<int>(Call(Message::GetPositionCache));
+}
+
+void ScintillaCall::CopyAllowLine() {
+	Call(Message::CopyAllowLine);
+}
+
+void *ScintillaCall::CharacterPointer() {
+	return reinterpret_cast<void *>(Call(Message::GetCharacterPointer));
+}
+
+void *ScintillaCall::RangePointer(Position start, Position lengthRange) {
+	return reinterpret_cast<void *>(Call(Message::GetRangePointer, start, lengthRange));
+}
+
+Position ScintillaCall::GapPosition() {
+	return Call(Message::GetGapPosition);
+}
+
+void ScintillaCall::IndicSetAlpha(int indicator, Scintilla::Alpha alpha) {
+	Call(Message::IndicSetAlpha, indicator, static_cast<intptr_t>(alpha));
+}
+
+Alpha ScintillaCall::IndicGetAlpha(int indicator) {
+	return static_cast<Scintilla::Alpha>(Call(Message::IndicGetAlpha, indicator));
+}
+
+void ScintillaCall::IndicSetOutlineAlpha(int indicator, Scintilla::Alpha alpha) {
+	Call(Message::IndicSetOutlineAlpha, indicator, static_cast<intptr_t>(alpha));
+}
+
+Alpha ScintillaCall::IndicGetOutlineAlpha(int indicator) {
+	return static_cast<Scintilla::Alpha>(Call(Message::IndicGetOutlineAlpha, indicator));
+}
+
+void ScintillaCall::SetExtraAscent(int extraAscent) {
+	Call(Message::SetExtraAscent, extraAscent);
+}
+
+int ScintillaCall::ExtraAscent() {
+	return static_cast<int>(Call(Message::GetExtraAscent));
+}
+
+void ScintillaCall::SetExtraDescent(int extraDescent) {
+	Call(Message::SetExtraDescent, extraDescent);
+}
+
+int ScintillaCall::ExtraDescent() {
+	return static_cast<int>(Call(Message::GetExtraDescent));
+}
+
+int ScintillaCall::MarkerSymbolDefined(int markerNumber) {
+	return static_cast<int>(Call(Message::MarkerSymbolDefined, markerNumber));
+}
+
+void ScintillaCall::MarginSetText(Line line, const char *text) {
+	CallString(Message::MarginSetText, line, text);
+}
+
+int ScintillaCall::MarginGetText(Line line, char *text) {
+	return static_cast<int>(CallPointer(Message::MarginGetText, line, text));
+}
+
+std::string ScintillaCall::MarginGetText(Line line) {
+	return CallReturnString(Message::MarginGetText, line);
+}
+
+void ScintillaCall::MarginSetStyle(Line line, int style) {
+	Call(Message::MarginSetStyle, line, style);
+}
+
+int ScintillaCall::MarginGetStyle(Line line) {
+	return static_cast<int>(Call(Message::MarginGetStyle, line));
+}
+
+void ScintillaCall::MarginSetStyles(Line line, const char *styles) {
+	CallString(Message::MarginSetStyles, line, styles);
+}
+
+int ScintillaCall::MarginGetStyles(Line line, char *styles) {
+	return static_cast<int>(CallPointer(Message::MarginGetStyles, line, styles));
+}
+
+std::string ScintillaCall::MarginGetStyles(Line line) {
+	return CallReturnString(Message::MarginGetStyles, line);
+}
+
+void ScintillaCall::MarginTextClearAll() {
+	Call(Message::MarginTextClearAll);
+}
+
+void ScintillaCall::MarginSetStyleOffset(int style) {
+	Call(Message::MarginSetStyleOffset, style);
+}
+
+int ScintillaCall::MarginGetStyleOffset() {
+	return static_cast<int>(Call(Message::MarginGetStyleOffset));
+}
+
+void ScintillaCall::SetMarginOptions(Scintilla::MarginOption marginOptions) {
+	Call(Message::SetMarginOptions, static_cast<uintptr_t>(marginOptions));
+}
+
+MarginOption ScintillaCall::MarginOptions() {
+	return static_cast<Scintilla::MarginOption>(Call(Message::GetMarginOptions));
+}
+
+void ScintillaCall::AnnotationSetText(Line line, const char *text) {
+	CallString(Message::AnnotationSetText, line, text);
+}
+
+int ScintillaCall::AnnotationGetText(Line line, char *text) {
+	return static_cast<int>(CallPointer(Message::AnnotationGetText, line, text));
+}
+
+std::string ScintillaCall::AnnotationGetText(Line line) {
+	return CallReturnString(Message::AnnotationGetText, line);
+}
+
+void ScintillaCall::AnnotationSetStyle(Line line, int style) {
+	Call(Message::AnnotationSetStyle, line, style);
+}
+
+int ScintillaCall::AnnotationGetStyle(Line line) {
+	return static_cast<int>(Call(Message::AnnotationGetStyle, line));
+}
+
+void ScintillaCall::AnnotationSetStyles(Line line, const char *styles) {
+	CallString(Message::AnnotationSetStyles, line, styles);
+}
+
+int ScintillaCall::AnnotationGetStyles(Line line, char *styles) {
+	return static_cast<int>(CallPointer(Message::AnnotationGetStyles, line, styles));
+}
+
+std::string ScintillaCall::AnnotationGetStyles(Line line) {
+	return CallReturnString(Message::AnnotationGetStyles, line);
+}
+
+int ScintillaCall::AnnotationGetLines(Line line) {
+	return static_cast<int>(Call(Message::AnnotationGetLines, line));
+}
+
+void ScintillaCall::AnnotationClearAll() {
+	Call(Message::AnnotationClearAll);
+}
+
+void ScintillaCall::AnnotationSetVisible(Scintilla::AnnotationVisible visible) {
+	Call(Message::AnnotationSetVisible, static_cast<uintptr_t>(visible));
+}
+
+AnnotationVisible ScintillaCall::AnnotationGetVisible() {
+	return static_cast<Scintilla::AnnotationVisible>(Call(Message::AnnotationGetVisible));
+}
+
+void ScintillaCall::AnnotationSetStyleOffset(int style) {
+	Call(Message::AnnotationSetStyleOffset, style);
+}
+
+int ScintillaCall::AnnotationGetStyleOffset() {
+	return static_cast<int>(Call(Message::AnnotationGetStyleOffset));
+}
+
+void ScintillaCall::ReleaseAllExtendedStyles() {
+	Call(Message::ReleaseAllExtendedStyles);
+}
+
+int ScintillaCall::AllocateExtendedStyles(int numberStyles) {
+	return static_cast<int>(Call(Message::AllocateExtendedStyles, numberStyles));
+}
+
+void ScintillaCall::AddUndoAction(int token, Scintilla::UndoFlags flags) {
+	Call(Message::AddUndoAction, token, static_cast<intptr_t>(flags));
+}
+
+Position ScintillaCall::CharPositionFromPoint(int x, int y) {
+	return Call(Message::CharPositionFromPoint, x, y);
+}
+
+Position ScintillaCall::CharPositionFromPointClose(int x, int y) {
+	return Call(Message::CharPositionFromPointClose, x, y);
+}
+
+void ScintillaCall::SetMouseSelectionRectangularSwitch(bool mouseSelectionRectangularSwitch) {
+	Call(Message::SetMouseSelectionRectangularSwitch, mouseSelectionRectangularSwitch);
+}
+
+bool ScintillaCall::MouseSelectionRectangularSwitch() {
+	return Call(Message::GetMouseSelectionRectangularSwitch);
+}
+
+void ScintillaCall::SetMultipleSelection(bool multipleSelection) {
+	Call(Message::SetMultipleSelection, multipleSelection);
+}
+
+bool ScintillaCall::MultipleSelection() {
+	return Call(Message::GetMultipleSelection);
+}
+
+void ScintillaCall::SetAdditionalSelectionTyping(bool additionalSelectionTyping) {
+	Call(Message::SetAdditionalSelectionTyping, additionalSelectionTyping);
+}
+
+bool ScintillaCall::AdditionalSelectionTyping() {
+	return Call(Message::GetAdditionalSelectionTyping);
+}
+
+void ScintillaCall::SetAdditionalCaretsBlink(bool additionalCaretsBlink) {
+	Call(Message::SetAdditionalCaretsBlink, additionalCaretsBlink);
+}
+
+bool ScintillaCall::AdditionalCaretsBlink() {
+	return Call(Message::GetAdditionalCaretsBlink);
+}
+
+void ScintillaCall::SetAdditionalCaretsVisible(bool additionalCaretsVisible) {
+	Call(Message::SetAdditionalCaretsVisible, additionalCaretsVisible);
+}
+
+bool ScintillaCall::AdditionalCaretsVisible() {
+	return Call(Message::GetAdditionalCaretsVisible);
+}
+
+int ScintillaCall::Selections() {
+	return static_cast<int>(Call(Message::GetSelections));
+}
+
+bool ScintillaCall::SelectionEmpty() {
+	return Call(Message::GetSelectionEmpty);
+}
+
+void ScintillaCall::ClearSelections() {
+	Call(Message::ClearSelections);
+}
+
+void ScintillaCall::SetSelection(Position caret, Position anchor) {
+	Call(Message::SetSelection, caret, anchor);
+}
+
+void ScintillaCall::AddSelection(Position caret, Position anchor) {
+	Call(Message::AddSelection, caret, anchor);
+}
+
+void ScintillaCall::DropSelectionN(int selection) {
+	Call(Message::DropSelectionN, selection);
+}
+
+void ScintillaCall::SetMainSelection(int selection) {
+	Call(Message::SetMainSelection, selection);
+}
+
+int ScintillaCall::MainSelection() {
+	return static_cast<int>(Call(Message::GetMainSelection));
+}
+
+void ScintillaCall::SetSelectionNCaret(int selection, Position caret) {
+	Call(Message::SetSelectionNCaret, selection, caret);
+}
+
+Position ScintillaCall::SelectionNCaret(int selection) {
+	return Call(Message::GetSelectionNCaret, selection);
+}
+
+void ScintillaCall::SetSelectionNAnchor(int selection, Position anchor) {
+	Call(Message::SetSelectionNAnchor, selection, anchor);
+}
+
+Position ScintillaCall::SelectionNAnchor(int selection) {
+	return Call(Message::GetSelectionNAnchor, selection);
+}
+
+void ScintillaCall::SetSelectionNCaretVirtualSpace(int selection, Position space) {
+	Call(Message::SetSelectionNCaretVirtualSpace, selection, space);
+}
+
+Position ScintillaCall::SelectionNCaretVirtualSpace(int selection) {
+	return Call(Message::GetSelectionNCaretVirtualSpace, selection);
+}
+
+void ScintillaCall::SetSelectionNAnchorVirtualSpace(int selection, Position space) {
+	Call(Message::SetSelectionNAnchorVirtualSpace, selection, space);
+}
+
+Position ScintillaCall::SelectionNAnchorVirtualSpace(int selection) {
+	return Call(Message::GetSelectionNAnchorVirtualSpace, selection);
+}
+
+void ScintillaCall::SetSelectionNStart(int selection, Position anchor) {
+	Call(Message::SetSelectionNStart, selection, anchor);
+}
+
+Position ScintillaCall::SelectionNStart(int selection) {
+	return Call(Message::GetSelectionNStart, selection);
+}
+
+Position ScintillaCall::SelectionNStartVirtualSpace(int selection) {
+	return Call(Message::GetSelectionNStartVirtualSpace, selection);
+}
+
+void ScintillaCall::SetSelectionNEnd(int selection, Position caret) {
+	Call(Message::SetSelectionNEnd, selection, caret);
+}
+
+Position ScintillaCall::SelectionNEndVirtualSpace(int selection) {
+	return Call(Message::GetSelectionNEndVirtualSpace, selection);
+}
+
+Position ScintillaCall::SelectionNEnd(int selection) {
+	return Call(Message::GetSelectionNEnd, selection);
+}
+
+void ScintillaCall::SetRectangularSelectionCaret(Position caret) {
+	Call(Message::SetRectangularSelectionCaret, caret);
+}
+
+Position ScintillaCall::RectangularSelectionCaret() {
+	return Call(Message::GetRectangularSelectionCaret);
+}
+
+void ScintillaCall::SetRectangularSelectionAnchor(Position anchor) {
+	Call(Message::SetRectangularSelectionAnchor, anchor);
+}
+
+Position ScintillaCall::RectangularSelectionAnchor() {
+	return Call(Message::GetRectangularSelectionAnchor);
+}
+
+void ScintillaCall::SetRectangularSelectionCaretVirtualSpace(Position space) {
+	Call(Message::SetRectangularSelectionCaretVirtualSpace, space);
+}
+
+Position ScintillaCall::RectangularSelectionCaretVirtualSpace() {
+	return Call(Message::GetRectangularSelectionCaretVirtualSpace);
+}
+
+void ScintillaCall::SetRectangularSelectionAnchorVirtualSpace(Position space) {
+	Call(Message::SetRectangularSelectionAnchorVirtualSpace, space);
+}
+
+Position ScintillaCall::RectangularSelectionAnchorVirtualSpace() {
+	return Call(Message::GetRectangularSelectionAnchorVirtualSpace);
+}
+
+void ScintillaCall::SetVirtualSpaceOptions(Scintilla::VirtualSpace virtualSpaceOptions) {
+	Call(Message::SetVirtualSpaceOptions, static_cast<uintptr_t>(virtualSpaceOptions));
+}
+
+VirtualSpace ScintillaCall::VirtualSpaceOptions() {
+	return static_cast<Scintilla::VirtualSpace>(Call(Message::GetVirtualSpaceOptions));
+}
+
+void ScintillaCall::SetRectangularSelectionModifier(int modifier) {
+	Call(Message::SetRectangularSelectionModifier, modifier);
+}
+
+int ScintillaCall::RectangularSelectionModifier() {
+	return static_cast<int>(Call(Message::GetRectangularSelectionModifier));
+}
+
+void ScintillaCall::SetAdditionalSelFore(Colour fore) {
+	Call(Message::SetAdditionalSelFore, fore);
+}
+
+void ScintillaCall::SetAdditionalSelBack(Colour back) {
+	Call(Message::SetAdditionalSelBack, back);
+}
+
+void ScintillaCall::SetAdditionalSelAlpha(Scintilla::Alpha alpha) {
+	Call(Message::SetAdditionalSelAlpha, static_cast<uintptr_t>(alpha));
+}
+
+Alpha ScintillaCall::AdditionalSelAlpha() {
+	return static_cast<Scintilla::Alpha>(Call(Message::GetAdditionalSelAlpha));
+}
+
+void ScintillaCall::SetAdditionalCaretFore(Colour fore) {
+	Call(Message::SetAdditionalCaretFore, fore);
+}
+
+Colour ScintillaCall::AdditionalCaretFore() {
+	return static_cast<Colour>(Call(Message::GetAdditionalCaretFore));
+}
+
+void ScintillaCall::RotateSelection() {
+	Call(Message::RotateSelection);
+}
+
+void ScintillaCall::SwapMainAnchorCaret() {
+	Call(Message::SwapMainAnchorCaret);
+}
+
+void ScintillaCall::MultipleSelectAddNext() {
+	Call(Message::MultipleSelectAddNext);
+}
+
+void ScintillaCall::MultipleSelectAddEach() {
+	Call(Message::MultipleSelectAddEach);
+}
+
+int ScintillaCall::ChangeLexerState(Position start, Position end) {
+	return static_cast<int>(Call(Message::ChangeLexerState, start, end));
+}
+
+Line ScintillaCall::ContractedFoldNext(Line lineStart) {
+	return Call(Message::ContractedFoldNext, lineStart);
+}
+
+void ScintillaCall::VerticalCentreCaret() {
+	Call(Message::VerticalCentreCaret);
+}
+
+void ScintillaCall::MoveSelectedLinesUp() {
+	Call(Message::MoveSelectedLinesUp);
+}
+
+void ScintillaCall::MoveSelectedLinesDown() {
+	Call(Message::MoveSelectedLinesDown);
+}
+
+void ScintillaCall::SetIdentifier(int identifier) {
+	Call(Message::SetIdentifier, identifier);
+}
+
+int ScintillaCall::Identifier() {
+	return static_cast<int>(Call(Message::GetIdentifier));
+}
+
+void ScintillaCall::RGBAImageSetWidth(int width) {
+	Call(Message::RGBAImageSetWidth, width);
+}
+
+void ScintillaCall::RGBAImageSetHeight(int height) {
+	Call(Message::RGBAImageSetHeight, height);
+}
+
+void ScintillaCall::RGBAImageSetScale(int scalePercent) {
+	Call(Message::RGBAImageSetScale, scalePercent);
+}
+
+void ScintillaCall::MarkerDefineRGBAImage(int markerNumber, const char *pixels) {
+	CallString(Message::MarkerDefineRGBAImage, markerNumber, pixels);
+}
+
+void ScintillaCall::RegisterRGBAImage(int type, const char *pixels) {
+	CallString(Message::RegisterRGBAImage, type, pixels);
+}
+
+void ScintillaCall::ScrollToStart() {
+	Call(Message::ScrollToStart);
+}
+
+void ScintillaCall::ScrollToEnd() {
+	Call(Message::ScrollToEnd);
+}
+
+void ScintillaCall::SetTechnology(Scintilla::Technology technology) {
+	Call(Message::SetTechnology, static_cast<uintptr_t>(technology));
+}
+
+Technology ScintillaCall::Technology() {
+	return static_cast<Scintilla::Technology>(Call(Message::GetTechnology));
+}
+
+void *ScintillaCall::CreateLoader(Position bytes, Scintilla::DocumentOption documentOptions) {
+	return reinterpret_cast<void *>(Call(Message::CreateLoader, bytes, static_cast<intptr_t>(documentOptions)));
+}
+
+void ScintillaCall::FindIndicatorShow(Position start, Position end) {
+	Call(Message::FindIndicatorShow, start, end);
+}
+
+void ScintillaCall::FindIndicatorFlash(Position start, Position end) {
+	Call(Message::FindIndicatorFlash, start, end);
+}
+
+void ScintillaCall::FindIndicatorHide() {
+	Call(Message::FindIndicatorHide);
+}
+
+void ScintillaCall::VCHomeDisplay() {
+	Call(Message::VCHomeDisplay);
+}
+
+void ScintillaCall::VCHomeDisplayExtend() {
+	Call(Message::VCHomeDisplayExtend);
+}
+
+bool ScintillaCall::CaretLineVisibleAlways() {
+	return Call(Message::GetCaretLineVisibleAlways);
+}
+
+void ScintillaCall::SetCaretLineVisibleAlways(bool alwaysVisible) {
+	Call(Message::SetCaretLineVisibleAlways, alwaysVisible);
+}
+
+void ScintillaCall::SetLineEndTypesAllowed(Scintilla::LineEndType lineEndBitSet) {
+	Call(Message::SetLineEndTypesAllowed, static_cast<uintptr_t>(lineEndBitSet));
+}
+
+LineEndType ScintillaCall::LineEndTypesAllowed() {
+	return static_cast<Scintilla::LineEndType>(Call(Message::GetLineEndTypesAllowed));
+}
+
+LineEndType ScintillaCall::LineEndTypesActive() {
+	return static_cast<Scintilla::LineEndType>(Call(Message::GetLineEndTypesActive));
+}
+
+void ScintillaCall::SetRepresentation(const char *encodedCharacter, const char *representation) {
+	CallString(Message::SetRepresentation, reinterpret_cast<uintptr_t>(encodedCharacter), representation);
+}
+
+int ScintillaCall::Representation(const char *encodedCharacter, char *representation) {
+	return static_cast<int>(CallPointer(Message::GetRepresentation, reinterpret_cast<uintptr_t>(encodedCharacter), representation));
+}
+
+std::string ScintillaCall::Representation(const char *encodedCharacter) {
+	return CallReturnString(Message::GetRepresentation, reinterpret_cast<uintptr_t>(encodedCharacter));
+}
+
+void ScintillaCall::ClearRepresentation(const char *encodedCharacter) {
+	Call(Message::ClearRepresentation, reinterpret_cast<uintptr_t>(encodedCharacter));
+}
+
+void ScintillaCall::ClearAllRepresentations() {
+	Call(Message::ClearAllRepresentations);
+}
+
+void ScintillaCall::SetRepresentationAppearance(const char *encodedCharacter, Scintilla::RepresentationAppearance appearance) {
+	Call(Message::SetRepresentationAppearance, reinterpret_cast<uintptr_t>(encodedCharacter), static_cast<intptr_t>(appearance));
+}
+
+RepresentationAppearance ScintillaCall::RepresentationAppearance(const char *encodedCharacter) {
+	return static_cast<Scintilla::RepresentationAppearance>(Call(Message::GetRepresentationAppearance, reinterpret_cast<uintptr_t>(encodedCharacter)));
+}
+
+void ScintillaCall::SetRepresentationColour(const char *encodedCharacter, ColourAlpha colour) {
+	Call(Message::SetRepresentationColour, reinterpret_cast<uintptr_t>(encodedCharacter), colour);
+}
+
+ColourAlpha ScintillaCall::RepresentationColour(const char *encodedCharacter) {
+	return static_cast<ColourAlpha>(Call(Message::GetRepresentationColour, reinterpret_cast<uintptr_t>(encodedCharacter)));
+}
+
+void ScintillaCall::EOLAnnotationSetText(Line line, const char *text) {
+	CallString(Message::EOLAnnotationSetText, line, text);
+}
+
+int ScintillaCall::EOLAnnotationGetText(Line line, char *text) {
+	return static_cast<int>(CallPointer(Message::EOLAnnotationGetText, line, text));
+}
+
+std::string ScintillaCall::EOLAnnotationGetText(Line line) {
+	return CallReturnString(Message::EOLAnnotationGetText, line);
+}
+
+void ScintillaCall::EOLAnnotationSetStyle(Line line, int style) {
+	Call(Message::EOLAnnotationSetStyle, line, style);
+}
+
+int ScintillaCall::EOLAnnotationGetStyle(Line line) {
+	return static_cast<int>(Call(Message::EOLAnnotationGetStyle, line));
+}
+
+void ScintillaCall::EOLAnnotationClearAll() {
+	Call(Message::EOLAnnotationClearAll);
+}
+
+void ScintillaCall::EOLAnnotationSetVisible(Scintilla::EOLAnnotationVisible visible) {
+	Call(Message::EOLAnnotationSetVisible, static_cast<uintptr_t>(visible));
+}
+
+EOLAnnotationVisible ScintillaCall::EOLAnnotationGetVisible() {
+	return static_cast<Scintilla::EOLAnnotationVisible>(Call(Message::EOLAnnotationGetVisible));
+}
+
+void ScintillaCall::EOLAnnotationSetStyleOffset(int style) {
+	Call(Message::EOLAnnotationSetStyleOffset, style);
+}
+
+int ScintillaCall::EOLAnnotationGetStyleOffset() {
+	return static_cast<int>(Call(Message::EOLAnnotationGetStyleOffset));
+}
+
+bool ScintillaCall::SupportsFeature(Scintilla::Supports feature) {
+	return Call(Message::SupportsFeature, static_cast<uintptr_t>(feature));
+}
+
+LineCharacterIndexType ScintillaCall::LineCharacterIndex() {
+	return static_cast<Scintilla::LineCharacterIndexType>(Call(Message::GetLineCharacterIndex));
+}
+
+void ScintillaCall::AllocateLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex) {
+	Call(Message::AllocateLineCharacterIndex, static_cast<uintptr_t>(lineCharacterIndex));
+}
+
+void ScintillaCall::ReleaseLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex) {
+	Call(Message::ReleaseLineCharacterIndex, static_cast<uintptr_t>(lineCharacterIndex));
+}
+
+Line ScintillaCall::LineFromIndexPosition(Position pos, Scintilla::LineCharacterIndexType lineCharacterIndex) {
+	return Call(Message::LineFromIndexPosition, pos, static_cast<intptr_t>(lineCharacterIndex));
+}
+
+Position ScintillaCall::IndexPositionFromLine(Line line, Scintilla::LineCharacterIndexType lineCharacterIndex) {
+	return Call(Message::IndexPositionFromLine, line, static_cast<intptr_t>(lineCharacterIndex));
+}
+
+void ScintillaCall::StartRecord() {
+	Call(Message::StartRecord);
+}
+
+void ScintillaCall::StopRecord() {
+	Call(Message::StopRecord);
+}
+
+int ScintillaCall::Lexer() {
+	return static_cast<int>(Call(Message::GetLexer));
+}
+
+void ScintillaCall::Colourise(Position start, Position end) {
+	Call(Message::Colourise, start, end);
+}
+
+void ScintillaCall::SetProperty(const char *key, const char *value) {
+	CallString(Message::SetProperty, reinterpret_cast<uintptr_t>(key), value);
+}
+
+void ScintillaCall::SetKeyWords(int keyWordSet, const char *keyWords) {
+	CallString(Message::SetKeyWords, keyWordSet, keyWords);
+}
+
+int ScintillaCall::Property(const char *key, char *value) {
+	return static_cast<int>(CallPointer(Message::GetProperty, reinterpret_cast<uintptr_t>(key), value));
+}
+
+std::string ScintillaCall::Property(const char *key) {
+	return CallReturnString(Message::GetProperty, reinterpret_cast<uintptr_t>(key));
+}
+
+int ScintillaCall::PropertyExpanded(const char *key, char *value) {
+	return static_cast<int>(CallPointer(Message::GetPropertyExpanded, reinterpret_cast<uintptr_t>(key), value));
+}
+
+std::string ScintillaCall::PropertyExpanded(const char *key) {
+	return CallReturnString(Message::GetPropertyExpanded, reinterpret_cast<uintptr_t>(key));
+}
+
+int ScintillaCall::PropertyInt(const char *key, int defaultValue) {
+	return static_cast<int>(Call(Message::GetPropertyInt, reinterpret_cast<uintptr_t>(key), defaultValue));
+}
+
+int ScintillaCall::LexerLanguage(char *language) {
+	return static_cast<int>(CallPointer(Message::GetLexerLanguage, 0, language));
+}
+
+std::string ScintillaCall::LexerLanguage() {
+	return CallReturnString(Message::GetLexerLanguage, 0);
+}
+
+void *ScintillaCall::PrivateLexerCall(int operation, void *pointer) {
+	return reinterpret_cast<void *>(CallPointer(Message::PrivateLexerCall, operation, pointer));
+}
+
+int ScintillaCall::PropertyNames(char *names) {
+	return static_cast<int>(CallPointer(Message::PropertyNames, 0, names));
+}
+
+std::string ScintillaCall::PropertyNames() {
+	return CallReturnString(Message::PropertyNames, 0);
+}
+
+TypeProperty ScintillaCall::PropertyType(const char *name) {
+	return static_cast<Scintilla::TypeProperty>(Call(Message::PropertyType, reinterpret_cast<uintptr_t>(name)));
+}
+
+int ScintillaCall::DescribeProperty(const char *name, char *description) {
+	return static_cast<int>(CallPointer(Message::DescribeProperty, reinterpret_cast<uintptr_t>(name), description));
+}
+
+std::string ScintillaCall::DescribeProperty(const char *name) {
+	return CallReturnString(Message::DescribeProperty, reinterpret_cast<uintptr_t>(name));
+}
+
+int ScintillaCall::DescribeKeyWordSets(char *descriptions) {
+	return static_cast<int>(CallPointer(Message::DescribeKeyWordSets, 0, descriptions));
+}
+
+std::string ScintillaCall::DescribeKeyWordSets() {
+	return CallReturnString(Message::DescribeKeyWordSets, 0);
+}
+
+int ScintillaCall::LineEndTypesSupported() {
+	return static_cast<int>(Call(Message::GetLineEndTypesSupported));
+}
+
+int ScintillaCall::AllocateSubStyles(int styleBase, int numberStyles) {
+	return static_cast<int>(Call(Message::AllocateSubStyles, styleBase, numberStyles));
+}
+
+int ScintillaCall::SubStylesStart(int styleBase) {
+	return static_cast<int>(Call(Message::GetSubStylesStart, styleBase));
+}
+
+int ScintillaCall::SubStylesLength(int styleBase) {
+	return static_cast<int>(Call(Message::GetSubStylesLength, styleBase));
+}
+
+int ScintillaCall::StyleFromSubStyle(int subStyle) {
+	return static_cast<int>(Call(Message::GetStyleFromSubStyle, subStyle));
+}
+
+int ScintillaCall::PrimaryStyleFromStyle(int style) {
+	return static_cast<int>(Call(Message::GetPrimaryStyleFromStyle, style));
+}
+
+void ScintillaCall::FreeSubStyles() {
+	Call(Message::FreeSubStyles);
+}
+
+void ScintillaCall::SetIdentifiers(int style, const char *identifiers) {
+	CallString(Message::SetIdentifiers, style, identifiers);
+}
+
+int ScintillaCall::DistanceToSecondaryStyles() {
+	return static_cast<int>(Call(Message::DistanceToSecondaryStyles));
+}
+
+int ScintillaCall::SubStyleBases(char *styles) {
+	return static_cast<int>(CallPointer(Message::GetSubStyleBases, 0, styles));
+}
+
+std::string ScintillaCall::SubStyleBases() {
+	return CallReturnString(Message::GetSubStyleBases, 0);
+}
+
+int ScintillaCall::NamedStyles() {
+	return static_cast<int>(Call(Message::GetNamedStyles));
+}
+
+int ScintillaCall::NameOfStyle(int style, char *name) {
+	return static_cast<int>(CallPointer(Message::NameOfStyle, style, name));
+}
+
+std::string ScintillaCall::NameOfStyle(int style) {
+	return CallReturnString(Message::NameOfStyle, style);
+}
+
+int ScintillaCall::TagsOfStyle(int style, char *tags) {
+	return static_cast<int>(CallPointer(Message::TagsOfStyle, style, tags));
+}
+
+std::string ScintillaCall::TagsOfStyle(int style) {
+	return CallReturnString(Message::TagsOfStyle, style);
+}
+
+int ScintillaCall::DescriptionOfStyle(int style, char *description) {
+	return static_cast<int>(CallPointer(Message::DescriptionOfStyle, style, description));
+}
+
+std::string ScintillaCall::DescriptionOfStyle(int style) {
+	return CallReturnString(Message::DescriptionOfStyle, style);
+}
+
+void ScintillaCall::SetILexer(void *ilexer) {
+	CallPointer(Message::SetILexer, 0, ilexer);
+}
+
+Bidirectional ScintillaCall::Bidirectional() {
+	return static_cast<Scintilla::Bidirectional>(Call(Message::GetBidirectional));
+}
+
+void ScintillaCall::SetBidirectional(Scintilla::Bidirectional bidirectional) {
+	Call(Message::SetBidirectional, static_cast<uintptr_t>(bidirectional));
+}
+
+//--Autogenerated -- end of section automatically generated from Scintilla.iface */
+
+}
diff --git a/doc/ScintillaDoc.html b/doc/ScintillaDoc.html
index 7e048c273..9fbb50350 100644
--- a/doc/ScintillaDoc.html
+++ b/doc/ScintillaDoc.html
@@ -182,9 +182,12 @@
     Scintilla's facilities.</p>
 
     <p>There is a more type-safe binding of this API that can be used from C++.
-    It is implemented in the ScintillaTypes.h, ScintillaMessages.h, and ScintillaStructures.h headers.
-    SciTE contains (in src) a ScintillaCall module that can help further and will, in the future, be
-    moved into Scintilla.
+    It is implemented in the ScintillaTypes.h, ScintillaMessages.h, ScintillaStructures.h, and ScintillaCall.h headers
+    and call/ScintillaCall.cxx.
+    The ScintillaTypes.h, ScintillaMessages.h, and ScintillaStructures.h headers can be used without ScintillaCall
+    but ScintillaCall makes it easier to use the other headers by wrapping the messages in methods
+    which also avoids much type casting.
+    ScintillaCall throws Scintilla::Failure exceptions when a call fails.
     </p>
 
     <p>In the descriptions that follow, the messages are described as function calls with zero, one
diff --git a/doc/ScintillaHistory.html b/doc/ScintillaHistory.html
index 84a29578e..0ef408ce8 100644
--- a/doc/ScintillaHistory.html
+++ b/doc/ScintillaHistory.html
@@ -587,6 +587,11 @@
 	improve performance.
 	</li>
 	<li>
+	Add more type-safe wrappers to the API.
+	These are defined in include/ScintillaCall.h and implemented in call/ScintillaCall.cxx.
+	ScintillaCall throws Scintilla::Failure exceptions when a call fails.
+	</li>
+	<li>
 	Add APIs for setting appearance (traditional blob or plain text) and colour of representations
 	and support setting a representation for the "\r\n" line end sequence.
 	</li>
diff --git a/include/ScintillaCall.h b/include/ScintillaCall.h
new file mode 100644
index 000000000..778a195d0
--- /dev/null
+++ b/include/ScintillaCall.h
@@ -0,0 +1,878 @@
+// SciTE - Scintilla based Text Editor
+/** @file ScintillaCall.h
+ ** Interface to calling a Scintilla instance.
+ **/
+// Copyright 1998-2019 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+/* Most of this file is automatically generated from the Scintilla.iface interface definition
+ * file which contains any comments about the definitions. APIFacer.py does the generation. */
+
+#ifndef SCINTILLACALL_H
+#define SCINTILLACALL_H
+
+namespace Scintilla {
+
+enum class Message;	// Declare in case ScintillaMessages.h not included
+
+using FunctionDirect = intptr_t(*)(intptr_t ptr, unsigned int iMessage, uintptr_t wParam, intptr_t lParam, int *pStatus);
+
+struct Failure {
+	Scintilla::Status status;
+	explicit Failure(Scintilla::Status status_) noexcept : status(status_) {
+	}
+};
+
+struct Span {
+	// An ordered range
+	// end may be less than start when, for example, searching backwards
+	Position start;
+	Position end;
+	explicit Span(Position position) noexcept : start(position), end(position) {
+	}
+	Span(Position start_, Position end_) noexcept : start(start_), end(end_) {
+	}
+	Position Length() const noexcept {
+		if (end > start)
+			return end - start;
+		else
+			return start - end;
+	}
+	bool operator==(const Span &other) const noexcept {
+		return (other.start == start) && (other.end == end);
+	}
+};
+
+class ScintillaCall {
+	FunctionDirect fn;
+	intptr_t ptr;
+	intptr_t CallPointer(Message msg, uintptr_t wParam, void *s);
+	intptr_t CallString(Message msg, uintptr_t wParam, const char *s);
+	std::string CallReturnString(Message msg, uintptr_t wParam);
+public:
+	Scintilla::Status statusLastCall;
+	ScintillaCall() noexcept;
+	// All standard methods are fine
+
+	void SetFnPtr(FunctionDirect fn_, intptr_t ptr_) noexcept;
+	bool IsValid() const noexcept;
+	intptr_t Call(Message msg, uintptr_t wParam=0, intptr_t lParam=0);
+
+	// Common APIs made more structured and type-safe
+	Position LineStart(Line line);
+	Position LineEnd(Line line);
+	Span SelectionSpan();
+	Span TargetSpan();
+	void SetTarget(Span span);
+	void ColouriseAll();
+	char CharacterAt(Position position);
+	int UnsignedStyleAt(Position position);
+	std::string StringOfSpan(Span span);
+	Position ReplaceTarget(std::string_view text);
+	Position ReplaceTargetRE(std::string_view text);
+	Position SearchInTarget(std::string_view text);
+	Span SpanSearchInTarget(std::string_view text);
+
+	// Generated APIs
+//++Autogenerated -- start of section automatically generated from Scintilla.iface
+//**\(\*\n\)
+	void AddText(Position length, const char *text);
+	void AddStyledText(Position length, const char *c);
+	void InsertText(Position pos, const char *text);
+	void ChangeInsertion(Position length, const char *text);
+	void ClearAll();
+	void DeleteRange(Position start, Position lengthDelete);
+	void ClearDocumentStyle();
+	Position Length();
+	int CharAt(Position pos);
+	Position CurrentPos();
+	Position Anchor();
+	int StyleAt(Position pos);
+	void Redo();
+	void SetUndoCollection(bool collectUndo);
+	void SelectAll();
+	void SetSavePoint();
+	Position GetStyledText(void *tr);
+	bool CanRedo();
+	Line MarkerLineFromHandle(int markerHandle);
+	void MarkerDeleteHandle(int markerHandle);
+	int MarkerHandleFromLine(Line line, int which);
+	int MarkerNumberFromLine(Line line, int which);
+	bool UndoCollection();
+	Scintilla::WhiteSpace ViewWS();
+	void SetViewWS(Scintilla::WhiteSpace viewWS);
+	Scintilla::TabDrawMode TabDrawMode();
+	void SetTabDrawMode(Scintilla::TabDrawMode tabDrawMode);
+	Position PositionFromPoint(int x, int y);
+	Position PositionFromPointClose(int x, int y);
+	void GotoLine(Line line);
+	void GotoPos(Position caret);
+	void SetAnchor(Position anchor);
+	Position GetCurLine(Position length, char *text);
+	std::string GetCurLine(Position length);
+	Position EndStyled();
+	void ConvertEOLs(Scintilla::EndOfLine eolMode);
+	Scintilla::EndOfLine EOLMode();
+	void SetEOLMode(Scintilla::EndOfLine eolMode);
+	void StartStyling(Position start, int unused);
+	void SetStyling(Position length, int style);
+	bool BufferedDraw();
+	void SetBufferedDraw(bool buffered);
+	void SetTabWidth(int tabWidth);
+	int TabWidth();
+	void SetTabMinimumWidth(int pixels);
+	int TabMinimumWidth();
+	void ClearTabStops(Line line);
+	void AddTabStop(Line line, int x);
+	int GetNextTabStop(Line line, int x);
+	void SetCodePage(int codePage);
+	void SetFontLocale(const char *localeName);
+	int FontLocale(char *localeName);
+	std::string FontLocale();
+	Scintilla::IMEInteraction IMEInteraction();
+	void SetIMEInteraction(Scintilla::IMEInteraction imeInteraction);
+	void MarkerDefine(int markerNumber, Scintilla::MarkerSymbol markerSymbol);
+	void MarkerSetFore(int markerNumber, Colour fore);
+	void MarkerSetBack(int markerNumber, Colour back);
+	void MarkerSetBackSelected(int markerNumber, Colour back);
+	void MarkerSetForeTranslucent(int markerNumber, ColourAlpha fore);
+	void MarkerSetBackTranslucent(int markerNumber, ColourAlpha back);
+	void MarkerSetBackSelectedTranslucent(int markerNumber, ColourAlpha back);
+	void MarkerSetStrokeWidth(int markerNumber, int hundredths);
+	void MarkerEnableHighlight(bool enabled);
+	int MarkerAdd(Line line, int markerNumber);
+	void MarkerDelete(Line line, int markerNumber);
+	void MarkerDeleteAll(int markerNumber);
+	int MarkerGet(Line line);
+	Line MarkerNext(Line lineStart, int markerMask);
+	Line MarkerPrevious(Line lineStart, int markerMask);
+	void MarkerDefinePixmap(int markerNumber, const char *pixmap);
+	void MarkerAddSet(Line line, int markerSet);
+	void MarkerSetAlpha(int markerNumber, Scintilla::Alpha alpha);
+	Scintilla::Layer MarkerGetLayer(int markerNumber);
+	void MarkerSetLayer(int markerNumber, Scintilla::Layer layer);
+	void SetMarginTypeN(int margin, Scintilla::MarginType marginType);
+	Scintilla::MarginType MarginTypeN(int margin);
+	void SetMarginWidthN(int margin, int pixelWidth);
+	int MarginWidthN(int margin);
+	void SetMarginMaskN(int margin, int mask);
+	int MarginMaskN(int margin);
+	void SetMarginSensitiveN(int margin, bool sensitive);
+	bool MarginSensitiveN(int margin);
+	void SetMarginCursorN(int margin, Scintilla::CursorShape cursor);
+	Scintilla::CursorShape MarginCursorN(int margin);
+	void SetMarginBackN(int margin, Colour back);
+	Colour MarginBackN(int margin);
+	void SetMargins(int margins);
+	int Margins();
+	void StyleClearAll();
+	void StyleSetFore(int style, Colour fore);
+	void StyleSetBack(int style, Colour back);
+	void StyleSetBold(int style, bool bold);
+	void StyleSetItalic(int style, bool italic);
+	void StyleSetSize(int style, int sizePoints);
+	void StyleSetFont(int style, const char *fontName);
+	void StyleSetEOLFilled(int style, bool eolFilled);
+	void StyleResetDefault();
+	void StyleSetUnderline(int style, bool underline);
+	Colour StyleGetFore(int style);
+	Colour StyleGetBack(int style);
+	bool StyleGetBold(int style);
+	bool StyleGetItalic(int style);
+	int StyleGetSize(int style);
+	int StyleGetFont(int style, char *fontName);
+	std::string StyleGetFont(int style);
+	bool StyleGetEOLFilled(int style);
+	bool StyleGetUnderline(int style);
+	Scintilla::CaseVisible StyleGetCase(int style);
+	Scintilla::CharacterSet StyleGetCharacterSet(int style);
+	bool StyleGetVisible(int style);
+	bool StyleGetChangeable(int style);
+	bool StyleGetHotSpot(int style);
+	void StyleSetCase(int style, Scintilla::CaseVisible caseVisible);
+	void StyleSetSizeFractional(int style, int sizeHundredthPoints);
+	int StyleGetSizeFractional(int style);
+	void StyleSetWeight(int style, Scintilla::FontWeight weight);
+	Scintilla::FontWeight StyleGetWeight(int style);
+	void StyleSetCharacterSet(int style, Scintilla::CharacterSet characterSet);
+	void StyleSetHotSpot(int style, bool hotspot);
+	void SetElementColour(Scintilla::Element element, ColourAlpha colourElement);
+	ColourAlpha ElementColour(Scintilla::Element element);
+	void ResetElementColour(Scintilla::Element element);
+	bool ElementIsSet(Scintilla::Element element);
+	bool ElementAllowsTranslucent(Scintilla::Element element);
+	ColourAlpha ElementBaseColour(Scintilla::Element element);
+	void SetSelFore(bool useSetting, Colour fore);
+	void SetSelBack(bool useSetting, Colour back);
+	Scintilla::Alpha SelAlpha();
+	void SetSelAlpha(Scintilla::Alpha alpha);
+	bool SelEOLFilled();
+	void SetSelEOLFilled(bool filled);
+	Scintilla::Layer SelectionLayer();
+	void SetSelectionLayer(Scintilla::Layer layer);
+	Scintilla::Layer CaretLineLayer();
+	void SetCaretLineLayer(Scintilla::Layer layer);
+	void SetCaretFore(Colour fore);
+	void AssignCmdKey(int keyDefinition, int sciCommand);
+	void ClearCmdKey(int keyDefinition);
+	void ClearAllCmdKeys();
+	void SetStylingEx(Position length, const char *styles);
+	void StyleSetVisible(int style, bool visible);
+	int CaretPeriod();
+	void SetCaretPeriod(int periodMilliseconds);
+	void SetWordChars(const char *characters);
+	int WordChars(char *characters);
+	std::string WordChars();
+	void SetCharacterCategoryOptimization(int countCharacters);
+	int CharacterCategoryOptimization();
+	void BeginUndoAction();
+	void EndUndoAction();
+	void IndicSetStyle(int indicator, Scintilla::IndicatorStyle indicatorStyle);
+	Scintilla::IndicatorStyle IndicGetStyle(int indicator);
+	void IndicSetFore(int indicator, Colour fore);
+	Colour IndicGetFore(int indicator);
+	void IndicSetUnder(int indicator, bool under);
+	bool IndicGetUnder(int indicator);
+	void IndicSetHoverStyle(int indicator, Scintilla::IndicatorStyle indicatorStyle);
+	Scintilla::IndicatorStyle IndicGetHoverStyle(int indicator);
+	void IndicSetHoverFore(int indicator, Colour fore);
+	Colour IndicGetHoverFore(int indicator);
+	void IndicSetFlags(int indicator, Scintilla::IndicFlag flags);
+	Scintilla::IndicFlag IndicGetFlags(int indicator);
+	void IndicSetStrokeWidth(int indicator, int hundredths);
+	int IndicGetStrokeWidth(int indicator);
+	void SetWhitespaceFore(bool useSetting, Colour fore);
+	void SetWhitespaceBack(bool useSetting, Colour back);
+	void SetWhitespaceSize(int size);
+	int WhitespaceSize();
+	void SetLineState(Line line, int state);
+	int LineState(Line line);
+	int MaxLineState();
+	bool CaretLineVisible();
+	void SetCaretLineVisible(bool show);
+	Colour CaretLineBack();
+	void SetCaretLineBack(Colour back);
+	int CaretLineFrame();
+	void SetCaretLineFrame(int width);
+	void StyleSetChangeable(int style, bool changeable);
+	void AutoCShow(Position lengthEntered, const char *itemList);
+	void AutoCCancel();
+	bool AutoCActive();
+	Position AutoCPosStart();
+	void AutoCComplete();
+	void AutoCStops(const char *characterSet);
+	void AutoCSetSeparator(int separatorCharacter);
+	int AutoCGetSeparator();
+	void AutoCSelect(const char *select);
+	void AutoCSetCancelAtStart(bool cancel);
+	bool AutoCGetCancelAtStart();
+	void AutoCSetFillUps(const char *characterSet);
+	void AutoCSetChooseSingle(bool chooseSingle);
+	bool AutoCGetChooseSingle();
+	void AutoCSetIgnoreCase(bool ignoreCase);
+	bool AutoCGetIgnoreCase();
+	void UserListShow(int listType, const char *itemList);
+	void AutoCSetAutoHide(bool autoHide);
+	bool AutoCGetAutoHide();
+	void AutoCSetDropRestOfWord(bool dropRestOfWord);
+	bool AutoCGetDropRestOfWord();
+	void RegisterImage(int type, const char *xpmData);
+	void ClearRegisteredImages();
+	int AutoCGetTypeSeparator();
+	void AutoCSetTypeSeparator(int separatorCharacter);
+	void AutoCSetMaxWidth(int characterCount);
+	int AutoCGetMaxWidth();
+	void AutoCSetMaxHeight(int rowCount);
+	int AutoCGetMaxHeight();
+	void SetIndent(int indentSize);
+	int Indent();
+	void SetUseTabs(bool useTabs);
+	bool UseTabs();
+	void SetLineIndentation(Line line, int indentation);
+	int LineIndentation(Line line);
+	Position LineIndentPosition(Line line);
+	Position Column(Position pos);
+	Position CountCharacters(Position start, Position end);
+	Position CountCodeUnits(Position start, Position end);
+	void SetHScrollBar(bool visible);
+	bool HScrollBar();
+	void SetIndentationGuides(Scintilla::IndentView indentView);
+	Scintilla::IndentView IndentationGuides();
+	void SetHighlightGuide(Position column);
+	Position HighlightGuide();
+	Position LineEndPosition(Line line);
+	int CodePage();
+	Colour CaretFore();
+	bool ReadOnly();
+	void SetCurrentPos(Position caret);
+	void SetSelectionStart(Position anchor);
+	Position SelectionStart();
+	void SetSelectionEnd(Position caret);
+	Position SelectionEnd();
+	void SetEmptySelection(Position caret);
+	void SetPrintMagnification(int magnification);
+	int PrintMagnification();
+	void SetPrintColourMode(Scintilla::PrintOption mode);
+	Scintilla::PrintOption PrintColourMode();
+	Position FindText(Scintilla::FindOption searchFlags, void *ft);
+	Position FormatRange(bool draw, void *fr);
+	Line FirstVisibleLine();
+	Position GetLine(Line line, char *text);
+	std::string GetLine(Line line);
+	Line LineCount();
+	void SetMarginLeft(int pixelWidth);
+	int MarginLeft();
+	void SetMarginRight(int pixelWidth);
+	int MarginRight();
+	bool Modify();
+	void SetSel(Position anchor, Position caret);
+	Position GetSelText(char *text);
+	std::string GetSelText();
+	Position GetTextRange(void *tr);
+	void HideSelection(bool hide);
+	int PointXFromPosition(Position pos);
+	int PointYFromPosition(Position pos);
+	Line LineFromPosition(Position pos);
+	Position PositionFromLine(Line line);
+	void LineScroll(Position columns, Line lines);
+	void ScrollCaret();
+	void ScrollRange(Position secondary, Position primary);
+	void ReplaceSel(const char *text);
+	void SetReadOnly(bool readOnly);
+	void Null();
+	bool CanPaste();
+	bool CanUndo();
+	void EmptyUndoBuffer();
+	void Undo();
+	void Cut();
+	void Copy();
+	void Paste();
+	void Clear();
+	void SetText(const char *text);
+	Position GetText(Position length, char *text);
+	std::string GetText(Position length);
+	Position TextLength();
+	void *DirectFunction();
+	void *DirectStatusFunction();
+	void *DirectPointer();
+	void SetOvertype(bool overType);
+	bool Overtype();
+	void SetCaretWidth(int pixelWidth);
+	int CaretWidth();
+	void SetTargetStart(Position start);
+	Position TargetStart();
+	void SetTargetStartVirtualSpace(Position space);
+	Position TargetStartVirtualSpace();
+	void SetTargetEnd(Position end);
+	Position TargetEnd();
+	void SetTargetEndVirtualSpace(Position space);
+	Position TargetEndVirtualSpace();
+	void SetTargetRange(Position start, Position end);
+	Position TargetText(char *text);
+	std::string TargetText();
+	void TargetFromSelection();
+	void TargetWholeDocument();
+	Position ReplaceTarget(Position length, const char *text);
+	Position ReplaceTargetRE(Position length, const char *text);
+	Position SearchInTarget(Position length, const char *text);
+	void SetSearchFlags(Scintilla::FindOption searchFlags);
+	Scintilla::FindOption SearchFlags();
+	void CallTipShow(Position pos, const char *definition);
+	void CallTipCancel();
+	bool CallTipActive();
+	Position CallTipPosStart();
+	void CallTipSetPosStart(Position posStart);
+	void CallTipSetHlt(Position highlightStart, Position highlightEnd);
+	void CallTipSetBack(Colour back);
+	void CallTipSetFore(Colour fore);
+	void CallTipSetForeHlt(Colour fore);
+	void CallTipUseStyle(int tabSize);
+	void CallTipSetPosition(bool above);
+	Line VisibleFromDocLine(Line docLine);
+	Line DocLineFromVisible(Line displayLine);
+	Line WrapCount(Line docLine);
+	void SetFoldLevel(Line line, Scintilla::FoldLevel level);
+	Scintilla::FoldLevel FoldLevel(Line line);
+	Line LastChild(Line line, Scintilla::FoldLevel level);
+	Line FoldParent(Line line);
+	void ShowLines(Line lineStart, Line lineEnd);
+	void HideLines(Line lineStart, Line lineEnd);
+	bool LineVisible(Line line);
+	bool AllLinesVisible();
+	void SetFoldExpanded(Line line, bool expanded);
+	bool FoldExpanded(Line line);
+	void ToggleFold(Line line);
+	void ToggleFoldShowText(Line line, const char *text);
+	void FoldDisplayTextSetStyle(Scintilla::FoldDisplayTextStyle style);
+	Scintilla::FoldDisplayTextStyle FoldDisplayTextGetStyle();
+	void SetDefaultFoldDisplayText(const char *text);
+	int GetDefaultFoldDisplayText(char *text);
+	std::string GetDefaultFoldDisplayText();
+	void FoldLine(Line line, Scintilla::FoldAction action);
+	void FoldChildren(Line line, Scintilla::FoldAction action);
+	void ExpandChildren(Line line, Scintilla::FoldLevel level);
+	void FoldAll(Scintilla::FoldAction action);
+	void EnsureVisible(Line line);
+	void SetAutomaticFold(Scintilla::AutomaticFold automaticFold);
+	Scintilla::AutomaticFold AutomaticFold();
+	void SetFoldFlags(Scintilla::FoldFlag flags);
+	void EnsureVisibleEnforcePolicy(Line line);
+	void SetTabIndents(bool tabIndents);
+	bool TabIndents();
+	void SetBackSpaceUnIndents(bool bsUnIndents);
+	bool BackSpaceUnIndents();
+	void SetMouseDwellTime(int periodMilliseconds);
+	int MouseDwellTime();
+	Position WordStartPosition(Position pos, bool onlyWordCharacters);
+	Position WordEndPosition(Position pos, bool onlyWordCharacters);
+	bool IsRangeWord(Position start, Position end);
+	void SetIdleStyling(Scintilla::IdleStyling idleStyling);
+	Scintilla::IdleStyling IdleStyling();
+	void SetWrapMode(Scintilla::Wrap wrapMode);
+	Scintilla::Wrap WrapMode();
+	void SetWrapVisualFlags(Scintilla::WrapVisualFlag wrapVisualFlags);
+	Scintilla::WrapVisualFlag WrapVisualFlags();
+	void SetWrapVisualFlagsLocation(Scintilla::WrapVisualLocation wrapVisualFlagsLocation);
+	Scintilla::WrapVisualLocation WrapVisualFlagsLocation();
+	void SetWrapStartIndent(int indent);
+	int WrapStartIndent();
+	void SetWrapIndentMode(Scintilla::WrapIndentMode wrapIndentMode);
+	Scintilla::WrapIndentMode WrapIndentMode();
+	void SetLayoutCache(Scintilla::LineCache cacheMode);
+	Scintilla::LineCache LayoutCache();
+	void SetScrollWidth(int pixelWidth);
+	int ScrollWidth();
+	void SetScrollWidthTracking(bool tracking);
+	bool ScrollWidthTracking();
+	int TextWidth(int style, const char *text);
+	void SetEndAtLastLine(bool endAtLastLine);
+	bool EndAtLastLine();
+	int TextHeight(Line line);
+	void SetVScrollBar(bool visible);
+	bool VScrollBar();
+	void AppendText(Position length, const char *text);
+	Scintilla::PhasesDraw PhasesDraw();
+	void SetPhasesDraw(Scintilla::PhasesDraw phases);
+	void SetFontQuality(Scintilla::FontQuality fontQuality);
+	Scintilla::FontQuality FontQuality();
+	void SetFirstVisibleLine(Line displayLine);
+	void SetMultiPaste(Scintilla::MultiPaste multiPaste);
+	Scintilla::MultiPaste MultiPaste();
+	int Tag(int tagNumber, char *tagValue);
+	std::string Tag(int tagNumber);
+	void LinesJoin();
+	void LinesSplit(int pixelWidth);
+	void SetFoldMarginColour(bool useSetting, Colour back);
+	void SetFoldMarginHiColour(bool useSetting, Colour fore);
+	void SetAccessibility(Scintilla::Accessibility accessibility);
+	Scintilla::Accessibility Accessibility();
+	void LineDown();
+	void LineDownExtend();
+	void LineUp();
+	void LineUpExtend();
+	void CharLeft();
+	void CharLeftExtend();
+	void CharRight();
+	void CharRightExtend();
+	void WordLeft();
+	void WordLeftExtend();
+	void WordRight();
+	void WordRightExtend();
+	void Home();
+	void HomeExtend();
+	void LineEnd();
+	void LineEndExtend();
+	void DocumentStart();
+	void DocumentStartExtend();
+	void DocumentEnd();
+	void DocumentEndExtend();
+	void PageUp();
+	void PageUpExtend();
+	void PageDown();
+	void PageDownExtend();
+	void EditToggleOvertype();
+	void Cancel();
+	void DeleteBack();
+	void Tab();
+	void BackTab();
+	void NewLine();
+	void FormFeed();
+	void VCHome();
+	void VCHomeExtend();
+	void ZoomIn();
+	void ZoomOut();
+	void DelWordLeft();
+	void DelWordRight();
+	void DelWordRightEnd();
+	void LineCut();
+	void LineDelete();
+	void LineTranspose();
+	void LineReverse();
+	void LineDuplicate();
+	void LowerCase();
+	void UpperCase();
+	void LineScrollDown();
+	void LineScrollUp();
+	void DeleteBackNotLine();
+	void HomeDisplay();
+	void HomeDisplayExtend();
+	void LineEndDisplay();
+	void LineEndDisplayExtend();
+	void HomeWrap();
+	void HomeWrapExtend();
+	void LineEndWrap();
+	void LineEndWrapExtend();
+	void VCHomeWrap();
+	void VCHomeWrapExtend();
+	void LineCopy();
+	void MoveCaretInsideView();
+	Position LineLength(Line line);
+	void BraceHighlight(Position posA, Position posB);
+	void BraceHighlightIndicator(bool useSetting, int indicator);
+	void BraceBadLight(Position pos);
+	void BraceBadLightIndicator(bool useSetting, int indicator);
+	Position BraceMatch(Position pos, int maxReStyle);
+	Position BraceMatchNext(Position pos, Position startPos);
+	bool ViewEOL();
+	void SetViewEOL(bool visible);
+	void *DocPointer();
+	void SetDocPointer(void *doc);
+	void SetModEventMask(Scintilla::ModificationFlags eventMask);
+	Position EdgeColumn();
+	void SetEdgeColumn(Position column);
+	Scintilla::EdgeVisualStyle EdgeMode();
+	void SetEdgeMode(Scintilla::EdgeVisualStyle edgeMode);
+	Colour EdgeColour();
+	void SetEdgeColour(Colour edgeColour);
+	void MultiEdgeAddLine(Position column, Colour edgeColour);
+	void MultiEdgeClearAll();
+	Position MultiEdgeColumn(int which);
+	void SearchAnchor();
+	Position SearchNext(Scintilla::FindOption searchFlags, const char *text);
+	Position SearchPrev(Scintilla::FindOption searchFlags, const char *text);
+	Line LinesOnScreen();
+	void UsePopUp(Scintilla::PopUp popUpMode);
+	bool SelectionIsRectangle();
+	void SetZoom(int zoomInPoints);
+	int Zoom();
+	void *CreateDocument(Position bytes, Scintilla::DocumentOption documentOptions);
+	void AddRefDocument(void *doc);
+	void ReleaseDocument(void *doc);
+	Scintilla::DocumentOption DocumentOptions();
+	Scintilla::ModificationFlags ModEventMask();
+	void SetCommandEvents(bool commandEvents);
+	bool CommandEvents();
+	void SetFocus(bool focus);
+	bool Focus();
+	void SetStatus(Scintilla::Status status);
+	Scintilla::Status Status();
+	void SetMouseDownCaptures(bool captures);
+	bool MouseDownCaptures();
+	void SetMouseWheelCaptures(bool captures);
+	bool MouseWheelCaptures();
+	void SetCursor(Scintilla::CursorShape cursorType);
+	Scintilla::CursorShape Cursor();
+	void SetControlCharSymbol(int symbol);
+	int ControlCharSymbol();
+	void WordPartLeft();
+	void WordPartLeftExtend();
+	void WordPartRight();
+	void WordPartRightExtend();
+	void SetVisiblePolicy(Scintilla::VisiblePolicy visiblePolicy, int visibleSlop);
+	void DelLineLeft();
+	void DelLineRight();
+	void SetXOffset(int xOffset);
+	int XOffset();
+	void ChooseCaretX();
+	void GrabFocus();
+	void SetXCaretPolicy(Scintilla::CaretPolicy caretPolicy, int caretSlop);
+	void SetYCaretPolicy(Scintilla::CaretPolicy caretPolicy, int caretSlop);
+	void SetPrintWrapMode(Scintilla::Wrap wrapMode);
+	Scintilla::Wrap PrintWrapMode();
+	void SetHotspotActiveFore(bool useSetting, Colour fore);
+	Colour HotspotActiveFore();
+	void SetHotspotActiveBack(bool useSetting, Colour back);
+	Colour HotspotActiveBack();
+	void SetHotspotActiveUnderline(bool underline);
+	bool HotspotActiveUnderline();
+	void SetHotspotSingleLine(bool singleLine);
+	bool HotspotSingleLine();
+	void ParaDown();
+	void ParaDownExtend();
+	void ParaUp();
+	void ParaUpExtend();
+	Position PositionBefore(Position pos);
+	Position PositionAfter(Position pos);
+	Position PositionRelative(Position pos, Position relative);
+	Position PositionRelativeCodeUnits(Position pos, Position relative);
+	void CopyRange(Position start, Position end);
+	void CopyText(Position length, const char *text);
+	void SetSelectionMode(Scintilla::SelectionMode selectionMode);
+	Scintilla::SelectionMode SelectionMode();
+	bool MoveExtendsSelection();
+	Position GetLineSelStartPosition(Line line);
+	Position GetLineSelEndPosition(Line line);
+	void LineDownRectExtend();
+	void LineUpRectExtend();
+	void CharLeftRectExtend();
+	void CharRightRectExtend();
+	void HomeRectExtend();
+	void VCHomeRectExtend();
+	void LineEndRectExtend();
+	void PageUpRectExtend();
+	void PageDownRectExtend();
+	void StutteredPageUp();
+	void StutteredPageUpExtend();
+	void StutteredPageDown();
+	void StutteredPageDownExtend();
+	void WordLeftEnd();
+	void WordLeftEndExtend();
+	void WordRightEnd();
+	void WordRightEndExtend();
+	void SetWhitespaceChars(const char *characters);
+	int WhitespaceChars(char *characters);
+	std::string WhitespaceChars();
+	void SetPunctuationChars(const char *characters);
+	int PunctuationChars(char *characters);
+	std::string PunctuationChars();
+	void SetCharsDefault();
+	int AutoCGetCurrent();
+	int AutoCGetCurrentText(char *text);
+	std::string AutoCGetCurrentText();
+	void AutoCSetCaseInsensitiveBehaviour(Scintilla::CaseInsensitiveBehaviour behaviour);
+	Scintilla::CaseInsensitiveBehaviour AutoCGetCaseInsensitiveBehaviour();
+	void AutoCSetMulti(Scintilla::MultiAutoComplete multi);
+	Scintilla::MultiAutoComplete AutoCGetMulti();
+	void AutoCSetOrder(Scintilla::Ordering order);
+	Scintilla::Ordering AutoCGetOrder();
+	void Allocate(Position bytes);
+	Position TargetAsUTF8(char *s);
+	std::string TargetAsUTF8();
+	void SetLengthForEncode(Position bytes);
+	Position EncodedFromUTF8(const char *utf8, char *encoded);
+	std::string EncodedFromUTF8(const char *utf8);
+	Position FindColumn(Line line, Position column);
+	Scintilla::CaretSticky CaretSticky();
+	void SetCaretSticky(Scintilla::CaretSticky useCaretStickyBehaviour);
+	void ToggleCaretSticky();
+	void SetPasteConvertEndings(bool convert);
+	bool PasteConvertEndings();
+	void ReplaceRectangular(Position length, const char *text);
+	void SelectionDuplicate();
+	void SetCaretLineBackAlpha(Scintilla::Alpha alpha);
+	Scintilla::Alpha CaretLineBackAlpha();
+	void SetCaretStyle(Scintilla::CaretStyle caretStyle);
+	Scintilla::CaretStyle CaretStyle();
+	void SetIndicatorCurrent(int indicator);
+	int IndicatorCurrent();
+	void SetIndicatorValue(int value);
+	int IndicatorValue();
+	void IndicatorFillRange(Position start, Position lengthFill);
+	void IndicatorClearRange(Position start, Position lengthClear);
+	int IndicatorAllOnFor(Position pos);
+	int IndicatorValueAt(int indicator, Position pos);
+	Position IndicatorStart(int indicator, Position pos);
+	Position IndicatorEnd(int indicator, Position pos);
+	void SetPositionCache(int size);
+	int PositionCache();
+	void CopyAllowLine();
+	void *CharacterPointer();
+	void *RangePointer(Position start, Position lengthRange);
+	Position GapPosition();
+	void IndicSetAlpha(int indicator, Scintilla::Alpha alpha);
+	Scintilla::Alpha IndicGetAlpha(int indicator);
+	void IndicSetOutlineAlpha(int indicator, Scintilla::Alpha alpha);
+	Scintilla::Alpha IndicGetOutlineAlpha(int indicator);
+	void SetExtraAscent(int extraAscent);
+	int ExtraAscent();
+	void SetExtraDescent(int extraDescent);
+	int ExtraDescent();
+	int MarkerSymbolDefined(int markerNumber);
+	void MarginSetText(Line line, const char *text);
+	int MarginGetText(Line line, char *text);
+	std::string MarginGetText(Line line);
+	void MarginSetStyle(Line line, int style);
+	int MarginGetStyle(Line line);
+	void MarginSetStyles(Line line, const char *styles);
+	int MarginGetStyles(Line line, char *styles);
+	std::string MarginGetStyles(Line line);
+	void MarginTextClearAll();
+	void MarginSetStyleOffset(int style);
+	int MarginGetStyleOffset();
+	void SetMarginOptions(Scintilla::MarginOption marginOptions);
+	Scintilla::MarginOption MarginOptions();
+	void AnnotationSetText(Line line, const char *text);
+	int AnnotationGetText(Line line, char *text);
+	std::string AnnotationGetText(Line line);
+	void AnnotationSetStyle(Line line, int style);
+	int AnnotationGetStyle(Line line);
+	void AnnotationSetStyles(Line line, const char *styles);
+	int AnnotationGetStyles(Line line, char *styles);
+	std::string AnnotationGetStyles(Line line);
+	int AnnotationGetLines(Line line);
+	void AnnotationClearAll();
+	void AnnotationSetVisible(Scintilla::AnnotationVisible visible);
+	Scintilla::AnnotationVisible AnnotationGetVisible();
+	void AnnotationSetStyleOffset(int style);
+	int AnnotationGetStyleOffset();
+	void ReleaseAllExtendedStyles();
+	int AllocateExtendedStyles(int numberStyles);
+	void AddUndoAction(int token, Scintilla::UndoFlags flags);
+	Position CharPositionFromPoint(int x, int y);
+	Position CharPositionFromPointClose(int x, int y);
+	void SetMouseSelectionRectangularSwitch(bool mouseSelectionRectangularSwitch);
+	bool MouseSelectionRectangularSwitch();
+	void SetMultipleSelection(bool multipleSelection);
+	bool MultipleSelection();
+	void SetAdditionalSelectionTyping(bool additionalSelectionTyping);
+	bool AdditionalSelectionTyping();
+	void SetAdditionalCaretsBlink(bool additionalCaretsBlink);
+	bool AdditionalCaretsBlink();
+	void SetAdditionalCaretsVisible(bool additionalCaretsVisible);
+	bool AdditionalCaretsVisible();
+	int Selections();
+	bool SelectionEmpty();
+	void ClearSelections();
+	void SetSelection(Position caret, Position anchor);
+	void AddSelection(Position caret, Position anchor);
+	void DropSelectionN(int selection);
+	void SetMainSelection(int selection);
+	int MainSelection();
+	void SetSelectionNCaret(int selection, Position caret);
+	Position SelectionNCaret(int selection);
+	void SetSelectionNAnchor(int selection, Position anchor);
+	Position SelectionNAnchor(int selection);
+	void SetSelectionNCaretVirtualSpace(int selection, Position space);
+	Position SelectionNCaretVirtualSpace(int selection);
+	void SetSelectionNAnchorVirtualSpace(int selection, Position space);
+	Position SelectionNAnchorVirtualSpace(int selection);
+	void SetSelectionNStart(int selection, Position anchor);
+	Position SelectionNStart(int selection);
+	Position SelectionNStartVirtualSpace(int selection);
+	void SetSelectionNEnd(int selection, Position caret);
+	Position SelectionNEndVirtualSpace(int selection);
+	Position SelectionNEnd(int selection);
+	void SetRectangularSelectionCaret(Position caret);
+	Position RectangularSelectionCaret();
+	void SetRectangularSelectionAnchor(Position anchor);
+	Position RectangularSelectionAnchor();
+	void SetRectangularSelectionCaretVirtualSpace(Position space);
+	Position RectangularSelectionCaretVirtualSpace();
+	void SetRectangularSelectionAnchorVirtualSpace(Position space);
+	Position RectangularSelectionAnchorVirtualSpace();
+	void SetVirtualSpaceOptions(Scintilla::VirtualSpace virtualSpaceOptions);
+	Scintilla::VirtualSpace VirtualSpaceOptions();
+	void SetRectangularSelectionModifier(int modifier);
+	int RectangularSelectionModifier();
+	void SetAdditionalSelFore(Colour fore);
+	void SetAdditionalSelBack(Colour back);
+	void SetAdditionalSelAlpha(Scintilla::Alpha alpha);
+	Scintilla::Alpha AdditionalSelAlpha();
+	void SetAdditionalCaretFore(Colour fore);
+	Colour AdditionalCaretFore();
+	void RotateSelection();
+	void SwapMainAnchorCaret();
+	void MultipleSelectAddNext();
+	void MultipleSelectAddEach();
+	int ChangeLexerState(Position start, Position end);
+	Line ContractedFoldNext(Line lineStart);
+	void VerticalCentreCaret();
+	void MoveSelectedLinesUp();
+	void MoveSelectedLinesDown();
+	void SetIdentifier(int identifier);
+	int Identifier();
+	void RGBAImageSetWidth(int width);
+	void RGBAImageSetHeight(int height);
+	void RGBAImageSetScale(int scalePercent);
+	void MarkerDefineRGBAImage(int markerNumber, const char *pixels);
+	void RegisterRGBAImage(int type, const char *pixels);
+	void ScrollToStart();
+	void ScrollToEnd();
+	void SetTechnology(Scintilla::Technology technology);
+	Scintilla::Technology Technology();
+	void *CreateLoader(Position bytes, Scintilla::DocumentOption documentOptions);
+	void FindIndicatorShow(Position start, Position end);
+	void FindIndicatorFlash(Position start, Position end);
+	void FindIndicatorHide();
+	void VCHomeDisplay();
+	void VCHomeDisplayExtend();
+	bool CaretLineVisibleAlways();
+	void SetCaretLineVisibleAlways(bool alwaysVisible);
+	void SetLineEndTypesAllowed(Scintilla::LineEndType lineEndBitSet);
+	Scintilla::LineEndType LineEndTypesAllowed();
+	Scintilla::LineEndType LineEndTypesActive();
+	void SetRepresentation(const char *encodedCharacter, const char *representation);
+	int Representation(const char *encodedCharacter, char *representation);
+	std::string Representation(const char *encodedCharacter);
+	void ClearRepresentation(const char *encodedCharacter);
+	void ClearAllRepresentations();
+	void SetRepresentationAppearance(const char *encodedCharacter, Scintilla::RepresentationAppearance appearance);
+	Scintilla::RepresentationAppearance RepresentationAppearance(const char *encodedCharacter);
+	void SetRepresentationColour(const char *encodedCharacter, ColourAlpha colour);
+	ColourAlpha RepresentationColour(const char *encodedCharacter);
+	void EOLAnnotationSetText(Line line, const char *text);
+	int EOLAnnotationGetText(Line line, char *text);
+	std::string EOLAnnotationGetText(Line line);
+	void EOLAnnotationSetStyle(Line line, int style);
+	int EOLAnnotationGetStyle(Line line);
+	void EOLAnnotationClearAll();
+	void EOLAnnotationSetVisible(Scintilla::EOLAnnotationVisible visible);
+	Scintilla::EOLAnnotationVisible EOLAnnotationGetVisible();
+	void EOLAnnotationSetStyleOffset(int style);
+	int EOLAnnotationGetStyleOffset();
+	bool SupportsFeature(Scintilla::Supports feature);
+	Scintilla::LineCharacterIndexType LineCharacterIndex();
+	void AllocateLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex);
+	void ReleaseLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex);
+	Line LineFromIndexPosition(Position pos, Scintilla::LineCharacterIndexType lineCharacterIndex);
+	Position IndexPositionFromLine(Line line, Scintilla::LineCharacterIndexType lineCharacterIndex);
+	void StartRecord();
+	void StopRecord();
+	int Lexer();
+	void Colourise(Position start, Position end);
+	void SetProperty(const char *key, const char *value);
+	void SetKeyWords(int keyWordSet, const char *keyWords);
+	int Property(const char *key, char *value);
+	std::string Property(const char *key);
+	int PropertyExpanded(const char *key, char *value);
+	std::string PropertyExpanded(const char *key);
+	int PropertyInt(const char *key, int defaultValue);
+	int LexerLanguage(char *language);
+	std::string LexerLanguage();
+	void *PrivateLexerCall(int operation, void *pointer);
+	int PropertyNames(char *names);
+	std::string PropertyNames();
+	Scintilla::TypeProperty PropertyType(const char *name);
+	int DescribeProperty(const char *name, char *description);
+	std::string DescribeProperty(const char *name);
+	int DescribeKeyWordSets(char *descriptions);
+	std::string DescribeKeyWordSets();
+	int LineEndTypesSupported();
+	int AllocateSubStyles(int styleBase, int numberStyles);
+	int SubStylesStart(int styleBase);
+	int SubStylesLength(int styleBase);
+	int StyleFromSubStyle(int subStyle);
+	int PrimaryStyleFromStyle(int style);
+	void FreeSubStyles();
+	void SetIdentifiers(int style, const char *identifiers);
+	int DistanceToSecondaryStyles();
+	int SubStyleBases(char *styles);
+	std::string SubStyleBases();
+	int NamedStyles();
+	int NameOfStyle(int style, char *name);
+	std::string NameOfStyle(int style);
+	int TagsOfStyle(int style, char *tags);
+	std::string TagsOfStyle(int style);
+	int DescriptionOfStyle(int style, char *description);
+	std::string DescriptionOfStyle(int style);
+	void SetILexer(void *ilexer);
+	Scintilla::Bidirectional Bidirectional();
+	void SetBidirectional(Scintilla::Bidirectional bidirectional);
+
+//--Autogenerated -- end of section automatically generated from Scintilla.iface
+
+};
+
+}
+
+#endif
diff --git a/scripts/ScintillaAPIFacer.py b/scripts/ScintillaAPIFacer.py
index 3078b49c6..9fe5f56ce 100644
--- a/scripts/ScintillaAPIFacer.py
+++ b/scripts/ScintillaAPIFacer.py
@@ -10,6 +10,121 @@ import Face
 import FileGenerator
 import HFacer
 
+namespace = "Scintilla::"
+
+typeAliases = {
+	# Convert iface types to C++ types
+	# bool and void are OK as is
+	"cells": "const char *",
+	"colour": "Colour",
+	"colouralpha": "ColourAlpha",
+	"findtext": "void *",
+	"formatrange": "void *",
+	"int": "int",
+	"keymod": "int",
+	"line": "Line",
+	"pointer": "void *",
+	"position": "Position",
+	"string": "const char *",
+	"stringresult": "char *",
+	"textrange": "void *",
+}
+
+basicTypes = [
+	"bool",
+	"char *",
+	"Colour",
+	"ColourAlpha",
+	"const char *",
+	"int",
+	"intptr_t",
+	"Line",
+	"Position",
+	"void",
+	"void *",
+]
+
+deadValues = [
+	"INDIC_CONTAINER",
+	"INDIC_IME",
+	"INDIC_IME_MAX",
+	"INDIC_MAX",
+]
+
+def ActualTypeName(type, identifier=None):
+	if type in typeAliases:
+		return typeAliases[type]
+	else:
+		return type
+
+def IsEnumeration(s):
+	if s in ["Position", "Line", "Colour", "ColourAlpha"]:
+		return False
+	return s[:1].isupper()
+
+def JoinTypeAndIdentifier(type, identifier):
+	# Add a space to separate type from identifier unless type is pointer
+	if type.endswith("*"):
+		return type + identifier
+	else:
+		return type + " " + identifier
+
+def ParametersArgsCallname(v):
+	parameters = ""
+	args = ""
+	callName = "Call"
+
+	param1TypeBase = v["Param1Type"]
+	param1Name = v["Param1Name"]
+	param1Type = ActualTypeName(param1TypeBase, param1Name)
+	param1Arg = ""
+	if param1Type:
+		castName = param1Name
+		if param1Type.endswith("*"):
+			castName = "reinterpret_cast<uintptr_t>(" + param1Name + ")"
+		elif param1Type not in basicTypes:
+			castName = "static_cast<uintptr_t>(" + param1Name + ")"
+		if IsEnumeration(param1TypeBase):
+			param1Type = namespace + param1Type
+		param1Arg = JoinTypeAndIdentifier(param1Type, param1Name)
+		parameters = param1Arg
+		args = castName
+
+	param2TypeBase = v["Param2Type"]
+	param2Name = v["Param2Name"]
+	param2Type = ActualTypeName(param2TypeBase, param2Name)
+	param2Arg = ""
+	if param2Type:
+		castName = param2Name
+		if param2Type.endswith("*"):
+			if param2Type == "const char *":
+				callName = "CallString"
+			else:
+				callName = "CallPointer"
+		elif param2Type not in basicTypes:
+			castName = "static_cast<intptr_t>(" + param2Name + ")"
+		if IsEnumeration(param2TypeBase):
+			param2Type = namespace + param2Type
+		param2Arg = JoinTypeAndIdentifier(param2Type, param2Name)
+		if param1Arg:
+			parameters = parameters + ", "
+		parameters = parameters + param2Arg
+		if not args:
+			args = args + "0"
+		if args:
+			args = args + ", "
+		args = args + castName
+
+	if args:
+		args = ", " + args
+	return (parameters, args, callName)
+
+def ParametersExceptLast(parameters):
+	if "," in parameters:
+		return parameters[:parameters.rfind(",")]
+	else:
+		return ""
+
 def HMessages(f):
 	out = ["enum class Message {"]
 	for name in f.order:
@@ -20,13 +135,6 @@ def HMessages(f):
 	out.append("};")
 	return out
 
-deadValues = [
-	"INDIC_CONTAINER",
-	"INDIC_IME",
-	"INDIC_IME_MAX",
-	"INDIC_MAX",
-]
-
 def HEnumerations(f):
 	out = []
 	for name in f.order:
@@ -100,6 +208,67 @@ def HConstants(f):
 					out.append("constexpr " + type + " " + Face.PascalCase(name) + " = " + v["Value"] + ";")
 	return out
 
+def HMethods(f):
+	out = []
+	for name in f.order:
+		v = f.features[name]
+		if v["Category"] != "Deprecated":
+			if v["FeatureType"] in ["fun", "get", "set"]:
+				if v["FeatureType"] == "get" and name.startswith("Get"):
+					name = name[len("Get"):]
+				retType = ActualTypeName(v["ReturnType"])
+				if IsEnumeration(retType):
+					retType = namespace + retType
+				parameters, args, callName = ParametersArgsCallname(v)
+
+				out.append("\t" + JoinTypeAndIdentifier(retType, name) + "(" + parameters + ");")
+
+				# Extra method for stringresult that returns std::string
+				if v["Param2Type"] == "stringresult":
+					out.append("\t" + JoinTypeAndIdentifier("std::string", name) + \
+						"(" + ParametersExceptLast(parameters) + ");")
+	return out
+
+def CXXMethods(f):
+	out = []
+	for name in f.order:
+		v = f.features[name]
+		if v["Category"] != "Deprecated":
+			if v["FeatureType"] in ["fun", "get", "set"]:
+				msgName = "Message::" + name
+				if v["FeatureType"] == "get" and name.startswith("Get"):
+					name = name[len("Get"):]
+				retType = ActualTypeName(v["ReturnType"])
+				parameters, args, callName = ParametersArgsCallname(v)
+				returnIfNeeded = "return " if retType != "void" else ""
+
+				out.append(JoinTypeAndIdentifier(retType, "ScintillaCall::" + name) + "(" + parameters + ")" + " {")
+				retCast = ""
+				retCastEnd = ""
+				if retType not in basicTypes or retType in ["int", "Colour", "ColourAlpha"]:
+					if IsEnumeration(retType):
+						retType = namespace + retType
+					retCast = "static_cast<" + retType + ">("
+					retCastEnd = ")"
+				elif retType in ["void *"]:
+					retCast = "reinterpret_cast<" + retType + ">("
+					retCastEnd = ")"
+				out.append("\t" + returnIfNeeded + retCast + callName + "(" + msgName + args + ")" + retCastEnd + ";")
+				out.append("}")
+				out.append("")
+
+				# Extra method for stringresult that returns std::string
+				if v["Param2Type"] == "stringresult":
+					paramList = ParametersExceptLast(parameters)
+					argList = ParametersExceptLast(args)
+					out.append(JoinTypeAndIdentifier("std::string", "ScintillaCall::" + name) + \
+						"(" + paramList + ") {")
+					out.append("\treturn CallReturnString(" + msgName + argList + ");")
+					out.append("}")
+					out.append("")
+
+	return out
+
 def RegenerateAll(root):
 	HFacer.RegenerateAll(root, False)
 	f = Face.Face()
@@ -107,6 +276,8 @@ def RegenerateAll(root):
 	f.ReadFromFile(include / "Scintilla.iface")
 	FileGenerator.Regenerate(include / "ScintillaMessages.h", "//", HMessages(f))
 	FileGenerator.Regenerate(include / "ScintillaTypes.h", "//", HEnumerations(f), HConstants(f))
+	FileGenerator.Regenerate(include / "ScintillaCall.h", "//", HMethods(f))
+	FileGenerator.Regenerate(root / "call" / "ScintillaCall.cxx", "//", CXXMethods(f))
 
 if __name__ == "__main__":
 	RegenerateAll(pathlib.Path(__file__).resolve().parent.parent)