Reduce casts by defining methods for common conversions.

6 files changed, 183 insertions, 170 deletions

diff --git a/src/Editor.cxx b/src/Editor.cxx
index 3ddd9daae..da22161c6 100644
--- a/src/Editor.cxx
+++ b/src/Editor.cxx
@@ -5708,10 +5708,10 @@ void Editor::StyleSetMessage(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	vs.EnsureStyle(wParam);
 	switch (iMessage) {
 	case Message::StyleSetFore:
-		vs.styles[wParam].fore = ColourRGBA::FromRGB(static_cast<int>(lParam));
+		vs.styles[wParam].fore = ColourRGBA::FromIpRGB(lParam);
 		break;
 	case Message::StyleSetBack:
-		vs.styles[wParam].back = ColourRGBA::FromRGB(static_cast<int>(lParam));
+		vs.styles[wParam].back = ColourRGBA::FromIpRGB(lParam);
 		break;
 	case Message::StyleSetBold:
 		vs.styles[wParam].weight = lParam != 0 ? FontWeight::Bold : FontWeight::Normal;
@@ -5925,7 +5925,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::CopyRange:
-		CopyRangeToClipboard(static_cast<Sci::Position>(wParam), lParam);
+		CopyRangeToClipboard(PositionFromUPtr(wParam), lParam);
 		break;
 
 	case Message::CopyText:
@@ -5945,7 +5945,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		if (!sel.Empty()) {
 			ClearSelection(); // want to replace rectangular selection contents
 		}
-		InsertPasteShape(CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam), PasteShape::rectangular);
+		InsertPasteShape(CharPtrFromSPtr(lParam), PositionFromUPtr(wParam), PasteShape::rectangular);
 		break;
 	}
 
@@ -5971,14 +5971,14 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return topLine;
 
 	case Message::SetFirstVisibleLine:
