Editor.cxx

Go to the documentation of this file.

// Scintilla source code edit control
/** @file Editor.cxx
 ** Main code for the edit control.
 **/
// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.
 
#include <cstddef>
#include <cstdlib>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cmath>
 
#include <stdexcept>
#include <string>
#include <vector>
#include <map>
#include <forward_list>
#include <algorithm>
#include <iterator>
#include <memory>
#include <chrono>
 
#include "Platform.h"
 
#include "ILoader.h"
#include "ILexer.h"
#include "Scintilla.h"
 
#include "CharacterSet.h"
#include "CharacterCategory.h"
#include "Position.h"
#include "UniqueString.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "ContractionState.h"
#include "CellBuffer.h"
#include "PerLine.h"
#include "KeyMap.h"
#include "Indicator.h"
#include "LineMarker.h"
#include "Style.h"
#include "ViewStyle.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "CaseFolder.h"
#include "Document.h"
#include "UniConversion.h"
#include "Selection.h"
#include "PositionCache.h"
#include "EditModel.h"
#include "MarginView.h"
#include "EditView.h"
#include "Editor.h"
#include "ElapsedPeriod.h"
 
using namespace Scintilla;
 
namespace {
 
/*
    return whether this modification represents an operation that
    may reasonably be deferred (not done now OR [possibly] at all)
*/
bool CanDeferToLastStep(const DocModification &mh) noexcept {
    if (mh.modificationType & (SC_MOD_BEFOREINSERT | SC_MOD_BEFOREDELETE))
        return true;    // CAN skip
    if (!(mh.modificationType & (SC_PERFORMED_UNDO | SC_PERFORMED_REDO)))
        return false;   // MUST do
    if (mh.modificationType & SC_MULTISTEPUNDOREDO)
        return true;    // CAN skip
    return false;       // PRESUMABLY must do
}
 
constexpr bool CanEliminate(const DocModification &mh) noexcept {
    return
        (mh.modificationType & (SC_MOD_BEFOREINSERT | SC_MOD_BEFOREDELETE)) != 0;
}
 
/*
    return whether this modification represents the FINAL step
    in a [possibly lengthy] multi-step Undo/Redo sequence
*/
constexpr bool IsLastStep(const DocModification &mh) noexcept {
    return
        (mh.modificationType & (SC_PERFORMED_UNDO | SC_PERFORMED_REDO)) != 0
        && (mh.modificationType & SC_MULTISTEPUNDOREDO) != 0
        && (mh.modificationType & SC_LASTSTEPINUNDOREDO) != 0
        && (mh.modificationType & SC_MULTILINEUNDOREDO) != 0;
}
 
}
 
Timer::Timer() noexcept :
        ticking(false), ticksToWait(0), tickerID{} {}
 
Idler::Idler() noexcept :
        state(false), idlerID(0) {}
 
static bool IsAllSpacesOrTabs(const char *s, unsigned int len) noexcept {
    for (unsigned int i = 0; i < len; i++) {
        // This is safe because IsSpaceOrTab() will return false for null terminators
        if (!IsSpaceOrTab(s[i]))
            return false;
    }
    return true;
}
 
Editor::Editor() : durationWrapOneLine(0.00001, 0.000001, 0.0001) {
    ctrlID = 0;
 
    stylesValid = false;
    technology = SC_TECHNOLOGY_DEFAULT;
    scaleRGBAImage = 100.0f;
 
    cursorMode = SC_CURSORNORMAL;
 
    hasFocus = false;
    errorStatus = 0;
    mouseDownCaptures = true;
    mouseWheelCaptures = true;
 
    lastClickTime = 0;
    doubleClickCloseThreshold = Point(3, 3);
    dwellDelay = SC_TIME_FOREVER;
    ticksToDwell = SC_TIME_FOREVER;
    dwelling = false;
    ptMouseLast.x = 0;
    ptMouseLast.y = 0;
    inDragDrop = ddNone;
    dropWentOutside = false;
    posDrop = SelectionPosition(Sci::invalidPosition);
    hotSpotClickPos = INVALID_POSITION;
    selectionUnit = TextUnit::character;
 
    lastXChosen = 0;
    lineAnchorPos = 0;
    originalAnchorPos = 0;
    wordSelectAnchorStartPos = 0;
    wordSelectAnchorEndPos = 0;
    wordSelectInitialCaretPos = -1;
 
    caretPolicies.x = { CARET_SLOP | CARET_EVEN, 50 };
    caretPolicies.y = { CARET_EVEN, 0 };
 
    visiblePolicy = { 0, 0 };
 
    searchAnchor = 0;
 
    xCaretMargin = 50;
    horizontalScrollBarVisible = true;
    scrollWidth = 2000;
    verticalScrollBarVisible = true;
    endAtLastLine = true;
    caretSticky = SC_CARETSTICKY_OFF;
    marginOptions = SC_MARGINOPTION_NONE;
    mouseSelectionRectangularSwitch = false;
    multipleSelection = false;
    additionalSelectionTyping = false;
    multiPasteMode = SC_MULTIPASTE_ONCE;
    virtualSpaceOptions = SCVS_NONE;
 
    targetRange = SelectionSegment();
    searchFlags = 0;
 
    topLine = 0;
    posTopLine = 0;
 
    lengthForEncode = -1;
 
    needUpdateUI = 0;
    ContainerNeedsUpdate(SC_UPDATE_CONTENT);
 
    paintState = notPainting;
    paintAbandonedByStyling = false;
    paintingAllText = false;
    willRedrawAll = false;
    idleStyling = SC_IDLESTYLING_NONE;
    needIdleStyling = false;
 
    modEventMask = SC_MODEVENTMASKALL;
    commandEvents = true;
 
    pdoc->AddWatcher(this, 0);
 
    recordingMacro = false;
    foldAutomatic = 0;
 
    convertPastes = true;
 
    SetRepresentations();
}
 
Editor::~Editor() {
    pdoc->RemoveWatcher(this, 0);
    DropGraphics(true);
}
 
void Editor::Finalise() {
    SetIdle(false);
    CancelModes();
}
 
void Editor::SetRepresentations() {
    reprs.Clear();
 
    // C0 control set
    const char *const reps[] = {
        "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
        "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
        "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
        "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"
    };
    for (size_t j=0; j < Sci::size(reps); j++) {
        const char c[2] = { static_cast<char>(j), 0 };
        reprs.SetRepresentation(c, reps[j]);
    }
    reprs.SetRepresentation("\x7f", "DEL");
 
    // C1 control set
    // As well as Unicode mode, ISO-8859-1 should use these
    if (IsUnicodeMode()) {
        const char *const repsC1[] = {
            "PAD", "HOP", "BPH", "NBH", "IND", "NEL", "SSA", "ESA",
            "HTS", "HTJ", "VTS", "PLD", "PLU", "RI", "SS2", "SS3",
            "DCS", "PU1", "PU2", "STS", "CCH", "MW", "SPA", "EPA",
            "SOS", "SGCI", "SCI", "CSI", "ST", "OSC", "PM", "APC"
        };
        for (size_t j=0; j < Sci::size(repsC1); j++) {
            const char c1[3] = { '\xc2',  static_cast<char>(0x80+j), 0 };
            reprs.SetRepresentation(c1, repsC1[j]);
        }
        reprs.SetRepresentation("\xe2\x80\xa8", "LS");
        reprs.SetRepresentation("\xe2\x80\xa9", "PS");
    }
 
    // UTF-8 invalid bytes
    if (IsUnicodeMode()) {
        for (int k=0x80; k < 0x100; k++) {
            const char hiByte[2] = {  static_cast<char>(k), 0 };
            char hexits[5]; // Really only needs 4 but that causes warning from gcc 7.1
            sprintf(hexits, "x%2X", k);
            reprs.SetRepresentation(hiByte, hexits);
        }
    } else if (pdoc->dbcsCodePage) {
        // DBCS invalid single lead bytes
        for (int k = 0x80; k < 0x100; k++) {
            const char ch = static_cast<char>(k);
            if (pdoc->IsDBCSLeadByteNoExcept(ch)  || pdoc->IsDBCSLeadByteInvalid(ch)) {
                const char hiByte[2] = { ch, 0 };
                char hexits[5]; // Really only needs 4 but that causes warning from gcc 7.1
                sprintf(hexits, "x%2X", k);
                reprs.SetRepresentation(hiByte, hexits);
            }
        }
    }
}
 
void Editor::DropGraphics(bool freeObjects) {
    marginView.DropGraphics(freeObjects);
    view.DropGraphics(freeObjects);
}
 
void Editor::AllocateGraphics() {
    marginView.AllocateGraphics(vs);
    view.AllocateGraphics(vs);
}
 
void Editor::InvalidateStyleData() {
    stylesValid = false;
    vs.technology = technology;
    DropGraphics(false);
    AllocateGraphics();
    view.llc.Invalidate(LineLayout::ValidLevel::invalid);
    view.posCache.Clear();
}
 
void Editor::InvalidateStyleRedraw() {
    NeedWrapping();
    InvalidateStyleData();
    Redraw();
}
 
void Editor::RefreshStyleData() {
    if (!stylesValid) {
        stylesValid = true;
        AutoSurface surface(this);
        if (surface) {
            vs.Refresh(*surface, pdoc->tabInChars);
        }
        SetScrollBars();
        SetRectangularRange();
    }
}
 
Point Editor::GetVisibleOriginInMain() const {
    return Point(0, 0);
}
 
PointDocument Editor::DocumentPointFromView(Point ptView) const {
    PointDocument ptDocument(ptView);
    if (wMargin.GetID()) {
        const Point ptOrigin = GetVisibleOriginInMain();
        ptDocument.x += ptOrigin.x;
        ptDocument.y += ptOrigin.y;
    } else {
        ptDocument.x += xOffset;
        ptDocument.y += topLine * vs.lineHeight;
    }
    return ptDocument;
}
 
Sci::Line Editor::TopLineOfMain() const {
    if (wMargin.GetID())
        return 0;
    else
        return topLine;
}
 
PRectangle Editor::GetClientRectangle() const {
    return wMain.GetClientPosition();
}
 
PRectangle Editor::GetClientDrawingRectangle() {
    return GetClientRectangle();
}
 
PRectangle Editor::GetTextRectangle() const {
    PRectangle rc = GetClientRectangle();
    rc.left += vs.textStart;
    rc.right -= vs.rightMarginWidth;
    return rc;
}
 
Sci::Line Editor::LinesOnScreen() const {
    const PRectangle rcClient = GetClientRectangle();
    const int htClient = static_cast<int>(rcClient.bottom - rcClient.top);
    //Platform::DebugPrintf("lines on screen = %d\n", htClient / lineHeight + 1);
    return htClient / vs.lineHeight;
}
 
Sci::Line Editor::LinesToScroll() const {
    const Sci::Line retVal = LinesOnScreen() - 1;
    if (retVal < 1)
        return 1;
    else
        return retVal;
}
 
Sci::Line Editor::MaxScrollPos() const {
    //Platform::DebugPrintf("Lines %d screen = %d maxScroll = %d\n",
    //LinesTotal(), LinesOnScreen(), LinesTotal() - LinesOnScreen() + 1);
    Sci::Line retVal = pcs->LinesDisplayed();
    if (endAtLastLine) {
        retVal -= LinesOnScreen();
    } else {
        retVal--;
    }
    if (retVal < 0) {
        return 0;
    } else {
        return retVal;
    }
}
 
SelectionPosition Editor::ClampPositionIntoDocument(SelectionPosition sp) const {
    if (sp.Position() < 0) {
        return SelectionPosition(0);
    } else if (sp.Position() > pdoc->Length()) {
        return SelectionPosition(pdoc->Length());
    } else {
        // If not at end of line then set offset to 0
        if (!pdoc->IsLineEndPosition(sp.Position()))
            sp.SetVirtualSpace(0);
        return sp;
    }
}
 
Point Editor::LocationFromPosition(SelectionPosition pos, PointEnd pe) {
    RefreshStyleData();
    AutoSurface surface(this);
    return view.LocationFromPosition(surface, *this, pos, topLine, vs, pe);
}
 
Point Editor::LocationFromPosition(Sci::Position pos, PointEnd pe) {
    return LocationFromPosition(SelectionPosition(pos), pe);
}
 
int Editor::XFromPosition(SelectionPosition sp) {
    const Point pt = LocationFromPosition(sp);
    return static_cast<int>(pt.x) - vs.textStart + xOffset;
}
 
SelectionPosition Editor::SPositionFromLocation(Point pt, bool canReturnInvalid, bool charPosition, bool virtualSpace) {
    RefreshStyleData();
    AutoSurface surface(this);
 
    if (canReturnInvalid) {
        PRectangle rcClient = GetTextRectangle();
        // May be in scroll view coordinates so translate back to main view
        const Point ptOrigin = GetVisibleOriginInMain();
        rcClient.Move(-ptOrigin.x, -ptOrigin.y);
        if (!rcClient.Contains(pt))
            return SelectionPosition(INVALID_POSITION);
        if (pt.x < vs.textStart)
            return SelectionPosition(INVALID_POSITION);
        if (pt.y < 0)
            return SelectionPosition(INVALID_POSITION);
    }
    const PointDocument ptdoc = DocumentPointFromView(pt);
    return view.SPositionFromLocation(surface, *this, ptdoc, canReturnInvalid, charPosition, virtualSpace, vs);
}
 
Sci::Position Editor::PositionFromLocation(Point pt, bool canReturnInvalid, bool charPosition) {
    return SPositionFromLocation(pt, canReturnInvalid, charPosition, false).Position();
}
 
/**
* Find the document position corresponding to an x coordinate on a particular document line.
* Ensure is between whole characters when document is in multi-byte or UTF-8 mode.
* This method is used for rectangular selections and does not work on wrapped lines.
*/
SelectionPosition Editor::SPositionFromLineX(Sci::Line lineDoc, int x) {
    RefreshStyleData();
    if (lineDoc >= pdoc->LinesTotal())
        return SelectionPosition(pdoc->Length());
    //Platform::DebugPrintf("Position of (%d,%d) line = %d top=%d\n", pt.x, pt.y, line, topLine);
    AutoSurface surface(this);
    return view.SPositionFromLineX(surface, *this, lineDoc, x, vs);
}
 
Sci::Position Editor::PositionFromLineX(Sci::Line lineDoc, int x) {
    return SPositionFromLineX(lineDoc, x).Position();
}
 
Sci::Line Editor::LineFromLocation(Point pt) const {
    return pcs->DocFromDisplay(static_cast<int>(pt.y) / vs.lineHeight + topLine);
}
 
void Editor::SetTopLine(Sci::Line topLineNew) {
    if ((topLine != topLineNew) && (topLineNew >= 0)) {
        topLine = topLineNew;
        ContainerNeedsUpdate(SC_UPDATE_V_SCROLL);
    }
    posTopLine = pdoc->LineStart(pcs->DocFromDisplay(topLine));
}
 
/**
 * If painting then abandon the painting because a wider redraw is needed.
 * @return true if calling code should stop drawing.
 */
bool Editor::AbandonPaint() {
    if ((paintState == painting) && !paintingAllText) {
        paintState = paintAbandoned;
    }
    return paintState == paintAbandoned;
}
 
void Editor::RedrawRect(PRectangle rc) {
    //Platform::DebugPrintf("Redraw %0d,%0d - %0d,%0d\n", rc.left, rc.top, rc.right, rc.bottom);
 
    // Clip the redraw rectangle into the client area
    const PRectangle rcClient = GetClientRectangle();
    if (rc.top < rcClient.top)
        rc.top = rcClient.top;
    if (rc.bottom > rcClient.bottom)
        rc.bottom = rcClient.bottom;
    if (rc.left < rcClient.left)
        rc.left = rcClient.left;
    if (rc.right > rcClient.right)
        rc.right = rcClient.right;
 
    if ((rc.bottom > rc.top) && (rc.right > rc.left)) {
        wMain.InvalidateRectangle(rc);
    }
}
 
void Editor::DiscardOverdraw() {
    // Overridden on platforms that may draw outside visible area.
}
 
void Editor::Redraw() {
    //Platform::DebugPrintf("Redraw all\n");
    const PRectangle rcClient = GetClientRectangle();
    wMain.InvalidateRectangle(rcClient);
    if (wMargin.GetID())
        wMargin.InvalidateAll();
    //wMain.InvalidateAll();
}
 
void Editor::RedrawSelMargin(Sci::Line line, bool allAfter) {
    const bool markersInText = vs.maskInLine || vs.maskDrawInText;
    if (!wMargin.GetID() || markersInText) {    // May affect text area so may need to abandon and retry
        if (AbandonPaint()) {
            return;
        }
    }
    if (wMargin.GetID() && markersInText) {
        Redraw();
        return;
    }
    PRectangle rcMarkers = GetClientRectangle();
    if (!markersInText) {
        // Normal case: just draw the margin
        rcMarkers.right = rcMarkers.left + vs.fixedColumnWidth;
    }
    if (line != -1) {
        PRectangle rcLine = RectangleFromRange(Range(pdoc->LineStart(line)), 0);
 
        // Inflate line rectangle if there are image markers with height larger than line height
        if (vs.largestMarkerHeight > vs.lineHeight) {
            const int delta = (vs.largestMarkerHeight - vs.lineHeight + 1) / 2;
            rcLine.top -= delta;
            rcLine.bottom += delta;
            if (rcLine.top < rcMarkers.top)
                rcLine.top = rcMarkers.top;
            if (rcLine.bottom > rcMarkers.bottom)
                rcLine.bottom = rcMarkers.bottom;
        }
 
        rcMarkers.top = rcLine.top;
        if (!allAfter)
            rcMarkers.bottom = rcLine.bottom;
        if (rcMarkers.Empty())
            return;
    }
    if (wMargin.GetID()) {
        const Point ptOrigin = GetVisibleOriginInMain();
        rcMarkers.Move(-ptOrigin.x, -ptOrigin.y);
        wMargin.InvalidateRectangle(rcMarkers);
    } else {
        wMain.InvalidateRectangle(rcMarkers);
    }
}
 
PRectangle Editor::RectangleFromRange(Range r, int overlap) {
    const Sci::Line minLine = pcs->DisplayFromDoc(
        pdoc->SciLineFromPosition(r.First()));
    const Sci::Line maxLine = pcs->DisplayLastFromDoc(
        pdoc->SciLineFromPosition(r.Last()));
    const PRectangle rcClientDrawing = GetClientDrawingRectangle();
    PRectangle rc;
    const int leftTextOverlap = ((xOffset == 0) && (vs.leftMarginWidth > 0)) ? 1 : 0;
    rc.left = static_cast<XYPOSITION>(vs.textStart - leftTextOverlap);
    rc.top = static_cast<XYPOSITION>((minLine - TopLineOfMain()) * vs.lineHeight - overlap);
    if (rc.top < rcClientDrawing.top)
        rc.top = rcClientDrawing.top;
    // Extend to right of prepared area if any to prevent artifacts from caret line highlight
    rc.right = rcClientDrawing.right;
    rc.bottom = static_cast<XYPOSITION>((maxLine - TopLineOfMain() + 1) * vs.lineHeight + overlap);
 
    return rc;
}
 
