1 files changed, 172 insertions, 169 deletions

diff --git a/src/ScintillaBase.cxx b/src/ScintillaBase.cxx
index 4c1e9a803..a6e769d81 100644
--- a/src/ScintillaBase.cxx
+++ b/src/ScintillaBase.cxx
@@ -20,14 +20,16 @@
 #include <algorithm>
 #include <memory>
 
+#include "ScintillaTypes.h"
+#include "ScintillaMessages.h"
+#include "ScintillaStructures.h"
+#include "ILoader.h"
+#include "ILexer.h"
+
 #include "Debugging.h"
 #include "Geometry.h"
 #include "Platform.h"
 
-#include "ILoader.h"
-#include "ILexer.h"
-#include "Scintilla.h"
-
 #include "CharacterCategoryMap.h"
 
 #include "Position.h"
@@ -57,12 +59,13 @@
 #include "ScintillaBase.h"
 
 using namespace Scintilla;
+using namespace Scintilla::Internal;
 
 ScintillaBase::ScintillaBase() {
-	displayPopupMenu = SC_POPUP_ALL;
+	displayPopupMenu = PopUp::All;
 	listType = 0;
 	maxListWidth = 0;
-	multiAutoCMode = SC_MULTIAUTOC_ONCE;
+	multiAutoCMode = MultiAutoComplete::Once;
 }
 
 ScintillaBase::~ScintillaBase() {
@@ -101,73 +104,73 @@ void ScintillaBase::Command(int cmdId) {
 		break;
 
 	case idcmdUndo:
-		WndProc(SCI_UNDO, 0, 0);
+		WndProc(Message::Undo, 0, 0);
 		break;
 
 	case idcmdRedo:
-		WndProc(SCI_REDO, 0, 0);
+		WndProc(Message::Redo, 0, 0);
 		break;
 
 	case idcmdCut:
-		WndProc(SCI_CUT, 0, 0);
+		WndProc(Message::Cut, 0, 0);
 		break;
 
 	case idcmdCopy:
-		WndProc(SCI_COPY, 0, 0);
+		WndProc(Message::Copy, 0, 0);
 		break;
 
 	case idcmdPaste:
-		WndProc(SCI_PASTE, 0, 0);
+		WndProc(Message::Paste, 0, 0);
 		break;
 
 	case idcmdDelete:
-		WndProc(SCI_CLEAR, 0, 0);
+		WndProc(Message::Clear, 0, 0);
 		break;
 
 	case idcmdSelectAll:
-		WndProc(SCI_SELECTALL, 0, 0);
+		WndProc(Message::SelectAll, 0, 0);
 		break;
 	}
 }
 