-		ScrollTo(static_cast<Sci::Line>(wParam));
+		ScrollTo(LineFromUPtr(wParam));
 		break;
 
 	case Message::GetLine: {	// Risk of overwriting the end of the buffer
 			const Sci::Position lineStart =
-				pdoc->LineStart(static_cast<Sci::Line>(wParam));
+				pdoc->LineStart(LineFromUPtr(wParam));
 			const Sci::Position lineEnd =
-				pdoc->LineStart(static_cast<Sci::Line>(wParam + 1));
+				pdoc->LineStart(LineFromUPtr(wParam + 1));
 			// not NUL terminated
 			const Sci::Position len = lineEnd - lineStart;
 			if (lParam == 0) {
@@ -5999,7 +5999,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return !pdoc->IsSavePoint();
 
 	case Message::SetSel: {
-			Sci::Position nStart = static_cast<Sci::Position>(wParam);
+			Sci::Position nStart = PositionFromUPtr(wParam);
 			Sci::Position nEnd = lParam;
 			if (nEnd < 0)
 				nEnd = pdoc->Length();
@@ -6032,27 +6032,27 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		}
 
 	case Message::LineFromPosition:
-		if (static_cast<Sci::Position>(wParam) < 0)
+		if (PositionFromUPtr(wParam) < 0)
 			return 0;
-		return pdoc->LineFromPosition(static_cast<Sci::Position>(wParam));
+		return pdoc->LineFromPosition(PositionFromUPtr(wParam));
 
 	case Message::PositionFromLine:
-		if (static_cast<Sci::Position>(wParam) < 0)
+		if (LineFromUPtr(wParam) < 0)
 			wParam = pdoc->LineFromPosition(SelectionStart().Position());
 		if (wParam == 0)
 			return 0; 	// Even if there is no text, there is a first line that starts at 0
-		if (static_cast<Sci::Line>(wParam) > pdoc->LinesTotal())
+		if (LineFromUPtr(wParam) > pdoc->LinesTotal())
 			return -1;
 		//if (wParam > pdoc->LineFromPosition(pdoc->Length()))	// Useful test, anyway...
 		//	return -1;
-		return pdoc->LineStart(static_cast<Sci::Position>(wParam));
+		return pdoc->LineStart(LineFromUPtr(wParam));
 
 		// Replacement of the old Scintilla interpretation of EM_LINELENGTH
 	case Message::LineLength:
-		if ((static_cast<Sci::Position>(wParam) < 0) ||
-		        (static_cast<Sci::Position>(wParam) > pdoc->LineFromPosition(pdoc->Length())))
+		if ((LineFromUPtr(wParam) < 0) ||
+		        (LineFromUPtr(wParam) > pdoc->LineFromPosition(pdoc->Length())))
 			return 0;
-		return pdoc->LineStart(static_cast<Sci::Position>(wParam) + 1) - pdoc->LineStart(static_cast<Sci::Position>(wParam));
+		return pdoc->LineStart(LineFromUPtr(wParam) + 1) - pdoc->LineStart(LineFromUPtr(wParam));
 
 	case Message::ReplaceSel: {
 			if (lParam == 0)
@@ -6069,35 +6069,35 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::SetTargetStart:
-		targetRange.start.SetPosition(static_cast<Sci::Position>(wParam));
+		targetRange.start.SetPosition(PositionFromUPtr(wParam));
 		break;
 
 	case Message::GetTargetStart:
 		return targetRange.start.Position();
 
 	case Message::SetTargetStartVirtualSpace:
-		targetRange.start.SetVirtualSpace(static_cast<Sci::Position>(wParam));
+		targetRange.start.SetVirtualSpace(PositionFromUPtr(wParam));
 		break;
 
 	case Message::GetTargetStartVirtualSpace:
 		return targetRange.start.VirtualSpace();
 
 	case Message::SetTargetEnd:
-		targetRange.end.SetPosition(static_cast<Sci::Position>(wParam));
+		targetRange.end.SetPosition(PositionFromUPtr(wParam));
 		break;
 
 	case Message::GetTargetEnd:
 		return targetRange.end.Position();
 
 	case Message::SetTargetEndVirtualSpace:
-		targetRange.end.SetVirtualSpace(static_cast<Sci::Position>(wParam));
+		targetRange.end.SetVirtualSpace(PositionFromUPtr(wParam));
 		break;
 
 	case Message::GetTargetEndVirtualSpace:
 		return targetRange.end.VirtualSpace();
 
 	case Message::SetTargetRange:
-		targetRange.start.SetPosition(static_cast<Sci::Position>(wParam));
+		targetRange.start.SetPosition(PositionFromUPtr(wParam));
 		targetRange.end.SetPosition(lParam);
 		break;
 
@@ -6118,15 +6118,15 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::ReplaceTarget:
 		PLATFORM_ASSERT(lParam);
-		return ReplaceTarget(false, CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
+		return ReplaceTarget(false, CharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
 
 	case Message::ReplaceTargetRE:
 		PLATFORM_ASSERT(lParam);
-		return ReplaceTarget(true, CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
+		return ReplaceTarget(true, CharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
 
 	case Message::SearchInTarget:
 		PLATFORM_ASSERT(lParam);
-		return SearchInTarget(CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
+		return SearchInTarget(CharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
 
 	case Message::SetSearchFlags:
 		searchFlags = static_cast<FindOption>(wParam);
@@ -6139,23 +6139,23 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return GetTag(CharPtrFromSPtr(lParam), static_cast<int>(wParam));
 
 	case Message::PositionBefore:
-		return pdoc->MovePositionOutsideChar(static_cast<Sci::Position>(wParam) - 1, -1, true);
+		return pdoc->MovePositionOutsideChar(PositionFromUPtr(wParam) - 1, -1, true);
 
 	case Message::PositionAfter:
-		return pdoc->MovePositionOutsideChar(static_cast<Sci::Position>(wParam) + 1, 1, true);
+		return pdoc->MovePositionOutsideChar(PositionFromUPtr(wParam) + 1, 1, true);
 
 	case Message::PositionRelative:
 		return std::clamp<Sci::Position>(pdoc->GetRelativePosition(
-			static_cast<Sci::Position>(wParam), lParam),
+			PositionFromUPtr(wParam), lParam),
 			0, pdoc->Length());
 
 	case Message::PositionRelativeCodeUnits:
 		return std::clamp<Sci::Position>(pdoc->GetRelativePositionUTF16(
-			static_cast<Sci::Position>(wParam), lParam),
+			PositionFromUPtr(wParam), lParam),
 			0, pdoc->Length());
 
 	case Message::LineScroll:
-		ScrollTo(topLine + static_cast<Sci::Line>(lParam));
+		ScrollTo(topLine + lParam);
 		HorizontalScrollTo(xOffset + static_cast<int>(wParam) * static_cast<int>(vs.spaceWidth));
 		return 1;
 
@@ -6253,20 +6253,20 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 			if (lParam == 0)
 				return 0;
 			const Sci::Position lengthInserted = pdoc->InsertString(
-				CurrentPosition(), CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
+				CurrentPosition(), CharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
 			SetEmptySelection(sel.MainCaret() + lengthInserted);
 			return 0;
 		}
 
 	case Message::AddStyledText:
 		if (lParam)
-			AddStyledText(CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
+			AddStyledText(CharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
 		return 0;
 
 	case Message::InsertText: {
 			if (lParam == 0)
 				return 0;
-			Sci::Position insertPos = static_cast<Sci::Position>(wParam);
+			Sci::Position insertPos = PositionFromUPtr(wParam);
 			if (insertPos == -1)
 				insertPos = CurrentPosition();
 			Sci::Position newCurrent = CurrentPosition();
@@ -6280,12 +6280,12 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::ChangeInsertion:
 		PLATFORM_ASSERT(lParam);
-		pdoc->ChangeInsertion(CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
+		pdoc->ChangeInsertion(CharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
 		return 0;
 
 	case Message::AppendText:
 		pdoc->InsertString(pdoc->Length(),
-			CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
+			CharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
 		return 0;
 
 	case Message::ClearAll:
@@ -6293,7 +6293,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return 0;
 
 	case Message::DeleteRange:
-		pdoc->DeleteChars(static_cast<Sci::Position>(wParam), lParam);
+		pdoc->DeleteChars(PositionFromUPtr(wParam), lParam);
 		return 0;
 
 	case Message::ClearDocumentStyle:
@@ -6368,19 +6368,19 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return pdoc->Length();
 
 	case Message::Allocate:
-		pdoc->Allocate(static_cast<Sci::Position>(wParam));
+		pdoc->Allocate(PositionFromUPtr(wParam));
 		break;
 
 	case Message::GetCharAt:
-		return pdoc->CharAt(static_cast<Sci::Position>(wParam));
+		return pdoc->CharAt(PositionFromUPtr(wParam));
 
 	case Message::SetCurrentPos:
 		if (sel.IsRectangular()) {
-			sel.Rectangular().caret.SetPosition(static_cast<Sci::Position>(wParam));
+			sel.Rectangular().caret.SetPosition(PositionFromUPtr(wParam));
 			SetRectangularRange();
 			Redraw();
 		} else {
-			SetSelection(static_cast<Sci::Position>(wParam), sel.MainAnchor());
+			SetSelection(PositionFromUPtr(wParam), sel.MainAnchor());
 		}
 		break;
 
@@ -6389,11 +6389,11 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::SetAnchor:
 		if (sel.IsRectangular()) {
-			sel.Rectangular().anchor.SetPosition(static_cast<Sci::Position>(wParam));
+			sel.Rectangular().anchor.SetPosition(PositionFromUPtr(wParam));
 			SetRectangularRange();
 			Redraw();
 		} else {
-			SetSelection(sel.MainCaret(), static_cast<Sci::Position>(wParam));
+			SetSelection(sel.MainCaret(), PositionFromUPtr(wParam));
 		}
 		break;
 
@@ -6401,21 +6401,21 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return sel.IsRectangular() ? sel.Rectangular().anchor.Position() : sel.MainAnchor();
 
 	case Message::SetSelectionStart:
-		SetSelection(std::max(sel.MainCaret(), static_cast<Sci::Position>(wParam)), static_cast<Sci::Position>(wParam));
+		SetSelection(std::max(sel.MainCaret(), PositionFromUPtr(wParam)), PositionFromUPtr(wParam));
 		break;
 
 	case Message::GetSelectionStart:
 		return sel.LimitsForRectangularElseMain().start.Position();
 
 	case Message::SetSelectionEnd:
-		SetSelection(static_cast<Sci::Position>(wParam), std::min(sel.MainAnchor(), static_cast<Sci::Position>(wParam)));
+		SetSelection(PositionFromUPtr(wParam), std::min(sel.MainAnchor(), PositionFromUPtr(wParam)));
 		break;
 
 	case Message::GetSelectionEnd:
 		return sel.LimitsForRectangularElseMain().end.Position();
 
 	case Message::SetEmptySelection:
-		SetEmptySelection(static_cast<Sci::Position>(wParam));
+		SetEmptySelection(PositionFromUPtr(wParam));
 		break;
 
 	case Message::SetPrintMagnification:
@@ -6440,10 +6440,10 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return static_cast<sptr_t>(view.printParameters.wrapState);
 
 	case Message::GetStyleAt:
-		if (static_cast<Sci::Position>(wParam) >= pdoc->Length())
+		if (PositionFromUPtr(wParam) >= pdoc->Length())
 			return 0;
 		else
-			return pdoc->StyleAt(static_cast<Sci::Position>(wParam));
+			return pdoc->StyleAt(PositionFromUPtr(wParam));
 
 	case Message::Redo:
 		Redo();
@@ -6482,10 +6482,10 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::MarkerHandleFromLine:
-		return pdoc->MarkerHandleFromLine(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		return pdoc->MarkerHandleFromLine(LineFromUPtr(wParam), static_cast<int>(lParam));
 
 	case Message::MarkerNumberFromLine:
-		return pdoc->MarkerNumberFromLine(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		return pdoc->MarkerNumberFromLine(LineFromUPtr(wParam), static_cast<int>(lParam));
 
 	case Message::GetViewWS:
 		return static_cast<sptr_t>(vs.viewWhitespace);
@@ -6512,27 +6512,23 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::PositionFromPoint:
-		return PositionFromLocation(Point::FromInts(static_cast<int>(wParam) - vs.ExternalMarginWidth(), static_cast<int>(lParam)),
-					    false, false);
+		return PositionFromLocation(PointFromParameters(wParam, lParam), false, false);
 
 	case Message::PositionFromPointClose:
-		return PositionFromLocation(Point::FromInts(static_cast<int>(wParam) - vs.ExternalMarginWidth(), static_cast<int>(lParam)),
-					    true, false);
+		return PositionFromLocation(PointFromParameters(wParam, lParam), true, false);
 
 	case Message::CharPositionFromPoint:
-		return PositionFromLocation(Point::FromInts(static_cast<int>(wParam) - vs.ExternalMarginWidth(), static_cast<int>(lParam)),
-					    false, true);
+		return PositionFromLocation(PointFromParameters(wParam, lParam), false, true);
 
 	case Message::CharPositionFromPointClose:
-		return PositionFromLocation(Point::FromInts(static_cast<int>(wParam) - vs.ExternalMarginWidth(), static_cast<int>(lParam)),
-					    true, true);
+		return PositionFromLocation(PointFromParameters(wParam, lParam), true, true);
 
 	case Message::GotoLine:
-		GoToLine(static_cast<Sci::Line>(wParam));
+		GoToLine(LineFromUPtr(wParam));
 		break;
 
 	case Message::GotoPos:
-		SetEmptySelection(static_cast<Sci::Position>(wParam));
+		SetEmptySelection(PositionFromUPtr(wParam));
 		EnsureCaretVisible();
 		break;
 
@@ -6577,20 +6573,20 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return static_cast<sptr_t>(pdoc->GetLineEndTypesActive());
 
 	case Message::StartStyling:
-		pdoc->StartStyling(static_cast<Sci::Position>(wParam));
+		pdoc->StartStyling(PositionFromUPtr(wParam));
 		break;
 
 	case Message::SetStyling:
-		if (static_cast<Sci::Position>(wParam) < 0)
+		if (PositionFromUPtr(wParam) < 0)
 			errorStatus = Status::Failure;
 		else
-			pdoc->SetStyleFor(static_cast<Sci::Position>(wParam), static_cast<char>(lParam));
+			pdoc->SetStyleFor(PositionFromUPtr(wParam), static_cast<char>(lParam));
 		break;
 
 	case Message::SetStylingEx:             // Specify a complete styling buffer
 		if (lParam == 0)
 			return 0;
-		pdoc->SetStyles(static_cast<Sci::Position>(wParam), CharPtrFromSPtr(lParam));
+		pdoc->SetStyles(PositionFromUPtr(wParam), CharPtrFromSPtr(lParam));
 		break;
 
 	case Message::SetBufferedDraw:
@@ -6648,21 +6644,21 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return view.tabWidthMinimumPixels;
 
 	case Message::ClearTabStops:
-		if (view.ClearTabstops(static_cast<Sci::Line>(wParam))) {
-			const DocModification mh(ModificationFlags::ChangeTabStops, 0, 0, 0, nullptr, static_cast<Sci::Line>(wParam));
+		if (view.ClearTabstops(LineFromUPtr(wParam))) {
+			const DocModification mh(ModificationFlags::ChangeTabStops, 0, 0, 0, nullptr, LineFromUPtr(wParam));
 			NotifyModified(pdoc, mh, nullptr);
 		}
 		break;
 
 	case Message::AddTabStop:
-		if (view.AddTabstop(static_cast<Sci::Line>(wParam), static_cast<int>(lParam))) {
-			const DocModification mh(ModificationFlags::ChangeTabStops, 0, 0, 0, nullptr, static_cast<Sci::Line>(wParam));
+		if (view.AddTabstop(LineFromUPtr(wParam), static_cast<int>(lParam))) {
+			const DocModification mh(ModificationFlags::ChangeTabStops, 0, 0, 0, nullptr, LineFromUPtr(wParam));
 			NotifyModified(pdoc, mh, nullptr);
 		}
 		break;
 
 	case Message::GetNextTabStop:
-		return view.GetNextTabstop(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		return view.GetNextTabstop(LineFromUPtr(wParam), static_cast<int>(lParam));
 
 	case Message::SetIndent:
 		pdoc->indentInChars = static_cast<int>(wParam);
@@ -6685,14 +6681,14 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return pdoc->useTabs;
 
 	case Message::SetLineIndentation:
-		pdoc->SetLineIndentation(static_cast<Sci::Line>(wParam), lParam);
+		pdoc->SetLineIndentation(LineFromUPtr(wParam), lParam);
 		break;
 
 	case Message::GetLineIndentation:
-		return pdoc->GetLineIndentation(static_cast<Sci::Line>(wParam));
+		return pdoc->GetLineIndentation(LineFromUPtr(wParam));
 
 	case Message::GetLineIndentPosition:
-		return pdoc->GetLineIndentPosition(static_cast<Sci::Line>(wParam));
+		return pdoc->GetLineIndentPosition(LineFromUPtr(wParam));
 
 	case Message::SetTabIndents:
 		pdoc->tabIndents = wParam != 0;
@@ -6717,13 +6713,13 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return dwellDelay;
 
 	case Message::WordStartPosition:
-		return pdoc->ExtendWordSelect(static_cast<Sci::Position>(wParam), -1, lParam != 0);
+		return pdoc->ExtendWordSelect(PositionFromUPtr(wParam), -1, lParam != 0);
 
 	case Message::WordEndPosition:
-		return pdoc->ExtendWordSelect(static_cast<Sci::Position>(wParam), 1, lParam != 0);
+		return pdoc->ExtendWordSelect(PositionFromUPtr(wParam), 1, lParam != 0);
 
 	case Message::IsRangeWord:
-		return pdoc->IsWordAt(static_cast<Sci::Position>(wParam), lParam);
+		return pdoc->IsWordAt(PositionFromUPtr(wParam), lParam);
 
 	case Message::SetIdleStyling:
 		idleStyling = static_cast<IdleStyling>(wParam);
@@ -6861,10 +6857,10 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::GetColumn:
-		return pdoc->GetColumn(static_cast<Sci::Position>(wParam));
+		return pdoc->GetColumn(PositionFromUPtr(wParam));
 
 	case Message::FindColumn:
-		return pdoc->FindColumn(static_cast<Sci::Line>(wParam), lParam);
+		return pdoc->FindColumn(LineFromUPtr(wParam), lParam);
 
 	case Message::SetHScrollBar :
 		if (horizontalScrollBarVisible != (wParam != 0)) {
@@ -6909,7 +6905,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return highlightGuideColumn;
 
 	case Message::GetLineEndPosition:
-		return pdoc->LineEnd(static_cast<Sci::Line>(wParam));
+		return pdoc->LineEnd(LineFromUPtr(wParam));
 
 	case Message::SetCodePage:
 		if (ValidCodePage(static_cast<int>(wParam))) {
@@ -6952,10 +6948,10 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::LineFromIndexPosition:
-		return pdoc->LineFromPositionIndex(static_cast<Sci::Position>(wParam), static_cast<LineCharacterIndexType>(lParam));
+		return pdoc->LineFromPositionIndex(PositionFromUPtr(wParam), static_cast<LineCharacterIndexType>(lParam));
 
 	case Message::IndexPositionFromLine:
-		return pdoc->IndexLineStart(static_cast<Sci::Line>(wParam), static_cast<LineCharacterIndexType>(lParam));
+		return pdoc->IndexLineStart(LineFromUPtr(wParam), static_cast<LineCharacterIndexType>(lParam));
 
 		// Marker definition and setting
 	case Message::MarkerDefine:
@@ -6975,19 +6971,19 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::MarkerSetFore:
 		if (wParam <= MarkerMax)
-			vs.markers[wParam].fore = ColourRGBA::FromRGB(static_cast<int>(lParam));
+			vs.markers[wParam].fore = ColourRGBA::FromIpRGB(lParam);
 		InvalidateStyleData();
 		RedrawSelMargin();
 		break;
 	case Message::MarkerSetBack:
 		if (wParam <= MarkerMax)
-			vs.markers[wParam].back = ColourRGBA::FromRGB(static_cast<int>(lParam));
+			vs.markers[wParam].back = ColourRGBA::FromIpRGB(lParam);
 		InvalidateStyleData();
 		RedrawSelMargin();
 		break;
 	case Message::MarkerSetBackSelected:
 		if (wParam <= MarkerMax)
-			vs.markers[wParam].backSelected = ColourRGBA::FromRGB(static_cast<int>(lParam));
+			vs.markers[wParam].backSelected = ColourRGBA::FromIpRGB(lParam);
 		InvalidateStyleData();
 		RedrawSelMargin();
 		break;
@@ -7041,16 +7037,16 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		}
 		return 0;
 	case Message::MarkerAdd: {
-			const int markerID = pdoc->AddMark(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+			const int markerID = pdoc->AddMark(LineFromUPtr(wParam), static_cast<int>(lParam));
 			return markerID;
 		}
 	case Message::MarkerAddSet:
 		if (lParam != 0)
-			pdoc->AddMarkSet(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+			pdoc->AddMarkSet(LineFromUPtr(wParam), static_cast<int>(lParam));
 		break;
 
 	case Message::MarkerDelete:
-		pdoc->DeleteMark(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		pdoc->DeleteMark(LineFromUPtr(wParam), static_cast<int>(lParam));
 		break;
 
 	case Message::MarkerDeleteAll:
@@ -7058,13 +7054,13 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::MarkerGet:
-		return pdoc->GetMark(static_cast<Sci::Line>(wParam));
+		return pdoc->GetMark(LineFromUPtr(wParam));
 
 	case Message::MarkerNext:
-		return pdoc->MarkerNext(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		return pdoc->MarkerNext(LineFromUPtr(wParam), static_cast<int>(lParam));
 
 	case Message::MarkerPrevious: {
-			for (Sci::Line iLine = static_cast<Sci::Line>(wParam); iLine >= 0; iLine--) {
+			for (Sci::Line iLine = LineFromUPtr(wParam); iLine >= 0; iLine--) {
 				if ((pdoc->GetMark(iLine) & lParam) != 0)
 					return iLine;
 			}
@@ -7170,7 +7166,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::SetMarginBackN:
 		if (ValidMargin(wParam)) {
-			vs.ms[wParam].back = ColourRGBA::FromRGB(static_cast<int>(lParam));
+			vs.ms[wParam].back = ColourRGBA::FromIpRGB(lParam);
 			InvalidateStyleRedraw();
 		}
 		break;
@@ -7278,10 +7274,10 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 #endif
 
 	case Message::SetLineState:
-		return pdoc->SetLineState(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		return pdoc->SetLineState(LineFromUPtr(wParam), static_cast<int>(lParam));
 
 	case Message::GetLineState:
-		return pdoc->GetLineState(static_cast<Sci::Line>(wParam));
+		return pdoc->GetLineState(LineFromUPtr(wParam));
 
 	case Message::GetMaxLineState:
 		return pdoc->GetMaxLineState();
@@ -7353,55 +7349,55 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		// Folding messages
 
 	case Message::VisibleFromDocLine:
-		return pcs->DisplayFromDoc(static_cast<Sci::Line>(wParam));
+		return pcs->DisplayFromDoc(LineFromUPtr(wParam));
 
 	case Message::DocLineFromVisible:
-		return pcs->DocFromDisplay(static_cast<Sci::Line>(wParam));
+		return pcs->DocFromDisplay(LineFromUPtr(wParam));
 
 	case Message::WrapCount:
-		return WrapCount(static_cast<Sci::Line>(wParam));
+		return WrapCount(LineFromUPtr(wParam));
 
 	case Message::SetFoldLevel: {
-			const int prev = pdoc->SetLevel(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+			const int prev = pdoc->SetLevel(LineFromUPtr(wParam), static_cast<int>(lParam));
 			if (prev != static_cast<int>(lParam))
 				RedrawSelMargin();
 			return prev;
 		}
 
 	case Message::GetFoldLevel:
-		return pdoc->GetLevel(static_cast<Sci::Line>(wParam));
+		return pdoc->GetLevel(LineFromUPtr(wParam));
 
 	case Message::GetLastChild:
-		return pdoc->GetLastChild(static_cast<Sci::Line>(wParam), OptionalFoldLevel(lParam));
+		return pdoc->GetLastChild(LineFromUPtr(wParam), OptionalFoldLevel(lParam));
 
 	case Message::GetFoldParent:
-		return pdoc->GetFoldParent(static_cast<Sci::Line>(wParam));
+		return pdoc->GetFoldParent(LineFromUPtr(wParam));
 
 	case Message::ShowLines:
-		pcs->SetVisible(static_cast<Sci::Line>(wParam), static_cast<Sci::Line>(lParam), true);
+		pcs->SetVisible(LineFromUPtr(wParam), lParam, true);
 		SetScrollBars();
 		Redraw();
 		break;
 
 	case Message::HideLines:
 		if (wParam > 0)
-			pcs->SetVisible(static_cast<Sci::Line>(wParam), static_cast<Sci::Line>(lParam), false);
+			pcs->SetVisible(LineFromUPtr(wParam), lParam, false);
 		SetScrollBars();
 		Redraw();
 		break;
 
 	case Message::GetLineVisible:
-		return pcs->GetVisible(static_cast<Sci::Line>(wParam));
+		return pcs->GetVisible(LineFromUPtr(wParam));
 
 	case Message::GetAllLinesVisible:
 		return pcs->HiddenLines() ? 0 : 1;
 
 	case Message::SetFoldExpanded:
-		SetFoldExpanded(static_cast<Sci::Line>(wParam), lParam != 0);
+		SetFoldExpanded(LineFromUPtr(wParam), lParam != 0);
 		break;
 
 	case Message::GetFoldExpanded:
-		return pcs->GetExpanded(static_cast<Sci::Line>(wParam));
+		return pcs->GetExpanded(LineFromUPtr(wParam));
 
 	case Message::SetAutomaticFold:
 		foldAutomatic = static_cast<AutomaticFold>(wParam);
@@ -7416,8 +7412,8 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::ToggleFoldShowText:
-		pcs->SetFoldDisplayText(static_cast<Sci::Line>(wParam), CharPtrFromSPtr(lParam));
-		FoldLine(static_cast<Sci::Line>(wParam), FoldAction::Toggle);
+		pcs->SetFoldDisplayText(LineFromUPtr(wParam), CharPtrFromSPtr(lParam));
+		FoldLine(LineFromUPtr(wParam), FoldAction::Toggle);
 		break;
 
 	case Message::FoldDisplayTextSetStyle:
@@ -7437,15 +7433,15 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return StringResult(lParam, GetDefaultFoldDisplayText());
 
 	case Message::ToggleFold:
-		FoldLine(static_cast<Sci::Line>(wParam), FoldAction::Toggle);
+		FoldLine(LineFromUPtr(wParam), FoldAction::Toggle);
 		break;
 
 	case Message::FoldLine:
-		FoldLine(static_cast<Sci::Line>(wParam), static_cast<FoldAction>(lParam));
+		FoldLine(LineFromUPtr(wParam), static_cast<FoldAction>(lParam));
 		break;
 
 	case Message::FoldChildren:
-		FoldExpand(static_cast<Sci::Line>(wParam), static_cast<FoldAction>(lParam), pdoc->GetFoldLevel(static_cast<Sci::Line>(wParam)));
+		FoldExpand(LineFromUPtr(wParam), static_cast<FoldAction>(lParam), pdoc->GetFoldLevel(LineFromUPtr(wParam)));
 		break;
 
 	case Message::FoldAll:
@@ -7453,22 +7449,22 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::ExpandChildren:
-		FoldExpand(static_cast<Sci::Line>(wParam), FoldAction::Expand, static_cast<FoldLevel>(lParam));
+		FoldExpand(LineFromUPtr(wParam), FoldAction::Expand, static_cast<FoldLevel>(lParam));
 		break;
 
 	case Message::ContractedFoldNext:
-		return ContractedFoldNext(static_cast<Sci::Line>(wParam));
+		return ContractedFoldNext(LineFromUPtr(wParam));
 
 	case Message::EnsureVisible:
-		EnsureLineVisible(static_cast<Sci::Line>(wParam), false);
+		EnsureLineVisible(LineFromUPtr(wParam), false);
 		break;
 
 	case Message::EnsureVisibleEnforcePolicy:
-		EnsureLineVisible(static_cast<Sci::Line>(wParam), true);
+		EnsureLineVisible(LineFromUPtr(wParam), true);
 		break;
 
 	case Message::ScrollRange:
-		ScrollRange(SelectionRange(static_cast<Sci::Position>(wParam), lParam));
+		ScrollRange(SelectionRange(PositionFromUPtr(wParam), lParam));
 		break;
 
 	case Message::SearchAnchor:
@@ -7563,7 +7559,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return static_cast<sptr_t>(vs.selection.layer);
 
 	case Message::SetCaretFore:
-		vs.elementColours[Element::Caret] = ColourRGBA::FromRGB(static_cast<int>(wParam));
+		vs.elementColours[Element::Caret] = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
 		InvalidateStyleRedraw();
 		break;
 
@@ -7618,8 +7614,8 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::IndicSetFore:
 		if (wParam <= IndicatorMax) {
-			vs.indicators[wParam].sacNormal.fore = ColourRGBA::FromRGB(static_cast<int>(lParam));
-			vs.indicators[wParam].sacHover.fore = ColourRGBA::FromRGB(static_cast<int>(lParam));
+			vs.indicators[wParam].sacNormal.fore = ColourRGBA::FromIpRGB(lParam);
+			vs.indicators[wParam].sacHover.fore = ColourRGBA::FromIpRGB(lParam);
 			InvalidateStyleRedraw();
 		}
 		break;
@@ -7641,7 +7637,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::IndicSetHoverFore:
 		if (wParam <= IndicatorMax) {
-			vs.indicators[wParam].sacHover.fore = ColourRGBA::FromRGB(static_cast<int>(lParam));
+			vs.indicators[wParam].sacHover.fore = ColourRGBA::FromIpRGB(lParam);
 			InvalidateStyleRedraw();
 		}
 		break;
@@ -7718,17 +7714,17 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return pdoc->decorations->GetCurrentValue();
 
 	case Message::IndicatorFillRange:
-		pdoc->DecorationFillRange(static_cast<Sci::Position>(wParam),
+		pdoc->DecorationFillRange(PositionFromUPtr(wParam),
 			pdoc->decorations->GetCurrentValue(), lParam);
 		break;
 
 	case Message::IndicatorClearRange:
-		pdoc->DecorationFillRange(static_cast<Sci::Position>(wParam), 0,
+		pdoc->DecorationFillRange(PositionFromUPtr(wParam), 0,
 			lParam);
 		break;
 
 	case Message::IndicatorAllOnFor:
-		return pdoc->decorations->AllOnFor(static_cast<Sci::Position>(wParam));
+		return pdoc->decorations->AllOnFor(PositionFromUPtr(wParam));
 
 	case Message::IndicatorValueAt:
 		return pdoc->decorations->ValueAt(static_cast<int>(wParam), lParam);
@@ -7835,7 +7831,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return KeyCommand(iMessage);
 
 	case Message::BraceHighlight:
-		SetBraceHighlight(static_cast<Sci::Position>(wParam), lParam, StyleBraceLight);
+		SetBraceHighlight(PositionFromUPtr(wParam), lParam, StyleBraceLight);
 		break;
 
 	case Message::BraceHighlightIndicator:
@@ -7846,7 +7842,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::BraceBadLight:
-		SetBraceHighlight(static_cast<Sci::Position>(wParam), -1, StyleBraceBad);
+		SetBraceHighlight(PositionFromUPtr(wParam), -1, StyleBraceBad);
 		break;
 
 	case Message::BraceBadLightIndicator:
@@ -7859,10 +7855,10 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	case Message::BraceMatch:
 		// wParam is position of char to find brace for,
 		// lParam is maximum amount of text to restyle to find it
-		return pdoc->BraceMatch(static_cast<Sci::Position>(wParam), lParam, 0, false);
+		return pdoc->BraceMatch(PositionFromUPtr(wParam), lParam, 0, false);
 
 	case Message::BraceMatchNext:
-		return pdoc->BraceMatch(static_cast<Sci::Position>(wParam), 0, lParam, true);
+		return pdoc->BraceMatch(PositionFromUPtr(wParam), 0, lParam, true);
 
 	case Message::GetViewEOL:
 		return vs.viewEOL;
@@ -7905,7 +7901,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return vs.theEdge.colour.OpaqueRGB();
 
 	case Message::SetEdgeColour:
-		vs.theEdge.colour = ColourRGBA::FromRGB(static_cast<int>(wParam));
+		vs.theEdge.colour = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
 		InvalidateStyleRedraw();
 		break;
 
@@ -7946,7 +7942,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	case Message::CreateDocument: {
 			Document *doc = new Document(static_cast<DocumentOption>(lParam));
 			doc->AddRef();
-			doc->Allocate(static_cast<Sci::Position>(wParam));
+			doc->Allocate(PositionFromUPtr(wParam));
 			pcs = ContractionStateCreate(pdoc->IsLarge());
 			return reinterpret_cast<sptr_t>(doc);
 		}
@@ -7965,7 +7961,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	case Message::CreateLoader: {
 			Document *doc = new Document(static_cast<DocumentOption>(lParam));
 			doc->AddRef();
-			doc->Allocate(static_cast<Sci::Position>(wParam));
+			doc->Allocate(PositionFromUPtr(wParam));
 			doc->SetUndoCollection(false);
 			pcs = ContractionStateCreate(pdoc->IsLarge());
 			return reinterpret_cast<sptr_t>(static_cast<ILoader *>(doc));
@@ -7991,7 +7987,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return 0;
 
 	case Message::SetLengthForEncode:
-		lengthForEncode = static_cast<Sci::Position>(wParam);
+		lengthForEncode = PositionFromUPtr(wParam);
 		return 0;
 
 	case Message::SelectionIsRectangle:
@@ -8042,8 +8038,8 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	case Message::GetLineSelStartPosition:
 	case Message::GetLineSelEndPosition: {
 			const SelectionSegment segmentLine(
-				SelectionPosition(pdoc->LineStart(static_cast<Sci::Position>(wParam))),
-				SelectionPosition(pdoc->LineEnd(static_cast<Sci::Position>(wParam))));
+				SelectionPosition(pdoc->LineStart(LineFromUPtr(wParam))),
+				SelectionPosition(pdoc->LineEnd(LineFromUPtr(wParam))));
 			for (size_t r=0; r<sel.Count(); r++) {
 				const SelectionSegment portion = sel.Range(r).Intersect(segmentLine);
 				if (portion.start.IsValid()) {
@@ -8223,7 +8219,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::GetRangePointer:
 		return reinterpret_cast<sptr_t>(pdoc->RangePointer(
-			static_cast<Sci::Position>(wParam), lParam));
+			PositionFromUPtr(wParam), lParam));
 
 	case Message::GetGapPosition:
 		return pdoc->GapPosition();
@@ -8260,29 +8256,29 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return static_cast<sptr_t>(marginOptions);
 
 	case Message::MarginSetText:
-		pdoc->MarginSetText(static_cast<Sci::Line>(wParam), CharPtrFromSPtr(lParam));
+		pdoc->MarginSetText(LineFromUPtr(wParam), CharPtrFromSPtr(lParam));
 		break;
 
 	case Message::MarginGetText: {
-			const StyledText st = pdoc->MarginStyledText(static_cast<Sci::Line>(wParam));
+			const StyledText st = pdoc->MarginStyledText(LineFromUPtr(wParam));
 			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(st.text), st.length);
 		}
 
 	case Message::MarginSetStyle:
-		pdoc->MarginSetStyle(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		pdoc->MarginSetStyle(LineFromUPtr(wParam), static_cast<int>(lParam));
 		break;
 
 	case Message::MarginGetStyle: {
-			const StyledText st = pdoc->MarginStyledText(static_cast<Sci::Line>(wParam));
+			const StyledText st = pdoc->MarginStyledText(LineFromUPtr(wParam));
 			return st.style;
 		}
 
 	case Message::MarginSetStyles:
-		pdoc->MarginSetStyles(static_cast<Sci::Line>(wParam), ConstUCharPtrFromSPtr(lParam));
+		pdoc->MarginSetStyles(LineFromUPtr(wParam), ConstUCharPtrFromSPtr(lParam));
 		break;
 
 	case Message::MarginGetStyles: {
-			const StyledText st = pdoc->MarginStyledText(static_cast<Sci::Line>(wParam));
+			const StyledText st = pdoc->MarginStyledText(LineFromUPtr(wParam));
 			return BytesResult(lParam, st.styles, st.length);
 		}
 
@@ -8291,34 +8287,34 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::AnnotationSetText:
-		pdoc->AnnotationSetText(static_cast<Sci::Line>(wParam), CharPtrFromSPtr(lParam));
+		pdoc->AnnotationSetText(LineFromUPtr(wParam), CharPtrFromSPtr(lParam));
 		break;
 
 	case Message::AnnotationGetText: {
-			const StyledText st = pdoc->AnnotationStyledText(static_cast<Sci::Line>(wParam));
+			const StyledText st = pdoc->AnnotationStyledText(LineFromUPtr(wParam));
 			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(st.text), st.length);
 		}
 
 	case Message::AnnotationGetStyle: {
-			const StyledText st = pdoc->AnnotationStyledText(static_cast<Sci::Line>(wParam));
+			const StyledText st = pdoc->AnnotationStyledText(LineFromUPtr(wParam));
 			return st.style;
 		}
 
 	case Message::AnnotationSetStyle:
-		pdoc->AnnotationSetStyle(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		pdoc->AnnotationSetStyle(LineFromUPtr(wParam), static_cast<int>(lParam));
 		break;
 
 	case Message::AnnotationSetStyles:
-		pdoc->AnnotationSetStyles(static_cast<Sci::Line>(wParam), ConstUCharPtrFromSPtr(lParam));
+		pdoc->AnnotationSetStyles(LineFromUPtr(wParam), ConstUCharPtrFromSPtr(lParam));
 		break;
 
 	case Message::AnnotationGetStyles: {
-			const StyledText st = pdoc->AnnotationStyledText(static_cast<Sci::Line>(wParam));
+			const StyledText st = pdoc->AnnotationStyledText(LineFromUPtr(wParam));
 			return BytesResult(lParam, st.styles, st.length);
 		}
 
 	case Message::AnnotationGetLines:
-		return pdoc->AnnotationLines(static_cast<Sci::Line>(wParam));
+		return pdoc->AnnotationLines(LineFromUPtr(wParam));
 
 	case Message::AnnotationClearAll:
 		pdoc->AnnotationClearAll();
@@ -8340,21 +8336,21 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return vs.annotationStyleOffset;
 
 	case Message::EOLAnnotationSetText:
-		pdoc->EOLAnnotationSetText(static_cast<Sci::Line>(wParam), CharPtrFromSPtr(lParam));
+		pdoc->EOLAnnotationSetText(LineFromUPtr(wParam), CharPtrFromSPtr(lParam));
 		break;
 
 	case Message::EOLAnnotationGetText: {
-			const StyledText st = pdoc->EOLAnnotationStyledText(static_cast<Sci::Line>(wParam));
+			const StyledText st = pdoc->EOLAnnotationStyledText(LineFromUPtr(wParam));
 			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(st.text), st.length);
 		}
 
 	case Message::EOLAnnotationGetStyle: {
-			const StyledText st = pdoc->EOLAnnotationStyledText(static_cast<Sci::Line>(wParam));
+			const StyledText st = pdoc->EOLAnnotationStyledText(LineFromUPtr(wParam));
 			return st.style;
 		}
 
 	case Message::EOLAnnotationSetStyle:
-		pdoc->EOLAnnotationSetStyle(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		pdoc->EOLAnnotationSetStyle(LineFromUPtr(wParam), static_cast<int>(lParam));
 		break;
 
 	case Message::EOLAnnotationClearAll:
@@ -8387,7 +8383,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return SupportsFeature(static_cast<Supports>(wParam));
 
 	case Message::AddUndoAction:
-		pdoc->AddUndoAction(static_cast<Sci::Position>(wParam),
+		pdoc->AddUndoAction(PositionFromUPtr(wParam),
 			FlagSet(static_cast<UndoFlags>(lParam), UndoFlags::MayCoalesce));
 		break;
 
@@ -8450,24 +8446,24 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::SetSelection:
-		sel.SetSelection(SelectionRange(static_cast<Sci::Position>(wParam), lParam));
+		sel.SetSelection(SelectionRange(PositionFromUPtr(wParam), lParam));
 		Redraw();
 		break;
 
 	case Message::AddSelection:
-		sel.AddSelection(SelectionRange(static_cast<Sci::Position>(wParam), lParam));
+		sel.AddSelection(SelectionRange(PositionFromUPtr(wParam), lParam));
 		ContainerNeedsUpdate(Update::Selection);
 		Redraw();
 		break;
 
 	case Message::DropSelectionN:
-		sel.DropSelection(static_cast<size_t>(wParam));
+		sel.DropSelection(wParam);
 		ContainerNeedsUpdate(Update::Selection);
 		Redraw();
 		break;
 
 	case Message::SetMainSelection:
-		sel.SetMain(static_cast<size_t>(wParam));
+		sel.SetMain(wParam);
 		ContainerNeedsUpdate(Update::Selection);
 		Redraw();
 		break;
@@ -8512,7 +8508,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		if (!sel.IsRectangular())
 			sel.Clear();
 		sel.selType = Selection::SelTypes::rectangle;
-		sel.Rectangular().caret.SetPosition(static_cast<Sci::Position>(wParam));
+		sel.Rectangular().caret.SetPosition(PositionFromUPtr(wParam));
 		SetRectangularRange();
 		Redraw();
 		break;
@@ -8524,7 +8520,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		if (!sel.IsRectangular())
 			sel.Clear();
 		sel.selType = Selection::SelTypes::rectangle;
-		sel.Rectangular().anchor.SetPosition(static_cast<Sci::Position>(wParam));
+		sel.Rectangular().anchor.SetPosition(PositionFromUPtr(wParam));
 		SetRectangularRange();
 		Redraw();
 		break;
@@ -8536,7 +8532,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		if (!sel.IsRectangular())
 			sel.Clear();
 		sel.selType = Selection::SelTypes::rectangle;
-		sel.Rectangular().caret.SetVirtualSpace(static_cast<Sci::Position>(wParam));
+		sel.Rectangular().caret.SetVirtualSpace(PositionFromUPtr(wParam));
 		SetRectangularRange();
 		Redraw();
 		break;
@@ -8548,7 +8544,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		if (!sel.IsRectangular())
 			sel.Clear();
 		sel.selType = Selection::SelTypes::rectangle;
-		sel.Rectangular().anchor.SetVirtualSpace(static_cast<Sci::Position>(wParam));
+		sel.Rectangular().anchor.SetVirtualSpace(PositionFromUPtr(wParam));
 		SetRectangularRange();
 		Redraw();
 		break;
@@ -8564,7 +8560,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return static_cast<sptr_t>(virtualSpaceOptions);
 
 	case Message::SetAdditionalSelFore:
-		vs.elementColours[Element::SelectionAdditionalText] = ColourRGBA::FromRGB(static_cast<int>(wParam));
+		vs.elementColours[Element::SelectionAdditionalText] = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
 		InvalidateStyleRedraw();
 		break;
 
@@ -8584,7 +8580,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return vs.ElementColour(Element::SelectionAdditionalBack)->GetAlpha();
 
 	case Message::SetAdditionalCaretFore:
-		vs.elementColours[Element::CaretAdditional] = ColourRGBA::FromRGB(static_cast<int>(wParam));
+		vs.elementColours[Element::CaretAdditional] = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
 		InvalidateStyleRedraw();
 		break;
 
@@ -8610,7 +8606,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::ChangeLexerState:
-		pdoc->ChangeLexerState(static_cast<Sci::Position>(wParam), lParam);
+		pdoc->ChangeLexerState(PositionFromUPtr(wParam), lParam);
 		break;
 
 	case Message::SetIdentifier:
@@ -8628,10 +8624,10 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		return static_cast<sptr_t>(technology);
 
 	case Message::CountCharacters:
-		return pdoc->CountCharacters(static_cast<Sci::Position>(wParam), lParam);
+		return pdoc->CountCharacters(PositionFromUPtr(wParam), lParam);
 
 	case Message::CountCodeUnits:
-		return pdoc->CountUTF16(static_cast<Sci::Position>(wParam), lParam);
+		return pdoc->CountUTF16(PositionFromUPtr(wParam), lParam);
 
 	default:
 		return DefWndProc(iMessage, wParam, lParam);
diff --git a/src/Editor.h b/src/Editor.h
index 9af2add43..417700ed5 100644
--- a/src/Editor.h
+++ b/src/Editor.h
@@ -624,6 +624,19 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 		return static_cast<const char *>(PtrFromUPtr(wParam));
 	}
 
+	static constexpr Scintilla::sptr_t SPtrFromUPtr(Scintilla::uptr_t wParam) noexcept {
+		return static_cast<Scintilla::sptr_t>(wParam);
+	}
+	static constexpr Sci::Position PositionFromUPtr(Scintilla::uptr_t wParam) noexcept {
+		return SPtrFromUPtr(wParam);
+	}
+	static constexpr Sci::Line LineFromUPtr(Scintilla::uptr_t wParam) noexcept {
+		return SPtrFromUPtr(wParam);
+	}
+	Point PointFromParameters(Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) const noexcept {
+		return Point(static_cast<XYPOSITION>(wParam) - vs.ExternalMarginWidth(), static_cast<XYPOSITION>(lParam));
+	}
+
 	constexpr std::optional<FoldLevel> OptionalFoldLevel(Scintilla::sptr_t lParam) {
 		if (lParam >= 0) {
 			return static_cast<FoldLevel>(lParam);
diff --git a/src/Geometry.h b/src/Geometry.h
index e471bdfc0..6456af0e8 100644
--- a/src/Geometry.h
+++ b/src/Geometry.h
@@ -180,6 +180,10 @@ public:
 		return ColourRGBA(co_ | (0xffu << 24));
 	}
 
+	static constexpr ColourRGBA FromIpRGB(intptr_t co_) noexcept {
+		return ColourRGBA(static_cast<int>(co_) | (0xffu << 24));
+	}
+
 	constexpr ColourRGBA WithoutAlpha() const noexcept {
 		return ColourRGBA(co & 0xffffff);
 	}
diff --git a/src/ScintillaBase.cxx b/src/ScintillaBase.cxx
index a6e769d81..50c8e87a7 100644
--- a/src/ScintillaBase.cxx
+++ b/src/ScintillaBase.cxx
@@ -846,7 +846,7 @@ sptr_t ScintillaBase::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	switch (iMessage) {
 	case Message::AutoCShow:
 		listType = 0;
-		AutoCompleteStart(static_cast<Sci::Position>(wParam), ConstCharPtrFromSPtr(lParam));
+		AutoCompleteStart(PositionFromUPtr(wParam), ConstCharPtrFromSPtr(lParam));
 		break;
 
 	case Message::AutoCCancel:
@@ -1007,19 +1007,19 @@ sptr_t ScintillaBase::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case Message::CallTipSetBack:
-		ct.colourBG = ColourRGBA::FromRGB(static_cast<int>(wParam));
+		ct.colourBG = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
 		vs.styles[StyleCallTip].back = ct.colourBG;
 		InvalidateStyleRedraw();
 		break;
 
 	case Message::CallTipSetFore:
-		ct.colourUnSel = ColourRGBA::FromRGB(static_cast<int>(wParam));
+		ct.colourUnSel = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
 		vs.styles[StyleCallTip].fore = ct.colourUnSel;
 		InvalidateStyleRedraw();
 		break;
 
 	case Message::CallTipSetForeHlt:
-		ct.colourSel = ColourRGBA::FromRGB(static_cast<int>(wParam));
+		ct.colourSel = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
 		InvalidateStyleRedraw();
 		break;
 
@@ -1046,10 +1046,10 @@ sptr_t ScintillaBase::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::Colourise:
 		if (DocumentLexState()->UseContainerLexing()) {
-			pdoc->ModifiedAt(static_cast<Sci::Position>(wParam));
+			pdoc->ModifiedAt(PositionFromUPtr(wParam));
 			NotifyStyleToNeeded((lParam == -1) ? pdoc->Length() : lParam);
 		} else {
-			DocumentLexState()->Colourise(static_cast<Sci::Position>(wParam), lParam);
+			DocumentLexState()->Colourise(PositionFromUPtr(wParam), lParam);
 		}
 		Redraw();
 		break;
diff --git a/src/ViewStyle.cxx b/src/ViewStyle.cxx
index a229b8a94..33b861445 100644
--- a/src/ViewStyle.cxx
+++ b/src/ViewStyle.cxx
@@ -586,7 +586,7 @@ bool ViewStyle::SetElementColour(Element element, ColourRGBA colour) {
 
 bool ViewStyle::SetElementColourOptional(Element element, uptr_t wParam, sptr_t lParam) {
 	if (wParam) {
-		return SetElementColour(element, ColourRGBA::FromRGB(static_cast<int>(lParam)));
+		return SetElementColour(element, ColourRGBA::FromIpRGB(lParam));
 	} else {
 		return ResetElement(element);
 	}
diff --git a/src/ViewStyle.h b/src/ViewStyle.h
index b59f441b1..8b9f125bd 100644
--- a/src/ViewStyle.h
+++ b/src/ViewStyle.h
@@ -45,7 +45,7 @@ typedef std::map<FontSpecification, std::unique_ptr<FontRealised>> FontMap;
 
 inline std::optional<ColourRGBA> OptionalColour(Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) {
 	if (wParam) {
-		return ColourRGBA::FromRGB(static_cast<int>(lParam));
+		return ColourRGBA::FromIpRGB(lParam);
 	} else {
 		return {};
 	}
@@ -94,7 +94,7 @@ struct EdgeProperties {
 		column(column_), colour(colour_) {
 	}
 	EdgeProperties(Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) noexcept :
-		column(static_cast<int>(wParam)), colour(ColourRGBA::FromRGB(static_cast<int>(lParam))) {
+		column(static_cast<int>(wParam)), colour(ColourRGBA::FromIpRGB(lParam)) {
 	}
 };