void Editor::InvalidateRange(Sci::Position start, Sci::Position end) {
    RedrawRect(RectangleFromRange(Range(start, end), view.LinesOverlap() ? vs.lineOverlap : 0));
}
 
Sci::Position Editor::CurrentPosition() const {
    return sel.MainCaret();
}
 
bool Editor::SelectionEmpty() const noexcept {
    return sel.Empty();
}
 
SelectionPosition Editor::SelectionStart() {
    return sel.RangeMain().Start();
}
 
SelectionPosition Editor::SelectionEnd() {
    return sel.RangeMain().End();
}
 
void Editor::SetRectangularRange() {
    if (sel.IsRectangular()) {
        const int xAnchor = XFromPosition(sel.Rectangular().anchor);
        int xCaret = XFromPosition(sel.Rectangular().caret);
        if (sel.selType == Selection::selThin) {
            xCaret = xAnchor;
        }
        const Sci::Line lineAnchorRect =
            pdoc->SciLineFromPosition(sel.Rectangular().anchor.Position());
        const Sci::Line lineCaret =
            pdoc->SciLineFromPosition(sel.Rectangular().caret.Position());
        const int increment = (lineCaret > lineAnchorRect) ? 1 : -1;
        AutoSurface surface(this);
        for (Sci::Line line=lineAnchorRect; line != lineCaret+increment; line += increment) {
            SelectionRange range(
                view.SPositionFromLineX(surface, *this, line, xCaret, vs),
                view.SPositionFromLineX(surface, *this, line, xAnchor, vs));
            if ((virtualSpaceOptions & SCVS_RECTANGULARSELECTION) == 0)
                range.ClearVirtualSpace();
            if (line == lineAnchorRect)
                sel.SetSelection(range);
            else
                sel.AddSelectionWithoutTrim(range);
        }
    }
}
 
void Editor::ThinRectangularRange() {
    if (sel.IsRectangular()) {
        sel.selType = Selection::selThin;
        if (sel.Rectangular().caret < sel.Rectangular().anchor) {
            sel.Rectangular() = SelectionRange(sel.Range(sel.Count()-1).caret, sel.Range(0).anchor);
        } else {
            sel.Rectangular() = SelectionRange(sel.Range(sel.Count()-1).anchor, sel.Range(0).caret);
        }
        SetRectangularRange();
    }
}
 
void Editor::InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection) {
    if (sel.Count() > 1 || !(sel.RangeMain().anchor == newMain.anchor) || sel.IsRectangular()) {
        invalidateWholeSelection = true;
    }
    Sci::Position firstAffected = std::min(sel.RangeMain().Start().Position(), newMain.Start().Position());
    // +1 for lastAffected ensures caret repainted
    Sci::Position lastAffected = std::max(newMain.caret.Position()+1, newMain.anchor.Position());
    lastAffected = std::max(lastAffected, sel.RangeMain().End().Position());
    if (invalidateWholeSelection) {
        for (size_t r=0; r<sel.Count(); r++) {
            firstAffected = std::min(firstAffected, sel.Range(r).caret.Position());
            firstAffected = std::min(firstAffected, sel.Range(r).anchor.Position());
            lastAffected = std::max(lastAffected, sel.Range(r).caret.Position()+1);
            lastAffected = std::max(lastAffected, sel.Range(r).anchor.Position());
        }
    }
    ContainerNeedsUpdate(SC_UPDATE_SELECTION);
    InvalidateRange(firstAffected, lastAffected);
}
 
void Editor::InvalidateWholeSelection() {
    InvalidateSelection(sel.RangeMain(), true);
}
 
/* For Line selection - the anchor and caret are always
   at the beginning and end of the region lines. */
SelectionRange Editor::LineSelectionRange(SelectionPosition currentPos_, SelectionPosition anchor_) const {
    if (currentPos_ > anchor_) {
        anchor_ = SelectionPosition(
            pdoc->LineStart(pdoc->LineFromPosition(anchor_.Position())));
        currentPos_ = SelectionPosition(
            pdoc->LineEnd(pdoc->LineFromPosition(currentPos_.Position())));
    } else {
        currentPos_ = SelectionPosition(
            pdoc->LineStart(pdoc->LineFromPosition(currentPos_.Position())));
        anchor_ = SelectionPosition(
            pdoc->LineEnd(pdoc->LineFromPosition(anchor_.Position())));
    }
    return SelectionRange(currentPos_, anchor_);
}
 
void Editor::SetSelection(SelectionPosition currentPos_, SelectionPosition anchor_) {
    currentPos_ = ClampPositionIntoDocument(currentPos_);
    anchor_ = ClampPositionIntoDocument(anchor_);
    const Sci::Line currentLine = pdoc->SciLineFromPosition(currentPos_.Position());
    SelectionRange rangeNew(currentPos_, anchor_);
    if (sel.selType == Selection::selLines) {
        rangeNew = LineSelectionRange(currentPos_, anchor_);
    }
    if (sel.Count() > 1 || !(sel.RangeMain() == rangeNew)) {
        InvalidateSelection(rangeNew);
    }
    sel.RangeMain() = rangeNew;
    SetRectangularRange();
    ClaimSelection();
    SetHoverIndicatorPosition(sel.MainCaret());
 
    if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
        RedrawSelMargin();
    }
    QueueIdleWork(WorkNeeded::workUpdateUI);
}
 
void Editor::SetSelection(Sci::Position currentPos_, Sci::Position anchor_) {
    SetSelection(SelectionPosition(currentPos_), SelectionPosition(anchor_));
}
 
// Just move the caret on the main selection
void Editor::SetSelection(SelectionPosition currentPos_) {
    currentPos_ = ClampPositionIntoDocument(currentPos_);
    const Sci::Line currentLine = pdoc->SciLineFromPosition(currentPos_.Position());
    if (sel.Count() > 1 || !(sel.RangeMain().caret == currentPos_)) {
        InvalidateSelection(SelectionRange(currentPos_));
    }
    if (sel.IsRectangular()) {
        sel.Rectangular() =
            SelectionRange(SelectionPosition(currentPos_), sel.Rectangular().anchor);
        SetRectangularRange();
    } else if (sel.selType == Selection::selLines) {
        sel.RangeMain() = LineSelectionRange(currentPos_, sel.RangeMain().anchor);
    } else {
        sel.RangeMain() =
            SelectionRange(SelectionPosition(currentPos_), sel.RangeMain().anchor);
    }
    ClaimSelection();
    SetHoverIndicatorPosition(sel.MainCaret());
 
    if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
        RedrawSelMargin();
    }
    QueueIdleWork(WorkNeeded::workUpdateUI);
}
 
void Editor::SetSelection(int currentPos_) {
    SetSelection(SelectionPosition(currentPos_));
}
 
void Editor::SetEmptySelection(SelectionPosition currentPos_) {
    const Sci::Line currentLine = pdoc->SciLineFromPosition(currentPos_.Position());
    SelectionRange rangeNew(ClampPositionIntoDocument(currentPos_));
    if (sel.Count() > 1 || !(sel.RangeMain() == rangeNew)) {
        InvalidateSelection(rangeNew);
    }
    sel.Clear();
    sel.RangeMain() = rangeNew;
    SetRectangularRange();
    ClaimSelection();
    SetHoverIndicatorPosition(sel.MainCaret());
 
    if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
        RedrawSelMargin();
    }
    QueueIdleWork(WorkNeeded::workUpdateUI);
}
 
void Editor::SetEmptySelection(Sci::Position currentPos_) {
    SetEmptySelection(SelectionPosition(currentPos_));
}
 
void Editor::MultipleSelectAdd(AddNumber addNumber) {
    if (SelectionEmpty() || !multipleSelection) {
        // Select word at caret
        const Sci::Position startWord = pdoc->ExtendWordSelect(sel.MainCaret(), -1, true);
        const Sci::Position endWord = pdoc->ExtendWordSelect(startWord, 1, true);
        TrimAndSetSelection(endWord, startWord);
 
    } else {
 
        if (!pdoc->HasCaseFolder())
            pdoc->SetCaseFolder(CaseFolderForEncoding());
 
        const Range rangeMainSelection(sel.RangeMain().Start().Position(), sel.RangeMain().End().Position());
        const std::string selectedText = RangeText(rangeMainSelection.start, rangeMainSelection.end);
 
        const Range rangeTarget(targetRange.start.Position(), targetRange.end.Position());
        std::vector<Range> searchRanges;
        // Search should be over the target range excluding the current selection so
        // may need to search 2 ranges, after the selection then before the selection.
        if (rangeTarget.Overlaps(rangeMainSelection)) {
            // Common case is that the selection is completely within the target but
            // may also have overlap at start or end.
            if (rangeMainSelection.end < rangeTarget.end)
                searchRanges.push_back(Range(rangeMainSelection.end, rangeTarget.end));
            if (rangeTarget.start < rangeMainSelection.start)
                searchRanges.push_back(Range(rangeTarget.start, rangeMainSelection.start));
        } else {
            // No overlap
            searchRanges.push_back(rangeTarget);
        }
 
        for (std::vector<Range>::const_iterator it = searchRanges.begin(); it != searchRanges.end(); ++it) {
            Sci::Position searchStart = it->start;
            const Sci::Position searchEnd = it->end;
            for (;;) {
                Sci::Position lengthFound = selectedText.length();
                const Sci::Position pos = pdoc->FindText(searchStart, searchEnd,
                    selectedText.c_str(), searchFlags, &lengthFound);
                if (pos >= 0) {
                    sel.AddSelection(SelectionRange(pos + lengthFound, pos));
                    ContainerNeedsUpdate(SC_UPDATE_SELECTION);
                    ScrollRange(sel.RangeMain());
                    Redraw();
                    if (addNumber == AddNumber::one)
                        return;
                    searchStart = pos + lengthFound;
                } else {
                    break;
                }
            }
        }
    }
}
 
bool Editor::RangeContainsProtected(Sci::Position start, Sci::Position end) const noexcept {
    if (vs.ProtectionActive()) {
        if (start > end) {
            const Sci::Position t = start;
            start = end;
            end = t;
        }
        for (Sci::Position pos = start; pos < end; pos++) {
            if (vs.styles[pdoc->StyleIndexAt(pos)].IsProtected())
                return true;
        }
    }
    return false;
}
 
bool Editor::SelectionContainsProtected() const {
    for (size_t r=0; r<sel.Count(); r++) {
        if (RangeContainsProtected(sel.Range(r).Start().Position(),
            sel.Range(r).End().Position())) {
            return true;
        }
    }
    return false;
}
 
/**
 * Asks document to find a good position and then moves out of any invisible positions.
 */
Sci::Position Editor::MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir, bool checkLineEnd) const {
    return MovePositionOutsideChar(SelectionPosition(pos), moveDir, checkLineEnd).Position();
}
 
SelectionPosition Editor::MovePositionOutsideChar(SelectionPosition pos, Sci::Position moveDir, bool checkLineEnd) const {
    const Sci::Position posMoved = pdoc->MovePositionOutsideChar(pos.Position(), moveDir, checkLineEnd);
    if (posMoved != pos.Position())
        pos.SetPosition(posMoved);
    if (vs.ProtectionActive()) {
        if (moveDir > 0) {
            if ((pos.Position() > 0) && vs.styles[pdoc->StyleIndexAt(pos.Position() - 1)].IsProtected()) {
                while ((pos.Position() < pdoc->Length()) &&
                        (vs.styles[pdoc->StyleIndexAt(pos.Position())].IsProtected()))
                    pos.Add(1);
            }
        } else if (moveDir < 0) {
            if (vs.styles[pdoc->StyleIndexAt(pos.Position())].IsProtected()) {
                while ((pos.Position() > 0) &&
                        (vs.styles[pdoc->StyleIndexAt(pos.Position() - 1)].IsProtected()))
                    pos.Add(-1);
            }
        }
    }
    return pos;
}
 
void Editor::MovedCaret(SelectionPosition newPos, SelectionPosition previousPos,
    bool ensureVisible, CaretPolicies policies) {
    const Sci::Line currentLine = pdoc->SciLineFromPosition(newPos.Position());
    if (ensureVisible) {
        // In case in need of wrapping to ensure DisplayFromDoc works.
        if (currentLine >= wrapPending.start) {
            if (WrapLines(WrapScope::wsAll)) {
                Redraw();
            }
        }
        const XYScrollPosition newXY = XYScrollToMakeVisible(
            SelectionRange(posDrag.IsValid() ? posDrag : newPos), xysDefault, policies);
        if (previousPos.IsValid() && (newXY.xOffset == xOffset)) {
            // simple vertical scroll then invalidate
            ScrollTo(newXY.topLine);
            InvalidateSelection(SelectionRange(previousPos), true);
        } else {
            SetXYScroll(newXY);
        }
    }
 
    ShowCaretAtCurrentPosition();
    NotifyCaretMove();
 
    ClaimSelection();
    SetHoverIndicatorPosition(sel.MainCaret());
    QueueIdleWork(WorkNeeded::workUpdateUI);
 
    if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
        RedrawSelMargin();
    }
}
 
void Editor::MovePositionTo(SelectionPosition newPos, Selection::selTypes selt, bool ensureVisible) {
    const SelectionPosition spCaret = ((sel.Count() == 1) && sel.Empty()) ?
        sel.Last() : SelectionPosition(INVALID_POSITION);
 
    const Sci::Position delta = newPos.Position() - sel.MainCaret();
    newPos = ClampPositionIntoDocument(newPos);
    newPos = MovePositionOutsideChar(newPos, delta);
    if (!multipleSelection && sel.IsRectangular() && (selt == Selection::selStream)) {
        // Can't turn into multiple selection so clear additional selections
        InvalidateSelection(SelectionRange(newPos), true);
        sel.DropAdditionalRanges();
    }
    if (!sel.IsRectangular() && (selt == Selection::selRectangle)) {
        // Switching to rectangular
        InvalidateSelection(sel.RangeMain(), false);
        SelectionRange rangeMain = sel.RangeMain();
        sel.Clear();
        sel.Rectangular() = rangeMain;
    }
    if (selt != Selection::noSel) {
        sel.selType = selt;
    }
    if (selt != Selection::noSel || sel.MoveExtends()) {
        SetSelection(newPos);
    } else {
        SetEmptySelection(newPos);
    }
 
    MovedCaret(newPos, spCaret, ensureVisible, caretPolicies);
}
 
void Editor::MovePositionTo(Sci::Position newPos, Selection::selTypes selt, bool ensureVisible) {
    MovePositionTo(SelectionPosition(newPos), selt, ensureVisible);
}
 
SelectionPosition Editor::MovePositionSoVisible(SelectionPosition pos, int moveDir) {
    pos = ClampPositionIntoDocument(pos);
    pos = MovePositionOutsideChar(pos, moveDir);
    const Sci::Line lineDoc = pdoc->SciLineFromPosition(pos.Position());
    if (pcs->GetVisible(lineDoc)) {
        return pos;
    } else {
        Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
        if (moveDir > 0) {
            // lineDisplay is already line before fold as lines in fold use display line of line after fold
            lineDisplay = Sci::clamp(lineDisplay, static_cast<Sci::Line>(0), pcs->LinesDisplayed());
            return SelectionPosition(
                pdoc->LineStart(pcs->DocFromDisplay(lineDisplay)));
        } else {
            lineDisplay = Sci::clamp(lineDisplay - 1, static_cast<Sci::Line>(0), pcs->LinesDisplayed());
            return SelectionPosition(
                pdoc->LineEnd(pcs->DocFromDisplay(lineDisplay)));
        }
    }
}
 
SelectionPosition Editor::MovePositionSoVisible(Sci::Position pos, int moveDir) {
    return MovePositionSoVisible(SelectionPosition(pos), moveDir);
}
 
Point Editor::PointMainCaret() {
    return LocationFromPosition(sel.Range(sel.Main()).caret);
}
 
/**
 * Choose the x position that the caret will try to stick to
 * as it moves up and down.
 */
void Editor::SetLastXChosen() {
    const Point pt = PointMainCaret();
    lastXChosen = static_cast<int>(pt.x) + xOffset;
}
 
void Editor::ScrollTo(Sci::Line line, bool moveThumb) {
    const Sci::Line topLineNew = Sci::clamp(line, static_cast<Sci::Line>(0), MaxScrollPos());
    if (topLineNew != topLine) {
        // Try to optimise small scrolls
#ifndef UNDER_CE
        const Sci::Line linesToMove = topLine - topLineNew;
        const bool performBlit = (std::abs(linesToMove) <= 10) && (paintState == notPainting);
        willRedrawAll = !performBlit;
#endif
        SetTopLine(topLineNew);
        // Optimize by styling the view as this will invalidate any needed area
        // which could abort the initial paint if discovered later.
        StyleAreaBounded(GetClientRectangle(), true);
#ifndef UNDER_CE
        // Perform redraw rather than scroll if many lines would be redrawn anyway.
        if (performBlit) {
            ScrollText(linesToMove);
        } else {
            Redraw();
        }
        willRedrawAll = false;
#else
        Redraw();
#endif
        if (moveThumb) {
            SetVerticalScrollPos();
        }
    }
}
 
void Editor::ScrollText(Sci::Line /* linesToMove */) {
    //Platform::DebugPrintf("Editor::ScrollText %d\n", linesToMove);
    Redraw();
}
 
void Editor::HorizontalScrollTo(int xPos) {
    //Platform::DebugPrintf("HorizontalScroll %d\n", xPos);
    if (xPos < 0)
        xPos = 0;
    if (!Wrapping() && (xOffset != xPos)) {
        xOffset = xPos;
        ContainerNeedsUpdate(SC_UPDATE_H_SCROLL);
        SetHorizontalScrollPos();
        RedrawRect(GetClientRectangle());
    }
}
 
void Editor::VerticalCentreCaret() {
    const Sci::Line lineDoc =
        pdoc->SciLineFromPosition(sel.IsRectangular() ? sel.Rectangular().caret.Position() : sel.MainCaret());
    const Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
    const Sci::Line newTop = lineDisplay - (LinesOnScreen() / 2);
    if (topLine != newTop) {
        SetTopLine(newTop > 0 ? newTop : 0);
        RedrawRect(GetClientRectangle());
    }
}
 