-int ScintillaBase::KeyCommand(unsigned int iMessage) {
+int ScintillaBase::KeyCommand(Message iMessage) {
 	// Most key commands cancel autocompletion mode
 	if (ac.Active()) {
 		switch (iMessage) {
 			// Except for these
-		case SCI_LINEDOWN:
+		case Message::LineDown:
 			AutoCompleteMove(1);
 			return 0;
-		case SCI_LINEUP:
+		case Message::LineUp:
 			AutoCompleteMove(-1);
 			return 0;
-		case SCI_PAGEDOWN:
+		case Message::PageDown:
 			AutoCompleteMove(ac.lb->GetVisibleRows());
 			return 0;
-		case SCI_PAGEUP:
+		case Message::PageUp:
 			AutoCompleteMove(-ac.lb->GetVisibleRows());
 			return 0;
-		case SCI_VCHOME:
+		case Message::VCHome:
 			AutoCompleteMove(-5000);
 			return 0;
-		case SCI_LINEEND:
+		case Message::LineEnd:
 			AutoCompleteMove(5000);
 			return 0;
-		case SCI_DELETEBACK:
+		case Message::DeleteBack:
 			DelCharBack(true);
 			AutoCompleteCharacterDeleted();
 			EnsureCaretVisible();
 			return 0;
-		case SCI_DELETEBACKNOTLINE:
+		case Message::DeleteBackNotLine:
 			DelCharBack(false);
 			AutoCompleteCharacterDeleted();
 			EnsureCaretVisible();
 			return 0;
-		case SCI_TAB:
-			AutoCompleteCompleted(0, SC_AC_TAB);
+		case Message::Tab:
+			AutoCompleteCompleted(0, CompletionMethods::Tab);
 			return 0;
-		case SCI_NEWLINE:
-			AutoCompleteCompleted(0, SC_AC_NEWLINE);
+		case Message::NewLine:
+			AutoCompleteCompleted(0, CompletionMethods::Newline);
 			return 0;
 
 		default:
@@ -177,17 +180,17 @@ int ScintillaBase::KeyCommand(unsigned int iMessage) {
 
 	if (ct.inCallTipMode) {
 		if (
-		    (iMessage != SCI_CHARLEFT) &&
-		    (iMessage != SCI_CHARLEFTEXTEND) &&
-		    (iMessage != SCI_CHARRIGHT) &&
-		    (iMessage != SCI_CHARRIGHTEXTEND) &&
-		    (iMessage != SCI_EDITTOGGLEOVERTYPE) &&
-		    (iMessage != SCI_DELETEBACK) &&
-		    (iMessage != SCI_DELETEBACKNOTLINE)
+		    (iMessage != Message::CharLeft) &&
+		    (iMessage != Message::CharLeftExtend) &&
+		    (iMessage != Message::CharRight) &&
+		    (iMessage != Message::CharRightExtend) &&
+		    (iMessage != Message::EditToggleOvertype) &&
+		    (iMessage != Message::DeleteBack) &&
+		    (iMessage != Message::DeleteBackNotLine)
 		) {
 			ct.CallTipCancel();
 		}
-		if ((iMessage == SCI_DELETEBACK) || (iMessage == SCI_DELETEBACKNOTLINE)) {
+		if ((iMessage == Message::DeleteBack) || (iMessage == Message::DeleteBackNotLine)) {
 			if (sel.MainCaret() <= ct.posStartCallTip) {
 				ct.CallTipCancel();
 			}
@@ -202,19 +205,19 @@ void ScintillaBase::ListNotify(ListBoxEvent *plbe) {
 		AutoCompleteSelection();
 		break;
 	case ListBoxEvent::EventType::doubleClick:
-		AutoCompleteCompleted(0, SC_AC_DOUBLECLICK);
+		AutoCompleteCompleted(0, CompletionMethods::DoubleClick);
 		break;
 	}
 }
 
 void ScintillaBase::AutoCompleteInsert(Sci::Position startPos, Sci::Position removeLen, const char *text, Sci::Position textLen) {
 	UndoGroup ug(pdoc);
-	if (multiAutoCMode == SC_MULTIAUTOC_ONCE) {
+	if (multiAutoCMode == MultiAutoComplete::Once) {
 		pdoc->DeleteChars(startPos, removeLen);
 		const Sci::Position lengthInserted = pdoc->InsertString(startPos, text, textLen);
 		SetEmptySelection(startPos + lengthInserted);
 	} else {
-		// SC_MULTIAUTOC_EACH
+		// MultiAutoComplete::Each
 		for (size_t r=0; r<sel.Count(); r++) {
 			if (!RangeContainsProtected(sel.Range(r).Start().Position(),
 				sel.Range(r).End().Position())) {
@@ -258,10 +261,10 @@ void ScintillaBase::AutoCompleteStart(Sci::Position lenEntered, const char *list
 				lenEntered, vs.lineHeight, IsUnicodeMode(), technology);
 
 	ListOptions options{
-		vs.ElementColour(SC_ELEMENT_LIST),
-		vs.ElementColour(SC_ELEMENT_LIST_BACK),
-		vs.ElementColour(SC_ELEMENT_LIST_SELECTED),
-		vs.ElementColour(SC_ELEMENT_LIST_SELECTED_BACK)
+		vs.ElementColour(Element::List),
+		vs.ElementColour(Element::ListBack),
+		vs.ElementColour(Element::ListSelected),
+		vs.ElementColour(Element::ListSelectedBack)
 	};
 	ac.lb->SetOptions(options);
 
@@ -296,8 +299,8 @@ void ScintillaBase::AutoCompleteStart(Sci::Position lenEntered, const char *list
 	rcac.right = rcac.left + widthLB;
 	rcac.bottom = static_cast<XYPOSITION>(std::min(static_cast<int>(rcac.top) + heightLB, static_cast<int>(rcPopupBounds.bottom)));
 	ac.lb->SetPositionRelative(rcac, &wMain);
-	ac.lb->SetFont(vs.styles[STYLE_DEFAULT].font.get());
-	const unsigned int aveCharWidth = static_cast<unsigned int>(vs.styles[STYLE_DEFAULT].aveCharWidth);
+	ac.lb->SetFont(vs.styles[StyleDefault].font.get());
+	const unsigned int aveCharWidth = static_cast<unsigned int>(vs.styles[StyleDefault].aveCharWidth);
 	ac.lb->SetAverageCharWidth(aveCharWidth);
 	ac.lb->SetDelegate(this);
 
@@ -328,8 +331,8 @@ void ScintillaBase::AutoCompleteStart(Sci::Position lenEntered, const char *list
 
 void ScintillaBase::AutoCompleteCancel() {
 	if (ac.Active()) {
-		SCNotification scn = {};
-		scn.nmhdr.code = SCN_AUTOCCANCELLED;
+		NotificationData scn = {};
+		scn.nmhdr.code = Notification::AutoCCancelled;
 		scn.wParam = 0;
 		scn.listType = 0;
 		NotifyParent(scn);
@@ -353,9 +356,9 @@ void ScintillaBase::AutoCompleteSelection() {
 		selected = ac.GetValue(item);
 	}
 
-	SCNotification scn = {};
-	scn.nmhdr.code = SCN_AUTOCSELECTIONCHANGE;
-	scn.message = 0;
+	NotificationData scn = {};
+	scn.nmhdr.code = Notification::AutoCSelectionChange;
+	scn.message = static_cast<Message>(0);
 	scn.wParam = listType;
 	scn.listType = listType;
 	const Sci::Position firstPos = ac.posStart - ac.startLen;
@@ -367,7 +370,7 @@ void ScintillaBase::AutoCompleteSelection() {
 
 void ScintillaBase::AutoCompleteCharacterAdded(char ch) {
 	if (ac.IsFillUpChar(ch)) {
-		AutoCompleteCompleted(ch, SC_AC_FILLUP);
+		AutoCompleteCompleted(ch, CompletionMethods::FillUp);
 	} else if (ac.IsStopChar(ch)) {
 		AutoCompleteCancel();
 	} else {
@@ -383,14 +386,14 @@ void ScintillaBase::AutoCompleteCharacterDeleted() {
 	} else {
 		AutoCompleteMoveToCurrentWord();
 	}
-	SCNotification scn = {};
-	scn.nmhdr.code = SCN_AUTOCCHARDELETED;
+	NotificationData scn = {};
+	scn.nmhdr.code = Notification::AutoCCharDeleted;
 	scn.wParam = 0;
 	scn.listType = 0;
 	NotifyParent(scn);
 }
 
-void ScintillaBase::AutoCompleteCompleted(char ch, unsigned int completionMethod) {
+void ScintillaBase::AutoCompleteCompleted(char ch, CompletionMethods completionMethod) {
 	const int item = ac.GetSelection();
 	if (item == -1) {
 		AutoCompleteCancel();
@@ -400,9 +403,9 @@ void ScintillaBase::AutoCompleteCompleted(char ch, unsigned int completionMethod
 
 	ac.Show(false);
 
-	SCNotification scn = {};
-	scn.nmhdr.code = listType > 0 ? SCN_USERLISTSELECTION : SCN_AUTOCSELECTION;
-	scn.message = 0;
+	NotificationData scn = {};
+	scn.nmhdr.code = listType > 0 ? Notification::UserListSelection : Notification::AutoCSelection;
+	scn.message = static_cast<Message>(0);
 	scn.ch = ch;
 	scn.listCompletionMethod = completionMethod;
 	scn.wParam = listType;
@@ -428,7 +431,7 @@ void ScintillaBase::AutoCompleteCompleted(char ch, unsigned int completionMethod
 	AutoCompleteInsert(firstPos, endPos - firstPos, selected.c_str(), selected.length());
 	SetLastXChosen();
 
-	scn.nmhdr.code = SCN_AUTOCCOMPLETED;
+	scn.nmhdr.code = Notification::AutoCCompleted;
 	NotifyParent(scn);
 
 }
@@ -456,12 +459,12 @@ int ScintillaBase::AutoCompleteGetCurrentText(char *buffer) const {
 
 void ScintillaBase::CallTipShow(Point pt, const char *defn) {
 	ac.Cancel();
-	// If container knows about STYLE_CALLTIP then use it in place of the
-	// STYLE_DEFAULT for the face name, size and character set. Also use it
+	// If container knows about StyleCallTip then use it in place of the
+	// StyleDefault for the face name, size and character set. Also use it
 	// for the foreground and background colour.
-	const int ctStyle = ct.UseStyleCallTip() ? STYLE_CALLTIP : STYLE_DEFAULT;
+	const int ctStyle = ct.UseStyleCallTip() ? StyleCallTip : StyleDefault;
 	if (ct.UseStyleCallTip()) {
-		ct.SetForeBack(vs.styles[STYLE_CALLTIP].fore, vs.styles[STYLE_CALLTIP].back);
+		ct.SetForeBack(vs.styles[StyleCallTip].fore, vs.styles[StyleCallTip].back);
 	}
 	if (wMargin.Created()) {
 		pt = pt + GetVisibleOriginInMain();
@@ -497,27 +500,27 @@ void ScintillaBase::CallTipShow(Point pt, const char *defn) {
 }
 
 void ScintillaBase::CallTipClick() {
-	SCNotification scn = {};
-	scn.nmhdr.code = SCN_CALLTIPCLICK;
+	NotificationData scn = {};
+	scn.nmhdr.code = Notification::CallTipClick;
 	scn.position = ct.clickPlace;
 	NotifyParent(scn);
 }
 
 bool ScintillaBase::ShouldDisplayPopup(Point ptInWindowCoordinates) const {
-	return (displayPopupMenu == SC_POPUP_ALL ||
-		(displayPopupMenu == SC_POPUP_TEXT && !PointInSelMargin(ptInWindowCoordinates)));
+	return (displayPopupMenu == PopUp::All ||
+		(displayPopupMenu == PopUp::Text && !PointInSelMargin(ptInWindowCoordinates)));
 }
 
 void ScintillaBase::ContextMenu(Point pt) {
-	if (displayPopupMenu) {
-		const bool writable = !WndProc(SCI_GETREADONLY, 0, 0);
+	if (displayPopupMenu != PopUp::Never) {
+		const bool writable = !WndProc(Message::GetReadOnly, 0, 0);
 		popup.CreatePopUp();
 		AddToPopUp("Undo", idcmdUndo, writable && pdoc->CanUndo());
 		AddToPopUp("Redo", idcmdRedo, writable && pdoc->CanRedo());
 		AddToPopUp("");
 		AddToPopUp("Cut", idcmdCut, writable && !sel.Empty());
 		AddToPopUp("Copy", idcmdCopy, !sel.Empty());
-		AddToPopUp("Paste", idcmdPaste, writable && WndProc(SCI_CANPASTE, 0, 0));
+		AddToPopUp("Paste", idcmdPaste, writable && WndProc(Message::CanPaste, 0, 0));
 		AddToPopUp("Delete", idcmdDelete, writable && !sel.Empty());
 		AddToPopUp("");
 		AddToPopUp("Select All", idcmdSelectAll);
@@ -531,17 +534,17 @@ void ScintillaBase::CancelModes() {
 	Editor::CancelModes();
 }
 
-void ScintillaBase::ButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers) {
+void ScintillaBase::ButtonDownWithModifiers(Point pt, unsigned int curTime, KeyMod modifiers) {
 	CancelModes();
 	Editor::ButtonDownWithModifiers(pt, curTime, modifiers);
 }
 
-void ScintillaBase::RightButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers) {
+void ScintillaBase::RightButtonDownWithModifiers(Point pt, unsigned int curTime, KeyMod modifiers) {
 	CancelModes();
 	Editor::RightButtonDownWithModifiers(pt, curTime, modifiers);
 }
 
-namespace Scintilla {
+namespace Scintilla::Internal {
 
 class LexState : public LexInterface {
 public:
@@ -560,14 +563,14 @@ public:
 	const char *GetName() const;
 	void *PrivateCall(int operation, void *pointer);
 	const char *PropertyNames();
-	int PropertyType(const char *name);
+	TypeProperty PropertyType(const char *name);
 	const char *DescribeProperty(const char *name);
 	void PropSet(const char *key, const char *val);
 	const char *PropGet(const char *key) const;
 	int PropGetInt(const char *key, int defaultValue=0) const;
 	size_t PropGetExpanded(const char *key, char *result) const;
 
-	int LineEndTypesSupported() override;
+	LineEndType LineEndTypesSupported() override;
 	int AllocateSubStyles(int styleBase, int numberStyles);
 	int SubStylesStart(int styleBase);
 	int SubStylesLength(int styleBase);
@@ -666,11 +669,11 @@ const char *LexState::PropertyNames() {
 	}
 }
 
-int LexState::PropertyType(const char *name) {
+TypeProperty LexState::PropertyType(const char *name) {
 	if (instance) {
-		return instance->PropertyType(name);
+		return static_cast<TypeProperty>(instance->PropertyType(name));
 	} else {
-		return SC_TYPE_BOOLEAN;
+		return TypeProperty::Boolean;
 	}
 }
 
@@ -722,11 +725,11 @@ size_t LexState::PropGetExpanded(const char *key, char *result) const {
 	return 0;
 }
 
-int LexState::LineEndTypesSupported() {
+LineEndType LexState::LineEndTypesSupported() {
 	if (instance) {
-		return instance->LineEndTypesSupported();
+		return static_cast<LineEndType>(instance->LineEndTypesSupported());
 	}
-	return 0;
+	return LineEndType::Default;
 }
 
 int LexState::AllocateSubStyles(int styleBase, int numberStyles) {
@@ -839,209 +842,209 @@ void ScintillaBase::NotifyLexerChanged(Document *, void *) {
 	vs.EnsureStyle(0xff);
 }
 
-sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+sptr_t ScintillaBase::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	switch (iMessage) {
-	case SCI_AUTOCSHOW:
+	case Message::AutoCShow:
 		listType = 0;
 		AutoCompleteStart(static_cast<Sci::Position>(wParam), ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_AUTOCCANCEL:
+	case Message::AutoCCancel:
 		ac.Cancel();
 		break;
 
-	case SCI_AUTOCACTIVE:
+	case Message::AutoCActive:
 		return ac.Active();
 
-	case SCI_AUTOCPOSSTART:
+	case Message::AutoCPosStart:
 		return ac.posStart;
 
-	case SCI_AUTOCCOMPLETE:
-		AutoCompleteCompleted(0, SC_AC_COMMAND);
+	case Message::AutoCComplete:
+		AutoCompleteCompleted(0, CompletionMethods::Command);
 		break;
 
-	case SCI_AUTOCSETSEPARATOR:
+	case Message::AutoCSetSeparator:
 		ac.SetSeparator(static_cast<char>(wParam));
 		break;
 
-	case SCI_AUTOCGETSEPARATOR:
+	case Message::AutoCGetSeparator:
 		return ac.GetSeparator();
 
-	case SCI_AUTOCSTOPS:
+	case Message::AutoCStops:
 		ac.SetStopChars(ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_AUTOCSELECT:
+	case Message::AutoCSelect:
 		ac.Select(ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_AUTOCGETCURRENT:
+	case Message::AutoCGetCurrent:
 		return AutoCompleteGetCurrent();
 
-	case SCI_AUTOCGETCURRENTTEXT:
+	case Message::AutoCGetCurrentText:
 		return AutoCompleteGetCurrentText(CharPtrFromSPtr(lParam));
 
-	case SCI_AUTOCSETCANCELATSTART:
+	case Message::AutoCSetCancelAtStart:
 		ac.cancelAtStartPos = wParam != 0;
 		break;
 
-	case SCI_AUTOCGETCANCELATSTART:
+	case Message::AutoCGetCancelAtStart:
 		return ac.cancelAtStartPos;
 
-	case SCI_AUTOCSETFILLUPS:
+	case Message::AutoCSetFillUps:
 		ac.SetFillUpChars(ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_AUTOCSETCHOOSESINGLE:
+	case Message::AutoCSetChooseSingle:
 		ac.chooseSingle = wParam != 0;
 		break;
 
-	case SCI_AUTOCGETCHOOSESINGLE:
+	case Message::AutoCGetChooseSingle:
 		return ac.chooseSingle;
 
-	case SCI_AUTOCSETIGNORECASE:
+	case Message::AutoCSetIgnoreCase:
 		ac.ignoreCase = wParam != 0;
 		break;
 
-	case SCI_AUTOCGETIGNORECASE:
+	case Message::AutoCGetIgnoreCase:
 		return ac.ignoreCase;
 
-	case SCI_AUTOCSETCASEINSENSITIVEBEHAVIOUR:
-		ac.ignoreCaseBehaviour = static_cast<unsigned int>(wParam);
+	case Message::AutoCSetCaseInsensitiveBehaviour:
+		ac.ignoreCaseBehaviour = static_cast<CaseInsensitiveBehaviour>(wParam);
 		break;
 
-	case SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR:
-		return ac.ignoreCaseBehaviour;
+	case Message::AutoCGetCaseInsensitiveBehaviour:
+		return static_cast<sptr_t>(ac.ignoreCaseBehaviour);
 
-	case SCI_AUTOCSETMULTI:
-		multiAutoCMode = static_cast<int>(wParam);
+	case Message::AutoCSetMulti:
+		multiAutoCMode = static_cast<MultiAutoComplete>(wParam);
 		break;
 
-	case SCI_AUTOCGETMULTI:
-		return multiAutoCMode;
+	case Message::AutoCGetMulti:
+		return static_cast<sptr_t>(multiAutoCMode);
 
-	case SCI_AUTOCSETORDER:
-		ac.autoSort = static_cast<int>(wParam);
+	case Message::AutoCSetOrder:
+		ac.autoSort = static_cast<Ordering>(wParam);
 		break;
 
-	case SCI_AUTOCGETORDER:
-		return ac.autoSort;
+	case Message::AutoCGetOrder:
+		return static_cast<sptr_t>(ac.autoSort);
 
-	case SCI_USERLISTSHOW:
+	case Message::UserListShow:
 		listType = static_cast<int>(wParam);
 		AutoCompleteStart(0, ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_AUTOCSETAUTOHIDE:
+	case Message::AutoCSetAutoHide:
 		ac.autoHide = wParam != 0;
 		break;
 
-	case SCI_AUTOCGETAUTOHIDE:
+	case Message::AutoCGetAutoHide:
 		return ac.autoHide;
 
-	case SCI_AUTOCSETDROPRESTOFWORD:
+	case Message::AutoCSetDropRestOfWord:
 		ac.dropRestOfWord = wParam != 0;
 		break;
 
-	case SCI_AUTOCGETDROPRESTOFWORD:
+	case Message::AutoCGetDropRestOfWord:
 		return ac.dropRestOfWord;
 
-	case SCI_AUTOCSETMAXHEIGHT:
+	case Message::AutoCSetMaxHeight:
 		ac.lb->SetVisibleRows(static_cast<int>(wParam));
 		break;
 
-	case SCI_AUTOCGETMAXHEIGHT:
+	case Message::AutoCGetMaxHeight:
 		return ac.lb->GetVisibleRows();
 
-	case SCI_AUTOCSETMAXWIDTH:
+	case Message::AutoCSetMaxWidth:
 		maxListWidth = static_cast<int>(wParam);
 		break;
 
-	case SCI_AUTOCGETMAXWIDTH:
+	case Message::AutoCGetMaxWidth:
 		return maxListWidth;
 
-	case SCI_REGISTERIMAGE:
+	case Message::RegisterImage:
 		ac.lb->RegisterImage(static_cast<int>(wParam), ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_REGISTERRGBAIMAGE:
+	case Message::RegisterRGBAImage:
 		ac.lb->RegisterRGBAImage(static_cast<int>(wParam), static_cast<int>(sizeRGBAImage.x), static_cast<int>(sizeRGBAImage.y),
 			ConstUCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_CLEARREGISTEREDIMAGES:
+	case Message::ClearRegisteredImages:
 		ac.lb->ClearRegisteredImages();
 		break;
 
-	case SCI_AUTOCSETTYPESEPARATOR:
+	case Message::AutoCSetTypeSeparator:
 		ac.SetTypesep(static_cast<char>(wParam));
 		break;
 
-	case SCI_AUTOCGETTYPESEPARATOR:
+	case Message::AutoCGetTypeSeparator:
 		return ac.GetTypesep();
 
-	case SCI_CALLTIPSHOW:
+	case Message::CallTipShow:
 		CallTipShow(LocationFromPosition(wParam),
 			ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_CALLTIPCANCEL:
+	case Message::CallTipCancel:
 		ct.CallTipCancel();
 		break;
 
-	case SCI_CALLTIPACTIVE:
+	case Message::CallTipActive:
 		return ct.inCallTipMode;
 
-	case SCI_CALLTIPPOSSTART:
+	case Message::CallTipPosStart:
 		return ct.posStartCallTip;
 
-	case SCI_CALLTIPSETPOSSTART:
+	case Message::CallTipSetPosStart:
 		ct.posStartCallTip = wParam;
 		break;
 
-	case SCI_CALLTIPSETHLT:
+	case Message::CallTipSetHlt:
 		ct.SetHighlight(wParam, lParam);
 		break;
 
-	case SCI_CALLTIPSETBACK:
+	case Message::CallTipSetBack:
 		ct.colourBG = ColourRGBA::FromRGB(static_cast<int>(wParam));
-		vs.styles[STYLE_CALLTIP].back = ct.colourBG;
+		vs.styles[StyleCallTip].back = ct.colourBG;
 		InvalidateStyleRedraw();
 		break;
 
-	case SCI_CALLTIPSETFORE:
+	case Message::CallTipSetFore:
 		ct.colourUnSel = ColourRGBA::FromRGB(static_cast<int>(wParam));
-		vs.styles[STYLE_CALLTIP].fore = ct.colourUnSel;
+		vs.styles[StyleCallTip].fore = ct.colourUnSel;
 		InvalidateStyleRedraw();
 		break;
 
-	case SCI_CALLTIPSETFOREHLT:
+	case Message::CallTipSetForeHlt:
 		ct.colourSel = ColourRGBA::FromRGB(static_cast<int>(wParam));
 		InvalidateStyleRedraw();
 		break;
 
-	case SCI_CALLTIPUSESTYLE:
+	case Message::CallTipUseStyle:
 		ct.SetTabSize(static_cast<int>(wParam));
 		InvalidateStyleRedraw();
 		break;
 
-	case SCI_CALLTIPSETPOSITION:
+	case Message::CallTipSetPosition:
 		ct.SetPosition(wParam != 0);
 		InvalidateStyleRedraw();
 		break;
 
-	case SCI_USEPOPUP:
-		displayPopupMenu = static_cast<int>(wParam);
+	case Message::UsePopUp:
+		displayPopupMenu = static_cast<PopUp>(wParam);
 		break;
 
-	case SCI_GETLEXER:
+	case Message::GetLexer:
 		return DocumentLexState()->GetIdentifier();
 
-	case SCI_SETILEXER:
+	case Message::SetILexer:
 		DocumentLexState()->SetInstance(static_cast<ILexer5 *>(PtrFromSPtr(lParam)));
 		return 0;
 
-	case SCI_COLOURISE:
+	case Message::Colourise:
 		if (DocumentLexState()->UseContainerLexing()) {
 			pdoc->ModifiedAt(static_cast<Sci::Position>(wParam));
 			NotifyStyleToNeeded((lParam == -1) ? pdoc->Length() : lParam);
@@ -1051,29 +1054,29 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
 		Redraw();
 		break;
 
-	case SCI_SETPROPERTY:
+	case Message::SetProperty:
 		DocumentLexState()->PropSet(ConstCharPtrFromUPtr(wParam),
 		          ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_GETPROPERTY:
+	case Message::GetProperty:
 		return StringResult(lParam, DocumentLexState()->PropGet(ConstCharPtrFromUPtr(wParam)));
 
-	case SCI_GETPROPERTYEXPANDED:
+	case Message::GetPropertyExpanded:
 		return DocumentLexState()->PropGetExpanded(ConstCharPtrFromUPtr(wParam),
 			CharPtrFromSPtr(lParam));
 
-	case SCI_GETPROPERTYINT:
+	case Message::GetPropertyInt:
 		return DocumentLexState()->PropGetInt(ConstCharPtrFromUPtr(wParam), static_cast<int>(lParam));
 
-	case SCI_SETKEYWORDS:
+	case Message::SetKeyWords:
 		DocumentLexState()->SetWordList(static_cast<int>(wParam), ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_GETLEXERLANGUAGE:
+	case Message::GetLexerLanguage:
 		return StringResult(lParam, DocumentLexState()->GetName());
 
-	case SCI_PRIVATELEXERCALL:
+	case Message::PrivateLexerCall:
 		return reinterpret_cast<sptr_t>(
 			DocumentLexState()->PrivateCall(static_cast<int>(wParam), PtrFromSPtr(lParam)));
 
@@ -1082,64 +1085,64 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
 		return 8;
 #endif
 
-	case SCI_PROPERTYNAMES:
+	case Message::PropertyNames:
 		return StringResult(lParam, DocumentLexState()->PropertyNames());
 
-	case SCI_PROPERTYTYPE:
-		return DocumentLexState()->PropertyType(ConstCharPtrFromUPtr(wParam));
+	case Message::PropertyType:
+		return static_cast<sptr_t>(DocumentLexState()->PropertyType(ConstCharPtrFromUPtr(wParam)));
 
-	case SCI_DESCRIBEPROPERTY:
+	case Message::DescribeProperty:
 		return StringResult(lParam,
 				    DocumentLexState()->DescribeProperty(ConstCharPtrFromUPtr(wParam)));
 
-	case SCI_DESCRIBEKEYWORDSETS:
+	case Message::DescribeKeyWordSets:
 		return StringResult(lParam, DocumentLexState()->DescribeWordListSets());
 
-	case SCI_GETLINEENDTYPESSUPPORTED:
-		return DocumentLexState()->LineEndTypesSupported();
+	case Message::GetLineEndTypesSupported:
+		return static_cast<sptr_t>(DocumentLexState()->LineEndTypesSupported());
 
-	case SCI_ALLOCATESUBSTYLES:
+	case Message::AllocateSubStyles:
 		return DocumentLexState()->AllocateSubStyles(static_cast<int>(wParam), static_cast<int>(lParam));
 
-	case SCI_GETSUBSTYLESSTART:
+	case Message::GetSubStylesStart:
 		return DocumentLexState()->SubStylesStart(static_cast<int>(wParam));
 
-	case SCI_GETSUBSTYLESLENGTH:
+	case Message::GetSubStylesLength:
 		return DocumentLexState()->SubStylesLength(static_cast<int>(wParam));
 
-	case SCI_GETSTYLEFROMSUBSTYLE:
+	case Message::GetStyleFromSubStyle:
 		return DocumentLexState()->StyleFromSubStyle(static_cast<int>(wParam));
 
-	case SCI_GETPRIMARYSTYLEFROMSTYLE:
+	case Message::GetPrimaryStyleFromStyle:
 		return DocumentLexState()->PrimaryStyleFromStyle(static_cast<int>(wParam));
 
-	case SCI_FREESUBSTYLES:
+	case Message::FreeSubStyles:
 		DocumentLexState()->FreeSubStyles();
 		break;
 
-	case SCI_SETIDENTIFIERS:
+	case Message::SetIdentifiers:
 		DocumentLexState()->SetIdentifiers(static_cast<int>(wParam),
 						   ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_DISTANCETOSECONDARYSTYLES:
+	case Message::DistanceToSecondaryStyles:
 		return DocumentLexState()->DistanceToSecondaryStyles();
 
-	case SCI_GETSUBSTYLEBASES:
+	case Message::GetSubStyleBases:
 		return StringResult(lParam, DocumentLexState()->GetSubStyleBases());
 
-	case SCI_GETNAMEDSTYLES:
+	case Message::GetNamedStyles:
 		return DocumentLexState()->NamedStyles();
 
-	case SCI_NAMEOFSTYLE:
+	case Message::NameOfStyle:
 		return StringResult(lParam, DocumentLexState()->
 				    NameOfStyle(static_cast<int>(wParam)));
 
-	case SCI_TAGSOFSTYLE:
+	case Message::TagsOfStyle:
 		return StringResult(lParam, DocumentLexState()->
 				    TagsOfStyle(static_cast<int>(wParam)));
 
-	case SCI_DESCRIPTIONOFSTYLE:
+	case Message::DescriptionOfStyle:
 		return StringResult(lParam, DocumentLexState()->
 				    DescriptionOfStyle(static_cast<int>(wParam)));