aboutsummaryrefslogtreecommitdiffhomepage
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Editor.cxx4677
-rw-r--r--src/Editor.h199
-rw-r--r--src/PositionCache.cxx25
-rw-r--r--src/PositionCache.h5
4 files changed, 2511 insertions, 2395 deletions
diff --git a/src/Editor.cxx b/src/Editor.cxx
index 89b61a222..360540a83 100644
--- a/src/Editor.cxx
+++ b/src/Editor.cxx
@@ -102,12 +102,2293 @@ static inline bool IsAllSpacesOrTabs(char *s, unsigned int len) {
return true;
}
+EditModel::EditModel() {
+ inOverstrike = false;
+ xOffset = 0;
+ trackLineWidth = false;
+ posDrag = SelectionPosition(invalidPosition);
+ braces[0] = invalidPosition;
+ braces[1] = invalidPosition;
+ bracesMatchStyle = STYLE_BRACEBAD;
+ highlightGuideColumn = 0;
+ primarySelection = true;
+ foldFlags = 0;
+ hotspot = Range(invalidPosition);
+ wrapWidth = LineLayout::wrapWidthInfinite;
+ pdoc = new Document();
+ pdoc->AddRef();
+}
+
+EditModel::~EditModel() {
+ pdoc->Release();
+ pdoc = 0;
+}
+
+bool ValidStyledText(const ViewStyle &vs, size_t styleOffset, const StyledText &st) {
+ if (st.multipleStyles) {
+ for (size_t iStyle = 0; iStyle<st.length; iStyle++) {
+ if (!vs.ValidStyle(styleOffset + st.styles[iStyle]))
+ return false;
+ }
+ } else {
+ if (!vs.ValidStyle(styleOffset + st.style))
+ return false;
+ }
+ return true;
+}
+
+static int WidthStyledText(Surface *surface, const ViewStyle &vs, int styleOffset,
+ const char *text, const unsigned char *styles, size_t len) {
+ int width = 0;
+ size_t start = 0;
+ while (start < len) {
+ size_t style = styles[start];
+ size_t endSegment = start;
+ while ((endSegment + 1 < len) && (static_cast<size_t>(styles[endSegment + 1]) == style))
+ endSegment++;
+ FontAlias fontText = vs.styles[style + styleOffset].font;
+ width += static_cast<int>(surface->WidthText(fontText, text + start,
+ static_cast<int>(endSegment - start + 1)));
+ start = endSegment + 1;
+ }
+ return width;
+}
+
+static int WidestLineWidth(Surface *surface, const ViewStyle &vs, int styleOffset, const StyledText &st) {
+ int widthMax = 0;
+ size_t start = 0;
+ while (start < st.length) {
+ size_t lenLine = st.LineLength(start);
+ int widthSubLine;
+ if (st.multipleStyles) {
+ widthSubLine = WidthStyledText(surface, vs, styleOffset, st.text + start, st.styles + start, lenLine);
+ } else {
+ FontAlias fontText = vs.styles[styleOffset + st.style].font;
+ widthSubLine = static_cast<int>(surface->WidthText(fontText,
+ st.text + start, static_cast<int>(lenLine)));
+ }
+ if (widthSubLine > widthMax)
+ widthMax = widthSubLine;
+ start += lenLine + 1;
+ }
+ return widthMax;
+}
+
+static void DrawTextInStyle(Surface *surface, PRectangle rcText, const Style &style, XYPOSITION ybase, const char *s, size_t length) {
+ FontAlias fontText = style.font;
+ surface->DrawTextNoClip(rcText, fontText, ybase, s, static_cast<int>(length),
+ style.fore, style.back);
+}
+
+static void DrawStyledText(Surface *surface, const ViewStyle &vs, int styleOffset, PRectangle rcText,
+ const StyledText &st, size_t start, size_t length) {
+
+ if (st.multipleStyles) {
+ int x = static_cast<int>(rcText.left);
+ size_t i = 0;
+ while (i < length) {
+ size_t end = i;
+ size_t style = st.styles[i + start];
+ while (end < length - 1 && st.styles[start + end + 1] == style)
+ end++;
+ style += styleOffset;
+ FontAlias fontText = vs.styles[style].font;
+ const int width = static_cast<int>(surface->WidthText(fontText,
+ st.text + start + i, static_cast<int>(end - i + 1)));
+ PRectangle rcSegment = rcText;
+ rcSegment.left = static_cast<XYPOSITION>(x);
+ rcSegment.right = static_cast<XYPOSITION>(x + width + 1);
+ DrawTextInStyle(surface, rcSegment, vs.styles[style], rcText.top + vs.maxAscent,
+ st.text + start + i, end - i + 1);
+ x += width;
+ i = end + 1;
+ }
+ } else {
+ const size_t style = st.style + styleOffset;
+ DrawTextInStyle(surface, rcText, vs.styles[style], rcText.top + vs.maxAscent,
+ st.text + start, length);
+ }
+}
+
+static void DrawWrapMarker(Surface *surface, PRectangle rcPlace,
+ bool isEndMarker, ColourDesired wrapColour) {
+ surface->PenColour(wrapColour);
+
+ enum { xa = 1 }; // gap before start
+ int w = static_cast<int>(rcPlace.right - rcPlace.left) - xa - 1;
+
+ bool xStraight = isEndMarker; // x-mirrored symbol for start marker
+
+ int x0 = static_cast<int>(xStraight ? rcPlace.left : rcPlace.right - 1);
+ int y0 = static_cast<int>(rcPlace.top);
+
+ int dy = static_cast<int>(rcPlace.bottom - rcPlace.top) / 5;
+ int y = static_cast<int>(rcPlace.bottom - rcPlace.top) / 2 + dy;
+
+ struct Relative {
+ Surface *surface;
+ int xBase;
+ int xDir;
+ int yBase;
+ int yDir;
+ void MoveTo(int xRelative, int yRelative) {
+ surface->MoveTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
+ }
+ void LineTo(int xRelative, int yRelative) {
+ surface->LineTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
+ }
+ };
+ Relative rel = { surface, x0, xStraight ? 1 : -1, y0, 1 };
+
+ // arrow head
+ rel.MoveTo(xa, y);
+ rel.LineTo(xa + 2 * w / 3, y - dy);
+ rel.MoveTo(xa, y);
+ rel.LineTo(xa + 2 * w / 3, y + dy);
+
+ // arrow body
+ rel.MoveTo(xa, y);
+ rel.LineTo(xa + w, y);
+ rel.LineTo(xa + w, y - 2 * dy);
+ rel.LineTo(xa - 1, // on windows lineto is exclusive endpoint, perhaps GTK not...
+ y - 2 * dy);
+}
+
+MarginView::MarginView() {
+ pixmapSelMargin = 0;
+ pixmapSelPattern = 0;
+ pixmapSelPatternOffset1 = 0;
+}
+
+void MarginView::DropGraphics(bool freeObjects) {
+ if (freeObjects) {
+ delete pixmapSelMargin;
+ pixmapSelMargin = 0;
+ delete pixmapSelPattern;
+ pixmapSelPattern = 0;
+ delete pixmapSelPatternOffset1;
+ pixmapSelPatternOffset1 = 0;
+ } else {
+ if (pixmapSelMargin)
+ pixmapSelMargin->Release();
+ if (pixmapSelPattern)
+ pixmapSelPattern->Release();
+ if (pixmapSelPatternOffset1)
+ pixmapSelPatternOffset1->Release();
+ }
+}
+
+void MarginView::AllocateGraphics(const ViewStyle &vsDraw) {
+ if (!pixmapSelMargin)
+ pixmapSelMargin = Surface::Allocate(vsDraw.technology);
+ if (!pixmapSelPattern)
+ pixmapSelPattern = Surface::Allocate(vsDraw.technology);
+ if (!pixmapSelPatternOffset1)
+ pixmapSelPatternOffset1 = Surface::Allocate(vsDraw.technology);
+}
+
+void MarginView::RefreshPixMaps(Surface *surfaceWindow, WindowID wid, const ViewStyle &vsDraw) {
+ if (!pixmapSelPattern->Initialised()) {
+ const int patternSize = 8;
+ pixmapSelPattern->InitPixMap(patternSize, patternSize, surfaceWindow, wid);
+ pixmapSelPatternOffset1->InitPixMap(patternSize, patternSize, surfaceWindow, wid);
+ // This complex procedure is to reproduce the checkerboard dithered pattern used by windows
+ // for scroll bars and Visual Studio for its selection margin. The colour of this pattern is half
+ // way between the chrome colour and the chrome highlight colour making a nice transition
+ // between the window chrome and the content area. And it works in low colour depths.
+ PRectangle rcPattern = PRectangle::FromInts(0, 0, patternSize, patternSize);
+
+ // Initialize default colours based on the chrome colour scheme. Typically the highlight is white.
+ ColourDesired colourFMFill = vsDraw.selbar;
+ ColourDesired colourFMStripes = vsDraw.selbarlight;
+
+ if (!(vsDraw.selbarlight == ColourDesired(0xff, 0xff, 0xff))) {
+ // User has chosen an unusual chrome colour scheme so just use the highlight edge colour.
+ // (Typically, the highlight colour is white.)
+ colourFMFill = vsDraw.selbarlight;
+ }
+
+ if (vsDraw.foldmarginColour.isSet) {
+ // override default fold margin colour
+ colourFMFill = vsDraw.foldmarginColour;
+ }
+ if (vsDraw.foldmarginHighlightColour.isSet) {
+ // override default fold margin highlight colour
+ colourFMStripes = vsDraw.foldmarginHighlightColour;
+ }
+
+ pixmapSelPattern->FillRectangle(rcPattern, colourFMFill);
+ pixmapSelPatternOffset1->FillRectangle(rcPattern, colourFMStripes);
+ for (int y = 0; y < patternSize; y++) {
+ for (int x = y % 2; x < patternSize; x += 2) {
+ PRectangle rcPixel = PRectangle::FromInts(x, y, x + 1, y + 1);
+ pixmapSelPattern->FillRectangle(rcPixel, colourFMStripes);
+ pixmapSelPatternOffset1->FillRectangle(rcPixel, colourFMFill);
+ }
+ }
+ }
+}
+
+static int SubstituteMarkerIfEmpty(int markerCheck, int markerDefault, const ViewStyle &vs) {
+ if (vs.markers[markerCheck].markType == SC_MARK_EMPTY)
+ return markerDefault;
+ return markerCheck;
+}
+
+void MarginView::PaintMargin(Surface *surface, int topLine, PRectangle rc, PRectangle rcMargin,
+ const EditModel &model, const ViewStyle &vs) {
+
+ PRectangle rcSelMargin = rcMargin;
+ rcSelMargin.right = rcMargin.left;
+ if (rcSelMargin.bottom < rc.bottom)
+ rcSelMargin.bottom = rc.bottom;
+
+ Point ptOrigin = model.GetVisibleOriginInMain();
+ FontAlias fontLineNumber = vs.styles[STYLE_LINENUMBER].font;
+ for (int margin = 0; margin <= SC_MAX_MARGIN; margin++) {
+ if (vs.ms[margin].width > 0) {
+
+ rcSelMargin.left = rcSelMargin.right;
+ rcSelMargin.right = rcSelMargin.left + vs.ms[margin].width;
+
+ if (vs.ms[margin].style != SC_MARGIN_NUMBER) {
+ if (vs.ms[margin].mask & SC_MASK_FOLDERS) {
+ // Required because of special way brush is created for selection margin
+ // Ensure patterns line up when scrolling with separate margin view
+ // by choosing correctly aligned variant.
+ bool invertPhase = static_cast<int>(ptOrigin.y) & 1;
+ surface->FillRectangle(rcSelMargin,
+ invertPhase ? *pixmapSelPattern : *pixmapSelPatternOffset1);
+ } else {
+ ColourDesired colour;
+ switch (vs.ms[margin].style) {
+ case SC_MARGIN_BACK:
+ colour = vs.styles[STYLE_DEFAULT].back;
+ break;
+ case SC_MARGIN_FORE:
+ colour = vs.styles[STYLE_DEFAULT].fore;
+ break;
+ default:
+ colour = vs.styles[STYLE_LINENUMBER].back;
+ break;
+ }
+ surface->FillRectangle(rcSelMargin, colour);
+ }
+ } else {
+ surface->FillRectangle(rcSelMargin, vs.styles[STYLE_LINENUMBER].back);
+ }
+
+ const int lineStartPaint = static_cast<int>(rcMargin.top + ptOrigin.y) / vs.lineHeight;
+ int visibleLine = model.TopLineOfMain() + lineStartPaint;
+ int yposScreen = lineStartPaint * vs.lineHeight - static_cast<int>(ptOrigin.y);
+ // Work out whether the top line is whitespace located after a
+ // lessening of fold level which implies a 'fold tail' but which should not
+ // be displayed until the last of a sequence of whitespace.
+ bool needWhiteClosure = false;
+ if (vs.ms[margin].mask & SC_MASK_FOLDERS) {
+ int level = model.pdoc->GetLevel(model.cs.DocFromDisplay(visibleLine));
+ if (level & SC_FOLDLEVELWHITEFLAG) {
+ int lineBack = model.cs.DocFromDisplay(visibleLine);
+ int levelPrev = level;
+ while ((lineBack > 0) && (levelPrev & SC_FOLDLEVELWHITEFLAG)) {
+ lineBack--;
+ levelPrev = model.pdoc->GetLevel(lineBack);
+ }
+ if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) {
+ if ((level & SC_FOLDLEVELNUMBERMASK) < (levelPrev & SC_FOLDLEVELNUMBERMASK))
+ needWhiteClosure = true;
+ }
+ }
+ if (highlightDelimiter.isEnabled) {
+ int lastLine = model.cs.DocFromDisplay(topLine + model.LinesOnScreen()) + 1;
+ model.pdoc->GetHighlightDelimiters(highlightDelimiter, model.pdoc->LineFromPosition(model.sel.MainCaret()), lastLine);
+ }
+ }
+
+ // Old code does not know about new markers needed to distinguish all cases
+ const int folderOpenMid = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEROPENMID,
+ SC_MARKNUM_FOLDEROPEN, vs);
+ const int folderEnd = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEREND,
+ SC_MARKNUM_FOLDER, vs);
+
+ while ((visibleLine < model.cs.LinesDisplayed()) && yposScreen < rc.bottom) {
+
+ PLATFORM_ASSERT(visibleLine < model.cs.LinesDisplayed());
+ const int lineDoc = model.cs.DocFromDisplay(visibleLine);
+ PLATFORM_ASSERT(model.cs.GetVisible(lineDoc));
+ const bool firstSubLine = visibleLine == model.cs.DisplayFromDoc(lineDoc);
+ const bool lastSubLine = visibleLine == model.cs.DisplayLastFromDoc(lineDoc);
+
+ int marks = model.pdoc->GetMark(lineDoc);
+ if (!firstSubLine)
+ marks = 0;
+
+ bool headWithTail = false;
+
+ if (vs.ms[margin].mask & SC_MASK_FOLDERS) {
+ // Decide which fold indicator should be displayed
+ const int level = model.pdoc->GetLevel(lineDoc);
+ const int levelNext = model.pdoc->GetLevel(lineDoc + 1);
+ const int levelNum = level & SC_FOLDLEVELNUMBERMASK;
+ const int levelNextNum = levelNext & SC_FOLDLEVELNUMBERMASK;
+ if (level & SC_FOLDLEVELHEADERFLAG) {
+ if (firstSubLine) {
+ if (levelNum < levelNextNum) {
+ if (model.cs.GetExpanded(lineDoc)) {
+ if (levelNum == SC_FOLDLEVELBASE)
+ marks |= 1 << SC_MARKNUM_FOLDEROPEN;
+ else
+ marks |= 1 << folderOpenMid;
+ } else {
+ if (levelNum == SC_FOLDLEVELBASE)
+ marks |= 1 << SC_MARKNUM_FOLDER;
+ else
+ marks |= 1 << folderEnd;
+ }
+ } else if (levelNum > SC_FOLDLEVELBASE) {
+ marks |= 1 << SC_MARKNUM_FOLDERSUB;
+ }
+ } else {
+ if (levelNum < levelNextNum) {
+ if (model.cs.GetExpanded(lineDoc)) {
+ marks |= 1 << SC_MARKNUM_FOLDERSUB;
+ } else if (levelNum > SC_FOLDLEVELBASE) {
+ marks |= 1 << SC_MARKNUM_FOLDERSUB;
+ }
+ } else if (levelNum > SC_FOLDLEVELBASE) {
+ marks |= 1 << SC_MARKNUM_FOLDERSUB;
+ }
+ }
+ needWhiteClosure = false;
+ const int firstFollowupLine = model.cs.DocFromDisplay(model.cs.DisplayFromDoc(lineDoc + 1));
+ const int firstFollowupLineLevel = model.pdoc->GetLevel(firstFollowupLine);
+ const int secondFollowupLineLevelNum = model.pdoc->GetLevel(firstFollowupLine + 1) & SC_FOLDLEVELNUMBERMASK;
+ if (!model.cs.GetExpanded(lineDoc)) {
+ if ((firstFollowupLineLevel & SC_FOLDLEVELWHITEFLAG) &&
+ (levelNum > secondFollowupLineLevelNum))
+ needWhiteClosure = true;
+
+ if (highlightDelimiter.IsFoldBlockHighlighted(firstFollowupLine))
+ headWithTail = true;
+ }
+ } else if (level & SC_FOLDLEVELWHITEFLAG) {
+ if (needWhiteClosure) {
+ if (levelNext & SC_FOLDLEVELWHITEFLAG) {
+ marks |= 1 << SC_MARKNUM_FOLDERSUB;
+ } else if (levelNextNum > SC_FOLDLEVELBASE) {
+ marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
+ needWhiteClosure = false;
+ } else {
+ marks |= 1 << SC_MARKNUM_FOLDERTAIL;
+ needWhiteClosure = false;
+ }
+ } else if (levelNum > SC_FOLDLEVELBASE) {
+ if (levelNextNum < levelNum) {
+ if (levelNextNum > SC_FOLDLEVELBASE) {
+ marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
+ } else {
+ marks |= 1 << SC_MARKNUM_FOLDERTAIL;
+ }
+ } else {
+ marks |= 1 << SC_MARKNUM_FOLDERSUB;
+ }
+ }
+ } else if (levelNum > SC_FOLDLEVELBASE) {
+ if (levelNextNum < levelNum) {
+ needWhiteClosure = false;
+ if (levelNext & SC_FOLDLEVELWHITEFLAG) {
+ marks |= 1 << SC_MARKNUM_FOLDERSUB;
+ needWhiteClosure = true;
+ } else if (lastSubLine) {
+ if (levelNextNum > SC_FOLDLEVELBASE) {
+ marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
+ } else {
+ marks |= 1 << SC_MARKNUM_FOLDERTAIL;
+ }
+ } else {
+ marks |= 1 << SC_MARKNUM_FOLDERSUB;
+ }
+ } else {
+ marks |= 1 << SC_MARKNUM_FOLDERSUB;
+ }
+ }
+ }
+
+ marks &= vs.ms[margin].mask;
+
+ PRectangle rcMarker = rcSelMargin;
+ rcMarker.top = static_cast<XYPOSITION>(yposScreen);
+ rcMarker.bottom = static_cast<XYPOSITION>(yposScreen + vs.lineHeight);
+ if (vs.ms[margin].style == SC_MARGIN_NUMBER) {
+ if (firstSubLine) {
+ char number[100] = "";
+ if (lineDoc >= 0)
+ sprintf(number, "%d", lineDoc + 1);
+ if (model.foldFlags & (SC_FOLDFLAG_LEVELNUMBERS | SC_FOLDFLAG_LINESTATE)) {
+ if (model.foldFlags & SC_FOLDFLAG_LEVELNUMBERS) {
+ int lev = model.pdoc->GetLevel(lineDoc);
+ sprintf(number, "%c%c %03X %03X",
+ (lev & SC_FOLDLEVELHEADERFLAG) ? 'H' : '_',
+ (lev & SC_FOLDLEVELWHITEFLAG) ? 'W' : '_',
+ lev & SC_FOLDLEVELNUMBERMASK,
+ lev >> 16
+ );
+ } else {
+ int state = model.pdoc->GetLineState(lineDoc);
+ sprintf(number, "%0X", state);
+ }
+ }
+ PRectangle rcNumber = rcMarker;
+ // Right justify
+ XYPOSITION width = surface->WidthText(fontLineNumber, number, static_cast<int>(strlen(number)));
+ XYPOSITION xpos = rcNumber.right - width - vs.marginNumberPadding;
+ rcNumber.left = xpos;
+ DrawTextInStyle(surface, rcNumber, vs.styles[STYLE_LINENUMBER],
+ rcNumber.top + vs.maxAscent, number, strlen(number));
+ } else if (vs.wrapVisualFlags & SC_WRAPVISUALFLAG_MARGIN) {
+ PRectangle rcWrapMarker = rcMarker;
+ rcWrapMarker.right -= 3;
+ rcWrapMarker.left = rcWrapMarker.right - vs.styles[STYLE_LINENUMBER].aveCharWidth;
+ DrawWrapMarker(surface, rcWrapMarker, false, vs.styles[STYLE_LINENUMBER].fore);
+ }
+ } else if (vs.ms[margin].style == SC_MARGIN_TEXT || vs.ms[margin].style == SC_MARGIN_RTEXT) {
+ if (firstSubLine) {
+ const StyledText stMargin = model.pdoc->MarginStyledText(lineDoc);
+ if (stMargin.text && ValidStyledText(vs, vs.marginStyleOffset, stMargin)) {
+ surface->FillRectangle(rcMarker,
+ vs.styles[stMargin.StyleAt(0) + vs.marginStyleOffset].back);
+ if (vs.ms[margin].style == SC_MARGIN_RTEXT) {
+ int width = WidestLineWidth(surface, vs, vs.marginStyleOffset, stMargin);
+ rcMarker.left = rcMarker.right - width - 3;
+ }
+ DrawStyledText(surface, vs, vs.marginStyleOffset, rcMarker,
+ stMargin, 0, stMargin.length);
+ }
+ }
+ }
+
+ if (marks) {
+ for (int markBit = 0; (markBit < 32) && marks; markBit++) {
+ if (marks & 1) {
+ LineMarker::typeOfFold tFold = LineMarker::undefined;
+ if ((vs.ms[margin].mask & SC_MASK_FOLDERS) && highlightDelimiter.IsFoldBlockHighlighted(lineDoc)) {
+ if (highlightDelimiter.IsBodyOfFoldBlock(lineDoc)) {
+ tFold = LineMarker::body;
+ } else if (highlightDelimiter.IsHeadOfFoldBlock(lineDoc)) {
+ if (firstSubLine) {
+ tFold = headWithTail ? LineMarker::headWithTail : LineMarker::head;
+ } else {
+ if (model.cs.GetExpanded(lineDoc) || headWithTail) {
+ tFold = LineMarker::body;
+ } else {
+ tFold = LineMarker::undefined;
+ }
+ }
+ } else if (highlightDelimiter.IsTailOfFoldBlock(lineDoc)) {
+ tFold = LineMarker::tail;
+ }
+ }
+ vs.markers[markBit].Draw(surface, rcMarker, fontLineNumber, tFold, vs.ms[margin].style);
+ }
+ marks >>= 1;
+ }
+ }
+
+ visibleLine++;
+ yposScreen += vs.lineHeight;
+ }
+ }
+ }
+
+ PRectangle rcBlankMargin = rcMargin;
+ rcBlankMargin.left = rcSelMargin.right;
+ surface->FillRectangle(rcBlankMargin, vs.styles[STYLE_DEFAULT].back);
+}
+
+/**
+* Convenience class to ensure LineLayout objects are always disposed.
+*/
+class AutoLineLayout {
+ LineLayoutCache &llc;
+ LineLayout *ll;
+ AutoLineLayout &operator=(const AutoLineLayout &);
+public:
+ AutoLineLayout(LineLayoutCache &llc_, LineLayout *ll_) : llc(llc_), ll(ll_) {}
+ ~AutoLineLayout() {
+ llc.Dispose(ll);
+ ll = 0;
+ }
+ LineLayout *operator->() const {
+ return ll;
+ }
+ operator LineLayout *() const {
+ return ll;
+ }
+ void Set(LineLayout *ll_) {
+ llc.Dispose(ll);
+ ll = ll_;
+ }
+};
+
PrintParameters::PrintParameters() {
magnification = 0;
colourMode = SC_PRINT_NORMAL;
wrapState = eWrapWord;
}
+const XYPOSITION epsilon = 0.0001f; // A small nudge to avoid floating point precision issues
+
+EditView::EditView() {
+ hideSelection = false;
+ drawOverstrikeCaret = true;
+ bufferedDraw = true;
+ twoPhaseDraw = true;
+ lineWidthMaxSeen = 0;
+ additionalCaretsBlink = true;
+ additionalCaretsVisible = true;
+ pixmapLine = 0;
+ pixmapIndentGuide = 0;
+ pixmapIndentGuideHighlight = 0;
+ llc.SetLevel(LineLayoutCache::llcCaret);
+ posCache.SetSize(0x400);
+}
+
+void EditView::DropGraphics(bool freeObjects) {
+ if (freeObjects) {
+ delete pixmapLine;
+ pixmapLine = 0;
+ delete pixmapIndentGuide;
+ pixmapIndentGuide = 0;
+ delete pixmapIndentGuideHighlight;
+ pixmapIndentGuideHighlight = 0;
+ } else {
+ if (pixmapLine)
+ pixmapLine->Release();
+ if (pixmapIndentGuide)
+ pixmapIndentGuide->Release();
+ if (pixmapIndentGuideHighlight)
+ pixmapIndentGuideHighlight->Release();
+ }
+}
+
+void EditView::AllocateGraphics(const ViewStyle &vsDraw) {
+ if (!pixmapLine)
+ pixmapLine = Surface::Allocate(vsDraw.technology);
+ if (!pixmapIndentGuide)
+ pixmapIndentGuide = Surface::Allocate(vsDraw.technology);
+ if (!pixmapIndentGuideHighlight)
+ pixmapIndentGuideHighlight = Surface::Allocate(vsDraw.technology);
+}
+
+const char *ControlCharacterString(unsigned char ch) {
+ const char *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"
+ };
+ if (ch < ELEMENTS(reps)) {
+ return reps[ch];
+ } else {
+ return "BAD";
+ }
+}
+
+void DrawTabArrow(Surface *surface, PRectangle rcTab, int ymid) {
+ int ydiff = static_cast<int>(rcTab.bottom - rcTab.top) / 2;
+ int xhead = static_cast<int>(rcTab.right) - 1 - ydiff;
+ if (xhead <= rcTab.left) {
+ ydiff -= static_cast<int>(rcTab.left) - xhead - 1;
+ xhead = static_cast<int>(rcTab.left) - 1;
+ }
+ if ((rcTab.left + 2) < (rcTab.right - 1))
+ surface->MoveTo(static_cast<int>(rcTab.left) + 2, ymid);
+ else
+ surface->MoveTo(static_cast<int>(rcTab.right) - 1, ymid);
+ surface->LineTo(static_cast<int>(rcTab.right) - 1, ymid);
+ surface->LineTo(xhead, ymid - ydiff);
+ surface->MoveTo(static_cast<int>(rcTab.right) - 1, ymid);
+ surface->LineTo(xhead, ymid + ydiff);
+}
+
+void EditView::RefreshPixMaps(Surface *surfaceWindow, WindowID wid, const ViewStyle &vsDraw) {
+ if (!pixmapIndentGuide->Initialised()) {
+ // 1 extra pixel in height so can handle odd/even positions and so produce a continuous line
+ pixmapIndentGuide->InitPixMap(1, vsDraw.lineHeight + 1, surfaceWindow, wid);
+ pixmapIndentGuideHighlight->InitPixMap(1, vsDraw.lineHeight + 1, surfaceWindow, wid);
+ PRectangle rcIG = PRectangle::FromInts(0, 0, 1, vsDraw.lineHeight);
+ pixmapIndentGuide->FillRectangle(rcIG, vsDraw.styles[STYLE_INDENTGUIDE].back);
+ pixmapIndentGuide->PenColour(vsDraw.styles[STYLE_INDENTGUIDE].fore);
+ pixmapIndentGuideHighlight->FillRectangle(rcIG, vsDraw.styles[STYLE_BRACELIGHT].back);
+ pixmapIndentGuideHighlight->PenColour(vsDraw.styles[STYLE_BRACELIGHT].fore);
+ for (int stripe = 1; stripe < vsDraw.lineHeight + 1; stripe += 2) {
+ PRectangle rcPixel = PRectangle::FromInts(0, stripe, 1, stripe + 1);
+ pixmapIndentGuide->FillRectangle(rcPixel, vsDraw.styles[STYLE_INDENTGUIDE].fore);
+ pixmapIndentGuideHighlight->FillRectangle(rcPixel, vsDraw.styles[STYLE_BRACELIGHT].fore);
+ }
+ }
+}
+
+LineLayout *EditView::RetrieveLineLayout(int lineNumber, const EditModel &model) {
+ int posLineStart = model.pdoc->LineStart(lineNumber);
+ int posLineEnd = model.pdoc->LineStart(lineNumber + 1);
+ PLATFORM_ASSERT(posLineEnd >= posLineStart);
+ int lineCaret = model.pdoc->LineFromPosition(model.sel.MainCaret());
+ return llc.Retrieve(lineNumber, lineCaret,
+ posLineEnd - posLineStart, model.pdoc->GetStyleClock(),
+ model.LinesOnScreen() + 1, model.pdoc->LinesTotal());
+}
+
+/**
+* Fill in the LineLayout data for the given line.
+* Copy the given @a line and its styles from the document into local arrays.
+* Also determine the x position at which each character starts.
+*/
+void EditView::LayoutLine(int line, Surface *surface, const ViewStyle &vstyle, LineLayout *ll, const EditModel &model, int width) {
+ if (!ll)
+ return;
+
+ PLATFORM_ASSERT(line < model.pdoc->LinesTotal());
+ PLATFORM_ASSERT(ll->chars != NULL);
+ int posLineStart = model.pdoc->LineStart(line);
+ int posLineEnd = model.pdoc->LineStart(line + 1);
+ // If the line is very long, limit the treatment to a length that should fit in the viewport
+ if (posLineEnd >(posLineStart + ll->maxLineLength)) {
+ posLineEnd = posLineStart + ll->maxLineLength;
+ }
+ if (ll->validity == LineLayout::llCheckTextAndStyle) {
+ int lineLength = posLineEnd - posLineStart;
+ if (!vstyle.viewEOL) {
+ lineLength = model.pdoc->LineEnd(line) - posLineStart;
+ }
+ if (lineLength == ll->numCharsInLine) {
+ // See if chars, styles, indicators, are all the same
+ bool allSame = true;
+ // Check base line layout
+ char styleByte = 0;
+ int numCharsInLine = 0;
+ while (numCharsInLine < lineLength) {
+ int charInDoc = numCharsInLine + posLineStart;
+ char chDoc = model.pdoc->CharAt(charInDoc);
+ styleByte = model.pdoc->StyleAt(charInDoc);
+ allSame = allSame &&
+ (ll->styles[numCharsInLine] == static_cast<unsigned char>(styleByte));
+ if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseMixed)
+ allSame = allSame &&
+ (ll->chars[numCharsInLine] == chDoc);
+ else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower)
+ allSame = allSame &&
+ (ll->chars[numCharsInLine] == static_cast<char>(tolower(chDoc)));
+ else // Style::caseUpper
+ allSame = allSame &&
+ (ll->chars[numCharsInLine] == static_cast<char>(toupper(chDoc)));
+ numCharsInLine++;
+ }
+ allSame = allSame && (ll->styles[numCharsInLine] == styleByte); // For eolFilled
+ if (allSame) {
+ ll->validity = LineLayout::llPositions;
+ } else {
+ ll->validity = LineLayout::llInvalid;
+ }
+ } else {
+ ll->validity = LineLayout::llInvalid;
+ }
+ }
+ if (ll->validity == LineLayout::llInvalid) {
+ ll->widthLine = LineLayout::wrapWidthInfinite;
+ ll->lines = 1;
+ if (vstyle.edgeState == EDGE_BACKGROUND) {
+ ll->edgeColumn = model.pdoc->FindColumn(line, vstyle.theEdge);
+ if (ll->edgeColumn >= posLineStart) {
+ ll->edgeColumn -= posLineStart;
+ }
+ } else {
+ ll->edgeColumn = -1;
+ }
+
+ // Fill base line layout
+ const int lineLength = posLineEnd - posLineStart;
+ model.pdoc->GetCharRange(ll->chars, posLineStart, lineLength);
+ model.pdoc->GetStyleRange(ll->styles, posLineStart, lineLength);
+ int numCharsBeforeEOL = model.pdoc->LineEnd(line) - posLineStart;
+ const int numCharsInLine = (vstyle.viewEOL) ? lineLength : numCharsBeforeEOL;
+ for (int styleInLine = 0; styleInLine < numCharsInLine; styleInLine++) {
+ const unsigned char styleByte = ll->styles[styleInLine];
+ ll->styles[styleInLine] = styleByte;
+ }
+ const unsigned char styleByteLast = (lineLength > 0) ? ll->styles[lineLength - 1] : 0;
+ if (vstyle.someStylesForceCase) {
+ for (int charInLine = 0; charInLine<lineLength; charInLine++) {
+ char chDoc = ll->chars[charInLine];
+ if (vstyle.styles[ll->styles[charInLine]].caseForce == Style::caseUpper)
+ ll->chars[charInLine] = static_cast<char>(toupper(chDoc));
+ else if (vstyle.styles[ll->styles[charInLine]].caseForce == Style::caseLower)
+ ll->chars[charInLine] = static_cast<char>(tolower(chDoc));
+ }
+ }
+ ll->xHighlightGuide = 0;
+ // Extra element at the end of the line to hold end x position and act as
+ ll->chars[numCharsInLine] = 0; // Also triggers processing in the loops as this is a control character
+ ll->styles[numCharsInLine] = styleByteLast; // For eolFilled
+
+ // Layout the line, determining the position of each character,
+ // with an extra element at the end for the end of the line.
+ ll->positions[0] = 0;
+ bool lastSegItalics = false;
+
+ BreakFinder bfLayout(ll, NULL, Range(0, numCharsInLine), posLineStart, 0, false, model.pdoc, &model.reprs);
+ while (bfLayout.More()) {
+
+ const TextSegment ts = bfLayout.Next();
+
+ std::fill(&ll->positions[ts.start + 1], &ll->positions[ts.end() + 1], 0.0f);
+ if (vstyle.styles[ll->styles[ts.start]].visible) {
+ if (ts.representation) {
+ XYPOSITION representationWidth = vstyle.controlCharWidth;
+ if (ll->chars[ts.start] == '\t') {
+ // Tab is a special case of representation, taking a variable amount of space
+ representationWidth =
+ ((static_cast<int>((ll->positions[ts.start] + 2) / vstyle.tabWidth) + 1) * vstyle.tabWidth) - ll->positions[ts.start];
+ } else {
+ if (representationWidth <= 0.0) {
+ XYPOSITION positionsRepr[256]; // Should expand when needed
+ posCache.MeasureWidths(surface, vstyle, STYLE_CONTROLCHAR, ts.representation->stringRep.c_str(),
+ static_cast<unsigned int>(ts.representation->stringRep.length()), positionsRepr, model.pdoc);
+ representationWidth = positionsRepr[ts.representation->stringRep.length() - 1] + vstyle.ctrlCharPadding;
+ }
+ }
+ for (int ii = 0; ii < ts.length; ii++)
+ ll->positions[ts.start + 1 + ii] = representationWidth;
+ } else {
+ if ((ts.length == 1) && (' ' == ll->chars[ts.start])) {
+ // Over half the segments are single characters and of these about half are space characters.
+ ll->positions[ts.start + 1] = vstyle.styles[ll->styles[ts.start]].spaceWidth;
+ } else {
+ posCache.MeasureWidths(surface, vstyle, ll->styles[ts.start], ll->chars + ts.start,
+ ts.length, ll->positions + ts.start + 1, model.pdoc);
+ }
+ }
+ lastSegItalics = (!ts.representation) && ((ll->chars[ts.end() - 1] != ' ') && vstyle.styles[ll->styles[ts.start]].italic);
+ }
+
+ for (int posToIncrease = ts.start + 1; posToIncrease <= ts.end(); posToIncrease++) {
+ ll->positions[posToIncrease] += ll->positions[ts.start];
+ }
+ }
+
+ // Small hack to make lines that end with italics not cut off the edge of the last character
+ if (lastSegItalics) {
+ ll->positions[numCharsInLine] += vstyle.lastSegItalicsOffset;
+ }
+ ll->numCharsInLine = numCharsInLine;
+ ll->numCharsBeforeEOL = numCharsBeforeEOL;
+ ll->validity = LineLayout::llPositions;
+ }
+ // Hard to cope when too narrow, so just assume there is space
+ if (width < 20) {
+ width = 20;
+ }
+ if ((ll->validity == LineLayout::llPositions) || (ll->widthLine != width)) {
+ ll->widthLine = width;
+ if (width == LineLayout::wrapWidthInfinite) {
+ ll->lines = 1;
+ } else if (width > ll->positions[ll->numCharsInLine]) {
+ // Simple common case where line does not need wrapping.
+ ll->lines = 1;
+ } else {
+ if (vstyle.wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
+ width -= static_cast<int>(vstyle.aveCharWidth); // take into account the space for end wrap mark
+ }
+ XYPOSITION wrapAddIndent = 0; // This will be added to initial indent of line
+ if (vstyle.wrapIndentMode == SC_WRAPINDENT_INDENT) {
+ wrapAddIndent = model.pdoc->IndentSize() * vstyle.spaceWidth;
+ } else if (vstyle.wrapIndentMode == SC_WRAPINDENT_FIXED) {
+ wrapAddIndent = vstyle.wrapVisualStartIndent * vstyle.aveCharWidth;
+ }
+ ll->wrapIndent = wrapAddIndent;
+ if (vstyle.wrapIndentMode != SC_WRAPINDENT_FIXED)
+ for (int i = 0; i < ll->numCharsInLine; i++) {
+ if (!IsSpaceOrTab(ll->chars[i])) {
+ ll->wrapIndent += ll->positions[i]; // Add line indent
+ break;
+ }
+ }
+ // Check for text width minimum
+ if (ll->wrapIndent > width - static_cast<int>(vstyle.aveCharWidth) * 15)
+ ll->wrapIndent = wrapAddIndent;
+ // Check for wrapIndent minimum
+ if ((vstyle.wrapVisualFlags & SC_WRAPVISUALFLAG_START) && (ll->wrapIndent < vstyle.aveCharWidth))
+ ll->wrapIndent = vstyle.aveCharWidth; // Indent to show start visual
+ ll->lines = 0;
+ // Calculate line start positions based upon width.
+ int lastGoodBreak = 0;
+ int lastLineStart = 0;
+ XYACCUMULATOR startOffset = 0;
+ int p = 0;
+ while (p < ll->numCharsInLine) {
+ if ((ll->positions[p + 1] - startOffset) >= width) {
+ if (lastGoodBreak == lastLineStart) {
+ // Try moving to start of last character
+ if (p > 0) {
+ lastGoodBreak = model.pdoc->MovePositionOutsideChar(p + posLineStart, -1)
+ - posLineStart;
+ }
+ if (lastGoodBreak == lastLineStart) {
+ // Ensure at least one character on line.
+ lastGoodBreak = model.pdoc->MovePositionOutsideChar(lastGoodBreak + posLineStart + 1, 1)
+ - posLineStart;
+ }
+ }
+ lastLineStart = lastGoodBreak;
+ ll->lines++;
+ ll->SetLineStart(ll->lines, lastGoodBreak);
+ startOffset = ll->positions[lastGoodBreak];
+ // take into account the space for start wrap mark and indent
+ startOffset -= ll->wrapIndent;
+ p = lastGoodBreak + 1;
+ continue;
+ }
+ if (p > 0) {
+ if (vstyle.wrapState == eWrapChar) {
+ lastGoodBreak = model.pdoc->MovePositionOutsideChar(p + posLineStart, -1)
+ - posLineStart;
+ p = model.pdoc->MovePositionOutsideChar(p + 1 + posLineStart, 1) - posLineStart;
+ continue;
+ } else if ((vstyle.wrapState == eWrapWord) && (ll->styles[p] != ll->styles[p - 1])) {
+ lastGoodBreak = p;
+ } else if (IsSpaceOrTab(ll->chars[p - 1]) && !IsSpaceOrTab(ll->chars[p])) {
+ lastGoodBreak = p;
+ }
+ }
+ p++;
+ }
+ ll->lines++;
+ }
+ ll->validity = LineLayout::llLines;
+ }
+}
+
+Point EditView::LocationFromPosition(Surface *surface, SelectionPosition pos, int topLine, const EditModel &model, const ViewStyle &vs) {
+ Point pt;
+ if (pos.Position() == INVALID_POSITION)
+ return pt;
+ const int line = model.pdoc->LineFromPosition(pos.Position());
+ const int lineVisible = model.cs.DisplayFromDoc(line);
+ //Platform::DebugPrintf("line=%d\n", line);
+ AutoLineLayout ll(llc, RetrieveLineLayout(line, model));
+ if (surface && ll) {
+ const int posLineStart = model.pdoc->LineStart(line);
+ LayoutLine(line, surface, vs, ll, model, model.wrapWidth);
+ const int posInLine = pos.Position() - posLineStart;
+ pt = ll->PointFromPosition(posInLine, vs.lineHeight);
+ pt.y += (lineVisible - topLine) * vs.lineHeight;
+ pt.x += vs.textStart - model.xOffset;
+ }
+ pt.x += pos.VirtualSpace() * vs.styles[ll->EndLineStyle()].spaceWidth;
+ return pt;
+}
+
+SelectionPosition EditView::SPositionFromLocation(Surface *surface, Point pt, bool canReturnInvalid, bool charPosition, bool virtualSpace, const EditModel &model, const ViewStyle &vs) {
+ pt.x = pt.x - vs.textStart;
+ int visibleLine = static_cast<int>(floor(pt.y / vs.lineHeight));
+ if (!canReturnInvalid && (visibleLine < 0))
+ visibleLine = 0;
+ const int lineDoc = model.cs.DocFromDisplay(visibleLine);
+ if (canReturnInvalid && (lineDoc < 0))
+ return SelectionPosition(INVALID_POSITION);
+ if (lineDoc >= model.pdoc->LinesTotal())
+ return SelectionPosition(canReturnInvalid ? INVALID_POSITION : model.pdoc->Length());
+ const int posLineStart = model.pdoc->LineStart(lineDoc);
+ AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc, model));
+ if (surface && ll) {
+ LayoutLine(lineDoc, surface, vs, ll, model, model.wrapWidth);
+ const int lineStartSet = model.cs.DisplayFromDoc(lineDoc);
+ const int subLine = visibleLine - lineStartSet;
+ if (subLine < ll->lines) {
+ const Range rangeSubLine = ll->SubLineRange(subLine);
+ const XYPOSITION subLineStart = ll->positions[rangeSubLine.start];
+ if (subLine > 0) // Wrapped
+ pt.x -= ll->wrapIndent;
+ const int positionInLine = ll->FindPositionFromX(pt.x + subLineStart, rangeSubLine, charPosition);
+ if (positionInLine < rangeSubLine.end) {
+ return SelectionPosition(model.pdoc->MovePositionOutsideChar(positionInLine + posLineStart, 1));
+ }
+ if (virtualSpace) {
+ const XYPOSITION spaceWidth = vs.styles[ll->EndLineStyle()].spaceWidth;
+ const int spaceOffset = static_cast<int>(
+ (pt.x + subLineStart - ll->positions[rangeSubLine.end] + spaceWidth / 2) / spaceWidth);
+ return SelectionPosition(rangeSubLine.end + posLineStart, spaceOffset);
+ } else if (canReturnInvalid) {
+ if (pt.x < (ll->positions[rangeSubLine.end] - subLineStart)) {
+ return SelectionPosition(model.pdoc->MovePositionOutsideChar(rangeSubLine.end + posLineStart, 1));
+ }
+ } else {
+ return SelectionPosition(rangeSubLine.end + posLineStart);
+ }
+ }
+ if (!canReturnInvalid)
+ return SelectionPosition(ll->numCharsInLine + posLineStart);
+ }
+ return SelectionPosition(canReturnInvalid ? INVALID_POSITION : posLineStart);
+}
+
+/**
+* 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 EditView::SPositionFromLineX(Surface *surface, int lineDoc, int x, const EditModel &model, const ViewStyle &vs) {
+ AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc, model));
+ if (surface && ll) {
+ const int posLineStart = model.pdoc->LineStart(lineDoc);
+ LayoutLine(lineDoc, surface, vs, ll, model, model.wrapWidth);
+ const Range rangeSubLine = ll->SubLineRange(0);
+ const XYPOSITION subLineStart = ll->positions[rangeSubLine.start];
+ const int positionInLine = ll->FindPositionFromX(x + subLineStart, rangeSubLine, false);
+ if (positionInLine < rangeSubLine.end) {
+ return SelectionPosition(model.pdoc->MovePositionOutsideChar(positionInLine + posLineStart, 1));
+ }
+ const XYPOSITION spaceWidth = vs.styles[ll->EndLineStyle()].spaceWidth;
+ const int spaceOffset = static_cast<int>(
+ (x + subLineStart - ll->positions[rangeSubLine.end] + spaceWidth / 2) / spaceWidth);
+ return SelectionPosition(rangeSubLine.end + posLineStart, spaceOffset);
+ }
+ return SelectionPosition(0);
+}
+
+int EditView::DisplayFromPosition(Surface *surface, int pos, const EditModel &model, const ViewStyle &vs) {
+ int lineDoc = model.pdoc->LineFromPosition(pos);
+ int lineDisplay = model.cs.DisplayFromDoc(lineDoc);
+ AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc, model));
+ if (surface && ll) {
+ LayoutLine(lineDoc, surface, vs, ll, model, model.wrapWidth);
+ unsigned int posLineStart = model.pdoc->LineStart(lineDoc);
+ int posInLine = pos - posLineStart;
+ lineDisplay--; // To make up for first increment ahead.
+ for (int subLine = 0; subLine < ll->lines; subLine++) {
+ if (posInLine >= ll->LineStart(subLine)) {
+ lineDisplay++;
+ }
+ }
+ }
+ return lineDisplay;
+}
+
+int EditView::StartEndDisplayLine(Surface *surface, int pos, bool start, const EditModel &model, const ViewStyle &vs) {
+ int line = model.pdoc->LineFromPosition(pos);
+ AutoLineLayout ll(llc, RetrieveLineLayout(line, model));
+ int posRet = INVALID_POSITION;
+ if (surface && ll) {
+ unsigned int posLineStart = model.pdoc->LineStart(line);
+ LayoutLine(line, surface, vs, ll, model, model.wrapWidth);
+ int posInLine = pos - posLineStart;
+ if (posInLine <= ll->maxLineLength) {
+ for (int subLine = 0; subLine < ll->lines; subLine++) {
+ if ((posInLine >= ll->LineStart(subLine)) && (posInLine <= ll->LineStart(subLine + 1))) {
+ if (start) {
+ posRet = ll->LineStart(subLine) + posLineStart;
+ } else {
+ if (subLine == ll->lines - 1)
+ posRet = ll->LineStart(subLine + 1) + posLineStart;
+ else
+ posRet = ll->LineStart(subLine + 1) + posLineStart - 1;
+ }
+ }
+ }
+ }
+ }
+ return posRet;
+}
+
+static ColourDesired SelectionBackground(const ViewStyle &vsDraw, bool main, bool primarySelection) {
+ return main ?
+ (primarySelection ? vsDraw.selColours.back : vsDraw.selBackground2) :
+ vsDraw.selAdditionalBackground;
+}
+
+static ColourDesired TextBackground(const ViewStyle &vsDraw,
+ ColourOptional background, int inSelection, bool inHotspot, int styleMain, int i,
+ LineLayout *ll, const EditModel &model) {
+ if (inSelection == 1) {
+ if (vsDraw.selColours.back.isSet && (vsDraw.selAlpha == SC_ALPHA_NOALPHA)) {
+ return SelectionBackground(vsDraw, true, model.primarySelection);
+ }
+ } else if (inSelection == 2) {
+ if (vsDraw.selColours.back.isSet && (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA)) {
+ return SelectionBackground(vsDraw, false, model.primarySelection);
+ }
+ } else {
+ if ((vsDraw.edgeState == EDGE_BACKGROUND) &&
+ (i >= ll->edgeColumn) &&
+ (i < ll->numCharsBeforeEOL))
+ return vsDraw.edgecolour;
+ if (inHotspot && vsDraw.hotspotColours.back.isSet)
+ return vsDraw.hotspotColours.back;
+ }
+ if (background.isSet && (styleMain != STYLE_BRACELIGHT) && (styleMain != STYLE_BRACEBAD)) {
+ return background;
+ } else {
+ return vsDraw.styles[styleMain].back;
+ }
+}
+
+void EditView::DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight) {
+ Point from = Point::FromInts(0, ((lineVisible & 1) && (lineHeight & 1)) ? 1 : 0);
+ PRectangle rcCopyArea = PRectangle::FromInts(start + 1, static_cast<int>(rcSegment.top), start + 2, static_cast<int>(rcSegment.bottom));
+ surface->Copy(rcCopyArea, from,
+ highlight ? *pixmapIndentGuideHighlight : *pixmapIndentGuide);
+}
+
+static void SimpleAlphaRectangle(Surface *surface, PRectangle rc, ColourDesired fill, int alpha) {
+ if (alpha != SC_ALPHA_NOALPHA) {
+ surface->AlphaRectangle(rc, 0, fill, alpha, fill, alpha, 0);
+ }
+}
+
+void DrawTextBlob(Surface *surface, const ViewStyle &vsDraw, PRectangle rcSegment,
+ const char *s, ColourDesired textBack, ColourDesired textFore, bool twoPhaseDraw) {
+ if (!twoPhaseDraw) {
+ surface->FillRectangle(rcSegment, textBack);
+ }
+ FontAlias ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
+ int normalCharHeight = static_cast<int>(surface->Ascent(ctrlCharsFont) -
+ surface->InternalLeading(ctrlCharsFont));
+ PRectangle rcCChar = rcSegment;
+ rcCChar.left = rcCChar.left + 1;
+ rcCChar.top = rcSegment.top + vsDraw.maxAscent - normalCharHeight;
+ rcCChar.bottom = rcSegment.top + vsDraw.maxAscent + 1;
+ PRectangle rcCentral = rcCChar;
+ rcCentral.top++;
+ rcCentral.bottom--;
+ surface->FillRectangle(rcCentral, textFore);
+ PRectangle rcChar = rcCChar;
+ rcChar.left++;
+ rcChar.right--;
+ surface->DrawTextClipped(rcChar, ctrlCharsFont,
+ rcSegment.top + vsDraw.maxAscent, s, static_cast<int>(s ? strlen(s) : 0),
+ textBack, textFore);
+}
+
+void EditView::DrawEOL(Surface *surface, const ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
+ int line, int lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,
+ ColourOptional background, const EditModel &model) {
+
+ const int posLineStart = model.pdoc->LineStart(line);
+ PRectangle rcSegment = rcLine;
+
+ const bool lastSubLine = subLine == (ll->lines - 1);
+ XYPOSITION virtualSpace = 0;
+ if (lastSubLine) {
+ const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+ virtualSpace = model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line)) * spaceWidth;
+ }
+ XYPOSITION xEol = static_cast<XYPOSITION>(ll->positions[lineEnd] - subLineStart);
+
+ // Fill the virtual space and show selections within it
+ if (virtualSpace) {
+ rcSegment.left = xEol + xStart;
+ rcSegment.right = xEol + xStart + virtualSpace;
+ surface->FillRectangle(rcSegment, background.isSet ? background : vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
+ if (!hideSelection && ((vsDraw.selAlpha == SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA))) {
+ SelectionSegment virtualSpaceRange(SelectionPosition(model.pdoc->LineEnd(line)), SelectionPosition(model.pdoc->LineEnd(line), model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line))));
+ for (size_t r = 0; r<model.sel.Count(); r++) {
+ int alpha = (r == model.sel.Main()) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
+ if (alpha == SC_ALPHA_NOALPHA) {
+ SelectionSegment portion = model.sel.Range(r).Intersect(virtualSpaceRange);
+ if (!portion.Empty()) {
+ const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+ rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] -
+ static_cast<XYPOSITION>(subLineStart)+portion.start.VirtualSpace() * spaceWidth;
+ rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] -
+ static_cast<XYPOSITION>(subLineStart)+portion.end.VirtualSpace() * spaceWidth;
+ rcSegment.left = (rcSegment.left > rcLine.left) ? rcSegment.left : rcLine.left;
+ rcSegment.right = (rcSegment.right < rcLine.right) ? rcSegment.right : rcLine.right;
+ surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, r == model.sel.Main(), model.primarySelection));
+ }
+ }
+ }
+ }
+ }
+
+ int eolInSelection = 0;
+ int alpha = SC_ALPHA_NOALPHA;
+ if (!hideSelection) {
+ int posAfterLineEnd = model.pdoc->LineStart(line + 1);
+ eolInSelection = (subLine == (ll->lines - 1)) ? model.sel.InSelectionForEOL(posAfterLineEnd) : 0;
+ alpha = (eolInSelection == 1) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
+ }
+
+ // Draw the [CR], [LF], or [CR][LF] blobs if visible line ends are on
+ XYPOSITION blobsWidth = 0;
+ if (lastSubLine) {
+ for (int eolPos = ll->numCharsBeforeEOL; eolPos<ll->numCharsInLine; eolPos++) {
+ rcSegment.left = xStart + ll->positions[eolPos] - static_cast<XYPOSITION>(subLineStart)+virtualSpace;
+ rcSegment.right = xStart + ll->positions[eolPos + 1] - static_cast<XYPOSITION>(subLineStart)+virtualSpace;
+ blobsWidth += rcSegment.Width();
+ char hexits[4];
+ const char *ctrlChar;
+ unsigned char chEOL = ll->chars[eolPos];
+ int styleMain = ll->styles[eolPos];
+ ColourDesired textBack = TextBackground(vsDraw, background, eolInSelection, false, styleMain, eolPos, ll, model);
+ if (UTF8IsAscii(chEOL)) {
+ ctrlChar = ControlCharacterString(chEOL);
+ } else {
+ const Representation *repr = model.reprs.RepresentationFromCharacter(ll->chars + eolPos, ll->numCharsInLine - eolPos);
+ if (repr) {
+ ctrlChar = repr->stringRep.c_str();
+ eolPos = ll->numCharsInLine;
+ } else {
+ sprintf(hexits, "x%2X", chEOL);
+ ctrlChar = hexits;
+ }
+ }
+ ColourDesired textFore = vsDraw.styles[styleMain].fore;
+ if (eolInSelection && vsDraw.selColours.fore.isSet) {
+ textFore = (eolInSelection == 1) ? vsDraw.selColours.fore : vsDraw.selAdditionalForeground;
+ }
+ if (eolInSelection && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1)) {
+ if (alpha == SC_ALPHA_NOALPHA) {
+ surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection));
+ } else {
+ surface->FillRectangle(rcSegment, textBack);
+ }
+ } else {
+ surface->FillRectangle(rcSegment, textBack);
+ }
+ DrawTextBlob(surface, vsDraw, rcSegment, ctrlChar, textBack, textFore, twoPhaseDraw);
+ if (eolInSelection && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) {
+ SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection), alpha);
+ }
+ }
+ }
+
+ // Draw the eol-is-selected rectangle
+ rcSegment.left = xEol + xStart + virtualSpace + blobsWidth;
+ rcSegment.right = rcSegment.left + vsDraw.aveCharWidth;
+
+ if (eolInSelection && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha == SC_ALPHA_NOALPHA)) {
+ surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection));
+ } else {
+ if (background.isSet) {
+ surface->FillRectangle(rcSegment, background);
+ } else if (line < model.pdoc->LinesTotal() - 1) {
+ surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
+ } else if (vsDraw.styles[ll->styles[ll->numCharsInLine]].eolFilled) {
+ surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
+ } else {
+ surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back);
+ }
+ if (eolInSelection && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) {
+ SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection), alpha);
+ }
+ }
+
+ // Fill the remainder of the line
+ rcSegment.left = rcSegment.right;
+ if (rcSegment.left < rcLine.left)
+ rcSegment.left = rcLine.left;
+ rcSegment.right = rcLine.right;
+
+ if (eolInSelection && vsDraw.selEOLFilled && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha == SC_ALPHA_NOALPHA)) {
+ surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection));
+ } else {
+ if (background.isSet) {
+ surface->FillRectangle(rcSegment, background);
+ } else if (vsDraw.styles[ll->styles[ll->numCharsInLine]].eolFilled) {
+ surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
+ } else {
+ surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back);
+ }
+ if (eolInSelection && vsDraw.selEOLFilled && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) {
+ SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection), alpha);
+ }
+ }
+
+ bool drawWrapMarkEnd = false;
+
+ if (vsDraw.wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
+ if (subLine + 1 < ll->lines) {
+ drawWrapMarkEnd = ll->LineStart(subLine + 1) != 0;
+ }
+ }
+
+ if (drawWrapMarkEnd) {
+ PRectangle rcPlace = rcSegment;
+
+ if (vsDraw.wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_END_BY_TEXT) {
+ rcPlace.left = xEol + xStart + virtualSpace;
+ rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
+ } else {
+ // rcLine is clipped to text area
+ rcPlace.right = rcLine.right;
+ rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
+ }
+ DrawWrapMarker(surface, rcPlace, true, vsDraw.WrapColour());
+ }
+}
+
+static void DrawIndicator(int indicNum, int startPos, int endPos, Surface *surface, const ViewStyle &vsDraw,
+ int xStart, PRectangle rcLine, LineLayout *ll, int subLine) {
+ const XYPOSITION subLineStart = ll->positions[ll->LineStart(subLine)];
+ PRectangle rcIndic(
+ ll->positions[startPos] + xStart - subLineStart,
+ rcLine.top + vsDraw.maxAscent,
+ ll->positions[endPos] + xStart - subLineStart,
+ rcLine.top + vsDraw.maxAscent + 3);
+ vsDraw.indicators[indicNum].Draw(surface, rcIndic, rcLine);
+}
+
+static void DrawIndicators(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
+ PRectangle rcLine, LineLayout *ll, int subLine, int lineEnd, bool under, const EditModel &model) {
+ // Draw decorators
+ const int posLineStart = model.pdoc->LineStart(line);
+ const int lineStart = ll->LineStart(subLine);
+ const int posLineEnd = posLineStart + lineEnd;
+
+ for (Decoration *deco = model.pdoc->decorations.root; deco; deco = deco->next) {
+ if (under == vsDraw.indicators[deco->indicator].under) {
+ int startPos = posLineStart + lineStart;
+ if (!deco->rs.ValueAt(startPos)) {
+ startPos = deco->rs.EndRun(startPos);
+ }
+ while ((startPos < posLineEnd) && (deco->rs.ValueAt(startPos))) {
+ int endPos = deco->rs.EndRun(startPos);
+ if (endPos > posLineEnd)
+ endPos = posLineEnd;
+ DrawIndicator(deco->indicator, startPos - posLineStart, endPos - posLineStart,
+ surface, vsDraw, xStart, rcLine, ll, subLine);
+ startPos = endPos;
+ if (!deco->rs.ValueAt(startPos)) {
+ startPos = deco->rs.EndRun(startPos);
+ }
+ }
+ }
+ }
+
+ // Use indicators to highlight matching braces
+ if ((vsDraw.braceHighlightIndicatorSet && (model.bracesMatchStyle == STYLE_BRACELIGHT)) ||
+ (vsDraw.braceBadLightIndicatorSet && (model.bracesMatchStyle == STYLE_BRACEBAD))) {
+ int braceIndicator = (model.bracesMatchStyle == STYLE_BRACELIGHT) ? vsDraw.braceHighlightIndicator : vsDraw.braceBadLightIndicator;
+ if (under == vsDraw.indicators[braceIndicator].under) {
+ Range rangeLine(posLineStart + lineStart, posLineEnd);
+ if (rangeLine.ContainsCharacter(model.braces[0])) {
+ int braceOffset = model.braces[0] - posLineStart;
+ if (braceOffset < ll->numCharsInLine) {
+ DrawIndicator(braceIndicator, braceOffset, braceOffset + 1, surface, vsDraw, xStart, rcLine, ll, subLine);
+ }
+ }
+ if (rangeLine.ContainsCharacter(model.braces[1])) {
+ int braceOffset = model.braces[1] - posLineStart;
+ if (braceOffset < ll->numCharsInLine) {
+ DrawIndicator(braceIndicator, braceOffset, braceOffset + 1, surface, vsDraw, xStart, rcLine, ll, subLine);
+ }
+ }
+ }
+ }
+}
+
+void EditView::DrawAnnotation(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
+ PRectangle rcLine, LineLayout *ll, int subLine, const EditModel &model) {
+ int indent = static_cast<int>(model.pdoc->GetLineIndentation(line) * vsDraw.spaceWidth);
+ PRectangle rcSegment = rcLine;
+ int annotationLine = subLine - ll->lines;
+ const StyledText stAnnotation = model.pdoc->AnnotationStyledText(line);
+ if (stAnnotation.text && ValidStyledText(vsDraw, vsDraw.annotationStyleOffset, stAnnotation)) {
+ surface->FillRectangle(rcSegment, vsDraw.styles[0].back);
+ rcSegment.left = static_cast<XYPOSITION>(xStart);
+ if (model.trackLineWidth || (vsDraw.annotationVisible == ANNOTATION_BOXED)) {
+ // Only care about calculating width if tracking or need to draw box
+ int widthAnnotation = WidestLineWidth(surface, vsDraw, vsDraw.annotationStyleOffset, stAnnotation);
+ if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
+ widthAnnotation += static_cast<int>(vsDraw.spaceWidth * 2); // Margins
+ }
+ if (widthAnnotation > lineWidthMaxSeen)
+ lineWidthMaxSeen = widthAnnotation;
+ if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
+ rcSegment.left = static_cast<XYPOSITION>(xStart + indent);
+ rcSegment.right = rcSegment.left + widthAnnotation;
+ }
+ }
+ const int annotationLines = model.pdoc->AnnotationLines(line);
+ size_t start = 0;
+ size_t lengthAnnotation = stAnnotation.LineLength(start);
+ int lineInAnnotation = 0;
+ while ((lineInAnnotation < annotationLine) && (start < stAnnotation.length)) {
+ start += lengthAnnotation + 1;
+ lengthAnnotation = stAnnotation.LineLength(start);
+ lineInAnnotation++;
+ }
+ PRectangle rcText = rcSegment;
+ if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
+ surface->FillRectangle(rcText,
+ vsDraw.styles[stAnnotation.StyleAt(start) + vsDraw.annotationStyleOffset].back);
+ rcText.left += vsDraw.spaceWidth;
+ }
+ DrawStyledText(surface, vsDraw, vsDraw.annotationStyleOffset, rcText,
+ stAnnotation, start, lengthAnnotation);
+ if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
+ surface->PenColour(vsDraw.styles[vsDraw.annotationStyleOffset].fore);
+ surface->MoveTo(static_cast<int>(rcSegment.left), static_cast<int>(rcSegment.top));
+ surface->LineTo(static_cast<int>(rcSegment.left), static_cast<int>(rcSegment.bottom));
+ surface->MoveTo(static_cast<int>(rcSegment.right), static_cast<int>(rcSegment.top));
+ surface->LineTo(static_cast<int>(rcSegment.right), static_cast<int>(rcSegment.bottom));
+ if (subLine == ll->lines) {
+ surface->MoveTo(static_cast<int>(rcSegment.left), static_cast<int>(rcSegment.top));
+ surface->LineTo(static_cast<int>(rcSegment.right), static_cast<int>(rcSegment.top));
+ }
+ if (subLine == ll->lines + annotationLines - 1) {
+ surface->MoveTo(static_cast<int>(rcSegment.left), static_cast<int>(rcSegment.bottom - 1));
+ surface->LineTo(static_cast<int>(rcSegment.right), static_cast<int>(rcSegment.bottom - 1));
+ }
+ }
+ }
+}
+
+static void DrawBlockCaret(Surface *surface, const ViewStyle &vsDraw, LineLayout *ll, int subLine,
+ int xStart, int offset, int posCaret, PRectangle rcCaret, ColourDesired caretColour, const EditModel &model) {
+
+ int lineStart = ll->LineStart(subLine);
+ int posBefore = posCaret;
+ int posAfter = model.pdoc->MovePositionOutsideChar(posCaret + 1, 1);
+ int numCharsToDraw = posAfter - posCaret;
+
+ // Work out where the starting and ending offsets are. We need to
+ // see if the previous character shares horizontal space, such as a
+ // glyph / combining character. If so we'll need to draw that too.
+ int offsetFirstChar = offset;
+ int offsetLastChar = offset + (posAfter - posCaret);
+ while ((posBefore > 0) && ((offsetLastChar - numCharsToDraw) >= lineStart)) {
+ if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - numCharsToDraw]) > 0) {
+ // The char does not share horizontal space
+ break;
+ }
+ // Char shares horizontal space, update the numChars to draw
+ // Update posBefore to point to the prev char
+ posBefore = model.pdoc->MovePositionOutsideChar(posBefore - 1, -1);
+ numCharsToDraw = posAfter - posBefore;
+ offsetFirstChar = offset - (posCaret - posBefore);
+ }
+
+ // See if the next character shares horizontal space, if so we'll
+ // need to draw that too.
+ if (offsetFirstChar < 0)
+ offsetFirstChar = 0;
+ numCharsToDraw = offsetLastChar - offsetFirstChar;
+ while ((offsetLastChar < ll->LineStart(subLine + 1)) && (offsetLastChar <= ll->numCharsInLine)) {
+ // Update posAfter to point to the 2nd next char, this is where
+ // the next character ends, and 2nd next begins. We'll need
+ // to compare these two
+ posBefore = posAfter;
+ posAfter = model.pdoc->MovePositionOutsideChar(posAfter + 1, 1);
+ offsetLastChar = offset + (posAfter - posCaret);
+ if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - (posAfter - posBefore)]) > 0) {
+ // The char does not share horizontal space
+ break;
+ }
+ // Char shares horizontal space, update the numChars to draw
+ numCharsToDraw = offsetLastChar - offsetFirstChar;
+ }
+
+ // We now know what to draw, update the caret drawing rectangle
+ rcCaret.left = ll->positions[offsetFirstChar] - ll->positions[lineStart] + xStart;
+ rcCaret.right = ll->positions[offsetFirstChar + numCharsToDraw] - ll->positions[lineStart] + xStart;
+
+ // Adjust caret position to take into account any word wrapping symbols.
+ if ((ll->wrapIndent != 0) && (lineStart != 0)) {
+ XYPOSITION wordWrapCharWidth = ll->wrapIndent;
+ rcCaret.left += wordWrapCharWidth;
+ rcCaret.right += wordWrapCharWidth;
+ }
+
+ // This character is where the caret block is, we override the colours
+ // (inversed) for drawing the caret here.
+ int styleMain = ll->styles[offsetFirstChar];
+ FontAlias fontText = vsDraw.styles[styleMain].font;
+ surface->DrawTextClipped(rcCaret, fontText,
+ rcCaret.top + vsDraw.maxAscent, ll->chars + offsetFirstChar,
+ numCharsToDraw, vsDraw.styles[styleMain].back,
+ caretColour);
+}
+
+void EditView::DrawCarets(Surface *surface, const ViewStyle &vsDraw, int lineDoc, int xStart,
+ PRectangle rcLine, LineLayout *ll, int subLine, const EditModel &model) const {
+ // When drag is active it is the only caret drawn
+ bool drawDrag = model.posDrag.IsValid();
+ if (hideSelection && !drawDrag)
+ return;
+ const int posLineStart = model.pdoc->LineStart(lineDoc);
+ // For each selection draw
+ for (size_t r = 0; (r<model.sel.Count()) || drawDrag; r++) {
+ const bool mainCaret = r == model.sel.Main();
+ const SelectionPosition posCaret = (drawDrag ? model.posDrag : model.sel.Range(r).caret);
+ const int offset = posCaret.Position() - posLineStart;
+ const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+ const XYPOSITION virtualOffset = posCaret.VirtualSpace() * spaceWidth;
+ if (ll->InLine(offset, subLine) && offset <= ll->numCharsBeforeEOL) {
+ XYPOSITION xposCaret = ll->positions[offset] + virtualOffset - ll->positions[ll->LineStart(subLine)];
+ if (ll->wrapIndent != 0) {
+ int lineStart = ll->LineStart(subLine);
+ if (lineStart != 0) // Wrapped
+ xposCaret += ll->wrapIndent;
+ }
+ bool caretBlinkState = (model.caret.active && model.caret.on) || (!additionalCaretsBlink && !mainCaret);
+ bool caretVisibleState = additionalCaretsVisible || mainCaret;
+ if ((xposCaret >= 0) && (vsDraw.caretWidth > 0) && (vsDraw.caretStyle != CARETSTYLE_INVISIBLE) &&
+ ((model.posDrag.IsValid()) || (caretBlinkState && caretVisibleState))) {
+ bool caretAtEOF = false;
+ bool caretAtEOL = false;
+ bool drawBlockCaret = false;
+ XYPOSITION widthOverstrikeCaret;
+ XYPOSITION caretWidthOffset = 0;
+ PRectangle rcCaret = rcLine;
+
+ if (posCaret.Position() == model.pdoc->Length()) { // At end of document
+ caretAtEOF = true;
+ widthOverstrikeCaret = vsDraw.aveCharWidth;
+ } else if ((posCaret.Position() - posLineStart) >= ll->numCharsInLine) { // At end of line
+ caretAtEOL = true;
+ widthOverstrikeCaret = vsDraw.aveCharWidth;
+ } else {
+ widthOverstrikeCaret = ll->positions[offset + 1] - ll->positions[offset];
+ }
+ if (widthOverstrikeCaret < 3) // Make sure its visible
+ widthOverstrikeCaret = 3;
+
+ if (xposCaret > 0)
+ caretWidthOffset = 0.51f; // Move back so overlaps both character cells.
+ xposCaret += xStart;
+ if (model.posDrag.IsValid()) {
+ /* Dragging text, use a line caret */
+ rcCaret.left = static_cast<XYPOSITION>(RoundXYPosition(xposCaret - caretWidthOffset));
+ rcCaret.right = rcCaret.left + vsDraw.caretWidth;
+ } else if (model.inOverstrike && drawOverstrikeCaret) {
+ /* Overstrike (insert mode), use a modified bar caret */
+ rcCaret.top = rcCaret.bottom - 2;
+ rcCaret.left = xposCaret + 1;
+ rcCaret.right = rcCaret.left + widthOverstrikeCaret - 1;
+ } else if (vsDraw.caretStyle == CARETSTYLE_BLOCK) {
+ /* Block caret */
+ rcCaret.left = xposCaret;
+ if (!caretAtEOL && !caretAtEOF && (ll->chars[offset] != '\t') && !(IsControlCharacter(ll->chars[offset]))) {
+ drawBlockCaret = true;
+ rcCaret.right = xposCaret + widthOverstrikeCaret;
+ } else {
+ rcCaret.right = xposCaret + vsDraw.aveCharWidth;
+ }
+ } else {
+ /* Line caret */
+ rcCaret.left = static_cast<XYPOSITION>(RoundXYPosition(xposCaret - caretWidthOffset));
+ rcCaret.right = rcCaret.left + vsDraw.caretWidth;
+ }
+ ColourDesired caretColour = mainCaret ? vsDraw.caretcolour : vsDraw.additionalCaretColour;
+ if (drawBlockCaret) {
+ DrawBlockCaret(surface, vsDraw, ll, subLine, xStart, offset, posCaret.Position(), rcCaret, caretColour, model);
+ } else {
+ surface->FillRectangle(rcCaret, caretColour);
+ }
+ }
+ }
+ if (drawDrag)
+ break;
+ }
+}
+
+void EditView::DrawLine(Surface *surface, const ViewStyle &vsDraw, int line, int lineVisible, int xStart,
+ PRectangle rcLine, LineLayout *ll, int subLine, const EditModel &model) {
+
+ if (subLine >= ll->lines) {
+ DrawAnnotation(surface, vsDraw, line, xStart, rcLine, ll, subLine, model);
+ return; // No further drawing
+ }
+
+ // Using one font for all control characters so it can be controlled independently to ensure
+ // the box goes around the characters tightly. Seems to be no way to work out what height
+ // is taken by an individual character - internal leading gives varying results.
+ FontAlias ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
+
+ // See if something overrides the line background color.
+ const ColourOptional background = vsDraw.Background(model.pdoc->GetMark(line), model.caret.active, ll->containsCaret);
+
+ const bool drawWhitespaceBackground = (vsDraw.viewWhitespace != wsInvisible) &&
+ (!background.isSet) && (vsDraw.whitespaceColours.back.isSet);
+
+ const XYPOSITION indentWidth = model.pdoc->IndentSize() * vsDraw.spaceWidth;
+
+ const int posLineStart = model.pdoc->LineStart(line);
+
+ const Range lineRange = ll->SubLineRange(subLine);
+ const XYACCUMULATOR subLineStart = ll->positions[lineRange.start];
+
+ if ((ll->wrapIndent != 0) && (subLine > 0) && (subLine < ll->lines)) {
+ // default bgnd here..
+ surface->FillRectangle(rcLine, background.isSet ? background :
+ vsDraw.styles[STYLE_DEFAULT].back);
+
+ if (vsDraw.wrapVisualFlags & SC_WRAPVISUALFLAG_START) {
+
+ // draw continuation rect
+ PRectangle rcPlace = rcLine;
+
+ rcPlace.left = static_cast<XYPOSITION>(xStart);
+ rcPlace.right = rcPlace.left + ll->wrapIndent;
+
+ if (vsDraw.wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_START_BY_TEXT)
+ rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
+ else
+ rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
+
+ DrawWrapMarker(surface, rcPlace, false, vsDraw.WrapColour());
+ }
+
+ xStart += static_cast<int>(ll->wrapIndent);
+ }
+
+ const bool selBackDrawn = vsDraw.selColours.back.isSet &&
+ ((vsDraw.selAlpha == SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA));
+
+ // Does not take margin into account but not significant
+ const int xStartVisible = static_cast<int>(subLineStart)-xStart;
+
+ if (twoPhaseDraw) {
+ bool inIndentation = subLine == 0; // Do not handle indentation except on first subline.
+ BreakFinder bfBack(ll, &model.sel, lineRange, posLineStart, xStartVisible, selBackDrawn, model.pdoc, &model.reprs);
+
+ // Background drawing loop
+ while (bfBack.More()) {
+
+ const TextSegment ts = bfBack.Next();
+ const int i = ts.end() - 1;
+ const int iDoc = i + posLineStart;
+
+ PRectangle rcSegment = rcLine;
+ rcSegment.left = ll->positions[ts.start] + xStart - static_cast<XYPOSITION>(subLineStart);
+ rcSegment.right = ll->positions[ts.end()] + xStart - static_cast<XYPOSITION>(subLineStart);
+ // Only try to draw if really visible - enhances performance by not calling environment to
+ // draw strings that are completely past the right side of the window.
+ if (rcSegment.Intersects(rcLine)) {
+ // Clip to line rectangle, since may have a huge position which will not work with some platforms
+ if (rcSegment.left < rcLine.left)
+ rcSegment.left = rcLine.left;
+ if (rcSegment.right > rcLine.right)
+ rcSegment.right = rcLine.right;
+
+ const int inSelection = hideSelection ? 0 : model.sel.CharacterInSelection(iDoc);
+ const bool inHotspot = (ll->hotspot.Valid()) && ll->hotspot.ContainsCharacter(iDoc);
+ ColourDesired textBack = TextBackground(vsDraw, background, inSelection,
+ inHotspot, ll->styles[i], i, ll, model);
+ if (ts.representation) {
+ if (ll->chars[i] == '\t') {
+ // Tab display
+ if (drawWhitespaceBackground &&
+ (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways))
+ textBack = vsDraw.whitespaceColours.back;
+ } else {
+ // Blob display
+ inIndentation = false;
+ }
+ surface->FillRectangle(rcSegment, textBack);
+ } else {
+ // Normal text display
+ surface->FillRectangle(rcSegment, textBack);
+ if (vsDraw.viewWhitespace != wsInvisible ||
+ (inIndentation && vsDraw.viewIndentationGuides == ivReal)) {
+ for (int cpos = 0; cpos <= i - ts.start; cpos++) {
+ if (ll->chars[cpos + ts.start] == ' ') {
+ if (drawWhitespaceBackground &&
+ (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) {
+ PRectangle rcSpace(
+ ll->positions[cpos + ts.start] + xStart - static_cast<XYPOSITION>(subLineStart),
+ rcSegment.top,
+ ll->positions[cpos + ts.start + 1] + xStart - static_cast<XYPOSITION>(subLineStart),
+ rcSegment.bottom);
+ surface->FillRectangle(rcSpace, vsDraw.whitespaceColours.back);
+ }
+ } else {
+ inIndentation = false;
+ }
+ }
+ }
+ }
+ } else if (rcSegment.left > rcLine.right) {
+ break;
+ }
+ }
+
+ DrawEOL(surface, vsDraw, rcLine, ll, line, lineRange.end,
+ xStart, subLine, subLineStart, background, model);
+ }
+
+ DrawIndicators(surface, vsDraw, line, xStart, rcLine, ll, subLine, lineRange.end, true, model);
+
+ if (vsDraw.edgeState == EDGE_LINE) {
+ PRectangle rcSegment = rcLine;
+ int edgeX = static_cast<int>(vsDraw.theEdge * vsDraw.spaceWidth);
+ rcSegment.left = static_cast<XYPOSITION>(edgeX + xStart);
+ if ((ll->wrapIndent != 0) && (lineRange.start != 0))
+ rcSegment.left -= ll->wrapIndent;
+ rcSegment.right = rcSegment.left + 1;
+ surface->FillRectangle(rcSegment, vsDraw.edgecolour);
+ }
+
+ // Draw underline mark as part of background if not transparent
+ int marks = model.pdoc->GetMark(line);
+ int markBit;
+ for (markBit = 0; (markBit < 32) && marks; markBit++) {
+ if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_UNDERLINE) &&
+ (vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
+ PRectangle rcUnderline = rcLine;
+ rcUnderline.top = rcUnderline.bottom - 2;
+ surface->FillRectangle(rcUnderline, vsDraw.markers[markBit].back);
+ }
+ marks >>= 1;
+ }
+
+ bool inIndentation = subLine == 0; // Do not handle indentation except on first subline.
+ // Foreground drawing loop
+ BreakFinder bfFore(ll, &model.sel, lineRange, posLineStart, xStartVisible,
+ ((!twoPhaseDraw && selBackDrawn) || vsDraw.selColours.fore.isSet), model.pdoc, &model.reprs);
+
+ while (bfFore.More()) {
+
+ const TextSegment ts = bfFore.Next();
+ const int i = ts.end() - 1;
+ const int iDoc = i + posLineStart;
+
+ PRectangle rcSegment = rcLine;
+ rcSegment.left = ll->positions[ts.start] + xStart - static_cast<XYPOSITION>(subLineStart);
+ rcSegment.right = ll->positions[ts.end()] + xStart - static_cast<XYPOSITION>(subLineStart);
+ // Only try to draw if really visible - enhances performance by not calling environment to
+ // draw strings that are completely past the right side of the window.
+ if (rcSegment.Intersects(rcLine)) {
+ int styleMain = ll->styles[i];
+ ColourDesired textFore = vsDraw.styles[styleMain].fore;
+ FontAlias textFont = vsDraw.styles[styleMain].font;
+ //hotspot foreground
+ const bool inHotspot = (ll->hotspot.Valid()) && ll->hotspot.ContainsCharacter(iDoc);
+ if (inHotspot) {
+ if (vsDraw.hotspotColours.fore.isSet)
+ textFore = vsDraw.hotspotColours.fore;
+ }
+ const int inSelection = hideSelection ? 0 : model.sel.CharacterInSelection(iDoc);
+ if (inSelection && (vsDraw.selColours.fore.isSet)) {
+ textFore = (inSelection == 1) ? vsDraw.selColours.fore : vsDraw.selAdditionalForeground;
+ }
+ ColourDesired textBack = TextBackground(vsDraw, background, inSelection, inHotspot, styleMain, i, ll, model);
+ if (ts.representation) {
+ if (ll->chars[i] == '\t') {
+ // Tab display
+ if (!twoPhaseDraw) {
+ if (drawWhitespaceBackground &&
+ (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways))
+ textBack = vsDraw.whitespaceColours.back;
+ surface->FillRectangle(rcSegment, textBack);
+ }
+ if (inIndentation && vsDraw.viewIndentationGuides == ivReal) {
+ for (int indentCount = static_cast<int>((ll->positions[i] + epsilon) / indentWidth);
+ indentCount <= (ll->positions[i + 1] - epsilon) / indentWidth;
+ indentCount++) {
+ if (indentCount > 0) {
+ int xIndent = static_cast<int>(indentCount * indentWidth);
+ DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcSegment,
+ (ll->xHighlightGuide == xIndent));
+ }
+ }
+ }
+ if (vsDraw.viewWhitespace != wsInvisible) {
+ if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
+ if (vsDraw.whitespaceColours.fore.isSet)
+ textFore = vsDraw.whitespaceColours.fore;
+ surface->PenColour(textFore);
+ PRectangle rcTab(rcSegment.left + 1, rcSegment.top + 4,
+ rcSegment.right - 1, rcSegment.bottom - vsDraw.maxDescent);
+ DrawTabArrow(surface, rcTab, static_cast<int>(rcSegment.top + vsDraw.lineHeight / 2));
+ }
+ }
+ } else {
+ inIndentation = false;
+ if (vsDraw.controlCharSymbol >= 32) {
+ char cc[2] = { static_cast<char>(vsDraw.controlCharSymbol), '\0' };
+ surface->DrawTextNoClip(rcSegment, ctrlCharsFont,
+ rcSegment.top + vsDraw.maxAscent,
+ cc, 1, textBack, textFore);
+ } else {
+ DrawTextBlob(surface, vsDraw, rcSegment, ts.representation->stringRep.c_str(), textBack, textFore, twoPhaseDraw);
+ }
+ }
+ } else {
+ // Normal text display
+ if (vsDraw.styles[styleMain].visible) {
+ if (twoPhaseDraw) {
+ surface->DrawTextTransparent(rcSegment, textFont,
+ rcSegment.top + vsDraw.maxAscent, ll->chars + ts.start,
+ i - ts.start + 1, textFore);
+ } else {
+ surface->DrawTextNoClip(rcSegment, textFont,
+ rcSegment.top + vsDraw.maxAscent, ll->chars + ts.start,
+ i - ts.start + 1, textFore, textBack);
+ }
+ }
+ if (vsDraw.viewWhitespace != wsInvisible ||
+ (inIndentation && vsDraw.viewIndentationGuides != ivNone)) {
+ for (int cpos = 0; cpos <= i - ts.start; cpos++) {
+ if (ll->chars[cpos + ts.start] == ' ') {
+ if (vsDraw.viewWhitespace != wsInvisible) {
+ if (vsDraw.whitespaceColours.fore.isSet)
+ textFore = vsDraw.whitespaceColours.fore;
+ if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
+ XYPOSITION xmid = (ll->positions[cpos + ts.start] + ll->positions[cpos + ts.start + 1]) / 2;
+ if (!twoPhaseDraw && drawWhitespaceBackground &&
+ (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) {
+ textBack = vsDraw.whitespaceColours.back;
+ PRectangle rcSpace(
+ ll->positions[cpos + ts.start] + xStart - static_cast<XYPOSITION>(subLineStart),
+ rcSegment.top,
+ ll->positions[cpos + ts.start + 1] + xStart - static_cast<XYPOSITION>(subLineStart),
+ rcSegment.bottom);
+ surface->FillRectangle(rcSpace, textBack);
+ }
+ PRectangle rcDot(xmid + xStart - static_cast<XYPOSITION>(subLineStart),
+ rcSegment.top + vsDraw.lineHeight / 2, 0.0f, 0.0f);
+ rcDot.right = rcDot.left + vsDraw.whitespaceSize;
+ rcDot.bottom = rcDot.top + vsDraw.whitespaceSize;
+ surface->FillRectangle(rcDot, textFore);
+ }
+ }
+ if (inIndentation && vsDraw.viewIndentationGuides == ivReal) {
+ for (int indentCount = static_cast<int>((ll->positions[cpos + ts.start] + epsilon) / indentWidth);
+ indentCount <= (ll->positions[cpos + ts.start + 1] - epsilon) / indentWidth;
+ indentCount++) {
+ if (indentCount > 0) {
+ int xIndent = static_cast<int>(indentCount * indentWidth);
+ DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcSegment,
+ (ll->xHighlightGuide == xIndent));
+ }
+ }
+ }
+ } else {
+ inIndentation = false;
+ }
+ }
+ }
+ }
+ if (ll->hotspot.Valid() && vsDraw.hotspotUnderline && ll->hotspot.ContainsCharacter(iDoc)) {
+ PRectangle rcUL = rcSegment;
+ rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
+ rcUL.bottom = rcUL.top + 1;
+ if (vsDraw.hotspotColours.fore.isSet)
+ surface->FillRectangle(rcUL, vsDraw.hotspotColours.fore);
+ else
+ surface->FillRectangle(rcUL, textFore);
+ } else if (vsDraw.styles[styleMain].underline) {
+ PRectangle rcUL = rcSegment;
+ rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
+ rcUL.bottom = rcUL.top + 1;
+ surface->FillRectangle(rcUL, textFore);
+ }
+ } else if (rcSegment.left > rcLine.right) {
+ break;
+ }
+ }
+ if ((vsDraw.viewIndentationGuides == ivLookForward || vsDraw.viewIndentationGuides == ivLookBoth)
+ && (subLine == 0)) {
+ int indentSpace = model.pdoc->GetLineIndentation(line);
+ int xStartText = static_cast<int>(ll->positions[model.pdoc->GetLineIndentPosition(line) - posLineStart]);
+
+ // Find the most recent line with some text
+
+ int lineLastWithText = line;
+ while (lineLastWithText > Platform::Maximum(line - 20, 0) && model.pdoc->IsWhiteLine(lineLastWithText)) {
+ lineLastWithText--;
+ }
+ if (lineLastWithText < line) {
+ xStartText = 100000; // Don't limit to visible indentation on empty line
+ // This line is empty, so use indentation of last line with text
+ int indentLastWithText = model.pdoc->GetLineIndentation(lineLastWithText);
+ int isFoldHeader = model.pdoc->GetLevel(lineLastWithText) & SC_FOLDLEVELHEADERFLAG;
+ if (isFoldHeader) {
+ // Level is one more level than parent
+ indentLastWithText += model.pdoc->IndentSize();
+ }
+ if (vsDraw.viewIndentationGuides == ivLookForward) {
+ // In viLookForward mode, previous line only used if it is a fold header
+ if (isFoldHeader) {
+ indentSpace = Platform::Maximum(indentSpace, indentLastWithText);
+ }
+ } else { // viLookBoth
+ indentSpace = Platform::Maximum(indentSpace, indentLastWithText);
+ }
+ }
+
+ int lineNextWithText = line;
+ while (lineNextWithText < Platform::Minimum(line + 20, model.pdoc->LinesTotal()) && model.pdoc->IsWhiteLine(lineNextWithText)) {
+ lineNextWithText++;
+ }
+ if (lineNextWithText > line) {
+ xStartText = 100000; // Don't limit to visible indentation on empty line
+ // This line is empty, so use indentation of first next line with text
+ indentSpace = Platform::Maximum(indentSpace,
+ model.pdoc->GetLineIndentation(lineNextWithText));
+ }
+
+ for (int indentPos = model.pdoc->IndentSize(); indentPos < indentSpace; indentPos += model.pdoc->IndentSize()) {
+ int xIndent = static_cast<int>(indentPos * vsDraw.spaceWidth);
+ if (xIndent < xStartText) {
+ DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcLine,
+ (ll->xHighlightGuide == xIndent));
+ }
+ }
+ }
+
+ DrawIndicators(surface, vsDraw, line, xStart, rcLine, ll, subLine, lineRange.end, false, model);
+
+ // End of the drawing of the current line
+ if (!twoPhaseDraw) {
+ DrawEOL(surface, vsDraw, rcLine, ll, line, lineRange.end,
+ xStart, subLine, subLineStart, background, model);
+ }
+ if (!hideSelection && ((vsDraw.selAlpha != SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha != SC_ALPHA_NOALPHA))) {
+ // For each selection draw
+ int virtualSpaces = 0;
+ if (subLine == (ll->lines - 1)) {
+ virtualSpaces = model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line));
+ }
+ SelectionPosition posStart(posLineStart + lineRange.start);
+ SelectionPosition posEnd(posLineStart + lineRange.end, virtualSpaces);
+ SelectionSegment virtualSpaceRange(posStart, posEnd);
+ for (size_t r = 0; r<model.sel.Count(); r++) {
+ int alpha = (r == model.sel.Main()) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
+ if (alpha != SC_ALPHA_NOALPHA) {
+ SelectionSegment portion = model.sel.Range(r).Intersect(virtualSpaceRange);
+ if (!portion.Empty()) {
+ const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+ PRectangle rcSegment = rcLine;
+ rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] -
+ static_cast<XYPOSITION>(subLineStart)+portion.start.VirtualSpace() * spaceWidth;
+ rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] -
+ static_cast<XYPOSITION>(subLineStart)+portion.end.VirtualSpace() * spaceWidth;
+ if ((ll->wrapIndent != 0) && (lineRange.start != 0)) {
+ if ((portion.start.Position() - posLineStart) == lineRange.start && model.sel.Range(r).ContainsCharacter(portion.start.Position() - 1))
+ rcSegment.left -= static_cast<int>(ll->wrapIndent); // indentation added to xStart was truncated to int, so we do the same here
+ }
+ rcSegment.left = (rcSegment.left > rcLine.left) ? rcSegment.left : rcLine.left;
+ rcSegment.right = (rcSegment.right < rcLine.right) ? rcSegment.right : rcLine.right;
+ if (rcSegment.right > rcLine.left)
+ SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, r == model.sel.Main(), model.primarySelection), alpha);
+ }
+ }
+ }
+ }
+
+ // Draw any translucent whole line states
+ if ((model.caret.active || vsDraw.alwaysShowCaretLineBackground) && vsDraw.showCaretLineBackground && ll->containsCaret) {
+ SimpleAlphaRectangle(surface, rcLine, vsDraw.caretLineBackground, vsDraw.caretLineAlpha);
+ }
+ marks = model.pdoc->GetMark(line);
+ for (markBit = 0; (markBit < 32) && marks; markBit++) {
+ if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND)) {
+ SimpleAlphaRectangle(surface, rcLine, vsDraw.markers[markBit].back, vsDraw.markers[markBit].alpha);
+ } else if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_UNDERLINE)) {
+ PRectangle rcUnderline = rcLine;
+ rcUnderline.top = rcUnderline.bottom - 2;
+ SimpleAlphaRectangle(surface, rcUnderline, vsDraw.markers[markBit].back, vsDraw.markers[markBit].alpha);
+ }
+ marks >>= 1;
+ }
+ if (vsDraw.maskInLine) {
+ int marksMasked = model.pdoc->GetMark(line) & vsDraw.maskInLine;
+ if (marksMasked) {
+ for (markBit = 0; (markBit < 32) && marksMasked; markBit++) {
+ if ((marksMasked & 1) && (vsDraw.markers[markBit].markType != SC_MARK_EMPTY)) {
+ SimpleAlphaRectangle(surface, rcLine, vsDraw.markers[markBit].back, vsDraw.markers[markBit].alpha);
+ }
+ marksMasked >>= 1;
+ }
+ }
+ }
+}
+
+void EditView::PaintText(Surface *surfaceWindow, PRectangle rcArea, PRectangle rcClient,
+ const EditModel &model, const ViewStyle &vsDraw) {
+ // Allow text at start of line to overlap 1 pixel into the margin as this displays
+ // serifs and italic stems for aliased text.
+ const int leftTextOverlap = ((model.xOffset == 0) && (vsDraw.leftMarginWidth > 0)) ? 1 : 0;
+
+ // Do the painting
+ if (rcArea.right > vsDraw.textStart - leftTextOverlap) {
+
+ Surface *surface = surfaceWindow;
+ if (bufferedDraw) {
+ surface = pixmapLine;
+ PLATFORM_ASSERT(pixmapLine->Initialised());
+ }
+ surface->SetUnicodeMode(SC_CP_UTF8 == model.pdoc->dbcsCodePage);
+ surface->SetDBCSMode(model.pdoc->dbcsCodePage);
+
+ Point ptOrigin = model.GetVisibleOriginInMain();
+
+ int screenLinePaintFirst = static_cast<int>(rcArea.top) / vsDraw.lineHeight;
+ int ypos = 0;
+ if (!bufferedDraw)
+ ypos += screenLinePaintFirst * vsDraw.lineHeight;
+ int xStart = vsDraw.textStart - model.xOffset + static_cast<int>(ptOrigin.x);
+
+ int visibleLine = model.TopLineOfMain() + screenLinePaintFirst;
+ int yposScreen = screenLinePaintFirst * vsDraw.lineHeight;
+
+ SelectionPosition posCaret = model.sel.RangeMain().caret;
+ if (model.posDrag.IsValid())
+ posCaret = model.posDrag;
+ int lineCaret = model.pdoc->LineFromPosition(posCaret.Position());
+
+ PRectangle rcTextArea = rcClient;
+ if (vsDraw.marginInside) {
+ rcTextArea.left += vsDraw.textStart;
+ rcTextArea.right -= vsDraw.rightMarginWidth;
+ } else {
+ rcTextArea = rcArea;
+ }
+
+ // Remove selection margin from drawing area so text will not be drawn
+ // on it in unbuffered mode.
+ if (!bufferedDraw && vsDraw.marginInside) {
+ PRectangle rcClipText = rcTextArea;
+ rcClipText.left -= leftTextOverlap;
+ surfaceWindow->SetClip(rcClipText);
+ }
+
+ // Loop on visible lines
+ //double durLayout = 0.0;
+ //double durPaint = 0.0;
+ //double durCopy = 0.0;
+ //ElapsedTime etWhole;
+ int lineDocPrevious = -1; // Used to avoid laying out one document line multiple times
+ AutoLineLayout ll(llc, 0);
+ while (visibleLine < model.cs.LinesDisplayed() && yposScreen < rcArea.bottom) {
+
+ int lineDoc = model.cs.DocFromDisplay(visibleLine);
+ // Only visible lines should be handled by the code within the loop
+ PLATFORM_ASSERT(model.cs.GetVisible(lineDoc));
+ int lineStartSet = model.cs.DisplayFromDoc(lineDoc);
+ int subLine = visibleLine - lineStartSet;
+
+ // Copy this line and its styles from the document into local arrays
+ // and determine the x position at which each character starts.
+ //ElapsedTime et;
+ if (lineDoc != lineDocPrevious) {
+ ll.Set(0);
+ ll.Set(RetrieveLineLayout(lineDoc, model));
+ LayoutLine(lineDoc, surface, vsDraw, ll, model, model.wrapWidth);
+ lineDocPrevious = lineDoc;
+ }
+ //durLayout += et.Duration(true);
+
+ if (ll) {
+ ll->containsCaret = lineDoc == lineCaret;
+ if (hideSelection) {
+ ll->containsCaret = false;
+ }
+
+ ll->hotspot = model.GetHotSpotRange();
+
+ PRectangle rcLine = rcTextArea;
+ rcLine.top = static_cast<XYPOSITION>(ypos);
+ rcLine.bottom = static_cast<XYPOSITION>(ypos + vsDraw.lineHeight);
+
+ bool bracesIgnoreStyle = false;
+ if ((vsDraw.braceHighlightIndicatorSet && (model.bracesMatchStyle == STYLE_BRACELIGHT)) ||
+ (vsDraw.braceBadLightIndicatorSet && (model.bracesMatchStyle == STYLE_BRACEBAD))) {
+ bracesIgnoreStyle = true;
+ }
+ Range rangeLine(model.pdoc->LineStart(lineDoc), model.pdoc->LineStart(lineDoc + 1));
+ // Highlight the current braces if any
+ ll->SetBracesHighlight(rangeLine, model.braces, static_cast<char>(model.bracesMatchStyle),
+ static_cast<int>(model.highlightGuideColumn * vsDraw.spaceWidth), bracesIgnoreStyle);
+
+ if (leftTextOverlap && bufferedDraw) {
+ PRectangle rcSpacer = rcLine;
+ rcSpacer.right = rcSpacer.left;
+ rcSpacer.left -= 1;
+ surface->FillRectangle(rcSpacer, vsDraw.styles[STYLE_DEFAULT].back);
+ }
+
+ // Draw the line
+ DrawLine(surface, vsDraw, lineDoc, visibleLine, xStart, rcLine, ll, subLine, model);
+ //durPaint += et.Duration(true);
+
+ // Restore the previous styles for the brace highlights in case layout is in cache.
+ ll->RestoreBracesHighlight(rangeLine, model.braces, bracesIgnoreStyle);
+
+ bool expanded = model.cs.GetExpanded(lineDoc);
+ const int level = model.pdoc->GetLevel(lineDoc);
+ const int levelNext = model.pdoc->GetLevel(lineDoc + 1);
+ if ((level & SC_FOLDLEVELHEADERFLAG) &&
+ ((level & SC_FOLDLEVELNUMBERMASK) < (levelNext & SC_FOLDLEVELNUMBERMASK))) {
+ // Paint the line above the fold
+ if ((expanded && (model.foldFlags & SC_FOLDFLAG_LINEBEFORE_EXPANDED))
+ ||
+ (!expanded && (model.foldFlags & SC_FOLDFLAG_LINEBEFORE_CONTRACTED))) {
+ PRectangle rcFoldLine = rcLine;
+ rcFoldLine.bottom = rcFoldLine.top + 1;
+ surface->FillRectangle(rcFoldLine, vsDraw.styles[STYLE_DEFAULT].fore);
+ }
+ // Paint the line below the fold
+ if ((expanded && (model.foldFlags & SC_FOLDFLAG_LINEAFTER_EXPANDED))
+ ||
+ (!expanded && (model.foldFlags & SC_FOLDFLAG_LINEAFTER_CONTRACTED))) {
+ PRectangle rcFoldLine = rcLine;
+ rcFoldLine.top = rcFoldLine.bottom - 1;
+ surface->FillRectangle(rcFoldLine, vsDraw.styles[STYLE_DEFAULT].fore);
+ }
+ }
+
+ DrawCarets(surface, vsDraw, lineDoc, xStart, rcLine, ll, subLine, model);
+
+ if (bufferedDraw) {
+ Point from = Point::FromInts(vsDraw.textStart - leftTextOverlap, 0);
+ PRectangle rcCopyArea = PRectangle::FromInts(vsDraw.textStart - leftTextOverlap, yposScreen,
+ static_cast<int>(rcClient.right - vsDraw.rightMarginWidth),
+ yposScreen + vsDraw.lineHeight);
+ surfaceWindow->Copy(rcCopyArea, from, *pixmapLine);
+ }
+
+ lineWidthMaxSeen = Platform::Maximum(
+ lineWidthMaxSeen, static_cast<int>(ll->positions[ll->numCharsInLine]));
+ //durCopy += et.Duration(true);
+ }
+
+ if (!bufferedDraw) {
+ ypos += vsDraw.lineHeight;
+ }
+
+ yposScreen += vsDraw.lineHeight;
+ visibleLine++;
+
+ //gdk_flush();
+ }
+ ll.Set(0);
+ //if (durPaint < 0.00000001)
+ // durPaint = 0.00000001;
+
+ // Right column limit indicator
+ PRectangle rcBeyondEOF = (vsDraw.marginInside) ? rcClient : rcArea;
+ rcBeyondEOF.left = static_cast<XYPOSITION>(vsDraw.textStart);
+ rcBeyondEOF.right = rcBeyondEOF.right - ((vsDraw.marginInside) ? vsDraw.rightMarginWidth : 0);
+ rcBeyondEOF.top = static_cast<XYPOSITION>((model.cs.LinesDisplayed() - model.TopLineOfMain()) * vsDraw.lineHeight);
+ if (rcBeyondEOF.top < rcBeyondEOF.bottom) {
+ surfaceWindow->FillRectangle(rcBeyondEOF, vsDraw.styles[STYLE_DEFAULT].back);
+ if (vsDraw.edgeState == EDGE_LINE) {
+ int edgeX = static_cast<int>(vsDraw.theEdge * vsDraw.spaceWidth);
+ rcBeyondEOF.left = static_cast<XYPOSITION>(edgeX + xStart);
+ rcBeyondEOF.right = rcBeyondEOF.left + 1;
+ surfaceWindow->FillRectangle(rcBeyondEOF, vsDraw.edgecolour);
+ }
+ }
+ //Platform::DebugPrintf("start display %d, offset = %d\n", pdoc->Length(), xOffset);
+
+ //Platform::DebugPrintf(
+ //"Layout:%9.6g Paint:%9.6g Ratio:%9.6g Copy:%9.6g Total:%9.6g\n",
+ //durLayout, durPaint, durLayout / durPaint, durCopy, etWhole.Duration());
+ }
+}
+
+// Space (3 space characters) between line numbers and text when printing.
+#define lineNumberPrintSpace " "
+
+ColourDesired InvertedLight(ColourDesired orig) {
+ unsigned int r = orig.GetRed();
+ unsigned int g = orig.GetGreen();
+ unsigned int b = orig.GetBlue();
+ unsigned int l = (r + g + b) / 3; // There is a better calculation for this that matches human eye
+ unsigned int il = 0xff - l;
+ if (l == 0)
+ return ColourDesired(0xff, 0xff, 0xff);
+ r = r * il / l;
+ g = g * il / l;
+ b = b * il / l;
+ return ColourDesired(Platform::Minimum(r, 0xff), Platform::Minimum(g, 0xff), Platform::Minimum(b, 0xff));
+}
+
+long EditView::FormatRange(bool draw, Sci_RangeToFormat *pfr, Surface *surface, Surface *surfaceMeasure,
+ const EditModel &model, const ViewStyle &vs) {
+ // Can't use measurements cached for screen
+ posCache.Clear();
+
+ ViewStyle vsPrint(vs);
+ vsPrint.technology = SC_TECHNOLOGY_DEFAULT;
+
+ // Modify the view style for printing as do not normally want any of the transient features to be printed
+ // Printing supports only the line number margin.
+ int lineNumberIndex = -1;
+ for (int margin = 0; margin <= SC_MAX_MARGIN; margin++) {
+ if ((vsPrint.ms[margin].style == SC_MARGIN_NUMBER) && (vsPrint.ms[margin].width > 0)) {
+ lineNumberIndex = margin;
+ } else {
+ vsPrint.ms[margin].width = 0;
+ }
+ }
+ vsPrint.fixedColumnWidth = 0;
+ vsPrint.zoomLevel = printParameters.magnification;
+ // Don't show indentation guides
+ // If this ever gets changed, cached pixmap would need to be recreated if technology != SC_TECHNOLOGY_DEFAULT
+ vsPrint.viewIndentationGuides = ivNone;
+ // Don't show the selection when printing
+ vsPrint.selColours.back.isSet = false;
+ vsPrint.selColours.fore.isSet = false;
+ vsPrint.selAlpha = SC_ALPHA_NOALPHA;
+ vsPrint.selAdditionalAlpha = SC_ALPHA_NOALPHA;
+ vsPrint.whitespaceColours.back.isSet = false;
+ vsPrint.whitespaceColours.fore.isSet = false;
+ vsPrint.showCaretLineBackground = false;
+ vsPrint.alwaysShowCaretLineBackground = false;
+ // Don't highlight matching braces using indicators
+ vsPrint.braceHighlightIndicatorSet = false;
+ vsPrint.braceBadLightIndicatorSet = false;
+
+ // Set colours for printing according to users settings
+ for (size_t sty = 0; sty < vsPrint.styles.size(); sty++) {
+ if (printParameters.colourMode == SC_PRINT_INVERTLIGHT) {
+ vsPrint.styles[sty].fore = InvertedLight(vsPrint.styles[sty].fore);
+ vsPrint.styles[sty].back = InvertedLight(vsPrint.styles[sty].back);
+ } else if (printParameters.colourMode == SC_PRINT_BLACKONWHITE) {
+ vsPrint.styles[sty].fore = ColourDesired(0, 0, 0);
+ vsPrint.styles[sty].back = ColourDesired(0xff, 0xff, 0xff);
+ } else if (printParameters.colourMode == SC_PRINT_COLOURONWHITE) {
+ vsPrint.styles[sty].back = ColourDesired(0xff, 0xff, 0xff);
+ } else if (printParameters.colourMode == SC_PRINT_COLOURONWHITEDEFAULTBG) {
+ if (sty <= STYLE_DEFAULT) {
+ vsPrint.styles[sty].back = ColourDesired(0xff, 0xff, 0xff);
+ }
+ }
+ }
+ // White background for the line numbers
+ vsPrint.styles[STYLE_LINENUMBER].back = ColourDesired(0xff, 0xff, 0xff);
+
+ // Printing uses different margins, so reset screen margins
+ vsPrint.leftMarginWidth = 0;
+ vsPrint.rightMarginWidth = 0;
+
+ vsPrint.Refresh(*surfaceMeasure, model.pdoc->tabInChars);
+ // Determining width must happen after fonts have been realised in Refresh
+ int lineNumberWidth = 0;
+ if (lineNumberIndex >= 0) {
+ lineNumberWidth = static_cast<int>(surfaceMeasure->WidthText(vsPrint.styles[STYLE_LINENUMBER].font,
+ "99999" lineNumberPrintSpace, 5 + static_cast<int>(strlen(lineNumberPrintSpace))));
+ vsPrint.ms[lineNumberIndex].width = lineNumberWidth;
+ vsPrint.Refresh(*surfaceMeasure, model.pdoc->tabInChars); // Recalculate fixedColumnWidth
+ }
+
+ int linePrintStart = model.pdoc->LineFromPosition(pfr->chrg.cpMin);
+ int linePrintLast = linePrintStart + (pfr->rc.bottom - pfr->rc.top) / vsPrint.lineHeight - 1;
+ if (linePrintLast < linePrintStart)
+ linePrintLast = linePrintStart;
+ int linePrintMax = model.pdoc->LineFromPosition(pfr->chrg.cpMax);
+ if (linePrintLast > linePrintMax)
+ linePrintLast = linePrintMax;
+ //Platform::DebugPrintf("Formatting lines=[%0d,%0d,%0d] top=%0d bottom=%0d line=%0d %0d\n",
+ // linePrintStart, linePrintLast, linePrintMax, pfr->rc.top, pfr->rc.bottom, vsPrint.lineHeight,
+ // surfaceMeasure->Height(vsPrint.styles[STYLE_LINENUMBER].font));
+ int endPosPrint = model.pdoc->Length();
+ if (linePrintLast < model.pdoc->LinesTotal())
+ endPosPrint = model.pdoc->LineStart(linePrintLast + 1);
+
+ // Ensure we are styled to where we are formatting.
+ model.pdoc->EnsureStyledTo(endPosPrint);
+
+ int xStart = vsPrint.fixedColumnWidth + pfr->rc.left;
+ int ypos = pfr->rc.top;
+
+ int lineDoc = linePrintStart;
+
+ int nPrintPos = pfr->chrg.cpMin;
+ int visibleLine = 0;
+ int widthPrint = pfr->rc.right - pfr->rc.left - vsPrint.fixedColumnWidth;
+ if (printParameters.wrapState == eWrapNone)
+ widthPrint = LineLayout::wrapWidthInfinite;
+
+ while (lineDoc <= linePrintLast && ypos < pfr->rc.bottom) {
+
+ // When printing, the hdc and hdcTarget may be the same, so
+ // changing the state of surfaceMeasure may change the underlying
+ // state of surface. Therefore, any cached state is discarded before
+ // using each surface.
+ surfaceMeasure->FlushCachedState();
+
+ // Copy this line and its styles from the document into local arrays
+ // and determine the x position at which each character starts.
+ LineLayout ll(model.pdoc->LineStart(lineDoc + 1) - model.pdoc->LineStart(lineDoc) + 1);
+ LayoutLine(lineDoc, surfaceMeasure, vsPrint, &ll, model, widthPrint);
+
+ ll.containsCaret = false;
+
+ PRectangle rcLine = PRectangle::FromInts(
+ pfr->rc.left,
+ ypos,
+ pfr->rc.right - 1,
+ ypos + vsPrint.lineHeight);
+
+ // When document line is wrapped over multiple display lines, find where
+ // to start printing from to ensure a particular position is on the first
+ // line of the page.
+ if (visibleLine == 0) {
+ int startWithinLine = nPrintPos - model.pdoc->LineStart(lineDoc);
+ for (int iwl = 0; iwl < ll.lines - 1; iwl++) {
+ if (ll.LineStart(iwl) <= startWithinLine && ll.LineStart(iwl + 1) >= startWithinLine) {
+ visibleLine = -iwl;
+ }
+ }
+
+ if (ll.lines > 1 && startWithinLine >= ll.LineStart(ll.lines - 1)) {
+ visibleLine = -(ll.lines - 1);
+ }
+ }
+
+ if (draw && lineNumberWidth &&
+ (ypos + vsPrint.lineHeight <= pfr->rc.bottom) &&
+ (visibleLine >= 0)) {
+ char number[100];
+ sprintf(number, "%d" lineNumberPrintSpace, lineDoc + 1);
+ PRectangle rcNumber = rcLine;
+ rcNumber.right = rcNumber.left + lineNumberWidth;
+ // Right justify
+ rcNumber.left = rcNumber.right - surfaceMeasure->WidthText(
+ vsPrint.styles[STYLE_LINENUMBER].font, number, static_cast<int>(strlen(number)));
+ surface->FlushCachedState();
+ surface->DrawTextNoClip(rcNumber, vsPrint.styles[STYLE_LINENUMBER].font,
+ static_cast<XYPOSITION>(ypos + vsPrint.maxAscent), number, static_cast<int>(strlen(number)),
+ vsPrint.styles[STYLE_LINENUMBER].fore,
+ vsPrint.styles[STYLE_LINENUMBER].back);
+ }
+
+ // Draw the line
+ surface->FlushCachedState();
+
+ for (int iwl = 0; iwl < ll.lines; iwl++) {
+ if (ypos + vsPrint.lineHeight <= pfr->rc.bottom) {
+ if (visibleLine >= 0) {
+ if (draw) {
+ rcLine.top = static_cast<XYPOSITION>(ypos);
+ rcLine.bottom = static_cast<XYPOSITION>(ypos + vsPrint.lineHeight);
+ DrawLine(surface, vsPrint, lineDoc, visibleLine, xStart, rcLine, &ll, iwl, model);
+ }
+ ypos += vsPrint.lineHeight;
+ }
+ visibleLine++;
+ if (iwl == ll.lines - 1)
+ nPrintPos = model.pdoc->LineStart(lineDoc + 1);
+ else
+ nPrintPos += ll.LineStart(iwl + 1) - ll.LineStart(iwl);
+ }
+ }
+
+ ++lineDoc;
+ }
+
+ // Clear cache so measurements are not used for screen
+ posCache.Clear();
+
+ return nPrintPos;
+}
+
Editor::Editor() {
ctrlID = 0;
@@ -118,15 +2399,9 @@ Editor::Editor() {
cursorMode = SC_CURSORNORMAL;
hasFocus = false;
- hideSelection = false;
- inOverstrike = false;
- drawOverstrikeCaret = true;
errorStatus = 0;
mouseDownCaptures = true;
- bufferedDraw = true;
- twoPhaseDraw = true;
-
lastClickTime = 0;
dwellDelay = SC_TIME_FOREVER;
ticksToDwell = SC_TIME_FOREVER;
@@ -135,7 +2410,6 @@ Editor::Editor() {
ptMouseLast.y = 0;
inDragDrop = ddNone;
dropWentOutside = false;
- posDrag = SelectionPosition(invalidPosition);
posDrop = SelectionPosition(invalidPosition);
hotSpotClickPos = INVALID_POSITION;
selectionType = selChar;
@@ -147,8 +2421,6 @@ Editor::Editor() {
wordSelectAnchorEndPos = 0;
wordSelectInitialCaretPos = -1;
- primarySelection = true;
-
caretXPolicy = CARET_SLOP | CARET_EVEN;
caretXSlop = 50;
@@ -160,12 +2432,9 @@ Editor::Editor() {
searchAnchor = 0;
- xOffset = 0;
xCaretMargin = 50;
horizontalScrollBarVisible = true;
scrollWidth = 2000;
- trackLineWidth = false;
- lineWidthMaxSeen = 0;
verticalScrollBarVisible = true;
endAtLastLine = true;
caretSticky = SC_CARETSTICKY_OFF;
@@ -174,17 +2443,8 @@ Editor::Editor() {
multipleSelection = false;
additionalSelectionTyping = false;
multiPasteMode = SC_MULTIPASTE_ONCE;
- additionalCaretsBlink = true;
- additionalCaretsVisible = true;
virtualSpaceOptions = SCVS_NONE;
- pixmapLine = 0;
- pixmapSelMargin = 0;
- pixmapSelPattern = 0;
- pixmapSelPatternOffset1 = 0;
- pixmapIndentGuide = 0;
- pixmapIndentGuideHighlight = 0;
-
targetStart = 0;
targetEnd = 0;
searchFlags = 0;
@@ -196,10 +2456,6 @@ Editor::Editor() {
needUpdateUI = 0;
ContainerNeedsUpdate(SC_UPDATE_CONTENT);
- braces[0] = invalidPosition;
- braces[1] = invalidPosition;
- bracesMatchStyle = STYLE_BRACEBAD;
- highlightGuideColumn = 0;
paintState = notPainting;
paintAbandonedByStyling = false;
@@ -208,30 +2464,18 @@ Editor::Editor() {
modEventMask = SC_MODEVENTMASKALL;
- pdoc = new Document();
- pdoc->AddRef();
pdoc->AddWatcher(this, 0);
recordingMacro = false;
- foldFlags = 0;
foldAutomatic = 0;
- wrapWidth = LineLayout::wrapWidthInfinite;
-
convertPastes = true;
- hotspot = Range(invalidPosition);
-
- llc.SetLevel(LineLayoutCache::llcCaret);
- posCache.SetSize(0x400);
-
SetRepresentations();
}
Editor::~Editor() {
pdoc->RemoveWatcher(this, 0);
- pdoc->Release();
- pdoc = 0;
DropGraphics(true);
}
@@ -284,48 +2528,13 @@ void Editor::SetRepresentations() {
}
void Editor::DropGraphics(bool freeObjects) {
- if (freeObjects) {
- delete pixmapLine;
- pixmapLine = 0;
- delete pixmapSelMargin;
- pixmapSelMargin = 0;
- delete pixmapSelPattern;
- pixmapSelPattern = 0;
- delete pixmapSelPatternOffset1;
- pixmapSelPatternOffset1 = 0;
- delete pixmapIndentGuide;
- pixmapIndentGuide = 0;
- delete pixmapIndentGuideHighlight;
- pixmapIndentGuideHighlight = 0;
- } else {
- if (pixmapLine)
- pixmapLine->Release();
- if (pixmapSelMargin)
- pixmapSelMargin->Release();
- if (pixmapSelPattern)
- pixmapSelPattern->Release();
- if (pixmapSelPatternOffset1)
- pixmapSelPatternOffset1->Release();
- if (pixmapIndentGuide)
- pixmapIndentGuide->Release();
- if (pixmapIndentGuideHighlight)
- pixmapIndentGuideHighlight->Release();
- }
+ marginView.DropGraphics(freeObjects);
+ view.DropGraphics(freeObjects);
}
void Editor::AllocateGraphics() {
- if (!pixmapLine)
- pixmapLine = Surface::Allocate(technology);
- if (!pixmapSelMargin)
- pixmapSelMargin = Surface::Allocate(technology);
- if (!pixmapSelPattern)
- pixmapSelPattern = Surface::Allocate(technology);
- if (!pixmapSelPatternOffset1)
- pixmapSelPatternOffset1 = Surface::Allocate(technology);
- if (!pixmapIndentGuide)
- pixmapIndentGuide = Surface::Allocate(technology);
- if (!pixmapIndentGuideHighlight)
- pixmapIndentGuideHighlight = Surface::Allocate(technology);
+ marginView.AllocateGraphics(vs);
+ view.AllocateGraphics(vs);
}
void Editor::InvalidateStyleData() {
@@ -333,8 +2542,8 @@ void Editor::InvalidateStyleData() {
vs.technology = technology;
DropGraphics(false);
AllocateGraphics();
- llc.Invalidate(LineLayout::llInvalid);
- posCache.Clear();
+ view.llc.Invalidate(LineLayout::llInvalid);
+ view.posCache.Clear();
}
void Editor::InvalidateStyleRedraw() {
@@ -426,45 +2635,6 @@ int Editor::MaxScrollPos() const {
}
}
-const char *ControlCharacterString(unsigned char ch) {
- const char *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"
- };
- if (ch < ELEMENTS(reps)) {
- return reps[ch];
- } else {
- return "BAD";
- }
-}
-
-/**
- * Convenience class to ensure LineLayout objects are always disposed.
- */
-class AutoLineLayout {
- LineLayoutCache &llc;
- LineLayout *ll;
- AutoLineLayout &operator=(const AutoLineLayout &);
-public:
- AutoLineLayout(LineLayoutCache &llc_, LineLayout *ll_) : llc(llc_), ll(ll_) {}
- ~AutoLineLayout() {
- llc.Dispose(ll);
- ll = 0;
- }
- LineLayout *operator->() const {
- return ll;
- }
- operator LineLayout *() const {
- return ll;
- }
- void Set(LineLayout *ll_) {
- llc.Dispose(ll);
- ll = ll_;
- }
-};
-
SelectionPosition Editor::ClampPositionIntoDocument(SelectionPosition sp) const {
if (sp.Position() < 0) {
return SelectionPosition(0);
@@ -479,25 +2649,9 @@ SelectionPosition Editor::ClampPositionIntoDocument(SelectionPosition sp) const
}
Point Editor::LocationFromPosition(SelectionPosition pos) {
- Point pt;
RefreshStyleData();
- if (pos.Position() == INVALID_POSITION)
- return pt;
- const int line = pdoc->LineFromPosition(pos.Position());
- const int lineVisible = cs.DisplayFromDoc(line);
- //Platform::DebugPrintf("line=%d\n", line);
AutoSurface surface(this);
- AutoLineLayout ll(llc, RetrieveLineLayout(line));
- if (surface && ll) {
- const int posLineStart = pdoc->LineStart(line);
- LayoutLine(line, surface, vs, ll, wrapWidth);
- const int posInLine = pos.Position() - posLineStart;
- pt = ll->PointFromPosition(posInLine, vs.lineHeight);
- pt.y += (lineVisible - topLine) * vs.lineHeight;
- pt.x += vs.textStart - xOffset;
- }
- pt.x += pos.VirtualSpace() * vs.styles[ll->EndLineStyle()].spaceWidth;
- return pt;
+ return view.LocationFromPosition(surface, pos, topLine, *this, vs);
}
Point Editor::LocationFromPosition(int pos) {
@@ -514,20 +2668,10 @@ int Editor::XFromPosition(SelectionPosition sp) {
return static_cast<int>(pt.x) - vs.textStart + xOffset;
}
-int Editor::LineFromLocation(Point pt) const {
- return cs.DocFromDisplay(static_cast<int>(pt.y) / vs.lineHeight + topLine);
-}
-
-void Editor::SetTopLine(int topLineNew) {
- if ((topLine != topLineNew) && (topLineNew >= 0)) {
- topLine = topLineNew;
- ContainerNeedsUpdate(SC_UPDATE_V_SCROLL);
- }
- posTopLine = pdoc->LineStart(cs.DocFromDisplay(topLine));
-}
-
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
@@ -541,48 +2685,7 @@ SelectionPosition Editor::SPositionFromLocation(Point pt, bool canReturnInvalid,
return SelectionPosition(INVALID_POSITION);
}
pt = DocumentPointFromView(pt);
- pt.x = pt.x - vs.textStart;
- int visibleLine = static_cast<int>(floor(pt.y / vs.lineHeight));
- if (!canReturnInvalid && (visibleLine < 0))
- visibleLine = 0;
- const int lineDoc = cs.DocFromDisplay(visibleLine);
- if (canReturnInvalid && (lineDoc < 0))
- return SelectionPosition(INVALID_POSITION);
- if (lineDoc >= pdoc->LinesTotal())
- return SelectionPosition(canReturnInvalid ? INVALID_POSITION : pdoc->Length());
- const int posLineStart = pdoc->LineStart(lineDoc);
- AutoSurface surface(this);
- AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
- if (surface && ll) {
- LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
- const int lineStartSet = cs.DisplayFromDoc(lineDoc);
- const int subLine = visibleLine - lineStartSet;
- if (subLine < ll->lines) {
- const Range rangeSubLine = ll->SubLineRange(subLine);
- const XYPOSITION subLineStart = ll->positions[rangeSubLine.start];
- if (subLine > 0) // Wrapped
- pt.x -= ll->wrapIndent;
- const int positionInLine = ll->FindPositionFromX(pt.x + subLineStart, rangeSubLine, charPosition);
- if (positionInLine < rangeSubLine.end) {
- return SelectionPosition(pdoc->MovePositionOutsideChar(positionInLine + posLineStart, 1));
- }
- if (virtualSpace) {
- const XYPOSITION spaceWidth = vs.styles[ll->EndLineStyle()].spaceWidth;
- const int spaceOffset = static_cast<int>(
- (pt.x + subLineStart - ll->positions[rangeSubLine.end] + spaceWidth / 2) / spaceWidth);
- return SelectionPosition(rangeSubLine.end + posLineStart, spaceOffset);
- } else if (canReturnInvalid) {
- if (pt.x < (ll->positions[rangeSubLine.end] - subLineStart)) {
- return SelectionPosition(pdoc->MovePositionOutsideChar(rangeSubLine.end + posLineStart, 1));
- }
- } else {
- return SelectionPosition(rangeSubLine.end + posLineStart);
- }
- }
- if (!canReturnInvalid)
- return SelectionPosition(ll->numCharsInLine + posLineStart);
- }
- return SelectionPosition(canReturnInvalid ? INVALID_POSITION : posLineStart);
+ return view.SPositionFromLocation(surface, pt, canReturnInvalid, charPosition, virtualSpace, *this, vs);
}
int Editor::PositionFromLocation(Point pt, bool canReturnInvalid, bool charPosition) {
@@ -590,38 +2693,35 @@ int Editor::PositionFromLocation(Point pt, bool canReturnInvalid, bool charPosit
}
/**
- * 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.
- */
+* 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(int 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);
- AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
- if (surface && ll) {
- const int posLineStart = pdoc->LineStart(lineDoc);
- LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
- const Range rangeSubLine = ll->SubLineRange(0);
- const XYPOSITION subLineStart = ll->positions[rangeSubLine.start];
- const int positionInLine = ll->FindPositionFromX(x + subLineStart, rangeSubLine, false);
- if (positionInLine < rangeSubLine.end) {
- return SelectionPosition(pdoc->MovePositionOutsideChar(positionInLine + posLineStart, 1));
- }
- const XYPOSITION spaceWidth = vs.styles[ll->EndLineStyle()].spaceWidth;
- const int spaceOffset = static_cast<int>(
- (x + subLineStart - ll->positions[rangeSubLine.end] + spaceWidth / 2) / spaceWidth);
- return SelectionPosition(rangeSubLine.end + posLineStart, spaceOffset);
- }
- return SelectionPosition(0);
+ return view.SPositionFromLineX(surface, lineDoc, x, *this, vs);
}
int Editor::PositionFromLineX(int lineDoc, int x) {
return SPositionFromLineX(lineDoc, x).Position();
}
+int Editor::LineFromLocation(Point pt) const {
+ return cs.DocFromDisplay(static_cast<int>(pt.y) / vs.lineHeight + topLine);
+}
+
+void Editor::SetTopLine(int topLineNew) {
+ if ((topLine != topLineNew) && (topLineNew >= 0)) {
+ topLine = topLineNew;
+ ContainerNeedsUpdate(SC_UPDATE_V_SCROLL);
+ }
+ posTopLine = pdoc->LineStart(cs.DocFromDisplay(topLine));
+}
+
/**
* If painting then abandon the painting because a wider redraw is needed.
* @return true if calling code should stop drawing.
@@ -820,7 +2920,7 @@ void Editor::SetSelection(SelectionPosition currentPos_, SelectionPosition ancho
SetRectangularRange();
ClaimSelection();
- if (highlightDelimiter.NeedsDrawing(currentLine)) {
+ if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
RedrawSelMargin();
}
QueueIdleWork(WorkNeeded::workUpdateUI);
@@ -847,7 +2947,7 @@ void Editor::SetSelection(SelectionPosition currentPos_) {
}
ClaimSelection();
- if (highlightDelimiter.NeedsDrawing(currentLine)) {
+ if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
RedrawSelMargin();
}
QueueIdleWork(WorkNeeded::workUpdateUI);
@@ -868,7 +2968,7 @@ void Editor::SetEmptySelection(SelectionPosition currentPos_) {
SetRectangularRange();
ClaimSelection();
- if (highlightDelimiter.NeedsDrawing(currentLine)) {
+ if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
RedrawSelMargin();
}
QueueIdleWork(WorkNeeded::workUpdateUI);
@@ -978,7 +3078,7 @@ int Editor::MovePositionTo(SelectionPosition newPos, Selection::selTypes selt, b
}
}
- if (highlightDelimiter.NeedsDrawing(currentLine)) {
+ if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
RedrawSelMargin();
}
return 0;
@@ -1175,22 +3275,8 @@ void Editor::MoveCaretInsideView(bool ensureVisible) {
}
int Editor::DisplayFromPosition(int pos) {
- int lineDoc = pdoc->LineFromPosition(pos);
- int lineDisplay = cs.DisplayFromDoc(lineDoc);
AutoSurface surface(this);
- AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
- if (surface && ll) {
- LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
- unsigned int posLineStart = pdoc->LineStart(lineDoc);
- int posInLine = pos - posLineStart;
- lineDisplay--; // To make up for first increment ahead.
- for (int subLine = 0; subLine < ll->lines; subLine++) {
- if (posInLine >= ll->LineStart(subLine)) {
- lineDisplay++;
- }
- }
- }
- return lineDisplay;
+ return view.DisplayFromPosition(surface, pos, *this, vs);
}
/**
@@ -1559,7 +3645,7 @@ bool Editor::Wrapping() const {
void Editor::NeedWrapping(int docLineStart, int docLineEnd) {
//Platform::DebugPrintf("\nNeedWrapping: %0d..%0d\n", docLineStart, docLineEnd);
if (wrapPending.AddRange(docLineStart, docLineEnd)) {
- llc.Invalidate(LineLayout::llPositions);
+ view.llc.Invalidate(LineLayout::llPositions);
}
// Wrap lines during idle.
if (Wrapping() && wrapPending.NeedsWrap()) {
@@ -1568,10 +3654,10 @@ void Editor::NeedWrapping(int docLineStart, int docLineEnd) {
}
bool Editor::WrapOneLine(Surface *surface, int lineToWrap) {
- AutoLineLayout ll(llc, RetrieveLineLayout(lineToWrap));
+ AutoLineLayout ll(view.llc, view.RetrieveLineLayout(lineToWrap, *this));
int linesWrapped = 1;
if (ll) {
- LayoutLine(lineToWrap, surface, vs, ll, wrapWidth);
+ view.LayoutLine(lineToWrap, surface, vs, ll, *this, wrapWidth);
linesWrapped = ll->lines;
}
return cs.SetHeight(lineToWrap, linesWrapped +
@@ -1714,10 +3800,10 @@ void Editor::LinesSplit(int pixelWidth) {
UndoGroup ug(pdoc);
for (int line = lineStart; line <= lineEnd; line++) {
AutoSurface surface(this);
- AutoLineLayout ll(llc, RetrieveLineLayout(line));
+ AutoLineLayout ll(view.llc, view.RetrieveLineLayout(line, *this));
if (surface && ll) {
unsigned int posLineStart = pdoc->LineStart(line);
- LayoutLine(line, surface, vs, ll, pixelWidth);
+ view.LayoutLine(line, surface, vs, ll, *this, pixelWidth);
int lengthInsertedTotal = 0;
for (int subLine = 1; subLine < ll->lines; subLine++) {
const int lengthInserted = pdoc->InsertString(
@@ -1733,98 +3819,6 @@ void Editor::LinesSplit(int pixelWidth) {
}
}
-int Editor::SubstituteMarkerIfEmpty(int markerCheck, int markerDefault) const {
- if (vs.markers[markerCheck].markType == SC_MARK_EMPTY)
- return markerDefault;
- return markerCheck;
-}
-
-bool ValidStyledText(const ViewStyle &vs, size_t styleOffset, const StyledText &st) {
- if (st.multipleStyles) {
- for (size_t iStyle=0; iStyle<st.length; iStyle++) {
- if (!vs.ValidStyle(styleOffset + st.styles[iStyle]))
- return false;
- }
- } else {
- if (!vs.ValidStyle(styleOffset + st.style))
- return false;
- }
- return true;
-}
-
-static int WidthStyledText(Surface *surface, const ViewStyle &vs, int styleOffset,
- const char *text, const unsigned char *styles, size_t len) {
- int width = 0;
- size_t start = 0;
- while (start < len) {
- size_t style = styles[start];
- size_t endSegment = start;
- while ((endSegment+1 < len) && (static_cast<size_t>(styles[endSegment+1]) == style))
- endSegment++;
- FontAlias fontText = vs.styles[style + styleOffset].font;
- width += static_cast<int>(surface->WidthText(fontText, text + start,
- static_cast<int>(endSegment - start + 1)));
- start = endSegment + 1;
- }
- return width;
-}
-
-static int WidestLineWidth(Surface *surface, const ViewStyle &vs, int styleOffset, const StyledText &st) {
- int widthMax = 0;
- size_t start = 0;
- while (start < st.length) {
- size_t lenLine = st.LineLength(start);
- int widthSubLine;
- if (st.multipleStyles) {
- widthSubLine = WidthStyledText(surface, vs, styleOffset, st.text + start, st.styles + start, lenLine);
- } else {
- FontAlias fontText = vs.styles[styleOffset + st.style].font;
- widthSubLine = static_cast<int>(surface->WidthText(fontText,
- st.text + start, static_cast<int>(lenLine)));
- }
- if (widthSubLine > widthMax)
- widthMax = widthSubLine;
- start += lenLine + 1;
- }
- return widthMax;
-}
-
-static void DrawTextInStyle(Surface *surface, PRectangle rcText, const Style &style, XYPOSITION ybase, const char *s, size_t length) {
- FontAlias fontText = style.font;
- surface->DrawTextNoClip(rcText, fontText, ybase, s, static_cast<int>(length),
- style.fore, style.back);
-}
-
-static void DrawStyledText(Surface *surface, const ViewStyle &vs, int styleOffset, PRectangle rcText,
- const StyledText &st, size_t start, size_t length) {
-
- if (st.multipleStyles) {
- int x = static_cast<int>(rcText.left);
- size_t i = 0;
- while (i < length) {
- size_t end = i;
- size_t style = st.styles[i + start];
- while (end < length-1 && st.styles[start+end+1] == style)
- end++;
- style += styleOffset;
- FontAlias fontText = vs.styles[style].font;
- const int width = static_cast<int>(surface->WidthText(fontText,
- st.text + start + i, static_cast<int>(end - i + 1)));
- PRectangle rcSegment = rcText;
- rcSegment.left = static_cast<XYPOSITION>(x);
- rcSegment.right = static_cast<XYPOSITION>(x + width + 1);
- DrawTextInStyle(surface, rcSegment, vs.styles[style], rcText.top + vs.maxAscent,
- st.text + start + i, end - i + 1);
- x += width;
- i = end + 1;
- }
- } else {
- const size_t style = st.style + styleOffset;
- DrawTextInStyle(surface, rcText, vs.styles[style], rcText.top + vs.maxAscent,
- st.text + start, length);
- }
-}
-
void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) {
if (vs.fixedColumnWidth == 0)
return;
@@ -1850,8 +3844,8 @@ void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) {
return;
Surface *surface;
- if (bufferedDraw) {
- surface = pixmapSelMargin;
+ if (view.bufferedDraw) {
+ surface = marginView.pixmapSelMargin;
} else {
surface = surfWindow;
}
@@ -1862,1568 +3856,27 @@ void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) {
if (rcMargin.top < rc.top)
rcMargin.top = rc.top;
- PRectangle rcSelMargin = rcMargin;
- rcSelMargin.right = rcMargin.left;
- if (rcSelMargin.bottom < rc.bottom)
- rcSelMargin.bottom = rc.bottom;
-
- for (int margin = 0; margin <= SC_MAX_MARGIN; margin++) {
- if (vs.ms[margin].width > 0) {
-
- rcSelMargin.left = rcSelMargin.right;
- rcSelMargin.right = rcSelMargin.left + vs.ms[margin].width;
-
- if (vs.ms[margin].style != SC_MARGIN_NUMBER) {
- if (vs.ms[margin].mask & SC_MASK_FOLDERS) {
- // Required because of special way brush is created for selection margin
- // Ensure patterns line up when scrolling with separate margin view
- // by choosing correctly aligned variant.
- bool invertPhase = static_cast<int>(ptOrigin.y) & 1;
- surface->FillRectangle(rcSelMargin,
- invertPhase ? *pixmapSelPattern : *pixmapSelPatternOffset1);
- } else {
- ColourDesired colour;
- switch (vs.ms[margin].style) {
- case SC_MARGIN_BACK:
- colour = vs.styles[STYLE_DEFAULT].back;
- break;
- case SC_MARGIN_FORE:
- colour = vs.styles[STYLE_DEFAULT].fore;
- break;
- default:
- colour = vs.styles[STYLE_LINENUMBER].back;
- break;
- }
- surface->FillRectangle(rcSelMargin, colour);
- }
- } else {
- surface->FillRectangle(rcSelMargin, vs.styles[STYLE_LINENUMBER].back);
- }
-
- const int lineStartPaint = static_cast<int>(rcMargin.top + ptOrigin.y) / vs.lineHeight;
- int visibleLine = TopLineOfMain() + lineStartPaint;
- int yposScreen = lineStartPaint * vs.lineHeight - static_cast<int>(ptOrigin.y);
- // Work out whether the top line is whitespace located after a
- // lessening of fold level which implies a 'fold tail' but which should not
- // be displayed until the last of a sequence of whitespace.
- bool needWhiteClosure = false;
- if (vs.ms[margin].mask & SC_MASK_FOLDERS) {
- int level = pdoc->GetLevel(cs.DocFromDisplay(visibleLine));
- if (level & SC_FOLDLEVELWHITEFLAG) {
- int lineBack = cs.DocFromDisplay(visibleLine);
- int levelPrev = level;
- while ((lineBack > 0) && (levelPrev & SC_FOLDLEVELWHITEFLAG)) {
- lineBack--;
- levelPrev = pdoc->GetLevel(lineBack);
- }
- if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) {
- if ((level & SC_FOLDLEVELNUMBERMASK) < (levelPrev & SC_FOLDLEVELNUMBERMASK))
- needWhiteClosure = true;
- }
- }
- if (highlightDelimiter.isEnabled) {
- int lastLine = cs.DocFromDisplay(topLine + LinesOnScreen()) + 1;
- pdoc->GetHighlightDelimiters(highlightDelimiter, pdoc->LineFromPosition(CurrentPosition()), lastLine);
- }
- }
-
- // Old code does not know about new markers needed to distinguish all cases
- const int folderOpenMid = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEROPENMID,
- SC_MARKNUM_FOLDEROPEN);
- const int folderEnd = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEREND,
- SC_MARKNUM_FOLDER);
-
- while ((visibleLine < cs.LinesDisplayed()) && yposScreen < rc.bottom) {
-
- PLATFORM_ASSERT(visibleLine < cs.LinesDisplayed());
- const int lineDoc = cs.DocFromDisplay(visibleLine);
- PLATFORM_ASSERT(cs.GetVisible(lineDoc));
- const bool firstSubLine = visibleLine == cs.DisplayFromDoc(lineDoc);
- const bool lastSubLine = visibleLine == cs.DisplayLastFromDoc(lineDoc);
-
- int marks = pdoc->GetMark(lineDoc);
- if (!firstSubLine)
- marks = 0;
-
- bool headWithTail = false;
-
- if (vs.ms[margin].mask & SC_MASK_FOLDERS) {
- // Decide which fold indicator should be displayed
- const int level = pdoc->GetLevel(lineDoc);
- const int levelNext = pdoc->GetLevel(lineDoc + 1);
- const int levelNum = level & SC_FOLDLEVELNUMBERMASK;
- const int levelNextNum = levelNext & SC_FOLDLEVELNUMBERMASK;
- if (level & SC_FOLDLEVELHEADERFLAG) {
- if (firstSubLine) {
- if (levelNum < levelNextNum) {
- if (cs.GetExpanded(lineDoc)) {
- if (levelNum == SC_FOLDLEVELBASE)
- marks |= 1 << SC_MARKNUM_FOLDEROPEN;
- else
- marks |= 1 << folderOpenMid;
- } else {
- if (levelNum == SC_FOLDLEVELBASE)
- marks |= 1 << SC_MARKNUM_FOLDER;
- else
- marks |= 1 << folderEnd;
- }
- } else if (levelNum > SC_FOLDLEVELBASE) {
- marks |= 1 << SC_MARKNUM_FOLDERSUB;
- }
- } else {
- if (levelNum < levelNextNum) {
- if (cs.GetExpanded(lineDoc)) {
- marks |= 1 << SC_MARKNUM_FOLDERSUB;
- } else if (levelNum > SC_FOLDLEVELBASE) {
- marks |= 1 << SC_MARKNUM_FOLDERSUB;
- }
- } else if (levelNum > SC_FOLDLEVELBASE) {
- marks |= 1 << SC_MARKNUM_FOLDERSUB;
- }
- }
- needWhiteClosure = false;
- const int firstFollowupLine = cs.DocFromDisplay(cs.DisplayFromDoc(lineDoc + 1));
- const int firstFollowupLineLevel = pdoc->GetLevel(firstFollowupLine);
- const int secondFollowupLineLevelNum = pdoc->GetLevel(firstFollowupLine + 1) & SC_FOLDLEVELNUMBERMASK;
- if (!cs.GetExpanded(lineDoc)) {
- if ((firstFollowupLineLevel & SC_FOLDLEVELWHITEFLAG) &&
- (levelNum > secondFollowupLineLevelNum))
- needWhiteClosure = true;
-
- if (highlightDelimiter.IsFoldBlockHighlighted(firstFollowupLine))
- headWithTail = true;
- }
- } else if (level & SC_FOLDLEVELWHITEFLAG) {
- if (needWhiteClosure) {
- if (levelNext & SC_FOLDLEVELWHITEFLAG) {
- marks |= 1 << SC_MARKNUM_FOLDERSUB;
- } else if (levelNextNum > SC_FOLDLEVELBASE) {
- marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
- needWhiteClosure = false;
- } else {
- marks |= 1 << SC_MARKNUM_FOLDERTAIL;
- needWhiteClosure = false;
- }
- } else if (levelNum > SC_FOLDLEVELBASE) {
- if (levelNextNum < levelNum) {
- if (levelNextNum > SC_FOLDLEVELBASE) {
- marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
- } else {
- marks |= 1 << SC_MARKNUM_FOLDERTAIL;
- }
- } else {
- marks |= 1 << SC_MARKNUM_FOLDERSUB;
- }
- }
- } else if (levelNum > SC_FOLDLEVELBASE) {
- if (levelNextNum < levelNum) {
- needWhiteClosure = false;
- if (levelNext & SC_FOLDLEVELWHITEFLAG) {
- marks |= 1 << SC_MARKNUM_FOLDERSUB;
- needWhiteClosure = true;
- } else if (lastSubLine) {
- if (levelNextNum > SC_FOLDLEVELBASE) {
- marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
- } else {
- marks |= 1 << SC_MARKNUM_FOLDERTAIL;
- }
- } else {
- marks |= 1 << SC_MARKNUM_FOLDERSUB;
- }
- } else {
- marks |= 1 << SC_MARKNUM_FOLDERSUB;
- }
- }
- }
-
- marks &= vs.ms[margin].mask;
-
- PRectangle rcMarker = rcSelMargin;
- rcMarker.top = static_cast<XYPOSITION>(yposScreen);
- rcMarker.bottom = static_cast<XYPOSITION>(yposScreen + vs.lineHeight);
- if (vs.ms[margin].style == SC_MARGIN_NUMBER) {
- if (firstSubLine) {
- char number[100] = "";
- if (lineDoc >= 0)
- sprintf(number, "%d", lineDoc + 1);
- if (foldFlags & (SC_FOLDFLAG_LEVELNUMBERS | SC_FOLDFLAG_LINESTATE)) {
- if (foldFlags & SC_FOLDFLAG_LEVELNUMBERS) {
- int lev = pdoc->GetLevel(lineDoc);
- sprintf(number, "%c%c %03X %03X",
- (lev & SC_FOLDLEVELHEADERFLAG) ? 'H' : '_',
- (lev & SC_FOLDLEVELWHITEFLAG) ? 'W' : '_',
- lev & SC_FOLDLEVELNUMBERMASK,
- lev >> 16
- );
- } else {
- int state = pdoc->GetLineState(lineDoc);
- sprintf(number, "%0X", state);
- }
- }
- PRectangle rcNumber = rcMarker;
- // Right justify
- XYPOSITION width = surface->WidthText(vs.styles[STYLE_LINENUMBER].font, number, istrlen(number));
- XYPOSITION xpos = rcNumber.right - width - vs.marginNumberPadding;
- rcNumber.left = xpos;
- DrawTextInStyle(surface, rcNumber, vs.styles[STYLE_LINENUMBER],
- rcNumber.top + vs.maxAscent, number, strlen(number));
- } else if (vs.wrapVisualFlags & SC_WRAPVISUALFLAG_MARGIN) {
- PRectangle rcWrapMarker = rcMarker;
- rcWrapMarker.right -= 3;
- rcWrapMarker.left = rcWrapMarker.right - vs.styles[STYLE_LINENUMBER].aveCharWidth;
- DrawWrapMarker(surface, rcWrapMarker, false, vs.styles[STYLE_LINENUMBER].fore);
- }
- } else if (vs.ms[margin].style == SC_MARGIN_TEXT || vs.ms[margin].style == SC_MARGIN_RTEXT) {
- if (firstSubLine) {
- const StyledText stMargin = pdoc->MarginStyledText(lineDoc);
- if (stMargin.text && ValidStyledText(vs, vs.marginStyleOffset, stMargin)) {
- surface->FillRectangle(rcMarker,
- vs.styles[stMargin.StyleAt(0)+vs.marginStyleOffset].back);
- if (vs.ms[margin].style == SC_MARGIN_RTEXT) {
- int width = WidestLineWidth(surface, vs, vs.marginStyleOffset, stMargin);
- rcMarker.left = rcMarker.right - width - 3;
- }
- DrawStyledText(surface, vs, vs.marginStyleOffset, rcMarker,
- stMargin, 0, stMargin.length);
- }
- }
- }
-
- if (marks) {
- for (int markBit = 0; (markBit < 32) && marks; markBit++) {
- if (marks & 1) {
- LineMarker::typeOfFold tFold = LineMarker::undefined;
- if ((vs.ms[margin].mask & SC_MASK_FOLDERS) && highlightDelimiter.IsFoldBlockHighlighted(lineDoc)) {
- if (highlightDelimiter.IsBodyOfFoldBlock(lineDoc)) {
- tFold = LineMarker::body;
- } else if (highlightDelimiter.IsHeadOfFoldBlock(lineDoc)) {
- if (firstSubLine) {
- tFold = headWithTail ? LineMarker::headWithTail : LineMarker::head;
- } else {
- if (cs.GetExpanded(lineDoc) || headWithTail) {
- tFold = LineMarker::body;
- } else {
- tFold = LineMarker::undefined;
- }
- }
- } else if (highlightDelimiter.IsTailOfFoldBlock(lineDoc)) {
- tFold = LineMarker::tail;
- }
- }
- vs.markers[markBit].Draw(surface, rcMarker, vs.styles[STYLE_LINENUMBER].font, tFold, vs.ms[margin].style);
- }
- marks >>= 1;
- }
- }
-
- visibleLine++;
- yposScreen += vs.lineHeight;
- }
- }
- }
-
- PRectangle rcBlankMargin = rcMargin;
- rcBlankMargin.left = rcSelMargin.right;
- surface->FillRectangle(rcBlankMargin, vs.styles[STYLE_DEFAULT].back);
-
- if (bufferedDraw) {
- surfWindow->Copy(rcMargin, Point(rcMargin.left, rcMargin.top), *pixmapSelMargin);
- }
-}
-
-void DrawTabArrow(Surface *surface, PRectangle rcTab, int ymid) {
- int ydiff = static_cast<int>(rcTab.bottom - rcTab.top) / 2;
- int xhead = static_cast<int>(rcTab.right) - 1 - ydiff;
- if (xhead <= rcTab.left) {
- ydiff -= static_cast<int>(rcTab.left) - xhead - 1;
- xhead = static_cast<int>(rcTab.left) - 1;
- }
- if ((rcTab.left + 2) < (rcTab.right - 1))
- surface->MoveTo(static_cast<int>(rcTab.left) + 2, ymid);
- else
- surface->MoveTo(static_cast<int>(rcTab.right) - 1, ymid);
- surface->LineTo(static_cast<int>(rcTab.right) - 1, ymid);
- surface->LineTo(xhead, ymid - ydiff);
- surface->MoveTo(static_cast<int>(rcTab.right) - 1, ymid);
- surface->LineTo(xhead, ymid + ydiff);
-}
-
-LineLayout *Editor::RetrieveLineLayout(int lineNumber) {
- int posLineStart = pdoc->LineStart(lineNumber);
- int posLineEnd = pdoc->LineStart(lineNumber + 1);
- PLATFORM_ASSERT(posLineEnd >= posLineStart);
- int lineCaret = pdoc->LineFromPosition(sel.MainCaret());
- return llc.Retrieve(lineNumber, lineCaret,
- posLineEnd - posLineStart, pdoc->GetStyleClock(),
- LinesOnScreen() + 1, pdoc->LinesTotal());
-}
-
-/**
- * Fill in the LineLayout data for the given line.
- * Copy the given @a line and its styles from the document into local arrays.
- * Also determine the x position at which each character starts.
- */
-void Editor::LayoutLine(int line, Surface *surface, const ViewStyle &vstyle, LineLayout *ll, int width) {
- if (!ll)
- return;
-
- PLATFORM_ASSERT(line < pdoc->LinesTotal());
- PLATFORM_ASSERT(ll->chars != NULL);
- int posLineStart = pdoc->LineStart(line);
- int posLineEnd = pdoc->LineStart(line + 1);
- // If the line is very long, limit the treatment to a length that should fit in the viewport
- if (posLineEnd > (posLineStart + ll->maxLineLength)) {
- posLineEnd = posLineStart + ll->maxLineLength;
- }
- if (ll->validity == LineLayout::llCheckTextAndStyle) {
- int lineLength = posLineEnd - posLineStart;
- if (!vstyle.viewEOL) {
- lineLength = pdoc->LineEnd(line) - posLineStart;
- }
- if (lineLength == ll->numCharsInLine) {
- // See if chars, styles, indicators, are all the same
- bool allSame = true;
- // Check base line layout
- char styleByte = 0;
- int numCharsInLine = 0;
- while (numCharsInLine < lineLength) {
- int charInDoc = numCharsInLine + posLineStart;
- char chDoc = pdoc->CharAt(charInDoc);
- styleByte = pdoc->StyleAt(charInDoc);
- allSame = allSame &&
- (ll->styles[numCharsInLine] == static_cast<unsigned char>(styleByte));
- if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseMixed)
- allSame = allSame &&
- (ll->chars[numCharsInLine] == chDoc);
- else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower)
- allSame = allSame &&
- (ll->chars[numCharsInLine] == static_cast<char>(tolower(chDoc)));
- else // Style::caseUpper
- allSame = allSame &&
- (ll->chars[numCharsInLine] == static_cast<char>(toupper(chDoc)));
- numCharsInLine++;
- }
- allSame = allSame && (ll->styles[numCharsInLine] == styleByte); // For eolFilled
- if (allSame) {
- ll->validity = LineLayout::llPositions;
- } else {
- ll->validity = LineLayout::llInvalid;
- }
- } else {
- ll->validity = LineLayout::llInvalid;
- }
- }
- if (ll->validity == LineLayout::llInvalid) {
- ll->widthLine = LineLayout::wrapWidthInfinite;
- ll->lines = 1;
- if (vstyle.edgeState == EDGE_BACKGROUND) {
- ll->edgeColumn = pdoc->FindColumn(line, vstyle.theEdge);
- if (ll->edgeColumn >= posLineStart) {
- ll->edgeColumn -= posLineStart;
- }
- } else {
- ll->edgeColumn = -1;
- }
-
- // Fill base line layout
- const int lineLength = posLineEnd - posLineStart;
- pdoc->GetCharRange(ll->chars, posLineStart, lineLength);
- pdoc->GetStyleRange(ll->styles, posLineStart, lineLength);
- int numCharsBeforeEOL = pdoc->LineEnd(line) - posLineStart;
- const int numCharsInLine = (vstyle.viewEOL) ? lineLength : numCharsBeforeEOL;
- for (int styleInLine = 0; styleInLine < numCharsInLine; styleInLine++) {
- const unsigned char styleByte = ll->styles[styleInLine];
- ll->styles[styleInLine] = styleByte;
- }
- const unsigned char styleByteLast = (lineLength > 0) ? ll->styles[lineLength-1] : 0;
- if (vstyle.someStylesForceCase) {
- for (int charInLine = 0; charInLine<lineLength; charInLine++) {
- char chDoc = ll->chars[charInLine];
- if (vstyle.styles[ll->styles[charInLine]].caseForce == Style::caseUpper)
- ll->chars[charInLine] = static_cast<char>(toupper(chDoc));
- else if (vstyle.styles[ll->styles[charInLine]].caseForce == Style::caseLower)
- ll->chars[charInLine] = static_cast<char>(tolower(chDoc));
- }
- }
- ll->xHighlightGuide = 0;
- // Extra element at the end of the line to hold end x position and act as
- ll->chars[numCharsInLine] = 0; // Also triggers processing in the loops as this is a control character
- ll->styles[numCharsInLine] = styleByteLast; // For eolFilled
-
- // Layout the line, determining the position of each character,
- // with an extra element at the end for the end of the line.
- ll->positions[0] = 0;
- bool lastSegItalics = false;
-
- BreakFinder bfLayout(ll, NULL, 0, numCharsInLine, posLineStart, 0, false, pdoc, &reprs);
- while (bfLayout.More()) {
-
- const TextSegment ts = bfLayout.Next();
-
- std::fill(&ll->positions[ts.start+1], &ll->positions[ts.end()+1], 0.0f);
- if (vstyle.styles[ll->styles[ts.start]].visible) {
- if (ts.representation) {
- XYPOSITION representationWidth = vstyle.controlCharWidth;
- if (ll->chars[ts.start] == '\t') {
- // Tab is a special case of representation, taking a variable amount of space
- representationWidth =
- ((static_cast<int>((ll->positions[ts.start] + 2) / vstyle.tabWidth) + 1) * vstyle.tabWidth) - ll->positions[ts.start];
- } else {
- if (representationWidth <= 0.0) {
- XYPOSITION positionsRepr[256]; // Should expand when needed
- posCache.MeasureWidths(surface, vstyle, STYLE_CONTROLCHAR, ts.representation->stringRep.c_str(),
- static_cast<unsigned int>(ts.representation->stringRep.length()), positionsRepr, pdoc);
- representationWidth = positionsRepr[ts.representation->stringRep.length()-1] + vstyle.ctrlCharPadding;
- }
- }
- for (int ii=0; ii < ts.length; ii++)
- ll->positions[ts.start + 1 + ii] = representationWidth;
- } else {
- if ((ts.length == 1) && (' ' == ll->chars[ts.start])) {
- // Over half the segments are single characters and of these about half are space characters.
- ll->positions[ts.start + 1] = vstyle.styles[ll->styles[ts.start]].spaceWidth;
- } else {
- posCache.MeasureWidths(surface, vstyle, ll->styles[ts.start], ll->chars + ts.start,
- ts.length, ll->positions + ts.start + 1, pdoc);
- }
- }
- lastSegItalics = (!ts.representation) && ((ll->chars[ts.end()-1] != ' ') && vstyle.styles[ll->styles[ts.start]].italic);
- }
-
- for (int posToIncrease = ts.start+1; posToIncrease <= ts.end(); posToIncrease++) {
- ll->positions[posToIncrease] += ll->positions[ts.start];
- }
- }
-
- // Small hack to make lines that end with italics not cut off the edge of the last character
- if (lastSegItalics) {
- ll->positions[numCharsInLine] += vstyle.lastSegItalicsOffset;
- }
- ll->numCharsInLine = numCharsInLine;
- ll->numCharsBeforeEOL = numCharsBeforeEOL;
- ll->validity = LineLayout::llPositions;
- }
- // Hard to cope when too narrow, so just assume there is space
- if (width < 20) {
- width = 20;
- }
- if ((ll->validity == LineLayout::llPositions) || (ll->widthLine != width)) {
- ll->widthLine = width;
- if (width == LineLayout::wrapWidthInfinite) {
- ll->lines = 1;
- } else if (width > ll->positions[ll->numCharsInLine]) {
- // Simple common case where line does not need wrapping.
- ll->lines = 1;
- } else {
- if (vstyle.wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
- width -= static_cast<int>(vstyle.aveCharWidth); // take into account the space for end wrap mark
- }
- XYPOSITION wrapAddIndent = 0; // This will be added to initial indent of line
- if (vstyle.wrapIndentMode == SC_WRAPINDENT_INDENT) {
- wrapAddIndent = pdoc->IndentSize() * vstyle.spaceWidth;
- } else if (vstyle.wrapIndentMode == SC_WRAPINDENT_FIXED) {
- wrapAddIndent = vstyle.wrapVisualStartIndent * vstyle.aveCharWidth;
- }
- ll->wrapIndent = wrapAddIndent;
- if (vstyle.wrapIndentMode != SC_WRAPINDENT_FIXED)
- for (int i = 0; i < ll->numCharsInLine; i++) {
- if (!IsSpaceOrTab(ll->chars[i])) {
- ll->wrapIndent += ll->positions[i]; // Add line indent
- break;
- }
- }
- // Check for text width minimum
- if (ll->wrapIndent > width - static_cast<int>(vstyle.aveCharWidth) * 15)
- ll->wrapIndent = wrapAddIndent;
- // Check for wrapIndent minimum
- if ((vstyle.wrapVisualFlags & SC_WRAPVISUALFLAG_START) && (ll->wrapIndent < vstyle.aveCharWidth))
- ll->wrapIndent = vstyle.aveCharWidth; // Indent to show start visual
- ll->lines = 0;
- // Calculate line start positions based upon width.
- int lastGoodBreak = 0;
- int lastLineStart = 0;
- XYACCUMULATOR startOffset = 0;
- int p = 0;
- while (p < ll->numCharsInLine) {
- if ((ll->positions[p + 1] - startOffset) >= width) {
- if (lastGoodBreak == lastLineStart) {
- // Try moving to start of last character
- if (p > 0) {
- lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1)
- - posLineStart;
- }
- if (lastGoodBreak == lastLineStart) {
- // Ensure at least one character on line.
- lastGoodBreak = pdoc->MovePositionOutsideChar(lastGoodBreak + posLineStart + 1, 1)
- - posLineStart;
- }
- }
- lastLineStart = lastGoodBreak;
- ll->lines++;
- ll->SetLineStart(ll->lines, lastGoodBreak);
- startOffset = ll->positions[lastGoodBreak];
- // take into account the space for start wrap mark and indent
- startOffset -= ll->wrapIndent;
- p = lastGoodBreak + 1;
- continue;
- }
- if (p > 0) {
- if (vstyle.wrapState == eWrapChar) {
- lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1)
- - posLineStart;
- p = pdoc->MovePositionOutsideChar(p + 1 + posLineStart, 1) - posLineStart;
- continue;
- } else if ((vstyle.wrapState == eWrapWord) && (ll->styles[p] != ll->styles[p - 1])) {
- lastGoodBreak = p;
- } else if (IsSpaceOrTab(ll->chars[p - 1]) && !IsSpaceOrTab(ll->chars[p])) {
- lastGoodBreak = p;
- }
- }
- p++;
- }
- ll->lines++;
- }
- ll->validity = LineLayout::llLines;
- }
-}
-
-ColourDesired Editor::SelectionBackground(const ViewStyle &vsDraw, bool main) const {
- return main ?
- (primarySelection ? vsDraw.selColours.back : vsDraw.selBackground2) :
- vsDraw.selAdditionalBackground;
-}
-
-ColourDesired Editor::TextBackground(const ViewStyle &vsDraw,
- ColourOptional background, int inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll) const {
- if (inSelection == 1) {
- if (vsDraw.selColours.back.isSet && (vsDraw.selAlpha == SC_ALPHA_NOALPHA)) {
- return SelectionBackground(vsDraw, true);
- }
- } else if (inSelection == 2) {
- if (vsDraw.selColours.back.isSet && (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA)) {
- return SelectionBackground(vsDraw, false);
- }
- } else {
- if ((vsDraw.edgeState == EDGE_BACKGROUND) &&
- (i >= ll->edgeColumn) &&
- (i < ll->numCharsBeforeEOL))
- return vsDraw.edgecolour;
- if (inHotspot && vsDraw.hotspotColours.back.isSet)
- return vsDraw.hotspotColours.back;
- }
- if (background.isSet && (styleMain != STYLE_BRACELIGHT) && (styleMain != STYLE_BRACEBAD)) {
- return background;
- } else {
- return vsDraw.styles[styleMain].back;
- }
-}
-
-void Editor::DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight) {
- Point from = Point::FromInts(0, ((lineVisible & 1) && (lineHeight & 1)) ? 1 : 0);
- PRectangle rcCopyArea = PRectangle::FromInts(start + 1, static_cast<int>(rcSegment.top), start + 2, static_cast<int>(rcSegment.bottom));
- surface->Copy(rcCopyArea, from,
- highlight ? *pixmapIndentGuideHighlight : *pixmapIndentGuide);
-}
-
-void Editor::DrawWrapMarker(Surface *surface, PRectangle rcPlace,
- bool isEndMarker, ColourDesired wrapColour) {
- surface->PenColour(wrapColour);
-
- enum { xa = 1 }; // gap before start
- int w = static_cast<int>(rcPlace.right - rcPlace.left) - xa - 1;
-
- bool xStraight = isEndMarker; // x-mirrored symbol for start marker
-
- int x0 = static_cast<int>(xStraight ? rcPlace.left : rcPlace.right - 1);
- int y0 = static_cast<int>(rcPlace.top);
-
- int dy = static_cast<int>(rcPlace.bottom - rcPlace.top) / 5;
- int y = static_cast<int>(rcPlace.bottom - rcPlace.top) / 2 + dy;
-
- struct Relative {
- Surface *surface;
- int xBase;
- int xDir;
- int yBase;
- int yDir;
- void MoveTo(int xRelative, int yRelative) {
- surface->MoveTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
- }
- void LineTo(int xRelative, int yRelative) {
- surface->LineTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
- }
- };
- Relative rel = {surface, x0, xStraight ? 1 : -1, y0, 1};
-
- // arrow head
- rel.MoveTo(xa, y);
- rel.LineTo(xa + 2*w / 3, y - dy);
- rel.MoveTo(xa, y);
- rel.LineTo(xa + 2*w / 3, y + dy);
-
- // arrow body
- rel.MoveTo(xa, y);
- rel.LineTo(xa + w, y);
- rel.LineTo(xa + w, y - 2 * dy);
- rel.LineTo(xa - 1, // on windows lineto is exclusive endpoint, perhaps GTK not...
- y - 2 * dy);
-}
-
-static void SimpleAlphaRectangle(Surface *surface, PRectangle rc, ColourDesired fill, int alpha) {
- if (alpha != SC_ALPHA_NOALPHA) {
- surface->AlphaRectangle(rc, 0, fill, alpha, fill, alpha, 0);
- }
-}
-
-void DrawTextBlob(Surface *surface, const ViewStyle &vsDraw, PRectangle rcSegment,
- const char *s, ColourDesired textBack, ColourDesired textFore, bool twoPhaseDraw) {
- if (!twoPhaseDraw) {
- surface->FillRectangle(rcSegment, textBack);
- }
- FontAlias ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
- int normalCharHeight = static_cast<int>(surface->Ascent(ctrlCharsFont) -
- surface->InternalLeading(ctrlCharsFont));
- PRectangle rcCChar = rcSegment;
- rcCChar.left = rcCChar.left + 1;
- rcCChar.top = rcSegment.top + vsDraw.maxAscent - normalCharHeight;
- rcCChar.bottom = rcSegment.top + vsDraw.maxAscent + 1;
- PRectangle rcCentral = rcCChar;
- rcCentral.top++;
- rcCentral.bottom--;
- surface->FillRectangle(rcCentral, textFore);
- PRectangle rcChar = rcCChar;
- rcChar.left++;
- rcChar.right--;
- surface->DrawTextClipped(rcChar, ctrlCharsFont,
- rcSegment.top + vsDraw.maxAscent, s, istrlen(s),
- textBack, textFore);
-}
-
-void Editor::DrawEOL(Surface *surface, const ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
- int line, int lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,
- ColourOptional background) {
-
- const int posLineStart = pdoc->LineStart(line);
- PRectangle rcSegment = rcLine;
-
- const bool lastSubLine = subLine == (ll->lines - 1);
- XYPOSITION virtualSpace = 0;
- if (lastSubLine) {
- const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
- virtualSpace = sel.VirtualSpaceFor(pdoc->LineEnd(line)) * spaceWidth;
- }
- XYPOSITION xEol = static_cast<XYPOSITION>(ll->positions[lineEnd] - subLineStart);
-
- // Fill the virtual space and show selections within it
- if (virtualSpace) {
- rcSegment.left = xEol + xStart;
- rcSegment.right = xEol + xStart + virtualSpace;
- surface->FillRectangle(rcSegment, background.isSet ? background : vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
- if (!hideSelection && ((vsDraw.selAlpha == SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA))) {
- SelectionSegment virtualSpaceRange(SelectionPosition(pdoc->LineEnd(line)), SelectionPosition(pdoc->LineEnd(line), sel.VirtualSpaceFor(pdoc->LineEnd(line))));
- for (size_t r=0; r<sel.Count(); r++) {
- int alpha = (r == sel.Main()) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
- if (alpha == SC_ALPHA_NOALPHA) {
- SelectionSegment portion = sel.Range(r).Intersect(virtualSpaceRange);
- if (!portion.Empty()) {
- const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
- rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] -
- static_cast<XYPOSITION>(subLineStart) + portion.start.VirtualSpace() * spaceWidth;
- rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] -
- static_cast<XYPOSITION>(subLineStart) + portion.end.VirtualSpace() * spaceWidth;
- rcSegment.left = (rcSegment.left > rcLine.left) ? rcSegment.left : rcLine.left;
- rcSegment.right = (rcSegment.right < rcLine.right) ? rcSegment.right : rcLine.right;
- surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, r == sel.Main()));
- }
- }
- }
- }
- }
-
- int eolInSelection = 0;
- int alpha = SC_ALPHA_NOALPHA;
- if (!hideSelection) {
- int posAfterLineEnd = pdoc->LineStart(line + 1);
- eolInSelection = (subLine == (ll->lines - 1)) ? sel.InSelectionForEOL(posAfterLineEnd) : 0;
- alpha = (eolInSelection == 1) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
- }
-
- // Draw the [CR], [LF], or [CR][LF] blobs if visible line ends are on
- XYPOSITION blobsWidth = 0;
- if (lastSubLine) {
- for (int eolPos=ll->numCharsBeforeEOL; eolPos<ll->numCharsInLine; eolPos++) {
- rcSegment.left = xStart + ll->positions[eolPos] - static_cast<XYPOSITION>(subLineStart) + virtualSpace;
- rcSegment.right = xStart + ll->positions[eolPos + 1] - static_cast<XYPOSITION>(subLineStart) + virtualSpace;
- blobsWidth += rcSegment.Width();
- char hexits[4];
- const char *ctrlChar;
- unsigned char chEOL = ll->chars[eolPos];
- int styleMain = ll->styles[eolPos];
- ColourDesired textBack = TextBackground(vsDraw, background, eolInSelection, false, styleMain, eolPos, ll);
- if (UTF8IsAscii(chEOL)) {
- ctrlChar = ControlCharacterString(chEOL);
- } else {
- const Representation *repr = reprs.RepresentationFromCharacter(ll->chars + eolPos, ll->numCharsInLine - eolPos);
- if (repr) {
- ctrlChar = repr->stringRep.c_str();
- eolPos = ll->numCharsInLine;
- } else {
- sprintf(hexits, "x%2X", chEOL);
- ctrlChar = hexits;
- }
- }
- ColourDesired textFore = vsDraw.styles[styleMain].fore;
- if (eolInSelection && vsDraw.selColours.fore.isSet) {
- textFore = (eolInSelection == 1) ? vsDraw.selColours.fore : vsDraw.selAdditionalForeground;
- }
- if (eolInSelection && vsDraw.selColours.back.isSet && (line < pdoc->LinesTotal() - 1)) {
- if (alpha == SC_ALPHA_NOALPHA) {
- surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1));
- } else {
- surface->FillRectangle(rcSegment, textBack);
- }
- } else {
- surface->FillRectangle(rcSegment, textBack);
- }
- DrawTextBlob(surface, vsDraw, rcSegment, ctrlChar, textBack, textFore, twoPhaseDraw);
- if (eolInSelection && vsDraw.selColours.back.isSet && (line < pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) {
- SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1), alpha);
- }
- }
- }
-
- // Draw the eol-is-selected rectangle
- rcSegment.left = xEol + xStart + virtualSpace + blobsWidth;
- rcSegment.right = rcSegment.left + vsDraw.aveCharWidth;
-
- if (eolInSelection && vsDraw.selColours.back.isSet && (line < pdoc->LinesTotal() - 1) && (alpha == SC_ALPHA_NOALPHA)) {
- surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1));
- } else {
- if (background.isSet) {
- surface->FillRectangle(rcSegment, background);
- } else if (line < pdoc->LinesTotal() - 1) {
- surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
- } else if (vsDraw.styles[ll->styles[ll->numCharsInLine]].eolFilled) {
- surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
- } else {
- surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back);
- }
- if (eolInSelection && vsDraw.selColours.back.isSet && (line < pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) {
- SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1), alpha);
- }
- }
-
- // Fill the remainder of the line
- rcSegment.left = rcSegment.right;
- if (rcSegment.left < rcLine.left)
- rcSegment.left = rcLine.left;
- rcSegment.right = rcLine.right;
-
- if (eolInSelection && vsDraw.selEOLFilled && vsDraw.selColours.back.isSet && (line < pdoc->LinesTotal() - 1) && (alpha == SC_ALPHA_NOALPHA)) {
- surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1));
- } else {
- if (background.isSet) {
- surface->FillRectangle(rcSegment, background);
- } else if (vsDraw.styles[ll->styles[ll->numCharsInLine]].eolFilled) {
- surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
- } else {
- surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back);
- }
- if (eolInSelection && vsDraw.selEOLFilled && vsDraw.selColours.back.isSet && (line < pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) {
- SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1), alpha);
- }
- }
-
- bool drawWrapMarkEnd = false;
-
- if (vsDraw.wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
- if (subLine + 1 < ll->lines) {
- drawWrapMarkEnd = ll->LineStart(subLine + 1) != 0;
- }
- }
-
- if (drawWrapMarkEnd) {
- PRectangle rcPlace = rcSegment;
-
- if (vsDraw.wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_END_BY_TEXT) {
- rcPlace.left = xEol + xStart + virtualSpace;
- rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
- } else {
- // rcLine is clipped to text area
- rcPlace.right = rcLine.right;
- rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
- }
- DrawWrapMarker(surface, rcPlace, true, vsDraw.WrapColour());
- }
-}
-
-void Editor::DrawIndicator(int indicNum, int startPos, int endPos, Surface *surface, const ViewStyle &vsDraw,
- int xStart, PRectangle rcLine, LineLayout *ll, int subLine) {
- const XYPOSITION subLineStart = ll->positions[ll->LineStart(subLine)];
- PRectangle rcIndic(
- ll->positions[startPos] + xStart - subLineStart,
- rcLine.top + vsDraw.maxAscent,
- ll->positions[endPos] + xStart - subLineStart,
- rcLine.top + vsDraw.maxAscent + 3);
- vsDraw.indicators[indicNum].Draw(surface, rcIndic, rcLine);
-}
-
-void Editor::DrawIndicators(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
- PRectangle rcLine, LineLayout *ll, int subLine, int lineEnd, bool under) {
- // Draw decorators
- const int posLineStart = pdoc->LineStart(line);
- const int lineStart = ll->LineStart(subLine);
- const int posLineEnd = posLineStart + lineEnd;
-
- for (Decoration *deco = pdoc->decorations.root; deco; deco = deco->next) {
- if (under == vsDraw.indicators[deco->indicator].under) {
- int startPos = posLineStart + lineStart;
- if (!deco->rs.ValueAt(startPos)) {
- startPos = deco->rs.EndRun(startPos);
- }
- while ((startPos < posLineEnd) && (deco->rs.ValueAt(startPos))) {
- int endPos = deco->rs.EndRun(startPos);
- if (endPos > posLineEnd)
- endPos = posLineEnd;
- DrawIndicator(deco->indicator, startPos - posLineStart, endPos - posLineStart,
- surface, vsDraw, xStart, rcLine, ll, subLine);
- startPos = endPos;
- if (!deco->rs.ValueAt(startPos)) {
- startPos = deco->rs.EndRun(startPos);
- }
- }
- }
- }
-
- // Use indicators to highlight matching braces
- if ((vsDraw.braceHighlightIndicatorSet && (bracesMatchStyle == STYLE_BRACELIGHT)) ||
- (vsDraw.braceBadLightIndicatorSet && (bracesMatchStyle == STYLE_BRACEBAD))) {
- int braceIndicator = (bracesMatchStyle == STYLE_BRACELIGHT) ? vsDraw.braceHighlightIndicator : vsDraw.braceBadLightIndicator;
- if (under == vsDraw.indicators[braceIndicator].under) {
- Range rangeLine(posLineStart + lineStart, posLineEnd);
- if (rangeLine.ContainsCharacter(braces[0])) {
- int braceOffset = braces[0] - posLineStart;
- if (braceOffset < ll->numCharsInLine) {
- DrawIndicator(braceIndicator, braceOffset, braceOffset + 1, surface, vsDraw, xStart, rcLine, ll, subLine);
- }
- }
- if (rangeLine.ContainsCharacter(braces[1])) {
- int braceOffset = braces[1] - posLineStart;
- if (braceOffset < ll->numCharsInLine) {
- DrawIndicator(braceIndicator, braceOffset, braceOffset + 1, surface, vsDraw, xStart, rcLine, ll, subLine);
- }
- }
- }
- }
-}
-
-void Editor::DrawAnnotation(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
- PRectangle rcLine, LineLayout *ll, int subLine) {
- int indent = static_cast<int>(pdoc->GetLineIndentation(line) * vsDraw.spaceWidth);
- PRectangle rcSegment = rcLine;
- int annotationLine = subLine - ll->lines;
- const StyledText stAnnotation = pdoc->AnnotationStyledText(line);
- if (stAnnotation.text && ValidStyledText(vsDraw, vsDraw.annotationStyleOffset, stAnnotation)) {
- surface->FillRectangle(rcSegment, vsDraw.styles[0].back);
- rcSegment.left = static_cast<XYPOSITION>(xStart);
- if (trackLineWidth || (vsDraw.annotationVisible == ANNOTATION_BOXED)) {
- // Only care about calculating width if tracking or need to draw box
- int widthAnnotation = WidestLineWidth(surface, vsDraw, vsDraw.annotationStyleOffset, stAnnotation);
- if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
- widthAnnotation += static_cast<int>(vsDraw.spaceWidth * 2); // Margins
- }
- if (widthAnnotation > lineWidthMaxSeen)
- lineWidthMaxSeen = widthAnnotation;
- if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
- rcSegment.left = static_cast<XYPOSITION>(xStart + indent);
- rcSegment.right = rcSegment.left + widthAnnotation;
- }
- }
- const int annotationLines = pdoc->AnnotationLines(line);
- size_t start = 0;
- size_t lengthAnnotation = stAnnotation.LineLength(start);
- int lineInAnnotation = 0;
- while ((lineInAnnotation < annotationLine) && (start < stAnnotation.length)) {
- start += lengthAnnotation + 1;
- lengthAnnotation = stAnnotation.LineLength(start);
- lineInAnnotation++;
- }
- PRectangle rcText = rcSegment;
- if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
- surface->FillRectangle(rcText,
- vsDraw.styles[stAnnotation.StyleAt(start) + vsDraw.annotationStyleOffset].back);
- rcText.left += vsDraw.spaceWidth;
- }
- DrawStyledText(surface, vsDraw, vsDraw.annotationStyleOffset, rcText,
- stAnnotation, start, lengthAnnotation);
- if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
- surface->PenColour(vsDraw.styles[vsDraw.annotationStyleOffset].fore);
- surface->MoveTo(static_cast<int>(rcSegment.left), static_cast<int>(rcSegment.top));
- surface->LineTo(static_cast<int>(rcSegment.left), static_cast<int>(rcSegment.bottom));
- surface->MoveTo(static_cast<int>(rcSegment.right), static_cast<int>(rcSegment.top));
- surface->LineTo(static_cast<int>(rcSegment.right), static_cast<int>(rcSegment.bottom));
- if (subLine == ll->lines) {
- surface->MoveTo(static_cast<int>(rcSegment.left), static_cast<int>(rcSegment.top));
- surface->LineTo(static_cast<int>(rcSegment.right), static_cast<int>(rcSegment.top));
- }
- if (subLine == ll->lines+annotationLines-1) {
- surface->MoveTo(static_cast<int>(rcSegment.left), static_cast<int>(rcSegment.bottom - 1));
- surface->LineTo(static_cast<int>(rcSegment.right), static_cast<int>(rcSegment.bottom - 1));
- }
- }
- }
-}
-
-void Editor::DrawLine(Surface *surface, const ViewStyle &vsDraw, int line, int lineVisible, int xStart,
- PRectangle rcLine, LineLayout *ll, int subLine) {
-
- if (subLine >= ll->lines) {
- DrawAnnotation(surface, vsDraw, line, xStart, rcLine, ll, subLine);
- return; // No further drawing
- }
-
- PRectangle rcSegment = rcLine;
-
- // Using one font for all control characters so it can be controlled independently to ensure
- // the box goes around the characters tightly. Seems to be no way to work out what height
- // is taken by an individual character - internal leading gives varying results.
- FontAlias ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
-
- // See if something overrides the line background color.
- const ColourOptional background = vsDraw.Background(pdoc->GetMark(line), caret.active, ll->containsCaret);
-
- const bool drawWhitespaceBackground = (vsDraw.viewWhitespace != wsInvisible) &&
- (!background.isSet) && (vsDraw.whitespaceColours.back.isSet);
-
- bool inIndentation = subLine == 0; // Do not handle indentation except on first subline.
- const XYPOSITION indentWidth = pdoc->IndentSize() * vsDraw.spaceWidth;
- const XYPOSITION epsilon = 0.0001f; // A small nudge to avoid floating point precision issues
-
- const int posLineStart = pdoc->LineStart(line);
-
- const int startseg = ll->LineStart(subLine);
- const XYACCUMULATOR subLineStart = ll->positions[startseg];
- int lineStart = 0;
- int lineEnd = 0;
- if (subLine < ll->lines) {
- lineStart = ll->LineStart(subLine);
- lineEnd = ll->LineStart(subLine + 1);
- if (subLine == ll->lines - 1) {
- lineEnd = ll->numCharsBeforeEOL;
- }
- }
-
- if (ll->wrapIndent != 0) {
-
- bool continuedWrapLine = false;
- if (subLine < ll->lines) {
- continuedWrapLine = ll->LineStart(subLine) != 0;
- }
-
- if (continuedWrapLine) {
- // draw continuation rect
- PRectangle rcPlace = rcSegment;
-
- rcPlace.left = ll->positions[startseg] + xStart - static_cast<XYPOSITION>(subLineStart);
- rcPlace.right = rcPlace.left + ll->wrapIndent;
-
- // default bgnd here..
- surface->FillRectangle(rcSegment, background.isSet ? background :
- vsDraw.styles[STYLE_DEFAULT].back);
-
- // main line style would be below but this would be inconsistent with end markers
- // also would possibly not be the style at wrap point
- //int styleMain = ll->styles[lineStart];
- //surface->FillRectangle(rcPlace, vsDraw.styles[styleMain].back);
-
- if (vsDraw.wrapVisualFlags & SC_WRAPVISUALFLAG_START) {
-
- if (vsDraw.wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_START_BY_TEXT)
- rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
- else
- rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
-
- DrawWrapMarker(surface, rcPlace, false, vsDraw.WrapColour());
- }
-
- xStart += static_cast<int>(ll->wrapIndent);
- }
- }
-
- const bool selBackDrawn = vsDraw.selColours.back.isSet &&
- ((vsDraw.selAlpha == SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA));
-
- // Does not take margin into account but not significant
- const int xStartVisible = static_cast<int>(subLineStart) - xStart;
-
- if (twoPhaseDraw) {
- BreakFinder bfBack(ll, &sel, lineStart, lineEnd, posLineStart, xStartVisible, selBackDrawn, pdoc, &reprs);
-
- // Background drawing loop
- while (bfBack.More()) {
-
- const TextSegment ts = bfBack.Next();
- const int i = ts.end() - 1;
- const int iDoc = i + posLineStart;
-
- rcSegment.left = ll->positions[ts.start] + xStart - static_cast<XYPOSITION>(subLineStart);
- rcSegment.right = ll->positions[ts.end()] + xStart - static_cast<XYPOSITION>(subLineStart);
- // Only try to draw if really visible - enhances performance by not calling environment to
- // draw strings that are completely past the right side of the window.
- if (rcSegment.Intersects(rcLine)) {
- // Clip to line rectangle, since may have a huge position which will not work with some platforms
- if (rcSegment.left < rcLine.left)
- rcSegment.left = rcLine.left;
- if (rcSegment.right > rcLine.right)
- rcSegment.right = rcLine.right;
-
- const int inSelection = hideSelection ? 0 : sel.CharacterInSelection(iDoc);
- const bool inHotspot = (ll->hotspot.Valid()) && ll->hotspot.ContainsCharacter(iDoc);
- ColourDesired textBack = TextBackground(vsDraw, background, inSelection,
- inHotspot, ll->styles[i], i, ll);
- if (ts.representation) {
- if (ll->chars[i] == '\t') {
- // Tab display
- if (drawWhitespaceBackground &&
- (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways))
- textBack = vsDraw.whitespaceColours.back;
- } else {
- // Blob display
- inIndentation = false;
- }
- surface->FillRectangle(rcSegment, textBack);
- } else {
- // Normal text display
- surface->FillRectangle(rcSegment, textBack);
- if (vsDraw.viewWhitespace != wsInvisible ||
- (inIndentation && vsDraw.viewIndentationGuides == ivReal)) {
- for (int cpos = 0; cpos <= i - ts.start; cpos++) {
- if (ll->chars[cpos + ts.start] == ' ') {
- if (drawWhitespaceBackground &&
- (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) {
- PRectangle rcSpace(
- ll->positions[cpos + ts.start] + xStart - static_cast<XYPOSITION>(subLineStart),
- rcSegment.top,
- ll->positions[cpos + ts.start + 1] + xStart - static_cast<XYPOSITION>(subLineStart),
- rcSegment.bottom);
- surface->FillRectangle(rcSpace, vsDraw.whitespaceColours.back);
- }
- } else {
- inIndentation = false;
- }
- }
- }
- }
- } else if (rcSegment.left > rcLine.right) {
- break;
- }
- }
-
- DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd,
- xStart, subLine, subLineStart, background);
- }
-
- DrawIndicators(surface, vsDraw, line, xStart, rcLine, ll, subLine, lineEnd, true);
-
- if (vsDraw.edgeState == EDGE_LINE) {
- int edgeX = static_cast<int>(vsDraw.theEdge * vsDraw.spaceWidth);
- rcSegment.left = static_cast<XYPOSITION>(edgeX + xStart);
- if ((ll->wrapIndent != 0) && (lineStart != 0))
- rcSegment.left -= ll->wrapIndent;
- rcSegment.right = rcSegment.left + 1;
- surface->FillRectangle(rcSegment, vsDraw.edgecolour);
- }
-
- // Draw underline mark as part of background if not transparent
- int marks = pdoc->GetMark(line);
- int markBit;
- for (markBit = 0; (markBit < 32) && marks; markBit++) {
- if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_UNDERLINE) &&
- (vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
- PRectangle rcUnderline = rcLine;
- rcUnderline.top = rcUnderline.bottom - 2;
- surface->FillRectangle(rcUnderline, vsDraw.markers[markBit].back);
- }
- marks >>= 1;
- }
-
- inIndentation = subLine == 0; // Do not handle indentation except on first subline.
- // Foreground drawing loop
- BreakFinder bfFore(ll, &sel, lineStart, lineEnd, posLineStart, xStartVisible,
- ((!twoPhaseDraw && selBackDrawn) || vsDraw.selColours.fore.isSet), pdoc, &reprs);
-
- while (bfFore.More()) {
-
- const TextSegment ts = bfFore.Next();
- const int i = ts.end() - 1;
- const int iDoc = i + posLineStart;
-
- rcSegment.left = ll->positions[ts.start] + xStart - static_cast<XYPOSITION>(subLineStart);
- rcSegment.right = ll->positions[ts.end()] + xStart - static_cast<XYPOSITION>(subLineStart);
- // Only try to draw if really visible - enhances performance by not calling environment to
- // draw strings that are completely past the right side of the window.
- if (rcSegment.Intersects(rcLine)) {
- int styleMain = ll->styles[i];
- ColourDesired textFore = vsDraw.styles[styleMain].fore;
- FontAlias textFont = vsDraw.styles[styleMain].font;
- //hotspot foreground
- const bool inHotspot = (ll->hotspot.Valid()) && ll->hotspot.ContainsCharacter(iDoc);
- if (inHotspot) {
- if (vsDraw.hotspotColours.fore.isSet)
- textFore = vsDraw.hotspotColours.fore;
- }
- const int inSelection = hideSelection ? 0 : sel.CharacterInSelection(iDoc);
- if (inSelection && (vsDraw.selColours.fore.isSet)) {
- textFore = (inSelection == 1) ? vsDraw.selColours.fore : vsDraw.selAdditionalForeground;
- }
- ColourDesired textBack = TextBackground(vsDraw, background, inSelection, inHotspot, styleMain, i, ll);
- if (ts.representation) {
- if (ll->chars[i] == '\t') {
- // Tab display
- if (!twoPhaseDraw) {
- if (drawWhitespaceBackground &&
- (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways))
- textBack = vsDraw.whitespaceColours.back;
- surface->FillRectangle(rcSegment, textBack);
- }
- if (inIndentation && vsDraw.viewIndentationGuides == ivReal) {
- for (int indentCount = static_cast<int>((ll->positions[i] + epsilon) / indentWidth);
- indentCount <= (ll->positions[i + 1] - epsilon) / indentWidth;
- indentCount++) {
- if (indentCount > 0) {
- int xIndent = static_cast<int>(indentCount * indentWidth);
- DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcSegment,
- (ll->xHighlightGuide == xIndent));
- }
- }
- }
- if (vsDraw.viewWhitespace != wsInvisible) {
- if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
- if (vsDraw.whitespaceColours.fore.isSet)
- textFore = vsDraw.whitespaceColours.fore;
- surface->PenColour(textFore);
- PRectangle rcTab(rcSegment.left + 1, rcSegment.top + 4,
- rcSegment.right - 1, rcSegment.bottom - vsDraw.maxDescent);
- DrawTabArrow(surface, rcTab, static_cast<int>(rcSegment.top + vsDraw.lineHeight / 2));
- }
- }
- } else {
- inIndentation = false;
- if (vsDraw.controlCharSymbol >= 32) {
- char cc[2] = { static_cast<char>(vsDraw.controlCharSymbol), '\0' };
- surface->DrawTextNoClip(rcSegment, ctrlCharsFont,
- rcSegment.top + vsDraw.maxAscent,
- cc, 1, textBack, textFore);
- } else {
- DrawTextBlob(surface, vsDraw, rcSegment, ts.representation->stringRep.c_str(), textBack, textFore, twoPhaseDraw);
- }
- }
- } else {
- // Normal text display
- if (vsDraw.styles[styleMain].visible) {
- if (twoPhaseDraw) {
- surface->DrawTextTransparent(rcSegment, textFont,
- rcSegment.top + vsDraw.maxAscent, ll->chars + ts.start,
- i - ts.start + 1, textFore);
- } else {
- surface->DrawTextNoClip(rcSegment, textFont,
- rcSegment.top + vsDraw.maxAscent, ll->chars + ts.start,
- i - ts.start + 1, textFore, textBack);
- }
- }
- if (vsDraw.viewWhitespace != wsInvisible ||
- (inIndentation && vsDraw.viewIndentationGuides != ivNone)) {
- for (int cpos = 0; cpos <= i - ts.start; cpos++) {
- if (ll->chars[cpos + ts.start] == ' ') {
- if (vsDraw.viewWhitespace != wsInvisible) {
- if (vsDraw.whitespaceColours.fore.isSet)
- textFore = vsDraw.whitespaceColours.fore;
- if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
- XYPOSITION xmid = (ll->positions[cpos + ts.start] + ll->positions[cpos + ts.start + 1]) / 2;
- if (!twoPhaseDraw && drawWhitespaceBackground &&
- (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) {
- textBack = vsDraw.whitespaceColours.back;
- PRectangle rcSpace(
- ll->positions[cpos + ts.start] + xStart - static_cast<XYPOSITION>(subLineStart),
- rcSegment.top,
- ll->positions[cpos + ts.start + 1] + xStart - static_cast<XYPOSITION>(subLineStart),
- rcSegment.bottom);
- surface->FillRectangle(rcSpace, textBack);
- }
- PRectangle rcDot(xmid + xStart - static_cast<XYPOSITION>(subLineStart),
- rcSegment.top + vsDraw.lineHeight / 2, 0.0f, 0.0f);
- rcDot.right = rcDot.left + vsDraw.whitespaceSize;
- rcDot.bottom = rcDot.top + vsDraw.whitespaceSize;
- surface->FillRectangle(rcDot, textFore);
- }
- }
- if (inIndentation && vsDraw.viewIndentationGuides == ivReal) {
- for (int indentCount = static_cast<int>((ll->positions[cpos + ts.start] + epsilon) / indentWidth);
- indentCount <= (ll->positions[cpos + ts.start + 1] - epsilon) / indentWidth;
- indentCount++) {
- if (indentCount > 0) {
- int xIndent = static_cast<int>(indentCount * indentWidth);
- DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcSegment,
- (ll->xHighlightGuide == xIndent));
- }
- }
- }
- } else {
- inIndentation = false;
- }
- }
- }
- }
- if (ll->hotspot.Valid() && vsDraw.hotspotUnderline && ll->hotspot.ContainsCharacter(iDoc)) {
- PRectangle rcUL = rcSegment;
- rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
- rcUL.bottom = rcUL.top + 1;
- if (vsDraw.hotspotColours.fore.isSet)
- surface->FillRectangle(rcUL, vsDraw.hotspotColours.fore);
- else
- surface->FillRectangle(rcUL, textFore);
- } else if (vsDraw.styles[styleMain].underline) {
- PRectangle rcUL = rcSegment;
- rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
- rcUL.bottom = rcUL.top + 1;
- surface->FillRectangle(rcUL, textFore);
- }
- } else if (rcSegment.left > rcLine.right) {
- break;
- }
- }
- if ((vsDraw.viewIndentationGuides == ivLookForward || vsDraw.viewIndentationGuides == ivLookBoth)
- && (subLine == 0)) {
- int indentSpace = pdoc->GetLineIndentation(line);
- int xStartText = static_cast<int>(ll->positions[pdoc->GetLineIndentPosition(line) - posLineStart]);
-
- // Find the most recent line with some text
-
- int lineLastWithText = line;
- while (lineLastWithText > Platform::Maximum(line-20, 0) && pdoc->IsWhiteLine(lineLastWithText)) {
- lineLastWithText--;
- }
- if (lineLastWithText < line) {
- xStartText = 100000; // Don't limit to visible indentation on empty line
- // This line is empty, so use indentation of last line with text
- int indentLastWithText = pdoc->GetLineIndentation(lineLastWithText);
- int isFoldHeader = pdoc->GetLevel(lineLastWithText) & SC_FOLDLEVELHEADERFLAG;
- if (isFoldHeader) {
- // Level is one more level than parent
- indentLastWithText += pdoc->IndentSize();
- }
- if (vsDraw.viewIndentationGuides == ivLookForward) {
- // In viLookForward mode, previous line only used if it is a fold header
- if (isFoldHeader) {
- indentSpace = Platform::Maximum(indentSpace, indentLastWithText);
- }
- } else { // viLookBoth
- indentSpace = Platform::Maximum(indentSpace, indentLastWithText);
- }
- }
-
- int lineNextWithText = line;
- while (lineNextWithText < Platform::Minimum(line+20, pdoc->LinesTotal()) && pdoc->IsWhiteLine(lineNextWithText)) {
- lineNextWithText++;
- }
- if (lineNextWithText > line) {
- xStartText = 100000; // Don't limit to visible indentation on empty line
- // This line is empty, so use indentation of first next line with text
- indentSpace = Platform::Maximum(indentSpace,
- pdoc->GetLineIndentation(lineNextWithText));
- }
-
- for (int indentPos = pdoc->IndentSize(); indentPos < indentSpace; indentPos += pdoc->IndentSize()) {
- int xIndent = static_cast<int>(indentPos * vsDraw.spaceWidth);
- if (xIndent < xStartText) {
- DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcSegment,
- (ll->xHighlightGuide == xIndent));
- }
- }
- }
-
- DrawIndicators(surface, vsDraw, line, xStart, rcLine, ll, subLine, lineEnd, false);
-
- // End of the drawing of the current line
- if (!twoPhaseDraw) {
- DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd,
- xStart, subLine, subLineStart, background);
- }
- if (!hideSelection && ((vsDraw.selAlpha != SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha != SC_ALPHA_NOALPHA))) {
- // For each selection draw
- int virtualSpaces = 0;
- if (subLine == (ll->lines - 1)) {
- virtualSpaces = sel.VirtualSpaceFor(pdoc->LineEnd(line));
- }
- SelectionPosition posStart(posLineStart + lineStart);
- SelectionPosition posEnd(posLineStart + lineEnd, virtualSpaces);
- SelectionSegment virtualSpaceRange(posStart, posEnd);
- for (size_t r=0; r<sel.Count(); r++) {
- int alpha = (r == sel.Main()) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
- if (alpha != SC_ALPHA_NOALPHA) {
- SelectionSegment portion = sel.Range(r).Intersect(virtualSpaceRange);
- if (!portion.Empty()) {
- const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
- rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] -
- static_cast<XYPOSITION>(subLineStart) + portion.start.VirtualSpace() * spaceWidth;
- rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] -
- static_cast<XYPOSITION>(subLineStart) + portion.end.VirtualSpace() * spaceWidth;
- if ((ll->wrapIndent != 0) && (lineStart != 0)) {
- if ((portion.start.Position() - posLineStart) == lineStart && sel.Range(r).ContainsCharacter(portion.start.Position() - 1))
- rcSegment.left -= static_cast<int>(ll->wrapIndent); // indentation added to xStart was truncated to int, so we do the same here
- }
- rcSegment.left = (rcSegment.left > rcLine.left) ? rcSegment.left : rcLine.left;
- rcSegment.right = (rcSegment.right < rcLine.right) ? rcSegment.right : rcLine.right;
- if (rcSegment.right > rcLine.left)
- SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, r == sel.Main()), alpha);
- }
- }
- }
- }
-
- // Draw any translucent whole line states
- rcSegment = rcLine;
- if ((caret.active || vsDraw.alwaysShowCaretLineBackground) && vsDraw.showCaretLineBackground && ll->containsCaret) {
- SimpleAlphaRectangle(surface, rcSegment, vsDraw.caretLineBackground, vsDraw.caretLineAlpha);
- }
- marks = pdoc->GetMark(line);
- for (markBit = 0; (markBit < 32) && marks; markBit++) {
- if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND)) {
- SimpleAlphaRectangle(surface, rcSegment, vsDraw.markers[markBit].back, vsDraw.markers[markBit].alpha);
- } else if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_UNDERLINE)) {
- PRectangle rcUnderline = rcSegment;
- rcUnderline.top = rcUnderline.bottom - 2;
- SimpleAlphaRectangle(surface, rcUnderline, vsDraw.markers[markBit].back, vsDraw.markers[markBit].alpha);
- }
- marks >>= 1;
- }
- if (vsDraw.maskInLine) {
- int marksMasked = pdoc->GetMark(line) & vsDraw.maskInLine;
- if (marksMasked) {
- for (markBit = 0; (markBit < 32) && marksMasked; markBit++) {
- if ((marksMasked & 1) && (vsDraw.markers[markBit].markType != SC_MARK_EMPTY)) {
- SimpleAlphaRectangle(surface, rcSegment, vsDraw.markers[markBit].back, vsDraw.markers[markBit].alpha);
- }
- marksMasked >>= 1;
- }
- }
- }
-}
-
-void Editor::DrawBlockCaret(Surface *surface, const ViewStyle &vsDraw, LineLayout *ll, int subLine,
- int xStart, int offset, int posCaret, PRectangle rcCaret, ColourDesired caretColour) const {
-
- int lineStart = ll->LineStart(subLine);
- int posBefore = posCaret;
- int posAfter = MovePositionOutsideChar(posCaret + 1, 1);
- int numCharsToDraw = posAfter - posCaret;
-
- // Work out where the starting and ending offsets are. We need to
- // see if the previous character shares horizontal space, such as a
- // glyph / combining character. If so we'll need to draw that too.
- int offsetFirstChar = offset;
- int offsetLastChar = offset + (posAfter - posCaret);
- while ((posBefore > 0) && ((offsetLastChar - numCharsToDraw) >= lineStart)) {
- if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - numCharsToDraw]) > 0) {
- // The char does not share horizontal space
- break;
- }
- // Char shares horizontal space, update the numChars to draw
- // Update posBefore to point to the prev char
- posBefore = MovePositionOutsideChar(posBefore - 1, -1);
- numCharsToDraw = posAfter - posBefore;
- offsetFirstChar = offset - (posCaret - posBefore);
- }
-
- // See if the next character shares horizontal space, if so we'll
- // need to draw that too.
- if (offsetFirstChar < 0)
- offsetFirstChar = 0;
- numCharsToDraw = offsetLastChar - offsetFirstChar;
- while ((offsetLastChar < ll->LineStart(subLine + 1)) && (offsetLastChar <= ll->numCharsInLine)) {
- // Update posAfter to point to the 2nd next char, this is where
- // the next character ends, and 2nd next begins. We'll need
- // to compare these two
- posBefore = posAfter;
- posAfter = MovePositionOutsideChar(posAfter + 1, 1);
- offsetLastChar = offset + (posAfter - posCaret);
- if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - (posAfter - posBefore)]) > 0) {
- // The char does not share horizontal space
- break;
- }
- // Char shares horizontal space, update the numChars to draw
- numCharsToDraw = offsetLastChar - offsetFirstChar;
- }
-
- // We now know what to draw, update the caret drawing rectangle
- rcCaret.left = ll->positions[offsetFirstChar] - ll->positions[lineStart] + xStart;
- rcCaret.right = ll->positions[offsetFirstChar+numCharsToDraw] - ll->positions[lineStart] + xStart;
+ marginView.PaintMargin(surface, topLine, rc, rcMargin, *this, vs);
- // Adjust caret position to take into account any word wrapping symbols.
- if ((ll->wrapIndent != 0) && (lineStart != 0)) {
- XYPOSITION wordWrapCharWidth = ll->wrapIndent;
- rcCaret.left += wordWrapCharWidth;
- rcCaret.right += wordWrapCharWidth;
+ if (view.bufferedDraw) {
+ surfWindow->Copy(rcMargin, Point(rcMargin.left, rcMargin.top), *marginView.pixmapSelMargin);
}
-
- // This character is where the caret block is, we override the colours
- // (inversed) for drawing the caret here.
- int styleMain = ll->styles[offsetFirstChar];
- FontAlias fontText = vsDraw.styles[styleMain].font;
- surface->DrawTextClipped(rcCaret, fontText,
- rcCaret.top + vsDraw.maxAscent, ll->chars + offsetFirstChar,
- numCharsToDraw, vsDraw.styles[styleMain].back,
- caretColour);
}
void Editor::RefreshPixMaps(Surface *surfaceWindow) {
- if (!pixmapSelPattern->Initialised()) {
- const int patternSize = 8;
- pixmapSelPattern->InitPixMap(patternSize, patternSize, surfaceWindow, wMain.GetID());
- pixmapSelPatternOffset1->InitPixMap(patternSize, patternSize, surfaceWindow, wMain.GetID());
- // This complex procedure is to reproduce the checkerboard dithered pattern used by windows
- // for scroll bars and Visual Studio for its selection margin. The colour of this pattern is half
- // way between the chrome colour and the chrome highlight colour making a nice transition
- // between the window chrome and the content area. And it works in low colour depths.
- PRectangle rcPattern = PRectangle::FromInts(0, 0, patternSize, patternSize);
-
- // Initialize default colours based on the chrome colour scheme. Typically the highlight is white.
- ColourDesired colourFMFill = vs.selbar;
- ColourDesired colourFMStripes = vs.selbarlight;
-
- if (!(vs.selbarlight == ColourDesired(0xff, 0xff, 0xff))) {
- // User has chosen an unusual chrome colour scheme so just use the highlight edge colour.
- // (Typically, the highlight colour is white.)
- colourFMFill = vs.selbarlight;
- }
-
- if (vs.foldmarginColour.isSet) {
- // override default fold margin colour
- colourFMFill = vs.foldmarginColour;
- }
- if (vs.foldmarginHighlightColour.isSet) {
- // override default fold margin highlight colour
- colourFMStripes = vs.foldmarginHighlightColour;
- }
-
- pixmapSelPattern->FillRectangle(rcPattern, colourFMFill);
- pixmapSelPatternOffset1->FillRectangle(rcPattern, colourFMStripes);
- for (int y = 0; y < patternSize; y++) {
- for (int x = y % 2; x < patternSize; x+=2) {
- PRectangle rcPixel = PRectangle::FromInts(x, y, x + 1, y + 1);
- pixmapSelPattern->FillRectangle(rcPixel, colourFMStripes);
- pixmapSelPatternOffset1->FillRectangle(rcPixel, colourFMFill);
- }
- }
- }
-
- if (!pixmapIndentGuide->Initialised()) {
- // 1 extra pixel in height so can handle odd/even positions and so produce a continuous line
- pixmapIndentGuide->InitPixMap(1, vs.lineHeight + 1, surfaceWindow, wMain.GetID());
- pixmapIndentGuideHighlight->InitPixMap(1, vs.lineHeight + 1, surfaceWindow, wMain.GetID());
- PRectangle rcIG = PRectangle::FromInts(0, 0, 1, vs.lineHeight);
- pixmapIndentGuide->FillRectangle(rcIG, vs.styles[STYLE_INDENTGUIDE].back);
- pixmapIndentGuide->PenColour(vs.styles[STYLE_INDENTGUIDE].fore);
- pixmapIndentGuideHighlight->FillRectangle(rcIG, vs.styles[STYLE_BRACELIGHT].back);
- pixmapIndentGuideHighlight->PenColour(vs.styles[STYLE_BRACELIGHT].fore);
- for (int stripe = 1; stripe < vs.lineHeight + 1; stripe += 2) {
- PRectangle rcPixel = PRectangle::FromInts(0, stripe, 1, stripe + 1);
- pixmapIndentGuide->FillRectangle(rcPixel, vs.styles[STYLE_INDENTGUIDE].fore);
- pixmapIndentGuideHighlight->FillRectangle(rcPixel, vs.styles[STYLE_BRACELIGHT].fore);
- }
- }
+ view.RefreshPixMaps(surfaceWindow, wMain.GetID(), vs);
+ marginView.RefreshPixMaps(surfaceWindow, wMain.GetID(), vs);
+ if (view.bufferedDraw) {
+ PRectangle rcClient = GetClientRectangle();
+ if (!view.pixmapLine->Initialised()) {
- if (bufferedDraw) {
- if (!pixmapLine->Initialised()) {
- PRectangle rcClient = GetClientRectangle();
- pixmapLine->InitPixMap(static_cast<int>(rcClient.Width()), vs.lineHeight,
+ view.pixmapLine->InitPixMap(static_cast<int>(rcClient.Width()), vs.lineHeight,
surfaceWindow, wMain.GetID());
- pixmapSelMargin->InitPixMap(vs.fixedColumnWidth,
- static_cast<int>(rcClient.Height()), surfaceWindow, wMain.GetID());
}
- }
-}
-
-void Editor::DrawCarets(Surface *surface, const ViewStyle &vsDraw, int lineDoc, int xStart,
- PRectangle rcLine, LineLayout *ll, int subLine) {
- // When drag is active it is the only caret drawn
- bool drawDrag = posDrag.IsValid();
- if (hideSelection && !drawDrag)
- return;
- const int posLineStart = pdoc->LineStart(lineDoc);
- // For each selection draw
- for (size_t r=0; (r<sel.Count()) || drawDrag; r++) {
- const bool mainCaret = r == sel.Main();
- const SelectionPosition posCaret = (drawDrag ? posDrag : sel.Range(r).caret);
- const int offset = posCaret.Position() - posLineStart;
- const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
- const XYPOSITION virtualOffset = posCaret.VirtualSpace() * spaceWidth;
- if (ll->InLine(offset, subLine) && offset <= ll->numCharsBeforeEOL) {
- XYPOSITION xposCaret = ll->positions[offset] + virtualOffset - ll->positions[ll->LineStart(subLine)];
- if (ll->wrapIndent != 0) {
- int lineStart = ll->LineStart(subLine);
- if (lineStart != 0) // Wrapped
- xposCaret += ll->wrapIndent;
- }
- bool caretBlinkState = (caret.active && caret.on) || (!additionalCaretsBlink && !mainCaret);
- bool caretVisibleState = additionalCaretsVisible || mainCaret;
- if ((xposCaret >= 0) && (vsDraw.caretWidth > 0) && (vsDraw.caretStyle != CARETSTYLE_INVISIBLE) &&
- ((posDrag.IsValid()) || (caretBlinkState && caretVisibleState))) {
- bool caretAtEOF = false;
- bool caretAtEOL = false;
- bool drawBlockCaret = false;
- XYPOSITION widthOverstrikeCaret;
- XYPOSITION caretWidthOffset = 0;
- PRectangle rcCaret = rcLine;
-
- if (posCaret.Position() == pdoc->Length()) { // At end of document
- caretAtEOF = true;
- widthOverstrikeCaret = vsDraw.aveCharWidth;
- } else if ((posCaret.Position() - posLineStart) >= ll->numCharsInLine) { // At end of line
- caretAtEOL = true;
- widthOverstrikeCaret = vsDraw.aveCharWidth;
- } else {
- widthOverstrikeCaret = ll->positions[offset + 1] - ll->positions[offset];
- }
- if (widthOverstrikeCaret < 3) // Make sure its visible
- widthOverstrikeCaret = 3;
-
- if (xposCaret > 0)
- caretWidthOffset = 0.51f; // Move back so overlaps both character cells.
- xposCaret += xStart;
- if (posDrag.IsValid()) {
- /* Dragging text, use a line caret */
- rcCaret.left = static_cast<XYPOSITION>(RoundXYPosition(xposCaret - caretWidthOffset));
- rcCaret.right = rcCaret.left + vsDraw.caretWidth;
- } else if (inOverstrike && drawOverstrikeCaret) {
- /* Overstrike (insert mode), use a modified bar caret */
- rcCaret.top = rcCaret.bottom - 2;
- rcCaret.left = xposCaret + 1;
- rcCaret.right = rcCaret.left + widthOverstrikeCaret - 1;
- } else if (vsDraw.caretStyle == CARETSTYLE_BLOCK) {
- /* Block caret */
- rcCaret.left = xposCaret;
- if (!caretAtEOL && !caretAtEOF && (ll->chars[offset] != '\t') && !(IsControlCharacter(ll->chars[offset]))) {
- drawBlockCaret = true;
- rcCaret.right = xposCaret + widthOverstrikeCaret;
- } else {
- rcCaret.right = xposCaret + vsDraw.aveCharWidth;
- }
- } else {
- /* Line caret */
- rcCaret.left = static_cast<XYPOSITION>(RoundXYPosition(xposCaret - caretWidthOffset));
- rcCaret.right = rcCaret.left + vsDraw.caretWidth;
- }
- ColourDesired caretColour = mainCaret ? vsDraw.caretcolour : vsDraw.additionalCaretColour;
- if (drawBlockCaret) {
- DrawBlockCaret(surface, vsDraw, ll, subLine, xStart, offset, posCaret.Position(), rcCaret, caretColour);
- } else {
- surface->FillRectangle(rcCaret, caretColour);
- }
- }
+ if (!marginView.pixmapSelMargin->Initialised()) {
+ marginView.pixmapSelMargin->InitPixMap(vs.fixedColumnWidth,
+ static_cast<int>(rcClient.Height()), surfaceWindow, wMain.GetID());
}
- if (drawDrag)
- break;
}
}
@@ -3442,18 +3895,9 @@ void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
StyleToPositionInView(PositionAfterArea(rcArea));
PRectangle rcClient = GetClientRectangle();
- Point ptOrigin = GetVisibleOriginInMain();
//Platform::DebugPrintf("Client: (%3d,%3d) ... (%3d,%3d) %d\n",
// rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
- int screenLinePaintFirst = static_cast<int>(rcArea.top) / vs.lineHeight;
-
- int xStart = vs.textStart - xOffset + static_cast<int>(ptOrigin.x);
- int ypos = 0;
- if (!bufferedDraw)
- ypos += screenLinePaintFirst * vs.lineHeight;
- int yposScreen = screenLinePaintFirst * vs.lineHeight;
-
if (NotifyUpdateUI()) {
RefreshStyleData();
RefreshPixMaps(surfaceWindow);
@@ -3468,9 +3912,9 @@ void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
}
RefreshPixMaps(surfaceWindow); // In case pixmaps invalidated by scrollbar change
}
- PLATFORM_ASSERT(pixmapSelPattern->Initialised());
+ PLATFORM_ASSERT(marginView.pixmapSelPattern->Initialised());
- if (!bufferedDraw)
+ if (!view.bufferedDraw)
surfaceWindow->SetClip(rcArea);
if (paintState != paintAbandoned) {
@@ -3504,195 +3948,10 @@ void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
}
return;
}
- //Platform::DebugPrintf("start display %d, offset = %d\n", pdoc->Length(), xOffset);
-
- // Allow text at start of line to overlap 1 pixel into the margin as this displays
- // serifs and italic stems for aliased text.
- const int leftTextOverlap = ((xOffset == 0) && (vs.leftMarginWidth > 0)) ? 1 : 0;
-
- // Do the painting
- if (rcArea.right > vs.textStart - leftTextOverlap) {
-
- Surface *surface = surfaceWindow;
- if (bufferedDraw) {
- surface = pixmapLine;
- PLATFORM_ASSERT(pixmapLine->Initialised());
- }
- surface->SetUnicodeMode(IsUnicodeMode());
- surface->SetDBCSMode(CodePage());
-
- int visibleLine = TopLineOfMain() + screenLinePaintFirst;
-
- SelectionPosition posCaret = sel.RangeMain().caret;
- if (posDrag.IsValid())
- posCaret = posDrag;
- int lineCaret = pdoc->LineFromPosition(posCaret.Position());
-
- PRectangle rcTextArea = rcClient;
- if (vs.marginInside) {
- rcTextArea.left += vs.textStart;
- rcTextArea.right -= vs.rightMarginWidth;
- } else {
- rcTextArea = rcArea;
- }
-
- // Remove selection margin from drawing area so text will not be drawn
- // on it in unbuffered mode.
- if (!bufferedDraw && vs.marginInside) {
- PRectangle rcClipText = rcTextArea;
- rcClipText.left -= leftTextOverlap;
- surfaceWindow->SetClip(rcClipText);
- }
-
- // Loop on visible lines
- //double durLayout = 0.0;
- //double durPaint = 0.0;
- //double durCopy = 0.0;
- //ElapsedTime etWhole;
- int lineDocPrevious = -1; // Used to avoid laying out one document line multiple times
- AutoLineLayout ll(llc, 0);
- while (visibleLine < cs.LinesDisplayed() && yposScreen < rcArea.bottom) {
-
- int lineDoc = cs.DocFromDisplay(visibleLine);
- // Only visible lines should be handled by the code within the loop
- PLATFORM_ASSERT(cs.GetVisible(lineDoc));
- int lineStartSet = cs.DisplayFromDoc(lineDoc);
- int subLine = visibleLine - lineStartSet;
-
- // Copy this line and its styles from the document into local arrays
- // and determine the x position at which each character starts.
- //ElapsedTime et;
- if (lineDoc != lineDocPrevious) {
- ll.Set(0);
- ll.Set(RetrieveLineLayout(lineDoc));
- LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
- lineDocPrevious = lineDoc;
- }
- //durLayout += et.Duration(true);
-
- if (ll) {
- ll->containsCaret = lineDoc == lineCaret;
- if (hideSelection) {
- ll->containsCaret = false;
- }
-
- ll->hotspot = GetHotSpotRange();
-
- PRectangle rcLine = rcTextArea;
- rcLine.top = static_cast<XYPOSITION>(ypos);
- rcLine.bottom = static_cast<XYPOSITION>(ypos + vs.lineHeight);
-
- bool bracesIgnoreStyle = false;
- if ((vs.braceHighlightIndicatorSet && (bracesMatchStyle == STYLE_BRACELIGHT)) ||
- (vs.braceBadLightIndicatorSet && (bracesMatchStyle == STYLE_BRACEBAD))) {
- bracesIgnoreStyle = true;
- }
- Range rangeLine(pdoc->LineStart(lineDoc), pdoc->LineStart(lineDoc + 1));
- // Highlight the current braces if any
- ll->SetBracesHighlight(rangeLine, braces, static_cast<char>(bracesMatchStyle),
- static_cast<int>(highlightGuideColumn * vs.spaceWidth), bracesIgnoreStyle);
-
- if (leftTextOverlap && bufferedDraw) {
- PRectangle rcSpacer = rcLine;
- rcSpacer.right = rcSpacer.left;
- rcSpacer.left -= 1;
- surface->FillRectangle(rcSpacer, vs.styles[STYLE_DEFAULT].back);
- }
-
- // Draw the line
- DrawLine(surface, vs, lineDoc, visibleLine, xStart, rcLine, ll, subLine);
- //durPaint += et.Duration(true);
-
- // Restore the previous styles for the brace highlights in case layout is in cache.
- ll->RestoreBracesHighlight(rangeLine, braces, bracesIgnoreStyle);
-
- bool expanded = cs.GetExpanded(lineDoc);
- const int level = pdoc->GetLevel(lineDoc);
- const int levelNext = pdoc->GetLevel(lineDoc + 1);
- if ((level & SC_FOLDLEVELHEADERFLAG) &&
- ((level & SC_FOLDLEVELNUMBERMASK) < (levelNext & SC_FOLDLEVELNUMBERMASK))) {
- // Paint the line above the fold
- if ((expanded && (foldFlags & SC_FOLDFLAG_LINEBEFORE_EXPANDED))
- ||
- (!expanded && (foldFlags & SC_FOLDFLAG_LINEBEFORE_CONTRACTED))) {
- PRectangle rcFoldLine = rcLine;
- rcFoldLine.bottom = rcFoldLine.top + 1;
- surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore);
- }
- // Paint the line below the fold
- if ((expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_EXPANDED))
- ||
- (!expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_CONTRACTED))) {
- PRectangle rcFoldLine = rcLine;
- rcFoldLine.top = rcFoldLine.bottom - 1;
- surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore);
- }
- }
-
- DrawCarets(surface, vs, lineDoc, xStart, rcLine, ll, subLine);
-
- if (bufferedDraw) {
- Point from = Point::FromInts(vs.textStart-leftTextOverlap, 0);
- PRectangle rcCopyArea = PRectangle::FromInts(vs.textStart - leftTextOverlap, yposScreen,
- static_cast<int>(rcClient.right - vs.rightMarginWidth),
- yposScreen + vs.lineHeight);
- surfaceWindow->Copy(rcCopyArea, from, *pixmapLine);
- }
-
- lineWidthMaxSeen = Platform::Maximum(
- lineWidthMaxSeen, static_cast<int>(ll->positions[ll->numCharsInLine]));
- //durCopy += et.Duration(true);
- }
-
- if (!bufferedDraw) {
- ypos += vs.lineHeight;
- }
-
- yposScreen += vs.lineHeight;
- visibleLine++;
-
- //gdk_flush();
- }
- ll.Set(0);
- //if (durPaint < 0.00000001)
- // durPaint = 0.00000001;
-
- // Right column limit indicator
- PRectangle rcBeyondEOF = (vs.marginInside) ? rcClient : rcArea;
- rcBeyondEOF.left = static_cast<XYPOSITION>(vs.textStart);
- rcBeyondEOF.right = rcBeyondEOF.right - ((vs.marginInside) ? vs.rightMarginWidth : 0);
- rcBeyondEOF.top = static_cast<XYPOSITION>((cs.LinesDisplayed() - TopLineOfMain()) * vs.lineHeight);
- if (rcBeyondEOF.top < rcBeyondEOF.bottom) {
- surfaceWindow->FillRectangle(rcBeyondEOF, vs.styles[STYLE_DEFAULT].back);
- if (vs.edgeState == EDGE_LINE) {
- int edgeX = static_cast<int>(vs.theEdge * vs.spaceWidth);
- rcBeyondEOF.left = static_cast<XYPOSITION>(edgeX + xStart);
- rcBeyondEOF.right = rcBeyondEOF.left + 1;
- surfaceWindow->FillRectangle(rcBeyondEOF, vs.edgecolour);
- }
- }
- //Platform::DebugPrintf(
- //"Layout:%9.6g Paint:%9.6g Ratio:%9.6g Copy:%9.6g Total:%9.6g\n",
- //durLayout, durPaint, durLayout / durPaint, durCopy, etWhole.Duration());
- NotifyPainted();
- }
-}
-// Space (3 space characters) between line numbers and text when printing.
-#define lineNumberPrintSpace " "
+ view.PaintText(surfaceWindow, rcArea, rcClient, *this, vs);
-ColourDesired InvertedLight(ColourDesired orig) {
- unsigned int r = orig.GetRed();
- unsigned int g = orig.GetGreen();
- unsigned int b = orig.GetBlue();
- unsigned int l = (r + g + b) / 3; // There is a better calculation for this that matches human eye
- unsigned int il = 0xff - l;
- if (l == 0)
- return ColourDesired(0xff, 0xff, 0xff);
- r = r * il / l;
- g = g * il / l;
- b = b * il / l;
- return ColourDesired(Platform::Minimum(r, 0xff), Platform::Minimum(g, 0xff), Platform::Minimum(b, 0xff));
+ NotifyPainted();
}
// This is mostly copied from the Paint method but with some things omitted
@@ -3709,184 +3968,7 @@ long Editor::FormatRange(bool draw, Sci_RangeToFormat *pfr) {
if (!surfaceMeasure) {
return 0;
}
-
- // Can't use measurements cached for screen
- posCache.Clear();
-
- ViewStyle vsPrint(vs);
- vsPrint.technology = SC_TECHNOLOGY_DEFAULT;
-
- // Modify the view style for printing as do not normally want any of the transient features to be printed
- // Printing supports only the line number margin.
- int lineNumberIndex = -1;
- for (int margin = 0; margin <= SC_MAX_MARGIN; margin++) {
- if ((vsPrint.ms[margin].style == SC_MARGIN_NUMBER) && (vsPrint.ms[margin].width > 0)) {
- lineNumberIndex = margin;
- } else {
- vsPrint.ms[margin].width = 0;
- }
- }
- vsPrint.fixedColumnWidth = 0;
- vsPrint.zoomLevel = printParameters.magnification;
- // Don't show indentation guides
- // If this ever gets changed, cached pixmap would need to be recreated if technology != SC_TECHNOLOGY_DEFAULT
- vsPrint.viewIndentationGuides = ivNone;
- // Don't show the selection when printing
- vsPrint.selColours.back.isSet = false;
- vsPrint.selColours.fore.isSet = false;
- vsPrint.selAlpha = SC_ALPHA_NOALPHA;
- vsPrint.selAdditionalAlpha = SC_ALPHA_NOALPHA;
- vsPrint.whitespaceColours.back.isSet = false;
- vsPrint.whitespaceColours.fore.isSet = false;
- vsPrint.showCaretLineBackground = false;
- vsPrint.alwaysShowCaretLineBackground = false;
- // Don't highlight matching braces using indicators
- vsPrint.braceHighlightIndicatorSet = false;
- vsPrint.braceBadLightIndicatorSet = false;
-
- // Set colours for printing according to users settings
- for (size_t sty = 0; sty < vsPrint.styles.size(); sty++) {
- if (printParameters.colourMode == SC_PRINT_INVERTLIGHT) {
- vsPrint.styles[sty].fore = InvertedLight(vsPrint.styles[sty].fore);
- vsPrint.styles[sty].back = InvertedLight(vsPrint.styles[sty].back);
- } else if (printParameters.colourMode == SC_PRINT_BLACKONWHITE) {
- vsPrint.styles[sty].fore = ColourDesired(0, 0, 0);
- vsPrint.styles[sty].back = ColourDesired(0xff, 0xff, 0xff);
- } else if (printParameters.colourMode == SC_PRINT_COLOURONWHITE) {
- vsPrint.styles[sty].back = ColourDesired(0xff, 0xff, 0xff);
- } else if (printParameters.colourMode == SC_PRINT_COLOURONWHITEDEFAULTBG) {
- if (sty <= STYLE_DEFAULT) {
- vsPrint.styles[sty].back = ColourDesired(0xff, 0xff, 0xff);
- }
- }
- }
- // White background for the line numbers
- vsPrint.styles[STYLE_LINENUMBER].back = ColourDesired(0xff, 0xff, 0xff);
-
- // Printing uses different margins, so reset screen margins
- vsPrint.leftMarginWidth = 0;
- vsPrint.rightMarginWidth = 0;
-
- vsPrint.Refresh(*surfaceMeasure, pdoc->tabInChars);
- // Determining width must happen after fonts have been realised in Refresh
- int lineNumberWidth = 0;
- if (lineNumberIndex >= 0) {
- lineNumberWidth = static_cast<int>(surfaceMeasure->WidthText(vsPrint.styles[STYLE_LINENUMBER].font,
- "99999" lineNumberPrintSpace, 5 + istrlen(lineNumberPrintSpace)));
- vsPrint.ms[lineNumberIndex].width = lineNumberWidth;
- vsPrint.Refresh(*surfaceMeasure, pdoc->tabInChars); // Recalculate fixedColumnWidth
- }
-
- int linePrintStart = pdoc->LineFromPosition(pfr->chrg.cpMin);
- int linePrintLast = linePrintStart + (pfr->rc.bottom - pfr->rc.top) / vsPrint.lineHeight - 1;
- if (linePrintLast < linePrintStart)
- linePrintLast = linePrintStart;
- int linePrintMax = pdoc->LineFromPosition(pfr->chrg.cpMax);
- if (linePrintLast > linePrintMax)
- linePrintLast = linePrintMax;
- //Platform::DebugPrintf("Formatting lines=[%0d,%0d,%0d] top=%0d bottom=%0d line=%0d %0d\n",
- // linePrintStart, linePrintLast, linePrintMax, pfr->rc.top, pfr->rc.bottom, vsPrint.lineHeight,
- // surfaceMeasure->Height(vsPrint.styles[STYLE_LINENUMBER].font));
- int endPosPrint = pdoc->Length();
- if (linePrintLast < pdoc->LinesTotal())
- endPosPrint = pdoc->LineStart(linePrintLast + 1);
-
- // Ensure we are styled to where we are formatting.
- pdoc->EnsureStyledTo(endPosPrint);
-
- int xStart = vsPrint.fixedColumnWidth + pfr->rc.left;
- int ypos = pfr->rc.top;
-
- int lineDoc = linePrintStart;
-
- int nPrintPos = pfr->chrg.cpMin;
- int visibleLine = 0;
- int widthPrint = pfr->rc.right - pfr->rc.left - vsPrint.fixedColumnWidth;
- if (printParameters.wrapState == eWrapNone)
- widthPrint = LineLayout::wrapWidthInfinite;
-
- while (lineDoc <= linePrintLast && ypos < pfr->rc.bottom) {
-
- // When printing, the hdc and hdcTarget may be the same, so
- // changing the state of surfaceMeasure may change the underlying
- // state of surface. Therefore, any cached state is discarded before
- // using each surface.
- surfaceMeasure->FlushCachedState();
-
- // Copy this line and its styles from the document into local arrays
- // and determine the x position at which each character starts.
- LineLayout ll(pdoc->LineStart(lineDoc+1)-pdoc->LineStart(lineDoc)+1);
- LayoutLine(lineDoc, surfaceMeasure, vsPrint, &ll, widthPrint);
-
- ll.containsCaret = false;
-
- PRectangle rcLine = PRectangle::FromInts(
- pfr->rc.left,
- ypos,
- pfr->rc.right - 1,
- ypos + vsPrint.lineHeight);
-
- // When document line is wrapped over multiple display lines, find where
- // to start printing from to ensure a particular position is on the first
- // line of the page.
- if (visibleLine == 0) {
- int startWithinLine = nPrintPos - pdoc->LineStart(lineDoc);
- for (int iwl = 0; iwl < ll.lines - 1; iwl++) {
- if (ll.LineStart(iwl) <= startWithinLine && ll.LineStart(iwl + 1) >= startWithinLine) {
- visibleLine = -iwl;
- }
- }
-
- if (ll.lines > 1 && startWithinLine >= ll.LineStart(ll.lines - 1)) {
- visibleLine = -(ll.lines - 1);
- }
- }
-
- if (draw && lineNumberWidth &&
- (ypos + vsPrint.lineHeight <= pfr->rc.bottom) &&
- (visibleLine >= 0)) {
- char number[100];
- sprintf(number, "%d" lineNumberPrintSpace, lineDoc + 1);
- PRectangle rcNumber = rcLine;
- rcNumber.right = rcNumber.left + lineNumberWidth;
- // Right justify
- rcNumber.left = rcNumber.right - surfaceMeasure->WidthText(
- vsPrint.styles[STYLE_LINENUMBER].font, number, istrlen(number));
- surface->FlushCachedState();
- surface->DrawTextNoClip(rcNumber, vsPrint.styles[STYLE_LINENUMBER].font,
- static_cast<XYPOSITION>(ypos + vsPrint.maxAscent), number, istrlen(number),
- vsPrint.styles[STYLE_LINENUMBER].fore,
- vsPrint.styles[STYLE_LINENUMBER].back);
- }
-
- // Draw the line
- surface->FlushCachedState();
-
- for (int iwl = 0; iwl < ll.lines; iwl++) {
- if (ypos + vsPrint.lineHeight <= pfr->rc.bottom) {
- if (visibleLine >= 0) {
- if (draw) {
- rcLine.top = static_cast<XYPOSITION>(ypos);
- rcLine.bottom = static_cast<XYPOSITION>(ypos + vsPrint.lineHeight);
- DrawLine(surface, vsPrint, lineDoc, visibleLine, xStart, rcLine, &ll, iwl);
- }
- ypos += vsPrint.lineHeight;
- }
- visibleLine++;
- if (iwl == ll.lines - 1)
- nPrintPos = pdoc->LineStart(lineDoc + 1);
- else
- nPrintPos += ll.LineStart(iwl + 1) - ll.LineStart(iwl);
- }
- }
-
- ++lineDoc;
- }
-
- // Clear cache so measurements are not used for screen
- posCache.Clear();
-
- return nPrintPos;
+ return view.FormatRange(draw, pfr, surface, surfaceMeasure, *this, vs);
}
int Editor::TextWidth(int style, const char *text) {
@@ -4593,7 +4675,7 @@ void Editor::NotifySavePoint(Document *, void *, bool atSavePoint) {
void Editor::CheckModificationForWrap(DocModification mh) {
if (mh.modificationType & (SC_MOD_INSERTTEXT | SC_MOD_DELETETEXT)) {
- llc.Invalidate(LineLayout::llCheckTextAndStyle);
+ view.llc.Invalidate(LineLayout::llCheckTextAndStyle);
int lineDoc = pdoc->LineFromPosition(mh.position);
int lines = Platform::Maximum(0, mh.linesAdded);
if (Wrapping()) {
@@ -4663,7 +4745,7 @@ void Editor::NotifyModified(Document *, DocModification mh, void *) {
}
}
if (mh.modificationType & SC_MOD_CHANGESTYLE) {
- llc.Invalidate(LineLayout::llCheckTextAndStyle);
+ view.llc.Invalidate(LineLayout::llCheckTextAndStyle);
}
} else {
// Move selection and brace highlights
@@ -4744,7 +4826,7 @@ void Editor::NotifyModified(Document *, DocModification mh, void *) {
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(highlightDelimiter.isEnabled ? -1 : mh.line-1, true);
+ RedrawSelMargin(marginView.highlightDelimiter.isEnabled ? -1 : mh.line - 1, true);
} else {
RedrawSelMargin(mh.line);
}
@@ -5197,29 +5279,8 @@ void Editor::ParaUpOrDown(int direction, Selection::selTypes selt) {
int Editor::StartEndDisplayLine(int pos, bool start) {
RefreshStyleData();
- int line = pdoc->LineFromPosition(pos);
AutoSurface surface(this);
- AutoLineLayout ll(llc, RetrieveLineLayout(line));
- int posRet = INVALID_POSITION;
- if (surface && ll) {
- unsigned int posLineStart = pdoc->LineStart(line);
- LayoutLine(line, surface, vs, ll, wrapWidth);
- int posInLine = pos - posLineStart;
- if (posInLine <= ll->maxLineLength) {
- for (int subLine = 0; subLine < ll->lines; subLine++) {
- if ((posInLine >= ll->LineStart(subLine)) && (posInLine <= ll->LineStart(subLine + 1))) {
- if (start) {
- posRet = ll->LineStart(subLine) + posLineStart;
- } else {
- if (subLine == ll->lines - 1)
- posRet = ll->LineStart(subLine + 1) + posLineStart;
- else
- posRet = ll->LineStart(subLine + 1) + posLineStart - 1;
- }
- }
- }
- }
- }
+ int posRet = view.StartEndDisplayLine(surface, pos, start, *this, vs);
if (posRet == INVALID_POSITION) {
return pos;
} else {
@@ -6721,8 +6782,8 @@ void Editor::Tick() {
}
}
}
- if (horizontalScrollBarVisible && trackLineWidth && (lineWidthMaxSeen > scrollWidth)) {
- scrollWidth = lineWidthMaxSeen;
+ if (horizontalScrollBarVisible && trackLineWidth && (view.lineWidthMaxSeen > scrollWidth)) {
+ scrollWidth = view.lineWidthMaxSeen;
SetScrollBars();
}
if ((dwellDelay < SC_TIME_FOREVER) &&
@@ -6882,9 +6943,9 @@ void Editor::SetAnnotationHeights(int start, int end) {
int linesWrapped = 1;
if (Wrapping()) {
AutoSurface surface(this);
- AutoLineLayout ll(llc, RetrieveLineLayout(line));
+ AutoLineLayout ll(view.llc, view.RetrieveLineLayout(line, *this));
if (surface && ll) {
- LayoutLine(line, surface, vs, ll, wrapWidth);
+ view.LayoutLine(line, surface, vs, ll, *this, wrapWidth);
linesWrapped = ll->lines;
}
}
@@ -6924,7 +6985,7 @@ void Editor::SetDocPointer(Document *document) {
cs.Clear();
cs.InsertLines(0, pdoc->LinesTotal() - 1);
SetAnnotationHeights(0, pdoc->LinesTotal());
- llc.Deallocate();
+ view.llc.Deallocate();
NeedWrapping();
pdoc->AddWatcher(this, 0);
@@ -7237,10 +7298,10 @@ int Editor::CodePage() const {
int Editor::WrapCount(int line) {
AutoSurface surface(this);
- AutoLineLayout ll(llc, RetrieveLineLayout(line));
+ AutoLineLayout ll(view.llc, view.RetrieveLineLayout(line, *this));
if (surface && ll) {
- LayoutLine(line, surface, vs, ll, wrapWidth);
+ view.LayoutLine(line, surface, vs, ll, *this, wrapWidth);
return ll->lines;
} else {
return 1;
@@ -7706,7 +7767,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
}
case SCI_HIDESELECTION:
- hideSelection = wParam != 0;
+ view.hideSelection = wParam != 0;
Redraw();
break;
@@ -7894,25 +7955,25 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
break;
case SCI_SETPRINTMAGNIFICATION:
- printParameters.magnification = static_cast<int>(wParam);
+ view.printParameters.magnification = static_cast<int>(wParam);
break;
case SCI_GETPRINTMAGNIFICATION:
- return printParameters.magnification;
+ return view.printParameters.magnification;
case SCI_SETPRINTCOLOURMODE:
- printParameters.colourMode = static_cast<int>(wParam);
+ view.printParameters.colourMode = static_cast<int>(wParam);
break;
case SCI_GETPRINTCOLOURMODE:
- return printParameters.colourMode;
+ return view.printParameters.colourMode;
case SCI_SETPRINTWRAPMODE:
- printParameters.wrapState = (wParam == SC_WRAP_WORD) ? eWrapWord : eWrapNone;
+ view.printParameters.wrapState = (wParam == SC_WRAP_WORD) ? eWrapWord : eWrapNone;
break;
case SCI_GETPRINTWRAPMODE:
- return printParameters.wrapState;
+ return view.printParameters.wrapState;
case SCI_GETSTYLEAT:
if (static_cast<int>(wParam) >= pdoc->Length())
@@ -8054,17 +8115,17 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
break;
case SCI_SETBUFFEREDDRAW:
- bufferedDraw = wParam != 0;
+ view.bufferedDraw = wParam != 0;
break;
case SCI_GETBUFFEREDDRAW:
- return bufferedDraw;
+ return view.bufferedDraw;
case SCI_GETTWOPHASEDRAW:
- return twoPhaseDraw;
+ return view.twoPhaseDraw;
case SCI_SETTWOPHASEDRAW:
- twoPhaseDraw = wParam != 0;
+ view.twoPhaseDraw = wParam != 0;
InvalidateStyleRedraw();
break;
@@ -8199,23 +8260,23 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
return vs.wrapIndentMode;
case SCI_SETLAYOUTCACHE:
- llc.SetLevel(static_cast<int>(wParam));
+ view.llc.SetLevel(static_cast<int>(wParam));
break;
case SCI_GETLAYOUTCACHE:
- return llc.GetLevel();
+ return view.llc.GetLevel();
case SCI_SETPOSITIONCACHE:
- posCache.SetSize(wParam);
+ view.posCache.SetSize(wParam);
break;
case SCI_GETPOSITIONCACHE:
- return posCache.GetSize();
+ return view.posCache.GetSize();
case SCI_SETSCROLLWIDTH:
PLATFORM_ASSERT(wParam > 0);
if ((wParam > 0) && (wParam != static_cast<unsigned int >(scrollWidth))) {
- lineWidthMaxSeen = 0;
+ view.lineWidthMaxSeen = 0;
scrollWidth = static_cast<int>(wParam);
SetScrollBars();
}
@@ -8376,7 +8437,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
RedrawSelMargin();
break;
case SCI_MARKERENABLEHIGHLIGHT:
- highlightDelimiter.isEnabled = wParam == 1;
+ marginView.highlightDelimiter.isEnabled = wParam == 1;
RedrawSelMargin();
break;
case SCI_MARKERSETBACK:
@@ -9443,20 +9504,20 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
return multiPasteMode;
case SCI_SETADDITIONALCARETSBLINK:
- additionalCaretsBlink = wParam != 0;
+ view.additionalCaretsBlink = wParam != 0;
InvalidateCaret();
break;
case SCI_GETADDITIONALCARETSBLINK:
- return additionalCaretsBlink;
+ return view.additionalCaretsBlink;
case SCI_SETADDITIONALCARETSVISIBLE:
- additionalCaretsVisible = wParam != 0;
+ view.additionalCaretsVisible = wParam != 0;
InvalidateCaret();
break;
case SCI_GETADDITIONALCARETSVISIBLE:
- return additionalCaretsVisible;
+ return view.additionalCaretsVisible;
case SCI_GETSELECTIONS:
return sel.Count();
diff --git a/src/Editor.h b/src/Editor.h
index 64e46f83d..fd368df39 100644
--- a/src/Editor.h
+++ b/src/Editor.h
@@ -168,8 +168,131 @@ struct PrintParameters {
};
/**
+* EditModel holds the state that needs to be seen by EditView.
+*/
+class EditModel {
+ // Private so EditModel objects can not be copied
+ EditModel(const EditModel &);
+ EditModel &operator=(const EditModel &);
+
+public:
+ bool inOverstrike;
+ int xOffset; ///< Horizontal scrolled amount in pixels
+ bool trackLineWidth;
+
+ SpecialRepresentations reprs;
+ Caret caret;
+ SelectionPosition posDrag;
+ Position braces[2];
+ int bracesMatchStyle;
+ int highlightGuideColumn;
+ Selection sel;
+ bool primarySelection;
+
+ int foldFlags;
+ ContractionState cs;
+
+ // Hotspot support
+ Range hotspot;
+
+ // Wrapping support
+ int wrapWidth;
+
+ Document *pdoc;
+
+ EditModel();
+ ~EditModel();
+
+ virtual int TopLineOfMain() const = 0;
+ virtual Point GetVisibleOriginInMain() const = 0;
+ virtual int LinesOnScreen() const = 0;
+ virtual Range GetHotSpotRange() const = 0;
+};
+
+/**
+* MarginView draws the margins.
+*/
+class MarginView {
+public:
+ // Highlight current folding block
+ HighlightDelimiter highlightDelimiter;
+ Surface *pixmapSelMargin;
+ Surface *pixmapSelPattern;
+ Surface *pixmapSelPatternOffset1;
+
+ MarginView();
+
+ void DropGraphics(bool freeObjects);
+ void AllocateGraphics(const ViewStyle &vsDraw);
+ void RefreshPixMaps(Surface *surfaceWindow, WindowID wid, const ViewStyle &vsDraw);
+ void PaintMargin(Surface *surface, int topLine, PRectangle rc, PRectangle rcMargin,
+ const EditModel &model, const ViewStyle &vs);
+};
+
+/**
+* EditView draws the main text area.
+*/
+class EditView {
+public:
+ PrintParameters printParameters;
+
+ bool hideSelection;
+ bool drawOverstrikeCaret;
+
+ /** In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to
+ * the screen. This avoids flashing but is about 30% slower. */
+ bool bufferedDraw;
+ /** In twoPhaseDraw mode, drawing is performed in two phases, first the background
+ * and then the foreground. This avoids chopping off characters that overlap the next run. */
+ bool twoPhaseDraw;
+
+ int lineWidthMaxSeen;
+ bool additionalCaretsBlink;
+ bool additionalCaretsVisible;
+
+ Surface *pixmapLine;
+ Surface *pixmapIndentGuide;
+ Surface *pixmapIndentGuideHighlight;
+
+ LineLayoutCache llc;
+ PositionCache posCache;
+
+ EditView();
+
+ void DropGraphics(bool freeObjects);
+ void AllocateGraphics(const ViewStyle &vsDraw);
+ void RefreshPixMaps(Surface *surfaceWindow, WindowID wid, const ViewStyle &vsDraw);
+
+ LineLayout *RetrieveLineLayout(int lineNumber, const EditModel &model);
+ void LayoutLine(int line, Surface *surface, const ViewStyle &vstyle, LineLayout *ll,
+ const EditModel &model, int width = LineLayout::wrapWidthInfinite);
+
+ Point LocationFromPosition(Surface *surface, SelectionPosition pos, int topLine, const EditModel &model, const ViewStyle &vs);
+ SelectionPosition SPositionFromLocation(Surface *surface, Point pt, bool canReturnInvalid, bool charPosition, bool virtualSpace,
+ const EditModel &model, const ViewStyle &vs);
+ SelectionPosition SPositionFromLineX(Surface *surface, int lineDoc, int x, const EditModel &model, const ViewStyle &vs);
+ int DisplayFromPosition(Surface *surface, int pos, const EditModel &model, const ViewStyle &vs);
+ int StartEndDisplayLine(Surface *surface, int pos, bool start, const EditModel &model, const ViewStyle &vs);
+
+ void DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight);
+ void DrawEOL(Surface *surface, const ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
+ int line, int lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,
+ ColourOptional background, const EditModel &model);
+ void DrawAnnotation(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
+ PRectangle rcLine, LineLayout *ll, int subLine, const EditModel &model);
+ void DrawCarets(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
+ PRectangle rcLine, LineLayout *ll, int subLine, const EditModel &model) const;
+ void DrawLine(Surface *surface, const ViewStyle &vsDraw, int line, int lineVisible, int xStart,
+ PRectangle rcLine, LineLayout *ll, int subLine, const EditModel &model);
+ void PaintText(Surface *surfaceWindow, PRectangle rcArea, PRectangle rcClient,
+ const EditModel &model, const ViewStyle &vsDraw);
+ long FormatRange(bool draw, Sci_RangeToFormat *pfr, Surface *surface, Surface *surfaceMeasure,
+ const EditModel &model, const ViewStyle &vs);
+};
+
+/**
*/
-class Editor : public DocWatcher {
+class Editor : public EditModel, public DocWatcher {
// Private so Editor objects can not be copied
Editor(const Editor &);
Editor &operator=(const Editor &);
@@ -189,32 +312,17 @@ protected: // ScintillaBase subclass needs access to much of Editor
Point sizeRGBAImage;
float scaleRGBAImage;
- PrintParameters printParameters;
+ MarginView marginView;
+ EditView view;
int cursorMode;
- // Highlight current folding block
- HighlightDelimiter highlightDelimiter;
-
bool hasFocus;
- bool hideSelection;
- bool inOverstrike;
- bool drawOverstrikeCaret;
bool mouseDownCaptures;
- /** In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to
- * the screen. This avoids flashing but is about 30% slower. */
- bool bufferedDraw;
- /** In twoPhaseDraw mode, drawing is performed in two phases, first the background
- * and then the foreground. This avoids chopping off characters that overlap the next run. */
- bool twoPhaseDraw;
-
- int xOffset; ///< Horizontal scrolled amount in pixels
int xCaretMargin; ///< Ensure this many pixels visible on both sides of caret
bool horizontalScrollBarVisible;
int scrollWidth;
- bool trackLineWidth;
- int lineWidthMaxSeen;
bool verticalScrollBarVisible;
bool endAtLastLine;
int caretSticky;
@@ -223,25 +331,11 @@ protected: // ScintillaBase subclass needs access to much of Editor
bool multipleSelection;
bool additionalSelectionTyping;
int multiPasteMode;
- bool additionalCaretsBlink;
- bool additionalCaretsVisible;
int virtualSpaceOptions;
- Surface *pixmapLine;
- Surface *pixmapSelMargin;
- Surface *pixmapSelPattern;
- Surface *pixmapSelPatternOffset1;
- Surface *pixmapIndentGuide;
- Surface *pixmapIndentGuideHighlight;
-
- LineLayoutCache llc;
- PositionCache posCache;
- SpecialRepresentations reprs;
-
KeyMap kmap;
- Caret caret;
Timer timer;
Timer autoScrollTimer;
enum { autoScrollDelay = 200 };
@@ -257,7 +351,6 @@ protected: // ScintillaBase subclass needs access to much of Editor
Point ptMouseLast;
enum { ddNone, ddInitial, ddDragging } inDragDrop;
bool dropWentOutside;
- SelectionPosition posDrag;
SelectionPosition posDrop;
int hotSpotClickPos;
int lastXChosen;
@@ -274,9 +367,6 @@ protected: // ScintillaBase subclass needs access to much of Editor
int lengthForEncode;
int needUpdateUI;
- Position braces[2];
- int bracesMatchStyle;
- int highlightGuideColumn;
enum { notPainting, painting, paintAbandoned } paintState;
bool paintAbandonedByStyling;
@@ -288,8 +378,6 @@ protected: // ScintillaBase subclass needs access to much of Editor
int modEventMask;
SelectionText drag;
- Selection sel;
- bool primarySelection;
int caretXPolicy;
int caretXSlop; ///< Ensure this many pixels visible on both sides of caret
@@ -304,21 +392,13 @@ protected: // ScintillaBase subclass needs access to much of Editor
bool recordingMacro;
- int foldFlags;
int foldAutomatic;
- ContractionState cs;
-
- // Hotspot support
- Range hotspot;
// Wrapping support
- int wrapWidth;
WrapPending wrapPending;
bool convertPastes;
- Document *pdoc;
-
Editor();
virtual ~Editor();
virtual void Initialise() = 0;
@@ -340,7 +420,7 @@ protected: // ScintillaBase subclass needs access to much of Editor
virtual PRectangle GetClientDrawingRectangle();
PRectangle GetTextRectangle() const;
- int LinesOnScreen() const;
+ virtual int LinesOnScreen() const;
int LinesToScroll() const;
int MaxScrollPos() const;
SelectionPosition ClampPositionIntoDocument(SelectionPosition sp) const;
@@ -349,7 +429,7 @@ protected: // ScintillaBase subclass needs access to much of Editor
int XFromPosition(int pos);
int XFromPosition(SelectionPosition sp);
SelectionPosition SPositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false, bool virtualSpace=true);
- int PositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false);
+ int PositionFromLocation(Point pt, bool canReturnInvalid = false, bool charPosition = false);
SelectionPosition SPositionFromLineX(int lineDoc, int x);
int PositionFromLineX(int line, int x);
int LineFromLocation(Point pt) const;
@@ -431,30 +511,7 @@ protected: // ScintillaBase subclass needs access to much of Editor
void LinesJoin();
void LinesSplit(int pixelWidth);
- int SubstituteMarkerIfEmpty(int markerCheck, int markerDefault) const;
void PaintSelMargin(Surface *surface, PRectangle &rc);
- LineLayout *RetrieveLineLayout(int lineNumber);
- void LayoutLine(int line, Surface *surface, const ViewStyle &vstyle, LineLayout *ll,
- int width=LineLayout::wrapWidthInfinite);
- ColourDesired SelectionBackground(const ViewStyle &vsDraw, bool main) const;
- ColourDesired TextBackground(const ViewStyle &vsDraw, ColourOptional background, int inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll) const;
- void DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight);
- static void DrawWrapMarker(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourDesired wrapColour);
- void DrawEOL(Surface *surface, const ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
- int line, int lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,
- ColourOptional background);
- static void DrawIndicator(int indicNum, int startPos, int endPos, Surface *surface, const ViewStyle &vsDraw,
- int xStart, PRectangle rcLine, LineLayout *ll, int subLine);
- void DrawIndicators(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
- PRectangle rcLine, LineLayout *ll, int subLine, int lineEnd, bool under);
- void DrawAnnotation(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
- PRectangle rcLine, LineLayout *ll, int subLine);
- void DrawLine(Surface *surface, const ViewStyle &vsDraw, int line, int lineVisible, int xStart,
- PRectangle rcLine, LineLayout *ll, int subLine);
- void DrawBlockCaret(Surface *surface, const ViewStyle &vsDraw, LineLayout *ll, int subLine,
- int xStart, int offset, int posCaret, PRectangle rcCaret, ColourDesired caretColour) const;
- void DrawCarets(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
- PRectangle rcLine, LineLayout *ll, int subLine);
void RefreshPixMaps(Surface *surfaceWindow);
void Paint(Surface *surfaceWindow, PRectangle rcArea);
long FormatRange(bool draw, Sci_RangeToFormat *pfr);
diff --git a/src/PositionCache.cxx b/src/PositionCache.cxx
index 9e55c1a82..53767e032 100644
--- a/src/PositionCache.cxx
+++ b/src/PositionCache.cxx
@@ -438,13 +438,12 @@ void BreakFinder::Insert(int val) {
}
}
-BreakFinder::BreakFinder(const LineLayout *ll_, const Selection *psel, int lineStart_, int lineEnd_, int posLineStart_,
+BreakFinder::BreakFinder(const LineLayout *ll_, const Selection *psel, Range lineRange_, int posLineStart_,
int xStart, bool breakForSelection, const Document *pdoc_, const SpecialRepresentations *preprs_) :
ll(ll_),
- lineStart(lineStart_),
- lineEnd(lineEnd_),
+ lineRange(lineRange_),
posLineStart(posLineStart_),
- nextBreak(lineStart_),
+ nextBreak(lineRange_.start),
saeCurrentPos(0),
saeNext(0),
subBreak(-1),
@@ -455,15 +454,15 @@ BreakFinder::BreakFinder(const LineLayout *ll_, const Selection *psel, int lineS
// Search for first visible break
// First find the first visible character
if (xStart > 0.0f)
- nextBreak = ll->FindBefore(static_cast<XYPOSITION>(xStart), lineStart, lineEnd);
+ nextBreak = ll->FindBefore(static_cast<XYPOSITION>(xStart), lineRange.start, lineRange.end);
// Now back to a style break
- while ((nextBreak > lineStart) && (ll->styles[nextBreak] == ll->styles[nextBreak - 1])) {
+ while ((nextBreak > lineRange.start) && (ll->styles[nextBreak] == ll->styles[nextBreak - 1])) {
nextBreak--;
}
if (breakForSelection) {
SelectionPosition posStart(posLineStart);
- SelectionPosition posEnd(posLineStart + lineEnd);
+ SelectionPosition posEnd(posLineStart + lineRange.end);
SelectionSegment segmentLine(posStart, posEnd);
for (size_t r=0; r<psel->Count(); r++) {
SelectionSegment portion = psel->Range(r).Intersect(segmentLine);
@@ -477,7 +476,7 @@ BreakFinder::BreakFinder(const LineLayout *ll_, const Selection *psel, int lineS
}
Insert(ll->edgeColumn);
- Insert(lineEnd);
+ Insert(lineRange.end);
saeNext = (!selAndEdge.empty()) ? selAndEdge[0] : -1;
}
@@ -487,19 +486,19 @@ BreakFinder::~BreakFinder() {
TextSegment BreakFinder::Next() {
if (subBreak == -1) {
int prev = nextBreak;
- while (nextBreak < lineEnd) {
+ while (nextBreak < lineRange.end) {
int charWidth = 1;
if (encodingFamily == efUnicode)
- charWidth = UTF8DrawBytes(reinterpret_cast<unsigned char *>(ll->chars) + nextBreak, lineEnd - nextBreak);
+ charWidth = UTF8DrawBytes(reinterpret_cast<unsigned char *>(ll->chars) + nextBreak, lineRange.end - nextBreak);
else if (encodingFamily == efDBCS)
charWidth = pdoc->IsDBCSLeadByte(ll->chars[nextBreak]) ? 2 : 1;
const Representation *repr = preprs->RepresentationFromCharacter(ll->chars + nextBreak, charWidth);
if (((nextBreak > 0) && (ll->styles[nextBreak] != ll->styles[nextBreak - 1])) ||
repr ||
(nextBreak == saeNext)) {
- while ((nextBreak >= saeNext) && (saeNext < lineEnd)) {
+ while ((nextBreak >= saeNext) && (saeNext < lineRange.end)) {
saeCurrentPos++;
- saeNext = (saeCurrentPos < selAndEdge.size()) ? selAndEdge[saeCurrentPos] : lineEnd;
+ saeNext = (saeCurrentPos < selAndEdge.size()) ? selAndEdge[saeCurrentPos] : lineRange.end;
}
if ((nextBreak > prev) || repr) {
// Have a segment to report
@@ -540,7 +539,7 @@ TextSegment BreakFinder::Next() {
}
bool BreakFinder::More() const {
- return (subBreak >= 0) || (nextBreak < lineEnd);
+ return (subBreak >= 0) || (nextBreak < lineRange.end);
}
PositionCacheEntry::PositionCacheEntry() :
diff --git a/src/PositionCache.h b/src/PositionCache.h
index 05005e9ac..c81740ee3 100644
--- a/src/PositionCache.h
+++ b/src/PositionCache.h
@@ -148,8 +148,7 @@ struct TextSegment {
// Class to break a line of text into shorter runs at sensible places.
class BreakFinder {
const LineLayout *ll;
- int lineStart;
- int lineEnd;
+ Range lineRange;
int posLineStart;
int nextBreak;
std::vector<int> selAndEdge;
@@ -168,7 +167,7 @@ public:
enum { lengthStartSubdivision = 300 };
// Try to make each subdivided run lengthEachSubdivision or shorter.
enum { lengthEachSubdivision = 100 };
- BreakFinder(const LineLayout *ll_, const Selection *psel, int lineStart_, int lineEnd_, int posLineStart_,
+ BreakFinder(const LineLayout *ll_, const Selection *psel, Range rangeLine_, int posLineStart_,
int xStart, bool breakForSelection, const Document *pdoc_, const SpecialRepresentations *preprs_);
~BreakFinder();
TextSegment Next();
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-30 14:36:55 +0000