void Editor::MoveSelectedLines(int lineDelta) {
 
    if (sel.IsRectangular()) {
        return;
    }
 
    // if selection doesn't start at the beginning of the line, set the new start
    Sci::Position selectionStart = SelectionStart().Position();
    const Sci::Line startLine = pdoc->SciLineFromPosition(selectionStart);
    const Sci::Position beginningOfStartLine = pdoc->LineStart(startLine);
    selectionStart = beginningOfStartLine;
 
    // if selection doesn't end at the beginning of a line greater than that of the start,
    // then set it at the beginning of the next one
    Sci::Position selectionEnd = SelectionEnd().Position();
    const Sci::Line endLine = pdoc->SciLineFromPosition(selectionEnd);
    const Sci::Position beginningOfEndLine = pdoc->LineStart(endLine);
    bool appendEol = false;
    if (selectionEnd > beginningOfEndLine
        || selectionStart == selectionEnd) {
        selectionEnd = pdoc->LineStart(endLine + 1);
        appendEol = (selectionEnd == pdoc->Length() && pdoc->SciLineFromPosition(selectionEnd) == endLine);
    }
 
    // if there's nowhere for the selection to move
    // (i.e. at the beginning going up or at the end going down),
    // stop it right there!
    if ((selectionStart == 0 && lineDelta < 0)
        || (selectionEnd == pdoc->Length() && lineDelta > 0)
            || selectionStart == selectionEnd) {
        return;
    }
 
    UndoGroup ug(pdoc);
 
    if (lineDelta > 0 && selectionEnd == pdoc->LineStart(pdoc->LinesTotal() - 1)) {
        SetSelection(pdoc->MovePositionOutsideChar(selectionEnd - 1, -1), selectionEnd);
        ClearSelection();
        selectionEnd = CurrentPosition();
    }
    SetSelection(selectionStart, selectionEnd);
 
    SelectionText selectedText;
    CopySelectionRange(&selectedText);
 
    const Point currentLocation = LocationFromPosition(CurrentPosition());
    const Sci::Line currentLine = LineFromLocation(currentLocation);
 
    if (appendEol)
        SetSelection(pdoc->MovePositionOutsideChar(selectionStart - 1, -1), selectionEnd);
    ClearSelection();
 
    const char *eol = StringFromEOLMode(pdoc->eolMode);
    if (currentLine + lineDelta >= pdoc->LinesTotal())
        pdoc->InsertString(pdoc->Length(), eol, strlen(eol));
    GoToLine(currentLine + lineDelta);
 
    Sci::Position selectionLength = pdoc->InsertString(CurrentPosition(), selectedText.Data(), selectedText.Length());
    if (appendEol) {
        const Sci::Position lengthInserted = pdoc->InsertString(CurrentPosition() + selectionLength, eol, strlen(eol));
        selectionLength += lengthInserted;
    }
    SetSelection(CurrentPosition(), CurrentPosition() + selectionLength);
}
 
void Editor::MoveSelectedLinesUp() {
    MoveSelectedLines(-1);
}
 
void Editor::MoveSelectedLinesDown() {
    MoveSelectedLines(1);
}
 
void Editor::MoveCaretInsideView(bool ensureVisible) {
    const PRectangle rcClient = GetTextRectangle();
    const Point pt = PointMainCaret();
    if (pt.y < rcClient.top) {
        MovePositionTo(SPositionFromLocation(
                    Point::FromInts(lastXChosen - xOffset, static_cast<int>(rcClient.top)),
                    false, false, UserVirtualSpace()),
                    Selection::noSel, ensureVisible);
    } else if ((pt.y + vs.lineHeight - 1) > rcClient.bottom) {
        const ptrdiff_t yOfLastLineFullyDisplayed = static_cast<ptrdiff_t>(rcClient.top) + (LinesOnScreen() - 1) * vs.lineHeight;
        MovePositionTo(SPositionFromLocation(
                    Point::FromInts(lastXChosen - xOffset, static_cast<int>(rcClient.top + yOfLastLineFullyDisplayed)),
                    false, false, UserVirtualSpace()),
                Selection::noSel, ensureVisible);
    }
}
 
Sci::Line Editor::DisplayFromPosition(Sci::Position pos) {
    AutoSurface surface(this);
    return view.DisplayFromPosition(surface, *this, pos, vs);
}
 
/**
 * Ensure the caret is reasonably visible in context.
 *
Caret policy in Scintilla
 
If slop is set, we can define a slop value.
This value defines an unwanted zone (UZ) where the caret is... unwanted.
This zone is defined as a number of pixels near the vertical margins,
and as a number of lines near the horizontal margins.
By keeping the caret away from the edges, it is seen within its context,
so it is likely that the identifier that the caret is on can be completely seen,
and that the current line is seen with some of the lines following it which are
often dependent on that line.
 
If strict is set, the policy is enforced... strictly.
The caret is centred on the display if slop is not set,
and cannot go in the UZ if slop is set.
 
If jumps is set, the display is moved more energetically
so the caret can move in the same direction longer before the policy is applied again.
'3UZ' notation is used to indicate three time the size of the UZ as a distance to the margin.
 
If even is not set, instead of having symmetrical UZs,
the left and bottom UZs are extended up to right and top UZs respectively.
This way, we favour the displaying of useful information: the beginning of lines,
where most code reside, and the lines after the caret, eg. the body of a function.
 
     |        |       |      |                                            |
slop | strict | jumps | even | Caret can go to the margin                 | When reaching limit (caret going out of
     |        |       |      |                                            | visibility or going into the UZ) display is...
-----+--------+-------+------+--------------------------------------------+--------------------------------------------------------------
  0  |   0    |   0   |   0  | Yes                                        | moved to put caret on top/on right
  0  |   0    |   0   |   1  | Yes                                        | moved by one position
  0  |   0    |   1   |   0  | Yes                                        | moved to put caret on top/on right
  0  |   0    |   1   |   1  | Yes                                        | centred on the caret
  0  |   1    |   -   |   0  | Caret is always on top/on right of display | -
  0  |   1    |   -   |   1  | No, caret is always centred                | -
  1  |   0    |   0   |   0  | Yes                                        | moved to put caret out of the asymmetrical UZ
  1  |   0    |   0   |   1  | Yes                                        | moved to put caret out of the UZ
  1  |   0    |   1   |   0  | Yes                                        | moved to put caret at 3UZ of the top or right margin
  1  |   0    |   1   |   1  | Yes                                        | moved to put caret at 3UZ of the margin
  1  |   1    |   -   |   0  | Caret is always at UZ of top/right margin  | -
  1  |   1    |   0   |   1  | No, kept out of UZ                         | moved by one position
  1  |   1    |   1   |   1  | No, kept out of UZ                         | moved to put caret at 3UZ of the margin
*/
 
Editor::XYScrollPosition Editor::XYScrollToMakeVisible(const SelectionRange &range,
    const XYScrollOptions options, CaretPolicies policies) {
    const PRectangle rcClient = GetTextRectangle();
    const Point ptOrigin = GetVisibleOriginInMain();
    const Point pt = LocationFromPosition(range.caret) + ptOrigin;
    const Point ptAnchor = LocationFromPosition(range.anchor) + ptOrigin;
    const Point ptBottomCaret(pt.x, pt.y + vs.lineHeight - 1);
 
    XYScrollPosition newXY(xOffset, topLine);
    if (rcClient.Empty()) {
        return newXY;
    }
 
    // Vertical positioning
    if ((options & xysVertical) && (pt.y < rcClient.top || ptBottomCaret.y >= rcClient.bottom || (policies.y.policy & CARET_STRICT) != 0)) {
        const Sci::Line lineCaret = DisplayFromPosition(range.caret.Position());
        const Sci::Line linesOnScreen = LinesOnScreen();
        const Sci::Line halfScreen = std::max(linesOnScreen - 1, static_cast<Sci::Line>(2)) / 2;
        const bool bSlop = (policies.y.policy & CARET_SLOP) != 0;
        const bool bStrict = (policies.y.policy & CARET_STRICT) != 0;
        const bool bJump = (policies.y.policy & CARET_JUMPS) != 0;
        const bool bEven = (policies.y.policy & CARET_EVEN) != 0;
 
        // It should be possible to scroll the window to show the caret,
        // but this fails to remove the caret on GTK+
        if (bSlop) {    // A margin is defined
            Sci::Line yMoveT, yMoveB;
            if (bStrict) {
                Sci::Line yMarginT, yMarginB;
                if (!(options & xysUseMargin)) {
                    // In drag mode, avoid moves
                    // otherwise, a double click will select several lines.
                    yMarginT = yMarginB = 0;
                } else {
                    // yMarginT must equal to caretYSlop, with a minimum of 1 and
                    // a maximum of slightly less than half the height of the text area.
                    yMarginT = Sci::clamp(static_cast<Sci::Line>(policies.y.slop), static_cast<Sci::Line>(1), halfScreen);
                    if (bEven) {
                        yMarginB = yMarginT;
                    } else {
                        yMarginB = linesOnScreen - yMarginT - 1;
                    }
                }
                yMoveT = yMarginT;
                if (bEven) {
                    if (bJump) {
                        yMoveT = Sci::clamp(static_cast<Sci::Line>(policies.y.slop * 3), static_cast<Sci::Line>(1), halfScreen);
                    }
                    yMoveB = yMoveT;
                } else {
                    yMoveB = linesOnScreen - yMoveT - 1;
                }
                if (lineCaret < topLine + yMarginT) {
                    // Caret goes too high
                    newXY.topLine = lineCaret - yMoveT;
                } else if (lineCaret > topLine + linesOnScreen - 1 - yMarginB) {
                    // Caret goes too low
                    newXY.topLine = lineCaret - linesOnScreen + 1 + yMoveB;
                }
            } else {    // Not strict
                yMoveT = bJump ? policies.y.slop * 3 : policies.y.slop;
                yMoveT = Sci::clamp(yMoveT, static_cast<Sci::Line>(1), halfScreen);
                if (bEven) {
                    yMoveB = yMoveT;
                } else {
                    yMoveB = linesOnScreen - yMoveT - 1;
                }
                if (lineCaret < topLine) {
                    // Caret goes too high
                    newXY.topLine = lineCaret - yMoveT;
                } else if (lineCaret > topLine + linesOnScreen - 1) {
                    // Caret goes too low
                    newXY.topLine = lineCaret - linesOnScreen + 1 + yMoveB;
                }
            }
        } else {    // No slop
            if (!bStrict && !bJump) {
                // Minimal move
                if (lineCaret < topLine) {
                    // Caret goes too high
                    newXY.topLine = lineCaret;
                } else if (lineCaret > topLine + linesOnScreen - 1) {
                    // Caret goes too low
                    if (bEven) {
                        newXY.topLine = lineCaret - linesOnScreen + 1;
                    } else {
                        newXY.topLine = lineCaret;
                    }
                }
            } else {    // Strict or going out of display
                if (bEven) {
                    // Always centre caret
                    newXY.topLine = lineCaret - halfScreen;
                } else {
                    // Always put caret on top of display
                    newXY.topLine = lineCaret;
                }
            }
        }
        if (!(range.caret == range.anchor)) {
            const Sci::Line lineAnchor = DisplayFromPosition(range.anchor.Position());
            if (lineAnchor < lineCaret) {
                // Shift up to show anchor or as much of range as possible
                newXY.topLine = std::min(newXY.topLine, lineAnchor);
                newXY.topLine = std::max(newXY.topLine, lineCaret - LinesOnScreen());
            } else {
                // Shift down to show anchor or as much of range as possible
                newXY.topLine = std::max(newXY.topLine, lineAnchor - LinesOnScreen());
                newXY.topLine = std::min(newXY.topLine, lineCaret);
            }
        }
        newXY.topLine = Sci::clamp(newXY.topLine, static_cast<Sci::Line>(0), MaxScrollPos());
    }
 
    // Horizontal positioning
    if ((options & xysHorizontal) && !Wrapping()) {
        const int halfScreen = std::max(static_cast<int>(rcClient.Width()) - 4, 4) / 2;
        const bool bSlop = (policies.x.policy & CARET_SLOP) != 0;
        const bool bStrict = (policies.x.policy & CARET_STRICT) != 0;
        const bool bJump = (policies.x.policy & CARET_JUMPS) != 0;
        const bool bEven = (policies.x.policy & CARET_EVEN) != 0;
 
        if (bSlop) {    // A margin is defined
            int xMoveL, xMoveR;
            if (bStrict) {
                int xMarginL, xMarginR;
                if (!(options & xysUseMargin)) {
                    // In drag mode, avoid moves unless very near of the margin
                    // otherwise, a simple click will select text.
                    xMarginL = xMarginR = 2;
                } else {
                    // xMargin must equal to caretXSlop, with a minimum of 2 and
                    // a maximum of slightly less than half the width of the text area.
                    xMarginR = Sci::clamp(policies.x.slop, 2, halfScreen);
                    if (bEven) {
                        xMarginL = xMarginR;
                    } else {
                        xMarginL = static_cast<int>(rcClient.Width()) - xMarginR - 4;
                    }
                }
                if (bJump && bEven) {
                    // Jump is used only in even mode
                    xMoveL = xMoveR = Sci::clamp(policies.x.slop * 3, 1, halfScreen);
                } else {
                    xMoveL = xMoveR = 0;    // Not used, avoid a warning
                }
                if (pt.x < rcClient.left + xMarginL) {
                    // Caret is on the left of the display
                    if (bJump && bEven) {
                        newXY.xOffset -= xMoveL;
                    } else {
                        // Move just enough to allow to display the caret
                        newXY.xOffset -= static_cast<int>((rcClient.left + xMarginL) - pt.x);
                    }
                } else if (pt.x >= rcClient.right - xMarginR) {
                    // Caret is on the right of the display
                    if (bJump && bEven) {
                        newXY.xOffset += xMoveR;
                    } else {
                        // Move just enough to allow to display the caret
                        newXY.xOffset += static_cast<int>(pt.x - (rcClient.right - xMarginR) + 1);
                    }
                }
            } else {    // Not strict
                xMoveR = bJump ? policies.x.slop * 3 : policies.x.slop;
                xMoveR = Sci::clamp(xMoveR, 1, halfScreen);
                if (bEven) {
                    xMoveL = xMoveR;
                } else {
                    xMoveL = static_cast<int>(rcClient.Width()) - xMoveR - 4;
                }
                if (pt.x < rcClient.left) {
                    // Caret is on the left of the display
                    newXY.xOffset -= xMoveL;
                } else if (pt.x >= rcClient.right) {
                    // Caret is on the right of the display
                    newXY.xOffset += xMoveR;
                }
            }
        } else {    // No slop
            if (bStrict ||
                    (bJump && (pt.x < rcClient.left || pt.x >= rcClient.right))) {
                // Strict or going out of display
                if (bEven) {
                    // Centre caret
                    newXY.xOffset += static_cast<int>(pt.x - rcClient.left - halfScreen);
                } else {
                    // Put caret on right
                    newXY.xOffset += static_cast<int>(pt.x - rcClient.right + 1);
                }
            } else {
                // Move just enough to allow to display the caret
                if (pt.x < rcClient.left) {
                    // Caret is on the left of the display
                    if (bEven) {
                        newXY.xOffset -= static_cast<int>(rcClient.left - pt.x);
                    } else {
                        newXY.xOffset += static_cast<int>(pt.x - rcClient.right) + 1;
                    }
                } else if (pt.x >= rcClient.right) {
                    // Caret is on the right of the display
                    newXY.xOffset += static_cast<int>(pt.x - rcClient.right) + 1;
                }
            }
        }
        // In case of a jump (find result) largely out of display, adjust the offset to display the caret
        if (pt.x + xOffset < rcClient.left + newXY.xOffset) {
            newXY.xOffset = static_cast<int>(pt.x + xOffset - rcClient.left) - 2;
        } else if (pt.x + xOffset >= rcClient.right + newXY.xOffset) {
            newXY.xOffset = static_cast<int>(pt.x + xOffset - rcClient.right) + 2;
            if (vs.IsBlockCaretStyle() || view.imeCaretBlockOverride) {
                // Ensure we can see a good portion of the block caret
                newXY.xOffset += static_cast<int>(vs.aveCharWidth);
            }
        }
        if (!(range.caret == range.anchor)) {
            if (ptAnchor.x < pt.x) {
                // Shift to left to show anchor or as much of range as possible
                const int maxOffset = static_cast<int>(ptAnchor.x + xOffset - rcClient.left) - 1;
                const int minOffset = static_cast<int>(pt.x + xOffset - rcClient.right) + 1;
                newXY.xOffset = std::min(newXY.xOffset, maxOffset);
                newXY.xOffset = std::max(newXY.xOffset, minOffset);
            } else {
                // Shift to right to show anchor or as much of range as possible
                const int minOffset = static_cast<int>(ptAnchor.x + xOffset - rcClient.right) + 1;
                const int maxOffset = static_cast<int>(pt.x + xOffset - rcClient.left) - 1;
                newXY.xOffset = std::max(newXY.xOffset, minOffset);
                newXY.xOffset = std::min(newXY.xOffset, maxOffset);
            }
        }
        if (newXY.xOffset < 0) {
            newXY.xOffset = 0;
        }
    }
 
    return newXY;
}
 
void Editor::SetXYScroll(XYScrollPosition newXY) {
    if ((newXY.topLine != topLine) || (newXY.xOffset != xOffset)) {
        if (newXY.topLine != topLine) {
            SetTopLine(newXY.topLine);
            SetVerticalScrollPos();
        }
        if (newXY.xOffset != xOffset) {
            xOffset = newXY.xOffset;
            ContainerNeedsUpdate(SC_UPDATE_H_SCROLL);
            if (newXY.xOffset > 0) {
                const PRectangle rcText = GetTextRectangle();
                if (horizontalScrollBarVisible &&
                    rcText.Width() + xOffset > scrollWidth) {
                    scrollWidth = xOffset + static_cast<int>(rcText.Width());
                    SetScrollBars();
                }
            }
            SetHorizontalScrollPos();
        }
        Redraw();
        UpdateSystemCaret();
    }
}
 
void Editor::ScrollRange(SelectionRange range) {
    SetXYScroll(XYScrollToMakeVisible(range, xysDefault, caretPolicies));
}
 
void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
    SetXYScroll(XYScrollToMakeVisible(SelectionRange(posDrag.IsValid() ? posDrag : sel.RangeMain().caret),
        static_cast<XYScrollOptions>((useMargin?xysUseMargin:0)|(vert?xysVertical:0)|(horiz?xysHorizontal:0)),
        caretPolicies));
}
 
void Editor::ShowCaretAtCurrentPosition() {
    if (hasFocus) {
        caret.active = true;
        caret.on = true;
        FineTickerCancel(tickCaret);
        if (caret.period > 0)
            FineTickerStart(tickCaret, caret.period, caret.period/10);
    } else {
        caret.active = false;
        caret.on = false;
        FineTickerCancel(tickCaret);
    }
    InvalidateCaret();
}
 
void Editor::DropCaret() {
    caret.active = false;
    FineTickerCancel(tickCaret);
    InvalidateCaret();
}
 
void Editor::CaretSetPeriod(int period) {
    if (caret.period != period) {
        caret.period = period;
        caret.on = true;
        FineTickerCancel(tickCaret);
        if ((caret.active) && (caret.period > 0))
            FineTickerStart(tickCaret, caret.period, caret.period/10);
        InvalidateCaret();
    }
}
 
void Editor::InvalidateCaret() {
    if (posDrag.IsValid()) {
        InvalidateRange(posDrag.Position(), posDrag.Position() + 1);
    } else {
        for (size_t r=0; r<sel.Count(); r++) {
            InvalidateRange(sel.Range(r).caret.Position(), sel.Range(r).caret.Position() + 1);
        }
    }
    UpdateSystemCaret();
}
 
void Editor::NotifyCaretMove() {
}
 
void Editor::UpdateSystemCaret() {
}
 
bool Editor::Wrapping() const noexcept {
    return vs.wrapState != WrapMode::none;
}
 
void Editor::NeedWrapping(Sci::Line docLineStart, Sci::Line docLineEnd) {
//Platform::DebugPrintf("\nNeedWrapping: %0d..%0d\n", docLineStart, docLineEnd);
    if (wrapPending.AddRange(docLineStart, docLineEnd)) {
        view.llc.Invalidate(LineLayout::ValidLevel::positions);
    }
    // Wrap lines during idle.
    if (Wrapping() && wrapPending.NeedsWrap()) {
        SetIdle(true);
    }
}
 
bool Editor::WrapOneLine(Surface *surface, Sci::Line lineToWrap) {
    AutoLineLayout ll(view.llc, view.RetrieveLineLayout(lineToWrap, *this));
    int linesWrapped = 1;
    if (ll) {
        view.LayoutLine(*this, lineToWrap, surface, vs, ll, wrapWidth);
        linesWrapped = ll->lines;
    }
    return pcs->SetHeight(lineToWrap, linesWrapped +
        (vs.annotationVisible ? pdoc->AnnotationLines(lineToWrap) : 0));
}
 
// Perform  wrapping for a subset of the lines needing wrapping.
// wsAll: wrap all lines which need wrapping in this single call
// wsVisible: wrap currently visible lines
// wsIdle: wrap one page + 100 lines
// Return true if wrapping occurred.
bool Editor::WrapLines(WrapScope ws) {
    Sci::Line goodTopLine = topLine;
    bool wrapOccurred = false;
    if (!Wrapping()) {
        if (wrapWidth != LineLayout::wrapWidthInfinite) {
            wrapWidth = LineLayout::wrapWidthInfinite;
            for (Sci::Line lineDoc = 0; lineDoc < pdoc->LinesTotal(); lineDoc++) {
                pcs->SetHeight(lineDoc, 1 +
                    (vs.annotationVisible ? pdoc->AnnotationLines(lineDoc) : 0));
            }
            wrapOccurred = true;
        }
        wrapPending.Reset();
 
    } else if (wrapPending.NeedsWrap()) {
        wrapPending.start = std::min(wrapPending.start, pdoc->LinesTotal());
        if (!SetIdle(true)) {
            // Idle processing not supported so full wrap required.
            ws = WrapScope::wsAll;
        }
        // Decide where to start wrapping
        Sci::Line lineToWrap = wrapPending.start;
        Sci::Line lineToWrapEnd = std::min(wrapPending.end, pdoc->LinesTotal());
        const Sci::Line lineDocTop = pcs->DocFromDisplay(topLine);
        const Sci::Line subLineTop = topLine - pcs->DisplayFromDoc(lineDocTop);
        if (ws == WrapScope::wsVisible) {
            lineToWrap = Sci::clamp(lineDocTop-5, wrapPending.start, pdoc->LinesTotal());
            // Priority wrap to just after visible area.
            // Since wrapping could reduce display lines, treat each
            // as taking only one display line.
            lineToWrapEnd = lineDocTop;
            Sci::Line lines = LinesOnScreen() + 1;
            while ((lineToWrapEnd < pcs->LinesInDoc()) && (lines>0)) {
                if (pcs->GetVisible(lineToWrapEnd))
                    lines--;
                lineToWrapEnd++;
            }
            // .. and if the paint window is outside pending wraps
            if ((lineToWrap > wrapPending.end) || (lineToWrapEnd < wrapPending.start)) {
                // Currently visible text does not need wrapping
                return false;
            }
        } else if (ws == WrapScope::wsIdle) {
            // Try to keep time taken by wrapping reasonable so interaction remains smooth.
            constexpr double secondsAllowed = 0.01;
            const Sci::Line linesInAllowedTime = Sci::clamp(
                static_cast<Sci::Line>(secondsAllowed / durationWrapOneLine.Duration()),
                LinesOnScreen() + 50, static_cast<Sci::Line>(0x10000));
            lineToWrapEnd = lineToWrap + linesInAllowedTime;
        }
        const Sci::Line lineEndNeedWrap = std::min(wrapPending.end, pdoc->LinesTotal());
        lineToWrapEnd = std::min(lineToWrapEnd, lineEndNeedWrap);
 
        // Ensure all lines being wrapped are styled.
        pdoc->EnsureStyledTo(pdoc->LineStart(lineToWrapEnd));
 
        if (lineToWrap < lineToWrapEnd) {
 
            PRectangle rcTextArea = GetClientRectangle();
            rcTextArea.left = static_cast<XYPOSITION>(vs.textStart);
            rcTextArea.right -= vs.rightMarginWidth;
            wrapWidth = static_cast<int>(rcTextArea.Width());
            RefreshStyleData();
            AutoSurface surface(this);
            if (surface) {
//Platform::DebugPrintf("Wraplines: scope=%0d need=%0d..%0d perform=%0d..%0d\n", ws, wrapPending.start, wrapPending.end, lineToWrap, lineToWrapEnd);
 
                const Sci::Line linesBeingWrapped = lineToWrapEnd - lineToWrap;
                ElapsedPeriod epWrapping;
                while (lineToWrap < lineToWrapEnd) {
                    if (WrapOneLine(surface, lineToWrap)) {
                        wrapOccurred = true;
                    }
                    wrapPending.Wrapped(lineToWrap);
                    lineToWrap++;
                }
                durationWrapOneLine.AddSample(linesBeingWrapped, epWrapping.Duration());
 
                goodTopLine = pcs->DisplayFromDoc(lineDocTop) + std::min(
                    subLineTop, static_cast<Sci::Line>(pcs->GetHeight(lineDocTop)-1));
            }
        }
 
        // If wrapping is done, bring it to resting position
        if (wrapPending.start >= lineEndNeedWrap) {
            wrapPending.Reset();
        }
    }
 
    if (wrapOccurred) {
        SetScrollBars();
        SetTopLine(Sci::clamp(goodTopLine, static_cast<Sci::Line>(0), MaxScrollPos()));
        SetVerticalScrollPos();
    }
 
    return wrapOccurred;
}
 
void Editor::LinesJoin() {
    if (!RangeContainsProtected(targetRange.start.Position(), targetRange.end.Position())) {
        UndoGroup ug(pdoc);
        bool prevNonWS = true;
        for (Sci::Position pos = targetRange.start.Position(); pos < targetRange.end.Position(); pos++) {
            if (pdoc->IsPositionInLineEnd(pos)) {
                targetRange.end.Add(-pdoc->LenChar(pos));
                pdoc->DelChar(pos);
                if (prevNonWS) {
                    // Ensure at least one space separating previous lines
                    const Sci::Position lengthInserted = pdoc->InsertString(pos, " ", 1);
                    targetRange.end.Add(lengthInserted);
                }
            } else {
                prevNonWS = pdoc->CharAt(pos) != ' ';
            }
        }
    }
}
 
const char *Editor::StringFromEOLMode(int eolMode) noexcept {
    if (eolMode == SC_EOL_CRLF) {
        return "\r\n";
    } else if (eolMode == SC_EOL_CR) {
        return "\r";
    } else {
        return "\n";
    }
}
 
void Editor::LinesSplit(int pixelWidth) {
    if (!RangeContainsProtected(targetRange.start.Position(), targetRange.end.Position())) {
        if (pixelWidth == 0) {
            const PRectangle rcText = GetTextRectangle();
            pixelWidth = static_cast<int>(rcText.Width());
        }
        const Sci::Line lineStart = pdoc->SciLineFromPosition(targetRange.start.Position());
        Sci::Line lineEnd = pdoc->SciLineFromPosition(targetRange.end.Position());
        const char *eol = StringFromEOLMode(pdoc->eolMode);
        UndoGroup ug(pdoc);
        for (Sci::Line line = lineStart; line <= lineEnd; line++) {
            AutoSurface surface(this);
            AutoLineLayout ll(view.llc, view.RetrieveLineLayout(line, *this));
            if (surface && ll) {
                const Sci::Position posLineStart = pdoc->LineStart(line);
                view.LayoutLine(*this, line, surface, vs, ll, pixelWidth);
                Sci::Position lengthInsertedTotal = 0;
                for (int subLine = 1; subLine < ll->lines; subLine++) {
                    const Sci::Position lengthInserted = pdoc->InsertString(
                        posLineStart + lengthInsertedTotal + ll->LineStart(subLine),
                        eol, strlen(eol));
                    targetRange.end.Add(lengthInserted);
                    lengthInsertedTotal += lengthInserted;
                }
            }
            lineEnd = pdoc->SciLineFromPosition(targetRange.end.Position());
        }
    }
}
 
void Editor::PaintSelMargin(Surface *surfaceWindow, const PRectangle &rc) {
    if (vs.fixedColumnWidth == 0)
        return;
 
    AllocateGraphics();
    RefreshStyleData();
    RefreshPixMaps(surfaceWindow);
 
    // On GTK+ with Ubuntu overlay scroll bars, the surface may have been finished
    // at this point. The Initialised call checks for this case and sets the status
    // to be bad which avoids crashes in following calls.
    if (!surfaceWindow->Initialised()) {
        return;
    }
 
    PRectangle rcMargin = GetClientRectangle();
    const Point ptOrigin = GetVisibleOriginInMain();
    rcMargin.Move(0, -ptOrigin.y);
    rcMargin.left = 0;
    rcMargin.right = static_cast<XYPOSITION>(vs.fixedColumnWidth);
 
    if (!rc.Intersects(rcMargin))
        return;
 
    Surface *surface;
    if (view.bufferedDraw) {
        surface = marginView.pixmapSelMargin.get();
    } else {
        surface = surfaceWindow;
    }
 
    // Clip vertically to paint area to avoid drawing line numbers
    if (rcMargin.bottom > rc.bottom)
        rcMargin.bottom = rc.bottom;
    if (rcMargin.top < rc.top)
        rcMargin.top = rc.top;
 
    marginView.PaintMargin(surface, topLine, rc, rcMargin, *this, vs);
 
    if (view.bufferedDraw) {
        surfaceWindow->Copy(rcMargin, Point(rcMargin.left, rcMargin.top), *marginView.pixmapSelMargin);
    }
}
 
void Editor::RefreshPixMaps(Surface *surfaceWindow) {
    view.RefreshPixMaps(surfaceWindow, wMain.GetID(), vs);
    marginView.RefreshPixMaps(surfaceWindow, wMain.GetID(), vs);
    if (view.bufferedDraw) {
        const PRectangle rcClient = GetClientRectangle();
        if (!view.pixmapLine->Initialised()) {
 
            view.pixmapLine->InitPixMap(static_cast<int>(rcClient.Width()), vs.lineHeight,
                    surfaceWindow, wMain.GetID());
        }
        if (!marginView.pixmapSelMargin->Initialised()) {
            marginView.pixmapSelMargin->InitPixMap(vs.fixedColumnWidth,
                static_cast<int>(rcClient.Height()), surfaceWindow, wMain.GetID());
        }
    }
}
 
void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
    //Platform::DebugPrintf("Paint:%1d (%3d,%3d) ... (%3d,%3d)\n",
    //  paintingAllText, rcArea.left, rcArea.top, rcArea.right, rcArea.bottom);
    AllocateGraphics();
 
    RefreshStyleData();
    if (paintState == paintAbandoned)
        return; // Scroll bars may have changed so need redraw
    RefreshPixMaps(surfaceWindow);
 
    paintAbandonedByStyling = false;
 
    StyleAreaBounded(rcArea, false);
 
    const PRectangle rcClient = GetClientRectangle();
    //Platform::DebugPrintf("Client: (%3d,%3d) ... (%3d,%3d)   %d\n",
    //  rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
 
    if (NotifyUpdateUI()) {
        RefreshStyleData();
        RefreshPixMaps(surfaceWindow);
    }
 
    // Wrap the visible lines if needed.
    if (WrapLines(WrapScope::wsVisible)) {
        // The wrapping process has changed the height of some lines so
        // abandon this paint for a complete repaint.
        if (AbandonPaint()) {
            return;
        }
        RefreshPixMaps(surfaceWindow);  // In case pixmaps invalidated by scrollbar change
    }
 
    if (!marginView.pixmapSelPattern->Initialised()) {
        // When Direct2D is used, pixmap creation may fail with D2DERR_RECREATE_TARGET so
        // abandon this paint to avoid further failures.
        // Main drawing surface and pixmaps should be recreated by next paint.
        return;
    }
 
    if (!view.bufferedDraw)
        surfaceWindow->SetClip(rcArea);
 
    if (paintState != paintAbandoned) {
        if (vs.marginInside) {
            PaintSelMargin(surfaceWindow, rcArea);
            PRectangle rcRightMargin = rcClient;
            rcRightMargin.left = rcRightMargin.right - vs.rightMarginWidth;
            if (rcArea.Intersects(rcRightMargin)) {
                surfaceWindow->FillRectangle(rcRightMargin, vs.styles[STYLE_DEFAULT].back);
            }
        } else { // Else separate view so separate paint event but leftMargin included to allow overlap
            PRectangle rcLeftMargin = rcArea;
            rcLeftMargin.left = 0;
            rcLeftMargin.right = rcLeftMargin.left + vs.leftMarginWidth;
            if (rcArea.Intersects(rcLeftMargin)) {
                surfaceWindow->FillRectangle(rcLeftMargin, vs.styles[STYLE_DEFAULT].back);
            }
        }
    }
 
    if (paintState == paintAbandoned) {
        // Either styling or NotifyUpdateUI noticed that painting is needed
        // outside the current painting rectangle
        //Platform::DebugPrintf("Abandoning paint\n");
        if (Wrapping()) {
            if (paintAbandonedByStyling) {
                // Styling has spilled over a line end, such as occurs by starting a multiline
                // comment. The width of subsequent text may have changed, so rewrap.
                NeedWrapping(pcs->DocFromDisplay(topLine));
            }
        }
        return;
    }
 
    view.PaintText(surfaceWindow, *this, rcArea, rcClient, vs);
 
    if (horizontalScrollBarVisible && trackLineWidth && (view.lineWidthMaxSeen > scrollWidth)) {
        scrollWidth = view.lineWidthMaxSeen;
        if (!FineTickerRunning(tickWiden)) {
            FineTickerStart(tickWiden, 50, 5);
        }
    }
 
    NotifyPainted();
}
 
// This is mostly copied from the Paint method but with some things omitted
// such as the margin markers, line numbers, selection and caret
// Should be merged back into a combined Draw method.
Sci::Position Editor::FormatRange(bool draw, const Sci_RangeToFormat *pfr) {
    if (!pfr)
        return 0;
 
    AutoSurface surface(pfr->hdc, this, SC_TECHNOLOGY_DEFAULT);
    if (!surface)
        return 0;
    AutoSurface surfaceMeasure(pfr->hdcTarget, this, SC_TECHNOLOGY_DEFAULT);
    if (!surfaceMeasure) {
        return 0;
    }
    return view.FormatRange(draw, pfr, surface, surfaceMeasure, *this, vs);
}
 
long Editor::TextWidth(uptr_t style, const char *text) {
    RefreshStyleData();
    AutoSurface surface(this);
    if (surface) {
        return Sci::lround(surface->WidthText(vs.styles[style].font, text, static_cast<int>(strlen(text))));
    } else {
        return 1;
    }
}
 
// Empty method is overridden on GTK+ to show / hide scrollbars
void Editor::ReconfigureScrollBars() {}
 
void Editor::SetScrollBars() {
    RefreshStyleData();
 
    const Sci::Line nMax = MaxScrollPos();
    const Sci::Line nPage = LinesOnScreen();
    const bool modified = ModifyScrollBars(nMax + nPage - 1, nPage);
    if (modified) {
        DwellEnd(true);
    }
 
    // TODO: ensure always showing as many lines as possible
    // May not be, if, for example, window made larger
    if (topLine > MaxScrollPos()) {
        SetTopLine(Sci::clamp(topLine, static_cast<Sci::Line>(0), MaxScrollPos()));
        SetVerticalScrollPos();
        Redraw();
    }
    if (modified) {
        if (!AbandonPaint())
            Redraw();
    }
    //Platform::DebugPrintf("end max = %d page = %d\n", nMax, nPage);
}
 
void Editor::ChangeSize() {
    DropGraphics(false);
    SetScrollBars();
    if (Wrapping()) {
        PRectangle rcTextArea = GetClientRectangle();
        rcTextArea.left = static_cast<XYPOSITION>(vs.textStart);
        rcTextArea.right -= vs.rightMarginWidth;
        if (wrapWidth != rcTextArea.Width()) {
            NeedWrapping();
            Redraw();
        }
    }
}
 
Sci::Position Editor::RealizeVirtualSpace(Sci::Position position, Sci::Position virtualSpace) {
    if (virtualSpace > 0) {
        const Sci::Line line = pdoc->SciLineFromPosition(position);
        const Sci::Position indent = pdoc->GetLineIndentPosition(line);
        if (indent == position) {
            return pdoc->SetLineIndentation(line, pdoc->GetLineIndentation(line) + virtualSpace);
        } else {
            std::string spaceText(virtualSpace, ' ');
            const Sci::Position lengthInserted = pdoc->InsertString(position, spaceText.c_str(), virtualSpace);
            position += lengthInserted;
        }
    }
    return position;
}
 
SelectionPosition Editor::RealizeVirtualSpace(const SelectionPosition &position) {
    // Return the new position with no virtual space
    return SelectionPosition(RealizeVirtualSpace(position.Position(), position.VirtualSpace()));
}
 
void Editor::AddChar(char ch) {
    char s[2];
    s[0] = ch;
    s[1] = '\0';
    InsertCharacter(s, 1, CharacterSource::directInput);
}
 
void Editor::FilterSelections() {
    if (!additionalSelectionTyping && (sel.Count() > 1)) {
        InvalidateWholeSelection();
        sel.DropAdditionalRanges();
    }
}
 
// InsertCharacter inserts a character encoded in document code page.
void Editor::InsertCharacter(const char *s, unsigned int len, CharacterSource charSource) {
    if (len == 0) {
        return;
    }
    FilterSelections();
    {
        UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty() || inOverstrike);
 
        // Vector elements point into selection in order to change selection.
        std::vector<SelectionRange *> selPtrs;
        for (size_t r = 0; r < sel.Count(); r++) {
            selPtrs.push_back(&sel.Range(r));
        }
        // Order selections by position in document.
        std::sort(selPtrs.begin(), selPtrs.end(),
            [](const SelectionRange *a, const SelectionRange *b) noexcept {return *a < *b;});
 
        // Loop in reverse to avoid disturbing positions of selections yet to be processed.
        for (std::vector<SelectionRange *>::reverse_iterator rit = selPtrs.rbegin();
            rit != selPtrs.rend(); ++rit) {
            SelectionRange *currentSel = *rit;
            if (!RangeContainsProtected(currentSel->Start().Position(),
                currentSel->End().Position())) {
                Sci::Position positionInsert = currentSel->Start().Position();
                if (!currentSel->Empty()) {
                    if (currentSel->Length()) {
                        pdoc->DeleteChars(positionInsert, currentSel->Length());
                        currentSel->ClearVirtualSpace();
                    } else {
                        // Range is all virtual so collapse to start of virtual space
                        currentSel->MinimizeVirtualSpace();
                    }
                } else if (inOverstrike) {
                    if (positionInsert < pdoc->Length()) {
                        if (!pdoc->IsPositionInLineEnd(positionInsert)) {
                            pdoc->DelChar(positionInsert);
                            currentSel->ClearVirtualSpace();
                        }
                    }
                }
                positionInsert = RealizeVirtualSpace(positionInsert, currentSel->caret.VirtualSpace());
                const Sci::Position lengthInserted = pdoc->InsertString(positionInsert, s, len);
                if (lengthInserted > 0) {
                    currentSel->caret.SetPosition(positionInsert + lengthInserted);
                    currentSel->anchor.SetPosition(positionInsert + lengthInserted);
                }
                currentSel->ClearVirtualSpace();
                // If in wrap mode rewrap current line so EnsureCaretVisible has accurate information
                if (Wrapping()) {
                    AutoSurface surface(this);
                    if (surface) {
                        if (WrapOneLine(surface, pdoc->SciLineFromPosition(positionInsert))) {
                            SetScrollBars();
                            SetVerticalScrollPos();
                            Redraw();
                        }
                    }
                }
            }
        }
    }
    if (Wrapping()) {
        SetScrollBars();
    }
    ThinRectangularRange();
    // If in wrap mode rewrap current line so EnsureCaretVisible has accurate information
    EnsureCaretVisible();
    // Avoid blinking during rapid typing:
    ShowCaretAtCurrentPosition();
    if ((caretSticky == SC_CARETSTICKY_OFF) ||
        ((caretSticky == SC_CARETSTICKY_WHITESPACE) && !IsAllSpacesOrTabs(s, len))) {
        SetLastXChosen();
    }
 
    int ch = static_cast<unsigned char>(s[0]);
    if (pdoc->dbcsCodePage != SC_CP_UTF8) {
        if (len > 1) {
            // DBCS code page or DBCS font character set.
            ch = (ch << 8) | static_cast<unsigned char>(s[1]);
        }
    } else {
        if ((ch < 0xC0) || (1 == len)) {
            // Handles UTF-8 characters between 0x01 and 0x7F and single byte
            // characters when not in UTF-8 mode.
            // Also treats \0 and naked trail bytes 0x80 to 0xBF as valid
            // characters representing themselves.
        } else {
            unsigned int utf32[1] = { 0 };
            UTF32FromUTF8(s, len, utf32, Sci::size(utf32));
            ch = utf32[0];
        }
    }
    NotifyChar(ch, charSource);
 
    if (recordingMacro && charSource != CharacterSource::tentativeInput) {
        std::string copy(s, len); // ensure NUL-terminated
        NotifyMacroRecord(SCI_REPLACESEL, 0, reinterpret_cast<sptr_t>(copy.data()));
    }
}
 
void Editor::ClearBeforeTentativeStart() {
    // Make positions for the first composition string.
    FilterSelections();
    UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty() || inOverstrike);
    for (size_t r = 0; r<sel.Count(); r++) {
        if (!RangeContainsProtected(sel.Range(r).Start().Position(),
            sel.Range(r).End().Position())) {
            const Sci::Position positionInsert = sel.Range(r).Start().Position();
            if (!sel.Range(r).Empty()) {
                if (sel.Range(r).Length()) {
                    pdoc->DeleteChars(positionInsert, sel.Range(r).Length());
                    sel.Range(r).ClearVirtualSpace();
                } else {
                    // Range is all virtual so collapse to start of virtual space
                    sel.Range(r).MinimizeVirtualSpace();
                }
            }
            RealizeVirtualSpace(positionInsert, sel.Range(r).caret.VirtualSpace());
            sel.Range(r).ClearVirtualSpace();
        }
    }
}
 
void Editor::InsertPaste(const char *text, Sci::Position len) {
    if (multiPasteMode == SC_MULTIPASTE_ONCE) {
        SelectionPosition selStart = sel.Start();
        selStart = RealizeVirtualSpace(selStart);
        const Sci::Position lengthInserted = pdoc->InsertString(selStart.Position(), text, len);
        if (lengthInserted > 0) {
            SetEmptySelection(selStart.Position() + lengthInserted);
        }
    } else {
        // SC_MULTIPASTE_EACH
        for (size_t r=0; r<sel.Count(); r++) {
            if (!RangeContainsProtected(sel.Range(r).Start().Position(),
                sel.Range(r).End().Position())) {
                Sci::Position positionInsert = sel.Range(r).Start().Position();
                if (!sel.Range(r).Empty()) {
                    if (sel.Range(r).Length()) {
                        pdoc->DeleteChars(positionInsert, sel.Range(r).Length());
                        sel.Range(r).ClearVirtualSpace();
                    } else {
                        // Range is all virtual so collapse to start of virtual space
                        sel.Range(r).MinimizeVirtualSpace();
                    }
                }
                positionInsert = RealizeVirtualSpace(positionInsert, sel.Range(r).caret.VirtualSpace());
                const Sci::Position lengthInserted = pdoc->InsertString(positionInsert, text, len);
                if (lengthInserted > 0) {
                    sel.Range(r).caret.SetPosition(positionInsert + lengthInserted);
                    sel.Range(r).anchor.SetPosition(positionInsert + lengthInserted);
                }
                sel.Range(r).ClearVirtualSpace();
            }
        }
    }
}
 
void Editor::InsertPasteShape(const char *text, Sci::Position len, PasteShape shape) {
    std::string convertedText;
    if (convertPastes) {
        // Convert line endings of the paste into our local line-endings mode
        convertedText = Document::TransformLineEnds(text, len, pdoc->eolMode);
        len = convertedText.length();
        text = convertedText.c_str();
    }
    if (shape == pasteRectangular) {
        PasteRectangular(sel.Start(), text, len);
    } else {
        if (shape == pasteLine) {
            const Sci::Position insertPos =
                pdoc->LineStart(pdoc->LineFromPosition(sel.MainCaret()));
            Sci::Position lengthInserted = pdoc->InsertString(insertPos, text, len);
            // add the newline if necessary
            if ((len > 0) && (text[len - 1] != '\n' && text[len - 1] != '\r')) {
                const char *endline = StringFromEOLMode(pdoc->eolMode);
                const Sci::Position length = strlen(endline);
                lengthInserted += pdoc->InsertString(insertPos + lengthInserted, endline, length);
            }
            if (sel.MainCaret() == insertPos) {
                SetEmptySelection(sel.MainCaret() + lengthInserted);
            }
        } else {
            InsertPaste(text, len);
        }
    }
}
 
void Editor::ClearSelection(bool retainMultipleSelections) {
    if (!sel.IsRectangular() && !retainMultipleSelections)
        FilterSelections();
    UndoGroup ug(pdoc);
    for (size_t r=0; r<sel.Count(); r++) {
        if (!sel.Range(r).Empty()) {
            if (!RangeContainsProtected(sel.Range(r).Start().Position(),
                sel.Range(r).End().Position())) {
                pdoc->DeleteChars(sel.Range(r).Start().Position(),
                    sel.Range(r).Length());
                sel.Range(r) = SelectionRange(sel.Range(r).Start());
            }
        }
    }
    ThinRectangularRange();
    sel.RemoveDuplicates();
    ClaimSelection();
    SetHoverIndicatorPosition(sel.MainCaret());
}
 
void Editor::ClearAll() {
    {
        UndoGroup ug(pdoc);
        if (0 != pdoc->Length()) {
            pdoc->DeleteChars(0, pdoc->Length());
        }
        if (!pdoc->IsReadOnly()) {
            pcs->Clear();
            pdoc->AnnotationClearAll();
            pdoc->EOLAnnotationClearAll();
            pdoc->MarginClearAll();
        }
    }
 
    view.ClearAllTabstops();
 
    sel.Clear();
    SetTopLine(0);
    SetVerticalScrollPos();
    InvalidateStyleRedraw();
}
 
void Editor::ClearDocumentStyle() {
    pdoc->decorations->DeleteLexerDecorations();
    pdoc->StartStyling(0, '\377');
    pdoc->SetStyleFor(pdoc->Length(), 0);
    pcs->ShowAll();
    SetAnnotationHeights(0, pdoc->LinesTotal());
    pdoc->ClearLevels();
}
 
void Editor::CopyAllowLine() {
    SelectionText selectedText;
    CopySelectionRange(&selectedText, true);
    CopyToClipboard(selectedText);
}
 
void Editor::Cut() {
    pdoc->CheckReadOnly();
    if (!pdoc->IsReadOnly() && !SelectionContainsProtected()) {
        Copy();
        ClearSelection();
    }
}
 
void Editor::PasteRectangular(SelectionPosition pos, const char *ptr, Sci::Position len) {
    if (pdoc->IsReadOnly() || SelectionContainsProtected()) {
        return;
    }
    sel.Clear();
    sel.RangeMain() = SelectionRange(pos);
    Sci::Line line = pdoc->SciLineFromPosition(sel.MainCaret());
    UndoGroup ug(pdoc);
    sel.RangeMain().caret = RealizeVirtualSpace(sel.RangeMain().caret);
    const int xInsert = XFromPosition(sel.RangeMain().caret);
    bool prevCr = false;
    while ((len > 0) && IsEOLChar(ptr[len-1]))
        len--;
    for (Sci::Position i = 0; i < len; i++) {
        if (IsEOLChar(ptr[i])) {
            if ((ptr[i] == '\r') || (!prevCr))
                line++;
            if (line >= pdoc->LinesTotal()) {
                if (pdoc->eolMode != SC_EOL_LF)
                    pdoc->InsertString(pdoc->Length(), "\r", 1);
                if (pdoc->eolMode != SC_EOL_CR)
                    pdoc->InsertString(pdoc->Length(), "\n", 1);
            }
            // Pad the end of lines with spaces if required
            sel.RangeMain().caret.SetPosition(PositionFromLineX(line, xInsert));
            if ((XFromPosition(sel.RangeMain().caret) < xInsert) && (i + 1 < len)) {
                while (XFromPosition(sel.RangeMain().caret) < xInsert) {
                    assert(pdoc);
                    const Sci::Position lengthInserted = pdoc->InsertString(sel.MainCaret(), " ", 1);
                    sel.RangeMain().caret.Add(lengthInserted);
                }
            }
            prevCr = ptr[i] == '\r';
        } else {
            const Sci::Position lengthInserted = pdoc->InsertString(sel.MainCaret(), ptr + i, 1);
            sel.RangeMain().caret.Add(lengthInserted);
            prevCr = false;
        }
    }
    SetEmptySelection(pos);
}
 
bool Editor::CanPaste() {
    return !pdoc->IsReadOnly() && !SelectionContainsProtected();
}
 
void Editor::Clear() {
    // If multiple selections, don't delete EOLS
    if (sel.Empty()) {
        bool singleVirtual = false;
        if ((sel.Count() == 1) &&
            !RangeContainsProtected(sel.MainCaret(), sel.MainCaret() + 1) &&
            sel.RangeMain().Start().VirtualSpace()) {
            singleVirtual = true;
        }
        UndoGroup ug(pdoc, (sel.Count() > 1) || singleVirtual);
        for (size_t r=0; r<sel.Count(); r++) {
            if (!RangeContainsProtected(sel.Range(r).caret.Position(), sel.Range(r).caret.Position() + 1)) {
                if (sel.Range(r).Start().VirtualSpace()) {
                    if (sel.Range(r).anchor < sel.Range(r).caret)
                        sel.Range(r) = SelectionRange(RealizeVirtualSpace(sel.Range(r).anchor.Position(), sel.Range(r).anchor.VirtualSpace()));
                    else
                        sel.Range(r) = SelectionRange(RealizeVirtualSpace(sel.Range(r).caret.Position(), sel.Range(r).caret.VirtualSpace()));
                }
                if ((sel.Count() == 1) || !pdoc->IsPositionInLineEnd(sel.Range(r).caret.Position())) {
                    pdoc->DelChar(sel.Range(r).caret.Position());
                    sel.Range(r).ClearVirtualSpace();
                }  // else multiple selection so don't eat line ends
            } else {
                sel.Range(r).ClearVirtualSpace();
            }
        }
    } else {
        ClearSelection();
    }
    sel.RemoveDuplicates();
    ShowCaretAtCurrentPosition();       // Avoid blinking
}
 
void Editor::SelectAll() {
    sel.Clear();
    SetSelection(0, pdoc->Length());
    Redraw();
}
 
void Editor::Undo() {
    if (pdoc->CanUndo()) {
        InvalidateCaret();
        const Sci::Position newPos = pdoc->Undo();
        if (newPos >= 0)
            SetEmptySelection(newPos);
        EnsureCaretVisible();
    }
}
 
void Editor::Redo() {
    if (pdoc->CanRedo()) {
        const Sci::Position newPos = pdoc->Redo();
        if (newPos >= 0)
            SetEmptySelection(newPos);
        EnsureCaretVisible();
    }
}
 
void Editor::DelCharBack(bool allowLineStartDeletion) {
    RefreshStyleData();
    if (!sel.IsRectangular())
        FilterSelections();
    if (sel.IsRectangular())
        allowLineStartDeletion = false;
    UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty());
    if (sel.Empty()) {
        for (size_t r=0; r<sel.Count(); r++) {
            if (!RangeContainsProtected(sel.Range(r).caret.Position() - 1, sel.Range(r).caret.Position())) {
                if (sel.Range(r).caret.VirtualSpace()) {
                    sel.Range(r).caret.SetVirtualSpace(sel.Range(r).caret.VirtualSpace() - 1);
                    sel.Range(r).anchor.SetVirtualSpace(sel.Range(r).caret.VirtualSpace());
                } else {
                    const Sci::Line lineCurrentPos =
                        pdoc->SciLineFromPosition(sel.Range(r).caret.Position());
                    if (allowLineStartDeletion || (pdoc->LineStart(lineCurrentPos) != sel.Range(r).caret.Position())) {
                        if (pdoc->GetColumn(sel.Range(r).caret.Position()) <= pdoc->GetLineIndentation(lineCurrentPos) &&
                                pdoc->GetColumn(sel.Range(r).caret.Position()) > 0 && pdoc->backspaceUnindents) {
                            UndoGroup ugInner(pdoc, !ug.Needed());
                            const int indentation = pdoc->GetLineIndentation(lineCurrentPos);
                            const int indentationStep = pdoc->IndentSize();
                            int indentationChange = indentation % indentationStep;
                            if (indentationChange == 0)
                                indentationChange = indentationStep;
                            const Sci::Position posSelect = pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationChange);
                            // SetEmptySelection
                            sel.Range(r) = SelectionRange(posSelect);
                        } else {
                            pdoc->DelCharBack(sel.Range(r).caret.Position());
                        }
                    }
                }
            } else {
                sel.Range(r).ClearVirtualSpace();
            }
        }
        ThinRectangularRange();
    } else {
        ClearSelection();
    }
    sel.RemoveDuplicates();
    ContainerNeedsUpdate(SC_UPDATE_SELECTION);
    // Avoid blinking during rapid typing:
    ShowCaretAtCurrentPosition();
}
 
int Editor::ModifierFlags(bool shift, bool ctrl, bool alt, bool meta, bool super) noexcept {
    return
        (shift ? SCI_SHIFT : 0) |
        (ctrl ? SCI_CTRL : 0) |
        (alt ? SCI_ALT : 0) |
        (meta ? SCI_META : 0) |
        (super ? SCI_SUPER : 0);
}
 
void Editor::NotifyFocus(bool focus) {
    SCNotification scn = {};
    scn.nmhdr.code = focus ? SCN_FOCUSIN : SCN_FOCUSOUT;
    NotifyParent(scn);
}
 
void Editor::SetCtrlID(int identifier) {
    ctrlID = identifier;
}
 
void Editor::NotifyStyleToNeeded(Sci::Position endStyleNeeded) {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_STYLENEEDED;
    scn.position = endStyleNeeded;
    NotifyParent(scn);
}
 
void Editor::NotifyStyleNeeded(Document *, void *, Sci::Position endStyleNeeded) {
    NotifyStyleToNeeded(endStyleNeeded);
}
 
void Editor::NotifyLexerChanged(Document *, void *) {
}
 
void Editor::NotifyErrorOccurred(Document *, void *, int status) {
    errorStatus = status;
}
 
void Editor::NotifyChar(int ch, CharacterSource charSource) {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_CHARADDED;
    scn.ch = ch;
    scn.characterSource = static_cast<int>(charSource);
    NotifyParent(scn);
}
 
void Editor::NotifySavePoint(bool isSavePoint) {
    SCNotification scn = {};
    if (isSavePoint) {
        scn.nmhdr.code = SCN_SAVEPOINTREACHED;
    } else {
        scn.nmhdr.code = SCN_SAVEPOINTLEFT;
    }
    NotifyParent(scn);
}
 
void Editor::NotifyModifyAttempt() {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_MODIFYATTEMPTRO;
    NotifyParent(scn);
}
 
void Editor::NotifyDoubleClick(Point pt, int modifiers) {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_DOUBLECLICK;
    scn.line = LineFromLocation(pt);
    scn.position = PositionFromLocation(pt, true);
    scn.modifiers = modifiers;
    NotifyParent(scn);
}
 
void Editor::NotifyHotSpotDoubleClicked(Sci::Position position, int modifiers) {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_HOTSPOTDOUBLECLICK;
    scn.position = position;
    scn.modifiers = modifiers;
    NotifyParent(scn);
}
 
void Editor::NotifyHotSpotClicked(Sci::Position position, int modifiers) {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_HOTSPOTCLICK;
    scn.position = position;
    scn.modifiers = modifiers;
    NotifyParent(scn);
}
 
void Editor::NotifyHotSpotReleaseClick(Sci::Position position, int modifiers) {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_HOTSPOTRELEASECLICK;
    scn.position = position;
    scn.modifiers = modifiers;
    NotifyParent(scn);
}
 
bool Editor::NotifyUpdateUI() {
    if (needUpdateUI) {
        SCNotification scn = {};
        scn.nmhdr.code = SCN_UPDATEUI;
        scn.updated = needUpdateUI;
        NotifyParent(scn);
        needUpdateUI = 0;
        return true;
    }
    return false;
}
 
void Editor::NotifyPainted() {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_PAINTED;
    NotifyParent(scn);
}
 
void Editor::NotifyIndicatorClick(bool click, Sci::Position position, int modifiers) {
    const int mask = pdoc->decorations->AllOnFor(position);
    if ((click && mask) || pdoc->decorations->ClickNotified()) {
        SCNotification scn = {};
        pdoc->decorations->SetClickNotified(click);
        scn.nmhdr.code = click ? SCN_INDICATORCLICK : SCN_INDICATORRELEASE;
        scn.modifiers = modifiers;
        scn.position = position;
        NotifyParent(scn);
    }
}
 
bool Editor::NotifyMarginClick(Point pt, int modifiers) {
    const int marginClicked = vs.MarginFromLocation(pt);
    if ((marginClicked >= 0) && vs.ms[marginClicked].sensitive) {
        const Sci::Position position = pdoc->LineStart(LineFromLocation(pt));
        if ((vs.ms[marginClicked].mask & SC_MASK_FOLDERS) && (foldAutomatic & SC_AUTOMATICFOLD_CLICK)) {
            const bool ctrl = (modifiers & SCI_CTRL) != 0;
            const bool shift = (modifiers & SCI_SHIFT) != 0;
            const Sci::Line lineClick = pdoc->SciLineFromPosition(position);
            if (shift && ctrl) {
                FoldAll(SC_FOLDACTION_TOGGLE);
            } else {
                const int levelClick = pdoc->GetLevel(lineClick);
                if (levelClick & SC_FOLDLEVELHEADERFLAG) {
                    if (shift) {
                        // Ensure all children visible
                        FoldExpand(lineClick, SC_FOLDACTION_EXPAND, levelClick);
                    } else if (ctrl) {
                        FoldExpand(lineClick, SC_FOLDACTION_TOGGLE, levelClick);
                    } else {
                        // Toggle this line
                        FoldLine(lineClick, SC_FOLDACTION_TOGGLE);
                    }
                }
            }
            return true;
        }
        SCNotification scn = {};
        scn.nmhdr.code = SCN_MARGINCLICK;
        scn.modifiers = modifiers;
        scn.position = position;
        scn.margin = marginClicked;
        NotifyParent(scn);
        return true;
    } else {
        return false;
    }
}
 
bool Editor::NotifyMarginRightClick(Point pt, int modifiers) {
    const int marginRightClicked = vs.MarginFromLocation(pt);
    if ((marginRightClicked >= 0) && vs.ms[marginRightClicked].sensitive) {
        const Sci::Position position = pdoc->LineStart(LineFromLocation(pt));
        SCNotification scn = {};
        scn.nmhdr.code = SCN_MARGINRIGHTCLICK;
        scn.modifiers = modifiers;
        scn.position = position;
        scn.margin = marginRightClicked;
        NotifyParent(scn);
        return true;
    } else {
        return false;
    }
}
 
void Editor::NotifyNeedShown(Sci::Position pos, Sci::Position len) {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_NEEDSHOWN;
    scn.position = pos;
    scn.length = len;
    NotifyParent(scn);
}
 
void Editor::NotifyDwelling(Point pt, bool state) {
    SCNotification scn = {};
    scn.nmhdr.code = state ? SCN_DWELLSTART : SCN_DWELLEND;
    scn.position = PositionFromLocation(pt, true);
    scn.x = static_cast<int>(pt.x + vs.ExternalMarginWidth());
    scn.y = static_cast<int>(pt.y);
    NotifyParent(scn);
}
 
void Editor::NotifyZoom() {
    SCNotification scn = {};
    scn.nmhdr.code = SCN_ZOOM;
    NotifyParent(scn);
}
 
// Notifications from document
void Editor::NotifyModifyAttempt(Document *, void *) {
    //Platform::DebugPrintf("** Modify Attempt\n");
    NotifyModifyAttempt();
}
 
void Editor::NotifySavePoint(Document *, void *, bool atSavePoint) {
    //Platform::DebugPrintf("** Save Point %s\n", atSavePoint ? "On" : "Off");
    NotifySavePoint(atSavePoint);
}
 
void Editor::CheckModificationForWrap(DocModification mh) {
    if (mh.modificationType & (SC_MOD_INSERTTEXT | SC_MOD_DELETETEXT)) {
        view.llc.Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
        const Sci::Line lineDoc = pdoc->SciLineFromPosition(mh.position);
        const Sci::Line lines = std::max(static_cast<Sci::Line>(0), mh.linesAdded);
        if (Wrapping()) {
            NeedWrapping(lineDoc, lineDoc + lines + 1);
        }
        RefreshStyleData();
        // Fix up annotation heights
        SetAnnotationHeights(lineDoc, lineDoc + lines + 2);
    }
}
 
namespace {
 
// Move a position so it is still after the same character as before the insertion.
Sci::Position MovePositionForInsertion(Sci::Position position, Sci::Position startInsertion, Sci::Position length) noexcept {
    if (position > startInsertion) {
        return position + length;
    }
    return position;
}
 
// Move a position so it is still after the same character as before the deletion if that
// character is still present else after the previous surviving character.
Sci::Position MovePositionForDeletion(Sci::Position position, Sci::Position startDeletion, Sci::Position length) noexcept {
    if (position > startDeletion) {
        const Sci::Position endDeletion = startDeletion + length;
        if (position > endDeletion) {
            return position - length;
        } else {
            return startDeletion;
        }
    } else {
        return position;
    }
}
 
}
 
void Editor::NotifyModified(Document *, DocModification mh, void *) {
    ContainerNeedsUpdate(SC_UPDATE_CONTENT);
    if (paintState == painting) {
        CheckForChangeOutsidePaint(Range(mh.position, mh.position + mh.length));
    }
    if (mh.modificationType & SC_MOD_CHANGELINESTATE) {
        if (paintState == painting) {
            CheckForChangeOutsidePaint(
                Range(pdoc->LineStart(mh.line),
                    pdoc->LineStart(mh.line + 1)));
        } else {
            // Could check that change is before last visible line.
            Redraw();
        }
    }
    if (mh.modificationType & SC_MOD_CHANGETABSTOPS) {
        Redraw();
    }
    if (mh.modificationType & SC_MOD_LEXERSTATE) {
        if (paintState == painting) {
            CheckForChangeOutsidePaint(
                Range(mh.position, mh.position + mh.length));
        } else {
            Redraw();
        }
    }
    if (mh.modificationType & (SC_MOD_CHANGESTYLE | SC_MOD_CHANGEINDICATOR)) {
        if (mh.modificationType & SC_MOD_CHANGESTYLE) {
            pdoc->IncrementStyleClock();
        }
        if (paintState == notPainting) {
            const Sci::Line lineDocTop = pcs->DocFromDisplay(topLine);
            if (mh.position < pdoc->LineStart(lineDocTop)) {
                // Styling performed before this view
                Redraw();
            } else {
                InvalidateRange(mh.position, mh.position + mh.length);
            }
        }
        if (mh.modificationType & SC_MOD_CHANGESTYLE) {
            view.llc.Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
        }
    } else {
        // Move selection and brace highlights
        if (mh.modificationType & SC_MOD_INSERTTEXT) {
            sel.MovePositions(true, mh.position, mh.length);
            braces[0] = MovePositionForInsertion(braces[0], mh.position, mh.length);
            braces[1] = MovePositionForInsertion(braces[1], mh.position, mh.length);
        } else if (mh.modificationType & SC_MOD_DELETETEXT) {
            sel.MovePositions(false, mh.position, mh.length);
            braces[0] = MovePositionForDeletion(braces[0], mh.position, mh.length);
            braces[1] = MovePositionForDeletion(braces[1], mh.position, mh.length);
        }
        if ((mh.modificationType & (SC_MOD_BEFOREINSERT | SC_MOD_BEFOREDELETE)) && pcs->HiddenLines()) {
            // Some lines are hidden so may need shown.
            const Sci::Line lineOfPos = pdoc->SciLineFromPosition(mh.position);
            Sci::Position endNeedShown = mh.position;
            if (mh.modificationType & SC_MOD_BEFOREINSERT) {
                if (pdoc->ContainsLineEnd(mh.text, mh.length) && (mh.position != pdoc->LineStart(lineOfPos)))
                    endNeedShown = pdoc->LineStart(lineOfPos+1);
            } else if (mh.modificationType & SC_MOD_BEFOREDELETE) {
                // If the deletion includes any EOL then we extend the need shown area.
                endNeedShown = mh.position + mh.length;
                Sci::Line lineLast = pdoc->SciLineFromPosition(mh.position+mh.length);
                for (Sci::Line line = lineOfPos + 1; line <= lineLast; line++) {
                    const Sci::Line lineMaxSubord = pdoc->GetLastChild(line, -1, -1);
                    if (lineLast < lineMaxSubord) {
                        lineLast = lineMaxSubord;
                        endNeedShown = pdoc->LineEnd(lineLast);
                    }
                }
            }
            NeedShown(mh.position, endNeedShown - mh.position);
        }
        if (mh.linesAdded != 0) {
            // Update contraction state for inserted and removed lines
            // lineOfPos should be calculated in context of state before modification, shouldn't it
            Sci::Line lineOfPos = pdoc->SciLineFromPosition(mh.position);
            if (mh.position > pdoc->LineStart(lineOfPos))
                lineOfPos++;    // Affecting subsequent lines
            if (mh.linesAdded > 0) {
                pcs->InsertLines(lineOfPos, mh.linesAdded);
            } else {
                pcs->DeleteLines(lineOfPos, -mh.linesAdded);
            }
            view.LinesAddedOrRemoved(lineOfPos, mh.linesAdded);
        }
        if (mh.modificationType & SC_MOD_CHANGEANNOTATION) {
            const Sci::Line lineDoc = pdoc->SciLineFromPosition(mh.position);
            if (vs.annotationVisible) {
                if (pcs->SetHeight(lineDoc, pcs->GetHeight(lineDoc) + static_cast<int>(mh.annotationLinesAdded))) {
                    SetScrollBars();
                }
                Redraw();
            }
        }
        if (mh.modificationType & SC_MOD_CHANGEEOLANNOTATION) {
            if (vs.eolAnnotationVisible) {
                Redraw();
            }
        }
        CheckModificationForWrap(mh);
        if (mh.linesAdded != 0) {
            // Avoid scrolling of display if change before current display
            if (mh.position < posTopLine && !CanDeferToLastStep(mh)) {
                const Sci::Line newTop = Sci::clamp(topLine + mh.linesAdded, static_cast<Sci::Line>(0), MaxScrollPos());
                if (newTop != topLine) {
                    SetTopLine(newTop);
                    SetVerticalScrollPos();
                }
            }
 
            if (paintState == notPainting && !CanDeferToLastStep(mh)) {
                if (SynchronousStylingToVisible()) {
                    QueueIdleWork(WorkNeeded::workStyle, pdoc->Length());
                }
                Redraw();
            }
        } else {
            if (paintState == notPainting && mh.length && !CanEliminate(mh)) {
                if (SynchronousStylingToVisible()) {
                    QueueIdleWork(WorkNeeded::workStyle, mh.position + mh.length);
                }
                InvalidateRange(mh.position, mh.position + mh.length);
            }
        }
    }
 
    if (mh.linesAdded != 0 && !CanDeferToLastStep(mh)) {
        SetScrollBars();
    }
 
    if ((mh.modificationType & SC_MOD_CHANGEMARKER) || (mh.modificationType & SC_MOD_CHANGEMARGIN)) {
        if ((!willRedrawAll) && ((paintState == notPainting) || !PaintContainsMargin())) {
            if (mh.modificationType & SC_MOD_CHANGEFOLD) {
                // Fold changes can affect the drawing of following lines so redraw whole margin
                RedrawSelMargin(marginView.highlightDelimiter.isEnabled ? -1 : mh.line - 1, true);
            } else {
                RedrawSelMargin(mh.line);
            }
        }
    }
    if ((mh.modificationType & SC_MOD_CHANGEFOLD) && (foldAutomatic & SC_AUTOMATICFOLD_CHANGE)) {
        FoldChanged(mh.line, mh.foldLevelNow, mh.foldLevelPrev);
    }
 
    // NOW pay the piper WRT "deferred" visual updates
    if (IsLastStep(mh)) {
        SetScrollBars();
        Redraw();
    }
 
    // If client wants to see this modification
    if (mh.modificationType & modEventMask) {
        if (commandEvents) {
            if ((mh.modificationType & (SC_MOD_CHANGESTYLE | SC_MOD_CHANGEINDICATOR)) == 0) {
                // Real modification made to text of document.
                NotifyChange(); // Send EN_CHANGE
            }
        }
 
        SCNotification scn = {};
        scn.nmhdr.code = SCN_MODIFIED;
        scn.position = mh.position;
        scn.modificationType = mh.modificationType;
        scn.text = mh.text;
        scn.length = mh.length;
        scn.linesAdded = mh.linesAdded;
        scn.line = mh.line;
        scn.foldLevelNow = mh.foldLevelNow;
        scn.foldLevelPrev = mh.foldLevelPrev;
        scn.token = static_cast<int>(mh.token);
        scn.annotationLinesAdded = mh.annotationLinesAdded;
        NotifyParent(scn);
    }
}
 
void Editor::NotifyDeleted(Document *, void *) noexcept {
    /* Do nothing */
}
 
void Editor::NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 
    // Enumerates all macroable messages
    switch (iMessage) {
    case SCI_CUT:
    case SCI_COPY:
    case SCI_PASTE:
    case SCI_CLEAR:
    case SCI_REPLACESEL:
    case SCI_ADDTEXT:
    case SCI_INSERTTEXT:
    case SCI_APPENDTEXT:
    case SCI_CLEARALL:
    case SCI_SELECTALL:
    case SCI_GOTOLINE:
    case SCI_GOTOPOS:
    case SCI_SEARCHANCHOR:
    case SCI_SEARCHNEXT:
    case SCI_SEARCHPREV:
    case SCI_LINEDOWN:
    case SCI_LINEDOWNEXTEND:
    case SCI_PARADOWN:
    case SCI_PARADOWNEXTEND:
    case SCI_LINEUP:
    case SCI_LINEUPEXTEND:
    case SCI_PARAUP:
    case SCI_PARAUPEXTEND:
    case SCI_CHARLEFT:
    case SCI_CHARLEFTEXTEND:
    case SCI_CHARRIGHT:
    case SCI_CHARRIGHTEXTEND:
    case SCI_WORDLEFT:
    case SCI_WORDLEFTEXTEND:
    case SCI_WORDRIGHT:
    case SCI_WORDRIGHTEXTEND:
    case SCI_WORDPARTLEFT:
    case SCI_WORDPARTLEFTEXTEND:
    case SCI_WORDPARTRIGHT:
    case SCI_WORDPARTRIGHTEXTEND:
    case SCI_WORDLEFTEND:
    case SCI_WORDLEFTENDEXTEND:
    case SCI_WORDRIGHTEND:
    case SCI_WORDRIGHTENDEXTEND:
    case SCI_HOME:
    case SCI_HOMEEXTEND:
    case SCI_LINEEND:
    case SCI_LINEENDEXTEND:
    case SCI_HOMEWRAP:
    case SCI_HOMEWRAPEXTEND:
    case SCI_LINEENDWRAP:
    case SCI_LINEENDWRAPEXTEND:
    case SCI_DOCUMENTSTART:
    case SCI_DOCUMENTSTARTEXTEND:
    case SCI_DOCUMENTEND:
    case SCI_DOCUMENTENDEXTEND:
    case SCI_STUTTEREDPAGEUP:
    case SCI_STUTTEREDPAGEUPEXTEND:
    case SCI_STUTTEREDPAGEDOWN:
    case SCI_STUTTEREDPAGEDOWNEXTEND:
    case SCI_PAGEUP:
    case SCI_PAGEUPEXTEND:
    case SCI_PAGEDOWN:
    case SCI_PAGEDOWNEXTEND:
    case SCI_EDITTOGGLEOVERTYPE:
    case SCI_CANCEL:
    case SCI_DELETEBACK:
    case SCI_TAB:
    case SCI_BACKTAB:
    case SCI_FORMFEED:
    case SCI_VCHOME:
    case SCI_VCHOMEEXTEND:
    case SCI_VCHOMEWRAP:
    case SCI_VCHOMEWRAPEXTEND:
    case SCI_VCHOMEDISPLAY:
    case SCI_VCHOMEDISPLAYEXTEND:
    case SCI_DELWORDLEFT:
    case SCI_DELWORDRIGHT:
    case SCI_DELWORDRIGHTEND:
    case SCI_DELLINELEFT:
    case SCI_DELLINERIGHT:
    case SCI_LINECOPY:
    case SCI_LINECUT:
    case SCI_LINEDELETE:
    case SCI_LINETRANSPOSE:
    case SCI_LINEREVERSE:
    case SCI_LINEDUPLICATE:
    case SCI_LOWERCASE:
    case SCI_UPPERCASE:
    case SCI_LINESCROLLDOWN:
    case SCI_LINESCROLLUP:
    case SCI_DELETEBACKNOTLINE:
    case SCI_HOMEDISPLAY:
    case SCI_HOMEDISPLAYEXTEND:
    case SCI_LINEENDDISPLAY:
    case SCI_LINEENDDISPLAYEXTEND:
    case SCI_SETSELECTIONMODE:
    case SCI_LINEDOWNRECTEXTEND:
    case SCI_LINEUPRECTEXTEND:
    case SCI_CHARLEFTRECTEXTEND:
    case SCI_CHARRIGHTRECTEXTEND:
    case SCI_HOMERECTEXTEND:
    case SCI_VCHOMERECTEXTEND:
    case SCI_LINEENDRECTEXTEND:
    case SCI_PAGEUPRECTEXTEND:
    case SCI_PAGEDOWNRECTEXTEND:
    case SCI_SELECTIONDUPLICATE:
    case SCI_COPYALLOWLINE:
    case SCI_VERTICALCENTRECARET:
    case SCI_MOVESELECTEDLINESUP:
    case SCI_MOVESELECTEDLINESDOWN:
    case SCI_SCROLLTOSTART:
    case SCI_SCROLLTOEND:
        break;
 
        // Filter out all others like display changes. Also, newlines are redundant
        // with char insert messages.
    case SCI_NEWLINE:
    default:
        //      printf("Filtered out %ld of macro recording\n", iMessage);
        return;
    }
 
    // Send notification
    SCNotification scn = {};
    scn.nmhdr.code = SCN_MACRORECORD;
    scn.message = iMessage;
    scn.wParam = wParam;
    scn.lParam = lParam;
    NotifyParent(scn);
}
 
// Something has changed that the container should know about
void Editor::ContainerNeedsUpdate(int flags) noexcept {
    needUpdateUI |= flags;
}
 
/**
 * Force scroll and keep position relative to top of window.
 *
 * If stuttered = true and not already at first/last row, move to first/last row of window.
 * If stuttered = true and already at first/last row, scroll as normal.
 */
void Editor::PageMove(int direction, Selection::selTypes selt, bool stuttered) {
    Sci::Line topLineNew;
    SelectionPosition newPos;
 
    const Sci::Line currentLine = pdoc->SciLineFromPosition(sel.MainCaret());
    const Sci::Line topStutterLine = topLine + caretPolicies.y.slop;
    const Sci::Line bottomStutterLine =
        pdoc->SciLineFromPosition(PositionFromLocation(
                    Point::FromInts(lastXChosen - xOffset, direction * vs.lineHeight * static_cast<int>(LinesToScroll()))))
        - caretPolicies.y.slop - 1;
 
    if (stuttered && (direction < 0 && currentLine > topStutterLine)) {
        topLineNew = topLine;
        newPos = SPositionFromLocation(Point::FromInts(lastXChosen - xOffset, vs.lineHeight * caretPolicies.y.slop),
            false, false, UserVirtualSpace());
 
    } else if (stuttered && (direction > 0 && currentLine < bottomStutterLine)) {
        topLineNew = topLine;
        newPos = SPositionFromLocation(Point::FromInts(lastXChosen - xOffset, vs.lineHeight * static_cast<int>(LinesToScroll() - caretPolicies.y.slop)),
            false, false, UserVirtualSpace());
 
    } else {
        const Point pt = LocationFromPosition(sel.MainCaret());
 
        topLineNew = Sci::clamp(
                    topLine + direction * LinesToScroll(), static_cast<Sci::Line>(0), MaxScrollPos());
        newPos = SPositionFromLocation(
            Point::FromInts(lastXChosen - xOffset, static_cast<int>(pt.y) +
                direction * (vs.lineHeight * static_cast<int>(LinesToScroll()))),
            false, false, UserVirtualSpace());
    }
 
    if (topLineNew != topLine) {
        SetTopLine(topLineNew);
        MovePositionTo(newPos, selt);
        Redraw();
        SetVerticalScrollPos();
    } else {
        MovePositionTo(newPos, selt);
    }
}
 
void Editor::ChangeCaseOfSelection(int caseMapping) {
    UndoGroup ug(pdoc);
    for (size_t r=0; r<sel.Count(); r++) {
        SelectionRange current = sel.Range(r);
        SelectionRange currentNoVS = current;
        currentNoVS.ClearVirtualSpace();
        const size_t rangeBytes = currentNoVS.Length();
        if (rangeBytes > 0) {
            std::string sText = RangeText(currentNoVS.Start().Position(), currentNoVS.End().Position());
 
            std::string sMapped = CaseMapString(sText, caseMapping);
 
            if (sMapped != sText) {
                size_t firstDifference = 0;
                while (sMapped[firstDifference] == sText[firstDifference])
                    firstDifference++;
                size_t lastDifferenceText = sText.size() - 1;
                size_t lastDifferenceMapped = sMapped.size() - 1;
                while (sMapped[lastDifferenceMapped] == sText[lastDifferenceText]) {
                    lastDifferenceText--;
                    lastDifferenceMapped--;
                }
                const size_t endDifferenceText = sText.size() - 1 - lastDifferenceText;
                pdoc->DeleteChars(
                    currentNoVS.Start().Position() + firstDifference,
                    rangeBytes - firstDifference - endDifferenceText);
                const Sci::Position lengthChange = lastDifferenceMapped - firstDifference + 1;
                const Sci::Position lengthInserted = pdoc->InsertString(
                    currentNoVS.Start().Position() + firstDifference,
                    sMapped.c_str() + firstDifference,
                    lengthChange);
                // Automatic movement changes selection so reset to exactly the same as it was.
                const Sci::Position diffSizes = sMapped.size() - sText.size() + lengthInserted - lengthChange;
                if (diffSizes != 0) {
                    if (current.anchor > current.caret)
                        current.anchor.Add(diffSizes);
                    else
                        current.caret.Add(diffSizes);
                }
                sel.Range(r) = current;
            }
        }
    }
}
 
void Editor::LineTranspose() {
    const Sci::Line line = pdoc->SciLineFromPosition(sel.MainCaret());
    if (line > 0) {
        UndoGroup ug(pdoc);
 
        const Sci::Position startPrevious = pdoc->LineStart(line - 1);
        const std::string linePrevious = RangeText(startPrevious, pdoc->LineEnd(line - 1));
 
        Sci::Position startCurrent = pdoc->LineStart(line);
        const std::string lineCurrent = RangeText(startCurrent, pdoc->LineEnd(line));
 
        pdoc->DeleteChars(startCurrent, lineCurrent.length());
        pdoc->DeleteChars(startPrevious, linePrevious.length());
        startCurrent -= linePrevious.length();
 
        startCurrent += pdoc->InsertString(startPrevious, lineCurrent.c_str(),
            lineCurrent.length());
        pdoc->InsertString(startCurrent, linePrevious.c_str(),
            linePrevious.length());
        // Move caret to start of current line
        MovePositionTo(SelectionPosition(startCurrent));
    }
}
 
void Editor::LineReverse() {
    const Sci::Line lineStart =
        pdoc->SciLineFromPosition(sel.RangeMain().Start().Position());
    const Sci::Line lineEnd =
        pdoc->SciLineFromPosition(sel.RangeMain().End().Position()-1);
    const Sci::Line lineDiff = lineEnd - lineStart;
    if (lineDiff <= 0)
        return;
    UndoGroup ug(pdoc);
    for (Sci::Line i=(lineDiff+1)/2-1; i>=0; --i) {
        const Sci::Line lineNum2 = lineEnd - i;
        const Sci::Line lineNum1 = lineStart + i;
        Sci::Position lineStart2 = pdoc->LineStart(lineNum2);
        const Sci::Position lineStart1 = pdoc->LineStart(lineNum1);
        const std::string line2 = RangeText(lineStart2, pdoc->LineEnd(lineNum2));
        const std::string line1 = RangeText(lineStart1, pdoc->LineEnd(lineNum1));
        const Sci::Position lineLen2 = line2.length();
        const Sci::Position lineLen1 = line1.length();
        pdoc->DeleteChars(lineStart2, lineLen2);
        pdoc->DeleteChars(lineStart1, lineLen1);
        lineStart2 -= lineLen1;
        pdoc->InsertString(lineStart2, line1.c_str(), lineLen1);
        pdoc->InsertString(lineStart1, line2.c_str(), lineLen2);
    }
    // Wholly select all affected lines
    sel.RangeMain() = SelectionRange(pdoc->LineStart(lineStart),
        pdoc->LineStart(lineEnd+1));
}
 
void Editor::Duplicate(bool forLine) {
    if (sel.Empty()) {
        forLine = true;
    }
    UndoGroup ug(pdoc);
    const char *eol = "";
    Sci::Position eolLen = 0;
    if (forLine) {
        eol = StringFromEOLMode(pdoc->eolMode);
        eolLen = strlen(eol);
    }
    for (size_t r=0; r<sel.Count(); r++) {
        SelectionPosition start = sel.Range(r).Start();
        SelectionPosition end = sel.Range(r).End();
        if (forLine) {
            const Sci::Line line = pdoc->SciLineFromPosition(sel.Range(r).caret.Position());
            start = SelectionPosition(pdoc->LineStart(line));
            end = SelectionPosition(pdoc->LineEnd(line));
        }
        std::string text = RangeText(start.Position(), end.Position());
        Sci::Position lengthInserted = eolLen;
        if (forLine)
            lengthInserted = pdoc->InsertString(end.Position(), eol, eolLen);
        pdoc->InsertString(end.Position() + lengthInserted, text.c_str(), text.length());
    }
    if (sel.Count() && sel.IsRectangular()) {
        SelectionPosition last = sel.Last();
        if (forLine) {
            const Sci::Line line = pdoc->SciLineFromPosition(last.Position());
            last = SelectionPosition(last.Position() +
                pdoc->LineStart(line+1) - pdoc->LineStart(line));
        }
        if (sel.Rectangular().anchor > sel.Rectangular().caret)
            sel.Rectangular().anchor = last;
        else
            sel.Rectangular().caret = last;
        SetRectangularRange();
    }
}
 
void Editor::CancelModes() {
    sel.SetMoveExtends(false);
}
 
void Editor::NewLine() {
    InvalidateWholeSelection();
    if (sel.IsRectangular() || !additionalSelectionTyping) {
        // Remove non-main ranges
        sel.DropAdditionalRanges();
    }
 
    UndoGroup ug(pdoc, !sel.Empty() || (sel.Count() > 1));
 
    // Clear each range
    if (!sel.Empty()) {
        ClearSelection();
    }
 
    // Insert each line end
    size_t countInsertions = 0;
    for (size_t r = 0; r < sel.Count(); r++) {
        sel.Range(r).ClearVirtualSpace();
        const char *eol = StringFromEOLMode(pdoc->eolMode);
        const Sci::Position positionInsert = sel.Range(r).caret.Position();
        const Sci::Position insertLength = pdoc->InsertString(positionInsert, eol, strlen(eol));
        if (insertLength > 0) {
            sel.Range(r) = SelectionRange(positionInsert + insertLength);
            countInsertions++;
        }
    }
 
    // Perform notifications after all the changes as the application may change the
    // selections in response to the characters.
    for (size_t i = 0; i < countInsertions; i++) {
        const char *eol = StringFromEOLMode(pdoc->eolMode);
        while (*eol) {
            NotifyChar(*eol, CharacterSource::directInput);
            if (recordingMacro) {
                char txt[2];
                txt[0] = *eol;
                txt[1] = '\0';
                NotifyMacroRecord(SCI_REPLACESEL, 0, reinterpret_cast<sptr_t>(txt));
            }
            eol++;
        }
    }
 
    SetLastXChosen();
    SetScrollBars();
    EnsureCaretVisible();
    // Avoid blinking during rapid typing:
    ShowCaretAtCurrentPosition();
}
 
SelectionPosition Editor::PositionUpOrDown(SelectionPosition spStart, int direction, int lastX) {
    const Point pt = LocationFromPosition(spStart);
    int skipLines = 0;
 
    if (vs.annotationVisible) {
        const Sci::Line lineDoc = pdoc->SciLineFromPosition(spStart.Position());
        const Point ptStartLine = LocationFromPosition(pdoc->LineStart(lineDoc));
        const int subLine = static_cast<int>(pt.y - ptStartLine.y) / vs.lineHeight;
 
        if (direction < 0 && subLine == 0) {
            const Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
            if (lineDisplay > 0) {
                skipLines = pdoc->AnnotationLines(pcs->DocFromDisplay(lineDisplay - 1));
            }
        } else if (direction > 0 && subLine >= (pcs->GetHeight(lineDoc) - 1 - pdoc->AnnotationLines(lineDoc))) {
            skipLines = pdoc->AnnotationLines(lineDoc);
        }
    }
 
    const Sci::Line newY = static_cast<Sci::Line>(pt.y) + (1 + skipLines) * direction * vs.lineHeight;
    if (lastX < 0) {
        lastX = static_cast<int>(pt.x) + xOffset;
    }
    SelectionPosition posNew = SPositionFromLocation(
        Point::FromInts(lastX - xOffset, static_cast<int>(newY)), false, false, UserVirtualSpace());
 
    if (direction < 0) {
        // Line wrapping may lead to a location on the same line, so
        // seek back if that is the case.
        Point ptNew = LocationFromPosition(posNew.Position());
        while ((posNew.Position() > 0) && (pt.y == ptNew.y)) {
            posNew.Add(-1);
            posNew.SetVirtualSpace(0);
            ptNew = LocationFromPosition(posNew.Position());
        }
    } else if (direction > 0 && posNew.Position() != pdoc->Length()) {
        // There is an equivalent case when moving down which skips
        // over a line.
        Point ptNew = LocationFromPosition(posNew.Position());
        while ((posNew.Position() > spStart.Position()) && (ptNew.y > newY)) {
            posNew.Add(-1);
            posNew.SetVirtualSpace(0);
            ptNew = LocationFromPosition(posNew.Position());
        }
    }
    return posNew;
}
 
void Editor::CursorUpOrDown(int direction, Selection::selTypes selt) {
    if ((selt == Selection::noSel) && sel.MoveExtends()) {
        selt = !sel.IsRectangular() ? Selection::selStream : Selection::selRectangle;
    }
    SelectionPosition caretToUse = sel.Range(sel.Main()).caret;
    if (sel.IsRectangular()) {
        if (selt ==  Selection::noSel) {
            caretToUse = (direction > 0) ? sel.Limits().end : sel.Limits().start;
        } else {
            caretToUse = sel.Rectangular().caret;
        }
    }
    if (selt == Selection::selRectangle) {
        const SelectionRange rangeBase = sel.IsRectangular() ? sel.Rectangular() : sel.RangeMain();
        if (!sel.IsRectangular()) {
            InvalidateWholeSelection();
            sel.DropAdditionalRanges();
        }
        const SelectionPosition posNew = MovePositionSoVisible(
            PositionUpOrDown(caretToUse, direction, lastXChosen), direction);
        sel.selType = Selection::selRectangle;
        sel.Rectangular() = SelectionRange(posNew, rangeBase.anchor);
        SetRectangularRange();
        MovedCaret(posNew, caretToUse, true, caretPolicies);
    } else if (sel.selType == Selection::selLines && sel.MoveExtends()) {
        // Calculate new caret position and call SetSelection(), which will ensure whole lines are selected.
        const SelectionPosition posNew = MovePositionSoVisible(
            PositionUpOrDown(caretToUse, direction, -1), direction);
        SetSelection(posNew, sel.Range(sel.Main()).anchor);
    } else {
        InvalidateWholeSelection();
        if (!additionalSelectionTyping || (sel.IsRectangular())) {
            sel.DropAdditionalRanges();
        }
        sel.selType = Selection::selStream;
        for (size_t r = 0; r < sel.Count(); r++) {
            const int lastX = (r == sel.Main()) ? lastXChosen : -1;
            const SelectionPosition spCaretNow = sel.Range(r).caret;
            const SelectionPosition posNew = MovePositionSoVisible(
                PositionUpOrDown(spCaretNow, direction, lastX), direction);
            sel.Range(r) = selt == Selection::selStream ?
                SelectionRange(posNew, sel.Range(r).anchor) : SelectionRange(posNew);
        }
        sel.RemoveDuplicates();
        MovedCaret(sel.RangeMain().caret, caretToUse, true, caretPolicies);
    }
}
 
void Editor::ParaUpOrDown(int direction, Selection::selTypes selt) {
    Sci::Line lineDoc;
    const Sci::Position savedPos = sel.MainCaret();
    do {
        MovePositionTo(SelectionPosition(direction > 0 ? pdoc->ParaDown(sel.MainCaret()) : pdoc->ParaUp(sel.MainCaret())), selt);
        lineDoc = pdoc->SciLineFromPosition(sel.MainCaret());
        if (direction > 0) {
            if (sel.MainCaret() >= pdoc->Length() && !pcs->GetVisible(lineDoc)) {
                if (selt == Selection::noSel) {
                    MovePositionTo(SelectionPosition(pdoc->LineEndPosition(savedPos)));
                }
                break;
            }
        }
    } while (!pcs->GetVisible(lineDoc));
}
 
Range Editor::RangeDisplayLine(Sci::Line lineVisible) {
    RefreshStyleData();
    AutoSurface surface(this);
    return view.RangeDisplayLine(surface, *this, lineVisible, vs);
}
 
Sci::Position Editor::StartEndDisplayLine(Sci::Position pos, bool start) {
    RefreshStyleData();
    AutoSurface surface(this);
    const Sci::Position posRet = view.StartEndDisplayLine(surface, *this, pos, start, vs);
    if (posRet == INVALID_POSITION) {
        return pos;
    } else {
        return posRet;
    }
}
 
namespace {
 
constexpr short HighShortFromWParam(uptr_t x) {
    return static_cast<short>(x >> 16);
}
 
constexpr short LowShortFromWParam(uptr_t x) {
    return static_cast<short>(x & 0xffff);
}
 
unsigned int WithExtends(unsigned int iMessage) noexcept {
    switch (iMessage) {
    case SCI_CHARLEFT: return SCI_CHARLEFTEXTEND;
    case SCI_CHARRIGHT: return SCI_CHARRIGHTEXTEND;
 
    case SCI_WORDLEFT: return SCI_WORDLEFTEXTEND;
    case SCI_WORDRIGHT: return SCI_WORDRIGHTEXTEND;
    case SCI_WORDLEFTEND: return SCI_WORDLEFTENDEXTEND;
    case SCI_WORDRIGHTEND: return SCI_WORDRIGHTENDEXTEND;
    case SCI_WORDPARTLEFT: return SCI_WORDPARTLEFTEXTEND;
    case SCI_WORDPARTRIGHT: return SCI_WORDPARTRIGHTEXTEND;
 
    case SCI_HOME: return SCI_HOMEEXTEND;
    case SCI_HOMEDISPLAY: return SCI_HOMEDISPLAYEXTEND;
    case SCI_HOMEWRAP: return SCI_HOMEWRAPEXTEND;
    case SCI_VCHOME: return SCI_VCHOMEEXTEND;
    case SCI_VCHOMEDISPLAY: return SCI_VCHOMEDISPLAYEXTEND;
    case SCI_VCHOMEWRAP: return SCI_VCHOMEWRAPEXTEND;
 
    case SCI_LINEEND: return SCI_LINEENDEXTEND;
    case SCI_LINEENDDISPLAY: return SCI_LINEENDDISPLAYEXTEND;
    case SCI_LINEENDWRAP: return SCI_LINEENDWRAPEXTEND;
 
    default:    return iMessage;
    }
}
 
int NaturalDirection(unsigned int iMessage) noexcept {
    switch (iMessage) {
    case SCI_CHARLEFT:
    case SCI_CHARLEFTEXTEND:
    case SCI_CHARLEFTRECTEXTEND:
    case SCI_WORDLEFT:
    case SCI_WORDLEFTEXTEND:
    case SCI_WORDLEFTEND:
    case SCI_WORDLEFTENDEXTEND:
    case SCI_WORDPARTLEFT:
    case SCI_WORDPARTLEFTEXTEND:
    case SCI_HOME:
    case SCI_HOMEEXTEND:
    case SCI_HOMEDISPLAY:
    case SCI_HOMEDISPLAYEXTEND:
    case SCI_HOMEWRAP:
    case SCI_HOMEWRAPEXTEND:
        // VC_HOME* mostly goes back
    case SCI_VCHOME:
    case SCI_VCHOMEEXTEND:
    case SCI_VCHOMEDISPLAY:
    case SCI_VCHOMEDISPLAYEXTEND:
    case SCI_VCHOMEWRAP:
    case SCI_VCHOMEWRAPEXTEND:
        return -1;
 
    default:
        return 1;
    }
}
 
bool IsRectExtend(unsigned int iMessage, bool isRectMoveExtends) noexcept {
    switch (iMessage) {
    case SCI_CHARLEFTRECTEXTEND:
    case SCI_CHARRIGHTRECTEXTEND:
    case SCI_HOMERECTEXTEND:
    case SCI_VCHOMERECTEXTEND:
    case SCI_LINEENDRECTEXTEND:
        return true;
    default:
        if (isRectMoveExtends) {
            // Handle SCI_SETSELECTIONMODE(SC_SEL_RECTANGLE) and subsequent movements.
            switch (iMessage) {
            case SCI_CHARLEFTEXTEND:
            case SCI_CHARRIGHTEXTEND:
            case SCI_HOMEEXTEND:
            case SCI_VCHOMEEXTEND:
            case SCI_LINEENDEXTEND:
                return true;
            default:
                return false;
            }
        }
        return false;
    }
}
 
}
 
Sci::Position Editor::VCHomeDisplayPosition(Sci::Position position) {
    const Sci::Position homePos = pdoc->VCHomePosition(position);
    const Sci::Position viewLineStart = StartEndDisplayLine(position, true);
    if (viewLineStart > homePos)
        return viewLineStart;
    else
        return homePos;
}
 
Sci::Position Editor::VCHomeWrapPosition(Sci::Position position) {
    const Sci::Position homePos = pdoc->VCHomePosition(position);
    const Sci::Position viewLineStart = StartEndDisplayLine(position, true);
    if ((viewLineStart < position) && (viewLineStart > homePos))
        return viewLineStart;
    else
        return homePos;
}
 
Sci::Position Editor::LineEndWrapPosition(Sci::Position position) {
    const Sci::Position endPos = StartEndDisplayLine(position, false);
    const Sci::Position realEndPos = pdoc->LineEndPosition(position);
    if (endPos > realEndPos      // if moved past visible EOLs
        || position >= endPos) // if at end of display line already
        return realEndPos;
    else
        return endPos;
}
 
int Editor::HorizontalMove(unsigned int iMessage) {
    if (sel.selType == Selection::selLines) {
        return 0; // horizontal moves with line selection have no effect
    }
    if (sel.MoveExtends()) {
        iMessage = WithExtends(iMessage);
    }
 
    if (!multipleSelection && !sel.IsRectangular()) {
        // Simplify selection down to 1
        sel.SetSelection(sel.RangeMain());
    }
 
    // Invalidate each of the current selections
    InvalidateWholeSelection();
 
    if (IsRectExtend(iMessage, sel.IsRectangular() && sel.MoveExtends())) {
        const SelectionRange rangeBase = sel.IsRectangular() ? sel.Rectangular() : sel.RangeMain();
        if (!sel.IsRectangular()) {
            sel.DropAdditionalRanges();
        }
        // Will change to rectangular if not currently rectangular
        SelectionPosition spCaret = rangeBase.caret;
        switch (iMessage) {
        case SCI_CHARLEFTRECTEXTEND:
        case SCI_CHARLEFTEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
            if (pdoc->IsLineEndPosition(spCaret.Position()) && spCaret.VirtualSpace()) {
                spCaret.SetVirtualSpace(spCaret.VirtualSpace() - 1);
            } else if ((virtualSpaceOptions & SCVS_NOWRAPLINESTART) == 0 || pdoc->GetColumn(spCaret.Position()) > 0) {
                spCaret = SelectionPosition(spCaret.Position() - 1);
            }
            break;
        case SCI_CHARRIGHTRECTEXTEND:
        case SCI_CHARRIGHTEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
            if ((virtualSpaceOptions & SCVS_RECTANGULARSELECTION) && pdoc->IsLineEndPosition(sel.MainCaret())) {
                spCaret.SetVirtualSpace(spCaret.VirtualSpace() + 1);
            } else {
                spCaret = SelectionPosition(spCaret.Position() + 1);
            }
            break;
        case SCI_HOMERECTEXTEND:
        case SCI_HOMEEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
            spCaret = SelectionPosition(
                pdoc->LineStart(pdoc->LineFromPosition(spCaret.Position())));
            break;
        case SCI_VCHOMERECTEXTEND:
        case SCI_VCHOMEEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
            spCaret = SelectionPosition(pdoc->VCHomePosition(spCaret.Position()));
            break;
        case SCI_LINEENDRECTEXTEND:
        case SCI_LINEENDEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
            spCaret = SelectionPosition(pdoc->LineEndPosition(spCaret.Position()));
            break;
        }
        const int directionMove = (spCaret < rangeBase.caret) ? -1 : 1;
        spCaret = MovePositionSoVisible(spCaret, directionMove);
        sel.selType = Selection::selRectangle;
        sel.Rectangular() = SelectionRange(spCaret, rangeBase.anchor);
        SetRectangularRange();
    } else if (sel.IsRectangular()) {
        // Not a rectangular extension so switch to stream.
        SelectionPosition selAtLimit = (NaturalDirection(iMessage) > 0) ? sel.Limits().end : sel.Limits().start;
        switch (iMessage) {
        case SCI_HOME:
            selAtLimit = SelectionPosition(
                pdoc->LineStart(pdoc->LineFromPosition(selAtLimit.Position())));
            break;
        case SCI_VCHOME:
            selAtLimit = SelectionPosition(pdoc->VCHomePosition(selAtLimit.Position()));
            break;
        case SCI_LINEEND:
            selAtLimit = SelectionPosition(pdoc->LineEndPosition(selAtLimit.Position()));
            break;
        }
        sel.selType = Selection::selStream;
        sel.SetSelection(SelectionRange(selAtLimit));
    } else {
        if (!additionalSelectionTyping) {
            InvalidateWholeSelection();
            sel.DropAdditionalRanges();
        }
        for (size_t r = 0; r < sel.Count(); r++) {
            const SelectionPosition spCaretNow = sel.Range(r).caret;
            SelectionPosition spCaret = spCaretNow;
            switch (iMessage) {
            case SCI_CHARLEFT:
            case SCI_CHARLEFTEXTEND:
                if (spCaret.VirtualSpace()) {
                    spCaret.SetVirtualSpace(spCaret.VirtualSpace() - 1);
                } else if ((virtualSpaceOptions & SCVS_NOWRAPLINESTART) == 0 || pdoc->GetColumn(spCaret.Position()) > 0) {
                    spCaret = SelectionPosition(spCaret.Position() - 1);
                }
                break;
            case SCI_CHARRIGHT:
            case SCI_CHARRIGHTEXTEND:
                if ((virtualSpaceOptions & SCVS_USERACCESSIBLE) && pdoc->IsLineEndPosition(spCaret.Position())) {
                    spCaret.SetVirtualSpace(spCaret.VirtualSpace() + 1);
                } else {
                    spCaret = SelectionPosition(spCaret.Position() + 1);
                }
                break;
            case SCI_WORDLEFT:
            case SCI_WORDLEFTEXTEND:
                spCaret = SelectionPosition(pdoc->NextWordStart(spCaret.Position(), -1));
                break;
            case SCI_WORDRIGHT:
            case SCI_WORDRIGHTEXTEND:
                spCaret = SelectionPosition(pdoc->NextWordStart(spCaret.Position(), 1));
                break;
            case SCI_WORDLEFTEND:
            case SCI_WORDLEFTENDEXTEND:
                spCaret = SelectionPosition(pdoc->NextWordEnd(spCaret.Position(), -1));
                break;
            case SCI_WORDRIGHTEND:
            case SCI_WORDRIGHTENDEXTEND:
                spCaret = SelectionPosition(pdoc->NextWordEnd(spCaret.Position(), 1));
                break;
            case SCI_WORDPARTLEFT:
            case SCI_WORDPARTLEFTEXTEND:
                spCaret = SelectionPosition(pdoc->WordPartLeft(spCaret.Position()));
                break;
            case SCI_WORDPARTRIGHT:
            case SCI_WORDPARTRIGHTEXTEND:
                spCaret = SelectionPosition(pdoc->WordPartRight(spCaret.Position()));
                break;
            case SCI_HOME:
            case SCI_HOMEEXTEND:
                spCaret = SelectionPosition(
                    pdoc->LineStart(pdoc->LineFromPosition(spCaret.Position())));
                break;
            case SCI_HOMEDISPLAY:
            case SCI_HOMEDISPLAYEXTEND:
                spCaret = SelectionPosition(StartEndDisplayLine(spCaret.Position(), true));
                break;
            case SCI_HOMEWRAP:
            case SCI_HOMEWRAPEXTEND:
                spCaret = MovePositionSoVisible(StartEndDisplayLine(spCaret.Position(), true), -1);
                if (spCaretNow <= spCaret)
                    spCaret = SelectionPosition(
                        pdoc->LineStart(pdoc->LineFromPosition(spCaret.Position())));
                break;
            case SCI_VCHOME:
            case SCI_VCHOMEEXTEND:
                // VCHome alternates between beginning of line and beginning of text so may move back or forwards
                spCaret = SelectionPosition(pdoc->VCHomePosition(spCaret.Position()));
                break;
            case SCI_VCHOMEDISPLAY:
            case SCI_VCHOMEDISPLAYEXTEND:
                spCaret = SelectionPosition(VCHomeDisplayPosition(spCaret.Position()));
                break;
            case SCI_VCHOMEWRAP:
            case SCI_VCHOMEWRAPEXTEND:
                spCaret = SelectionPosition(VCHomeWrapPosition(spCaret.Position()));
                break;
            case SCI_LINEEND:
            case SCI_LINEENDEXTEND:
                spCaret = SelectionPosition(pdoc->LineEndPosition(spCaret.Position()));
                break;
            case SCI_LINEENDDISPLAY:
            case SCI_LINEENDDISPLAYEXTEND:
                spCaret = SelectionPosition(StartEndDisplayLine(spCaret.Position(), false));
                break;
            case SCI_LINEENDWRAP:
            case SCI_LINEENDWRAPEXTEND:
                spCaret = SelectionPosition(LineEndWrapPosition(spCaret.Position()));
                break;
 
            default:
                PLATFORM_ASSERT(false);
            }
 
            const int directionMove = (spCaret < spCaretNow) ? -1 : 1;
            spCaret = MovePositionSoVisible(spCaret, directionMove);
 
            // Handle move versus extend, and special behaviour for non-empty left/right
            switch (iMessage) {
            case SCI_CHARLEFT:
            case SCI_CHARRIGHT:
                if (sel.Range(r).Empty()) {
                    sel.Range(r) = SelectionRange(spCaret);
                } else {
                    sel.Range(r) = SelectionRange(
                        (iMessage == SCI_CHARLEFT) ? sel.Range(r).Start() : sel.Range(r).End());
                }
                break;
 
            case SCI_WORDLEFT:
            case SCI_WORDRIGHT:
            case SCI_WORDLEFTEND:
            case SCI_WORDRIGHTEND:
            case SCI_WORDPARTLEFT:
            case SCI_WORDPARTRIGHT:
            case SCI_HOME:
            case SCI_HOMEDISPLAY:
            case SCI_HOMEWRAP:
            case SCI_VCHOME:
            case SCI_VCHOMEDISPLAY:
            case SCI_VCHOMEWRAP:
            case SCI_LINEEND:
            case SCI_LINEENDDISPLAY:
            case SCI_LINEENDWRAP:
                sel.Range(r) = SelectionRange(spCaret);
                break;
 
            case SCI_CHARLEFTEXTEND:
            case SCI_CHARRIGHTEXTEND:
            case SCI_WORDLEFTEXTEND:
            case SCI_WORDRIGHTEXTEND:
            case SCI_WORDLEFTENDEXTEND:
            case SCI_WORDRIGHTENDEXTEND:
            case SCI_WORDPARTLEFTEXTEND:
            case SCI_WORDPARTRIGHTEXTEND:
            case SCI_HOMEEXTEND:
            case SCI_HOMEDISPLAYEXTEND:
            case SCI_HOMEWRAPEXTEND:
            case SCI_VCHOMEEXTEND:
            case SCI_VCHOMEDISPLAYEXTEND:
            case SCI_VCHOMEWRAPEXTEND:
            case SCI_LINEENDEXTEND:
            case SCI_LINEENDDISPLAYEXTEND:
            case SCI_LINEENDWRAPEXTEND: {
                SelectionRange rangeNew = SelectionRange(spCaret, sel.Range(r).anchor);
                sel.TrimOtherSelections(r, SelectionRange(rangeNew));
                sel.Range(r) = rangeNew;
                }
                break;
 
            default:
                PLATFORM_ASSERT(false);
            }
        }
    }
 
    sel.RemoveDuplicates();
 
    MovedCaret(sel.RangeMain().caret, SelectionPosition(INVALID_POSITION), true, caretPolicies);
 
    // Invalidate the new state of the selection
    InvalidateWholeSelection();
 
    SetLastXChosen();
    // Need the line moving and so forth from MovePositionTo
    return 0;
}
 
int Editor::DelWordOrLine(unsigned int iMessage) {
    // Virtual space may be realised for SCI_DELWORDRIGHT or SCI_DELWORDRIGHTEND
    // which means 2 actions so wrap in an undo group.
 
    // Rightwards and leftwards deletions differ in treatment of virtual space.
    // Clear virtual space for leftwards, realise for rightwards.
    const bool leftwards = (iMessage == SCI_DELWORDLEFT) || (iMessage == SCI_DELLINELEFT);
 
    if (!additionalSelectionTyping) {
        InvalidateWholeSelection();
        sel.DropAdditionalRanges();
    }
 
    UndoGroup ug0(pdoc, (sel.Count() > 1) || !leftwards);
 
    for (size_t r = 0; r < sel.Count(); r++) {
        if (leftwards) {
            // Delete to the left so first clear the virtual space.
            sel.Range(r).ClearVirtualSpace();
        } else {
            // Delete to the right so first realise the virtual space.
            sel.Range(r) = SelectionRange(
                RealizeVirtualSpace(sel.Range(r).caret));
        }
 
        Range rangeDelete;
        switch (iMessage) {
        case SCI_DELWORDLEFT:
            rangeDelete = Range(
                pdoc->NextWordStart(sel.Range(r).caret.Position(), -1),
                sel.Range(r).caret.Position());
            break;
        case SCI_DELWORDRIGHT:
            rangeDelete = Range(
                sel.Range(r).caret.Position(),
                pdoc->NextWordStart(sel.Range(r).caret.Position(), 1));
            break;
        case SCI_DELWORDRIGHTEND:
            rangeDelete = Range(
                sel.Range(r).caret.Position(),
                pdoc->NextWordEnd(sel.Range(r).caret.Position(), 1));
            break;
        case SCI_DELLINELEFT:
            rangeDelete = Range(
                pdoc->LineStart(pdoc->LineFromPosition(sel.Range(r).caret.Position())),
                sel.Range(r).caret.Position());
            break;
        case SCI_DELLINERIGHT:
            rangeDelete = Range(
                sel.Range(r).caret.Position(),
                pdoc->LineEnd(pdoc->LineFromPosition(sel.Range(r).caret.Position())));
            break;
        }
        if (!RangeContainsProtected(rangeDelete.start, rangeDelete.end)) {
            pdoc->DeleteChars(rangeDelete.start, rangeDelete.end - rangeDelete.start);
        }
    }
 
    // May need something stronger here: can selections overlap at this point?
    sel.RemoveDuplicates();
 
    MovedCaret(sel.RangeMain().caret, SelectionPosition(INVALID_POSITION), true, caretPolicies);
 
    // Invalidate the new state of the selection
    InvalidateWholeSelection();
 
    SetLastXChosen();
    return 0;
}
 
int Editor::KeyCommand(unsigned int iMessage) {
    switch (iMessage) {
    case SCI_LINEDOWN:
        CursorUpOrDown(1, Selection::noSel);
        break;
    case SCI_LINEDOWNEXTEND:
        CursorUpOrDown(1, Selection::selStream);
        break;
    case SCI_LINEDOWNRECTEXTEND:
        CursorUpOrDown(1, Selection::selRectangle);
        break;
    case SCI_PARADOWN:
        ParaUpOrDown(1, Selection::noSel);
        break;
    case SCI_PARADOWNEXTEND:
        ParaUpOrDown(1, Selection::selStream);
        break;
    case SCI_LINESCROLLDOWN:
        ScrollTo(topLine + 1);
        MoveCaretInsideView(false);
        break;
    case SCI_LINEUP:
        CursorUpOrDown(-1, Selection::noSel);
        break;
    case SCI_LINEUPEXTEND:
        CursorUpOrDown(-1, Selection::selStream);
        break;
    case SCI_LINEUPRECTEXTEND:
        CursorUpOrDown(-1, Selection::selRectangle);
        break;
    case SCI_PARAUP:
        ParaUpOrDown(-1, Selection::noSel);
        break;
    case SCI_PARAUPEXTEND:
        ParaUpOrDown(-1, Selection::selStream);
        break;
    case SCI_LINESCROLLUP:
        ScrollTo(topLine - 1);
        MoveCaretInsideView(false);
        break;
 
    case SCI_CHARLEFT:
    case SCI_CHARLEFTEXTEND:
    case SCI_CHARLEFTRECTEXTEND:
    case SCI_CHARRIGHT:
    case SCI_CHARRIGHTEXTEND:
    case SCI_CHARRIGHTRECTEXTEND:
    case SCI_WORDLEFT:
    case SCI_WORDLEFTEXTEND:
    case SCI_WORDRIGHT:
    case SCI_WORDRIGHTEXTEND:
    case SCI_WORDLEFTEND:
    case SCI_WORDLEFTENDEXTEND:
    case SCI_WORDRIGHTEND:
    case SCI_WORDRIGHTENDEXTEND:
    case SCI_WORDPARTLEFT:
    case SCI_WORDPARTLEFTEXTEND:
    case SCI_WORDPARTRIGHT:
    case SCI_WORDPARTRIGHTEXTEND:
    case SCI_HOME:
    case SCI_HOMEEXTEND:
    case SCI_HOMERECTEXTEND:
    case SCI_HOMEDISPLAY:
    case SCI_HOMEDISPLAYEXTEND:
    case SCI_HOMEWRAP:
    case