[geany/geany] 98fa60: Update Scintilla to version 3.4.4 - Commits

4 Jul 2014


      Branch:      refs/heads/master
Author:      Colomban Wendling ban@herbesfolles.org
Committer:   Colomban Wendling ban@herbesfolles.org
Date:        Fri, 04 Jul 2014 01:06:17 UTC
Commit:      98fa600a2ff40cd55ec8010bff258ed0b32ff8aa
             https://github.com/geany/geany/commit/98fa600a2ff40cd55ec8010bff258ed0b32ff8...
Log Message:
-----------
Update Scintilla to version 3.4.4
Modified Paths:
--------------
    scintilla/gtk/PlatGTK.cxx
    scintilla/gtk/ScintillaGTK.cxx
    scintilla/include/Scintilla.h
    scintilla/include/Scintilla.iface
    scintilla/lexers/LexBash.cxx
    scintilla/lexers/LexCPP.cxx
    scintilla/lexers/LexHTML.cxx
    scintilla/lexers/LexHaskell.cxx
    scintilla/lexers/LexPerl.cxx
    scintilla/lexers/LexRuby.cxx
    scintilla/lexers/LexRust.cxx
    scintilla/lexers/LexTCL.cxx
    scintilla/lexers/LexVHDL.cxx
    scintilla/lexlib/Accessor.cxx
    scintilla/lexlib/CharacterCategory.cxx
    scintilla/lexlib/CharacterSet.cxx
    scintilla/lexlib/LexAccessor.h
    scintilla/lexlib/LexerBase.cxx
    scintilla/lexlib/LexerModule.cxx
    scintilla/lexlib/LexerModule.h
    scintilla/lexlib/LexerNoExceptions.cxx
    scintilla/lexlib/LexerSimple.cxx
    scintilla/lexlib/StyleContext.cxx
    scintilla/lexlib/StyleContext.h
    scintilla/lexlib/WordList.cxx
    scintilla/src/CaseFolder.cxx
    scintilla/src/Catalogue.cxx
    scintilla/src/CellBuffer.cxx
    scintilla/src/CellBuffer.h
    scintilla/src/Document.cxx
    scintilla/src/Document.h
    scintilla/src/Editor.cxx
    scintilla/src/Editor.h
    scintilla/src/ExternalLexer.cxx
    scintilla/src/Indicator.cxx
    scintilla/src/Indicator.h
    scintilla/src/LineMarker.cxx
    scintilla/src/LineMarker.h
    scintilla/src/PositionCache.cxx
    scintilla/src/PositionCache.h
    scintilla/src/ScintillaBase.cxx
    scintilla/src/ScintillaBase.h
    scintilla/src/Selection.cxx
    scintilla/src/Selection.h
    scintilla/src/Style.cxx
    scintilla/src/Style.h
    scintilla/src/ViewStyle.cxx
    scintilla/src/ViewStyle.h
    scintilla/version.txt
Modified: scintilla/gtk/PlatGTK.cxx
41 lines changed, 26 insertions(+), 15 deletions(-)
===================================================================
@@ -527,27 +527,32 @@ void SurfaceImpl::Release() {
 }
bool SurfaceImpl::Initialised() {
+	if (inited && context) {
+		if (cairo_status(context) == CAIRO_STATUS_SUCCESS) {
+			// Even when status is success, the target surface may have been
+			// finished whch may cause an assertion to fail crashing the application.
+			// The cairo_surface_has_show_text_glyphs call checks the finished flag
+			// and when set, sets the status to CAIRO_STATUS_SURFACE_FINISHED
+			// which leads to warning messages instead of crashes.
+			// Performing the check in this method as it is called rarely and has no
+			// other side effects.
+			cairo_surface_t *psurfContext = cairo_get_target(context);
+			if (psurfContext) {
+				cairo_surface_has_show_text_glyphs(psurfContext);
+			}
+		}
+		return cairo_status(context) == CAIRO_STATUS_SUCCESS;
+	}
    return inited;
 }
void SurfaceImpl::Init(WindowID wid) {
    Release();
    PLATFORM_ASSERT(wid);
-#if GTK_CHECK_VERSION(3,0,0)
-	GdkWindow *drawable_ = gtk_widget_get_window(PWidget(wid));
-#else
-	GdkDrawable *drawable_ = GDK_DRAWABLE(PWidget(wid)->window);
-#endif
-	if (drawable_) {
-		context = gdk_cairo_create(drawable_);
-		PLATFORM_ASSERT(context);
-	} else {
-		// Shouldn't happen with valid window but may when calls made before
-		// window completely allocated and mapped.
-		psurf = cairo_image_surface_create(CAIRO_FORMAT_RGB24, 1, 1);
-		context = cairo_create(psurf);
-	}
-	createdGC = true;
+	// if we are only created from a window ID, we can't perform drawing
+	psurf = 0;
+	context = 0;
+	createdGC = false;
    pcontext = gtk_widget_create_pango_context(PWidget(wid));
    PLATFORM_ASSERT(pcontext);
    layout = pango_layout_new(pcontext);
@@ -665,6 +670,7 @@ void SurfaceImpl::LineTo(int x_, int y_) {
void SurfaceImpl::Polygon(Point *pts, int npts, ColourDesired fore,
                           ColourDesired back) {
+	PLATFORM_ASSERT(context);
    PenColour(back);
    cairo_move_to(context, pts[0].x + 0.5, pts[0].y + 0.5);
    for (int i = 1; i < npts; i++) {
@@ -702,6 +708,7 @@ void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern) {
    SurfaceImpl &surfi = static_cast<SurfaceImpl &>(surfacePattern);
    bool canDraw = surfi.psurf;
    if (canDraw) {
+		PLATFORM_ASSERT(context);
    	// Tile pattern over rectangle
    	// Currently assumes 8x8 pattern
    	int widthPat = 8;
@@ -787,6 +794,7 @@ void SurfaceImpl::AlphaRectangle(PRectangle rc, int cornerSize, ColourDesired fi
 }
void SurfaceImpl::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) {
+	PLATFORM_ASSERT(context);
    if (rc.Width() > width)
    	rc.left += (rc.Width() - width) / 2;
    rc.right = rc.left + width;
@@ -821,6 +829,7 @@ void SurfaceImpl::DrawRGBAImage(PRectangle rc, int width, int height, const unsi
 }
void SurfaceImpl::Ellipse(PRectangle rc, ColourDesired fore, ColourDesired back) {
+	PLATFORM_ASSERT(context);
    PenColour(back);
    cairo_arc(context, (rc.left + rc.right) / 2, (rc.top + rc.bottom) / 2,
    	Platform::Minimum(rc.Width(), rc.Height()) / 2, 0, 2*kPi);
@@ -833,6 +842,7 @@ void SurfaceImpl::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
    SurfaceImpl &surfi = static_cast<SurfaceImpl &>(surfaceSource);
    bool canDraw = surfi.psurf;
    if (canDraw) {
+		PLATFORM_ASSERT(context);
    	cairo_set_source_surface(context, surfi.psurf,
    		rc.left - from.x, rc.top - from.y);
    	cairo_rectangle(context, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top);
@@ -1185,6 +1195,7 @@ XYPOSITION SurfaceImpl::AverageCharWidth(Font &font_) {
 }
void SurfaceImpl::SetClip(PRectangle rc) {
+	PLATFORM_ASSERT(context);
    cairo_rectangle(context, rc.left, rc.top, rc.right, rc.bottom);
    cairo_clip(context);
 }
Modified: scintilla/gtk/ScintillaGTK.cxx
28 lines changed, 15 insertions(+), 13 deletions(-)
===================================================================
@@ -6,9 +6,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <time.h>
 #include <assert.h>
+#include <ctype.h>
#include <new>
 #include <string>
@@ -16,15 +16,17 @@
 #include <map>
 #include <algorithm>
+#include <glib.h>
+#include <gmodule.h>
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
-#include "Platform.h"
-
-#if PLAT_GTK_WIN32
+#if defined(__WIN32__) || defined(_MSC_VER)
 #include <windows.h>
 #endif
+#include "Platform.h"
+
 #include "ILexer.h"
 #include "Scintilla.h"
 #include "ScintillaWidget.h"
@@ -32,6 +34,9 @@
 #include "SciLexer.h"
 #endif
 #include "StringCopy.h"
+#ifdef SCI_LEXER
+#include "LexerModule.h"
+#endif
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
@@ -43,28 +48,25 @@
 #include "XPM.h"
 #include "LineMarker.h"
 #include "Style.h"
-#include "AutoComplete.h"
 #include "ViewStyle.h"
-#include "Decoration.h"
 #include "CharClassify.h"
+#include "Decoration.h"
 #include "CaseFolder.h"
 #include "Document.h"
+#include "CaseConvert.h"
+#include "UniConversion.h"
 #include "Selection.h"
 #include "PositionCache.h"
 #include "Editor.h"
+#include "AutoComplete.h"
 #include "ScintillaBase.h"
-#include "UniConversion.h"
-#include "CaseConvert.h"
-
-#include "scintilla-marshal.h"
#ifdef SCI_LEXER
-#include <glib.h>
-#include <gmodule.h>
-#include "LexerModule.h"
 #include "ExternalLexer.h"
 #endif
+#include "scintilla-marshal.h"
+
 #include "Converter.h"
#if defined(__clang__)
Modified: scintilla/include/Scintilla.h
8 lines changed, 6 insertions(+), 2 deletions(-)
===================================================================
@@ -717,6 +717,10 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE 1
 #define SCI_AUTOCSETCASEINSENSITIVEBEHAVIOUR 2634
 #define SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR 2635
+#define SC_MULTIAUTOC_ONCE 0
+#define SC_MULTIAUTOC_EACH 1
+#define SCI_AUTOCSETMULTI 2636
+#define SCI_AUTOCGETMULTI 2637
 #define SC_ORDER_PRESORTED 0
 #define SC_ORDER_PERFORMSORT 1
 #define SC_ORDER_CUSTOM 2
@@ -1017,7 +1021,7 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
  * CHARRANGE, TEXTRANGE, FINDTEXTEX, FORMATRANGE, and NMHDR structs.
  * So older code that treats Scintilla as a RichEdit will work. */
-#ifdef SCI_NAMESPACE
+#if defined(__cplusplus) && defined(SCI_NAMESPACE)
 namespace Scintilla {
 #endif
@@ -1109,7 +1113,7 @@ struct SCNotification {
    int updated;	/* SCN_UPDATEUI */
 };
-#ifdef SCI_NAMESPACE
+#if defined(__cplusplus) && defined(SCI_NAMESPACE)
 }
 #endif
Modified: scintilla/include/Scintilla.iface
10 lines changed, 10 insertions(+), 0 deletions(-)
===================================================================
@@ -1884,6 +1884,16 @@ set void AutoCSetCaseInsensitiveBehaviour=2634(int behaviour,)
 # Get auto-completion case insensitive behaviour.
 get int AutoCGetCaseInsensitiveBehaviour=2635(,)
+enu MultiAutoComplete=SC_MULTIAUTOC_
+val SC_MULTIAUTOC_ONCE=0
+val SC_MULTIAUTOC_EACH=1
+
+# Change the effect of autocompleting when there are multiple selections.
+set void AutoCSetMulti=2636(int multi,)
+
+# Retrieve the effect of autocompleting when there are multiple selections..
+get int AutoCGetMulti=2637(,)
+
 enu Ordering=SC_ORDER_
 val SC_ORDER_PRESORTED=0
 val SC_ORDER_PERFORMSORT=1
Modified: scintilla/lexers/LexBash.cxx
11 lines changed, 10 insertions(+), 1 deletions(-)
===================================================================
@@ -767,6 +767,7 @@ static void FoldBashDoc(unsigned int startPos, int length, int, WordList *[],
    bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
    unsigned int endPos = startPos + length;
    int visibleChars = 0;
+	int skipHereCh = 0;
    int lineCurrent = styler.GetLine(startPos);
    int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
    int levelCurrent = levelPrev;
@@ -798,7 +799,15 @@ static void FoldBashDoc(unsigned int startPos, int length, int, WordList *[],
    	// Here Document folding
    	if (style == SCE_SH_HERE_DELIM) {
    		if (ch == '<' && chNext == '<') {
-				levelCurrent++;
+				if (styler.SafeGetCharAt(i + 2) == '<') {
+					skipHereCh = 1;
+				} else {
+					if (skipHereCh == 0) {
+						levelCurrent++;
+					} else {
+						skipHereCh = 0;
+					}
+				}
    		}
    	} else if (style == SCE_SH_HERE_Q && styler.StyleAt(i+1) == SCE_SH_DEFAULT) {
    		levelCurrent--;
Modified: scintilla/lexers/LexCPP.cxx
22 lines changed, 16 insertions(+), 6 deletions(-)
===================================================================
@@ -8,10 +8,10 @@
#include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <ctype.h>
#include <string>
 #include <vector>
@@ -821,10 +821,18 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle,
    						((lenS == 1) && ((s[0] == 'L') || (s[0] == 'u') || (s[0] == 'U'))) ||
    						((lenS == 2) && literalString && (s[0] == 'u') && (s[1] == '8'));
    					if (valid) {
-							if (literalString)
-								sc.ChangeState((raw ? SCE_C_STRINGRAW : SCE_C_STRING)|activitySet);
-							else
+							if (literalString) {
+								if (raw) {
+									// Set the style of the string prefix to SCE_C_STRINGRAW but then change to
+									// SCE_C_DEFAULT as that allows the raw string start code to run.
+									sc.ChangeState(SCE_C_STRINGRAW|activitySet);
+									sc.SetState(SCE_C_DEFAULT|activitySet);
+								} else {
+									sc.ChangeState(SCE_C_STRING|activitySet);
+								}
+							} else {
    							sc.ChangeState(SCE_C_CHARACTER|activitySet);
+							}
    					} else {
    						sc.SetState(SCE_C_DEFAULT | activitySet);
    					}
@@ -1203,7 +1211,7 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle,
    							while ((endName < restOfLine.length()) && setWord.Contains(static_cast<unsigned char>(restOfLine[endName])))
    								endName++;
    							std::string key = restOfLine.substr(startName, endName-startName);
-								if (restOfLine[endName] == '(') {
+								if ((endName < restOfLine.length()) && (restOfLine.at(endName) == '(')) {
    								// Macro
    								size_t endArgs = endName;
    								while ((endArgs < restOfLine.length()) && (restOfLine[endArgs] != ')'))
@@ -1212,7 +1220,9 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle,
    								size_t startValue = endArgs+1;
    								while ((startValue < restOfLine.length()) && IsSpaceOrTab(restOfLine[startValue]))
    									startValue++;
-									std::string value = restOfLine.substr(startValue);
+									std::string value;
+									if (startValue < restOfLine.length())
+										value = restOfLine.substr(startValue);
    								preprocessorDefinitions[key] = SymbolValue(value, args);
    								ppDefineHistory.push_back(PPDefinition(lineCurrent, key, value, false, args));
    								definitionsChanged = true;
Modified: scintilla/lexers/LexHTML.cxx
11 lines changed, 5 insertions(+), 6 deletions(-)
===================================================================
@@ -576,8 +576,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
    WordList &keywords5 = *keywordlists[4];
    WordList &keywords6 = *keywordlists[5]; // SGML (DTD) keywords
-	// Lexer for HTML requires more lexical states (8 bits worth) than most lexers
-	styler.StartAt(startPos, static_cast<unsigned char>(STYLE_MAX));
+	styler.StartAt(startPos);
    char prevWord[200];
    prevWord[0] = '\0';
    char phpStringDelimiter[200]; // PHP is not limited in length, we are
@@ -609,7 +608,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
    	if (startPos == 0)
    		state = SCE_H_DEFAULT;
    }
-	styler.StartAt(startPos, static_cast<unsigned char>(STYLE_MAX));
+	styler.StartAt(startPos);
int lineCurrent = styler.GetLine(startPos);
    int lineState;
@@ -2180,6 +2179,6 @@ static const char * const phpscriptWordListDesc[] = {
    0,
 };
-LexerModule lmHTML(SCLEX_HTML, ColouriseHTMLDoc, "hypertext", 0, htmlWordListDesc, 8);
-LexerModule lmXML(SCLEX_XML, ColouriseXMLDoc, "xml", 0, htmlWordListDesc, 8);
-LexerModule lmPHPSCRIPT(SCLEX_PHPSCRIPT, ColourisePHPScriptDoc, "phpscript", 0, phpscriptWordListDesc, 8);
+LexerModule lmHTML(SCLEX_HTML, ColouriseHTMLDoc, "hypertext", 0, htmlWordListDesc);
+LexerModule lmXML(SCLEX_XML, ColouriseXMLDoc, "xml", 0, htmlWordListDesc);
+LexerModule lmPHPSCRIPT(SCLEX_PHPSCRIPT, ColourisePHPScriptDoc, "phpscript", 0, phpscriptWordListDesc);
Modified: scintilla/lexers/LexHaskell.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -38,9 +38,9 @@
 #include "Accessor.h"
 #include "StyleContext.h"
 #include "CharacterSet.h"
+#include "CharacterCategory.h"
 #include "LexerModule.h"
 #include "OptionSet.h"
-#include "CharacterCategory.h"
#ifdef SCI_NAMESPACE
 using namespace Scintilla;
Modified: scintilla/lexers/LexPerl.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -1726,4 +1726,4 @@ void SCI_METHOD LexerPerl::Fold(unsigned int startPos, int length, int /* initSt
    styler.SetLevel(lineCurrent, levelPrev | flagsNext);
 }
-LexerModule lmPerl(SCLEX_PERL, LexerPerl::LexerFactoryPerl, "perl", perlWordListDesc, 8);
+LexerModule lmPerl(SCLEX_PERL, LexerPerl::LexerFactoryPerl, "perl", perlWordListDesc);
Modified: scintilla/lexers/LexRuby.cxx
5 lines changed, 2 insertions(+), 3 deletions(-)
===================================================================
@@ -705,8 +705,7 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
    char chPrev = styler.SafeGetCharAt(startPos - 1);
    char chNext = styler.SafeGetCharAt(startPos);
    bool is_real_number = true;   // Differentiate between constants and ?-sequences.
-	// Ruby uses a different mask because bad indentation is marked by oring with 32
-	styler.StartAt(startPos, 127);
+	styler.StartAt(startPos);
    styler.StartSegment(startPos);
static int q_states[] = {SCE_RB_STRING_Q,
@@ -1776,4 +1775,4 @@ static const char * const rubyWordListDesc[] = {
    0
 };
-LexerModule lmRuby(SCLEX_RUBY, ColouriseRbDoc, "ruby", FoldRbDoc, rubyWordListDesc, 6);
+LexerModule lmRuby(SCLEX_RUBY, ColouriseRbDoc, "ruby", FoldRbDoc, rubyWordListDesc);
Modified: scintilla/lexers/LexRust.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -21,6 +21,7 @@
 #include "Scintilla.h"
 #include "SciLexer.h"
+#include "PropSetSimple.h"
 #include "WordList.h"
 #include "LexAccessor.h"
 #include "Accessor.h"
@@ -28,7 +29,6 @@
 #include "CharacterSet.h"
 #include "LexerModule.h"
 #include "OptionSet.h"
-#include "PropSetSimple.h"
#ifdef SCI_NAMESPACE
 using namespace Scintilla;
Modified: scintilla/lexers/LexTCL.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -358,7 +358,7 @@ static const char * const tclWordListDesc[] = {
             "TK Keywords",
             "iTCL Keywords",
             "tkCommands",
-            "expand"
+            "expand",
             "user1",
             "user2",
             "user3",
Modified: scintilla/lexers/LexVHDL.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -12,10 +12,10 @@
#include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <ctype.h>
#include "ILexer.h"
 #include "Scintilla.h"
Modified: scintilla/lexlib/Accessor.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -8,9 +8,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <ctype.h>
#include "ILexer.h"
 #include "Scintilla.h"
Modified: scintilla/lexlib/CharacterCategory.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -3287,7 +3287,7 @@ const int nRanges = ELEMENTS(catRanges);
 // Initial version has 3249 entries and adds about 13K to the executable.
 // The array is in ascending order so can be searched using binary search.
 // Therefore the average call takes log2(3249) = 12 comparisons.
-// For speed, it may be an useful to make a linear table for the common values,
+// For speed, it may be useful to make a linear table for the common values,
 // possibly for 0..0xff for most Western European text or 0..0xfff for most
 // alphabetic languages.
Modified: scintilla/lexlib/CharacterSet.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -9,8 +9,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <assert.h>
+#include <ctype.h>
#include "CharacterSet.h"
Modified: scintilla/lexlib/LexAccessor.h
20 lines changed, 4 insertions(+), 16 deletions(-)
===================================================================
@@ -29,11 +29,8 @@ class LexAccessor {
    int codePage;
    enum EncodingType encodingType;
    int lenDoc;
-	int mask;
    char styleBuf[bufferSize];
    int validLen;
-	char chFlags;
-	char chWhile;
    unsigned int startSeg;
    int startPosStyling;
    int documentVersion;
@@ -58,7 +55,7 @@ class LexAccessor {
    	codePage(pAccess->CodePage()),
    	encodingType(enc8bit),
    	lenDoc(pAccess->Length()),
-		mask(127), validLen(0), chFlags(0), chWhile(0),
+		validLen(0),
    	startSeg(0), startPosStyling(0),
    	documentVersion(pAccess->Version()) {
    	switch (codePage) {
@@ -111,7 +108,7 @@ class LexAccessor {
    	return true;
    }
    char StyleAt(int position) const {
-		return static_cast<char>(pAccess->StyleAt(position) & mask);
+		return static_cast<char>(pAccess->StyleAt(position));
    }
    int GetLine(int position) const {
    	return pAccess->LineFromPosition(position);
@@ -152,16 +149,10 @@ class LexAccessor {
    	return pAccess->SetLineState(line, state);
    }
    // Style setting
-	void StartAt(unsigned int start, char chMask=31) {
-		// Store the mask specified for use with StyleAt.
-		mask = chMask;
-		pAccess->StartStyling(start, chMask);
+	void StartAt(unsigned int start) {
+		pAccess->StartStyling(start, '\377');
    	startPosStyling = start;
    }
-	void SetFlags(char chFlags_, char chWhile_) {
-		chFlags = chFlags_;
-		chWhile = chWhile_;
-	}
    unsigned int GetStartSegment() const {
    	return startSeg;
    }
@@ -182,9 +173,6 @@ class LexAccessor {
    			// Too big for buffer so send directly
    			pAccess->SetStyleFor(pos - startSeg + 1, static_cast<char>(chAttr));
    		} else {
-				if (chAttr != chWhile)
-					chFlags = 0;
-				chAttr = static_cast<char>(chAttr | chFlags);
    			for (unsigned int i = startSeg; i <= pos; i++) {
    				assert((startPosStyling + validLen) < Length());
    				styleBuf[validLen++] = static_cast<char>(chAttr);
Modified: scintilla/lexlib/LexerBase.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -8,9 +8,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <ctype.h>
#include "ILexer.h"
 #include "Scintilla.h"
Modified: scintilla/lexlib/LexerModule.cxx
14 lines changed, 3 insertions(+), 11 deletions(-)
===================================================================
@@ -8,9 +8,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <ctype.h>
#include <string>
@@ -34,28 +34,24 @@ LexerModule::LexerModule(int language_,
    LexerFunction fnLexer_,
    const char *languageName_,
    LexerFunction fnFolder_,
-        const char *const wordListDescriptions_[],
-	int styleBits_) :
+        const char *const wordListDescriptions_[]) :
    language(language_),
    fnLexer(fnLexer_),
    fnFolder(fnFolder_),
    fnFactory(0),
    wordListDescriptions(wordListDescriptions_),
-	styleBits(styleBits_),
    languageName(languageName_) {
 }
LexerModule::LexerModule(int language_,
    LexerFactoryFunction fnFactory_,
    const char *languageName_,
-	const char * const wordListDescriptions_[],
-	int styleBits_) :
+	const char * const wordListDescriptions_[]) :
    language(language_),
    fnLexer(0),
    fnFolder(0),
    fnFactory(fnFactory_),
    wordListDescriptions(wordListDescriptions_),
-	styleBits(styleBits_),
    languageName(languageName_) {
 }
@@ -82,10 +78,6 @@ const char *LexerModule::GetWordListDescription(int index) const {
    }
 }
-int LexerModule::GetStyleBitsNeeded() const {
-	return styleBits;
-}
-
 ILexer *LexerModule::Create() const {
    if (fnFactory)
    	return fnFactory();
Modified: scintilla/lexlib/LexerModule.h
9 lines changed, 2 insertions(+), 7 deletions(-)
===================================================================
@@ -31,7 +31,6 @@ class LexerModule {
    LexerFunction fnFolder;
    LexerFactoryFunction fnFactory;
    const char * const * wordListDescriptions;
-	int styleBits;
public:
    const char *languageName;
@@ -39,13 +38,11 @@ class LexerModule {
    	LexerFunction fnLexer_,
    	const char *languageName_=0,
    	LexerFunction fnFolder_=0,
-		const char * const wordListDescriptions_[] = NULL,
-		int styleBits_=5);
+		const char * const wordListDescriptions_[] = NULL);
    LexerModule(int language_,
    	LexerFactoryFunction fnFactory_,
    	const char *languageName_,
-		const char * const wordListDescriptions_[] = NULL,
-		int styleBits_=8);
+		const char * const wordListDescriptions_[] = NULL);
    virtual ~LexerModule() {
    }
    int GetLanguage() const { return language; }
@@ -54,8 +51,6 @@ class LexerModule {
    int GetNumWordLists() const;
    const char *GetWordListDescription(int index) const;
-	int GetStyleBitsNeeded() const;
-
    ILexer *Create() const;
virtual void Lex(unsigned int startPos, int length, int initStyle,
Modified: scintilla/lexlib/LexerNoExceptions.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -8,9 +8,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <ctype.h>
#include "ILexer.h"
 #include "Scintilla.h"
Modified: scintilla/lexlib/LexerSimple.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -8,9 +8,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <ctype.h>
#include <string>
Modified: scintilla/lexlib/StyleContext.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -8,8 +8,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <assert.h>
+#include <ctype.h>
#include "ILexer.h"
Modified: scintilla/lexlib/StyleContext.h
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -66,7 +66,7 @@ class StyleContext {
    int widthNext;
StyleContext(unsigned int startPos, unsigned int length,
-                        int initStyle, LexAccessor &styler_, char chMask=31) :
+                        int initStyle, LexAccessor &styler_, char chMask='\377') :
    	styler(styler_),
    	multiByteAccess(0),
    	endPos(startPos + length),
@@ -86,7 +86,7 @@ class StyleContext {
    	if (styler.Encoding() != enc8bit) {
    		multiByteAccess = styler.MultiByteAccess();
    	}
-		styler.StartAt(startPos, chMask);
+		styler.StartAt(startPos /*, chMask*/);
    	styler.StartSegment(startPos);
    	currentLine = styler.GetLine(startPos);
    	lineStartNext = styler.LineStart(currentLine+1);
Modified: scintilla/lexlib/WordList.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -8,8 +8,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <stdarg.h>
+#include <ctype.h>
#include <algorithm>
Modified: scintilla/src/CaseFolder.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -8,9 +8,9 @@
 #include <vector>
 #include <algorithm>
+#include "CaseFolder.h"
 #include "CaseConvert.h"
 #include "UniConversion.h"
-#include "CaseFolder.h"
#ifdef SCI_NAMESPACE
 using namespace Scintilla;
Modified: scintilla/src/Catalogue.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -8,9 +8,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <ctype.h>
#include <vector>
Modified: scintilla/src/CellBuffer.cxx
13 lines changed, 6 insertions(+), 7 deletions(-)
===================================================================
@@ -413,25 +413,24 @@ const char *CellBuffer::InsertString(int position, const char *s, int insertLeng
    return data;
 }
-bool CellBuffer::SetStyleAt(int position, char styleValue, char mask) {
-	styleValue &= mask;
+bool CellBuffer::SetStyleAt(int position, char styleValue) {
    char curVal = style.ValueAt(position);
-	if ((curVal & mask) != styleValue) {
-		style.SetValueAt(position, static_cast<char>((curVal & ~mask) | styleValue));
+	if (curVal != styleValue) {
+		style.SetValueAt(position, styleValue);
    	return true;
    } else {
    	return false;
    }
 }
-bool CellBuffer::SetStyleFor(int position, int lengthStyle, char styleValue, char mask) {
+bool CellBuffer::SetStyleFor(int position, int lengthStyle, char styleValue) {
    bool changed = false;
    PLATFORM_ASSERT(lengthStyle == 0 ||
    	(lengthStyle > 0 && lengthStyle + position <= style.Length()));
    while (lengthStyle--) {
    	char curVal = style.ValueAt(position);
-		if ((curVal & mask) != styleValue) {
-			style.SetValueAt(position, static_cast<char>((curVal & ~mask) | styleValue));
+		if (curVal != styleValue) {
+			style.SetValueAt(position, styleValue);
    		changed = true;
    	}
    	position++;
Modified: scintilla/src/CellBuffer.h
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -180,8 +180,8 @@ class CellBuffer {
/// Setting styles for positions outside the range of the buffer is safe and has no effect.
    /// @return true if the style of a character is changed.
-	bool SetStyleAt(int position, char styleValue, char mask='\377');
-	bool SetStyleFor(int position, int length, char styleValue, char mask);
+	bool SetStyleAt(int position, char styleValue);
+	bool SetStyleFor(int position, int length, char styleValue);
const char *DeleteChars(int position, int deleteLength, bool &startSequence);
Modified: scintilla/src/Document.cxx
26 lines changed, 8 insertions(+), 18 deletions(-)
===================================================================
@@ -8,8 +8,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <assert.h>
+#include <ctype.h>
#include <string>
 #include <vector>
@@ -20,13 +20,13 @@
 #include "ILexer.h"
 #include "Scintilla.h"
+#include "CharacterSet.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
 #include "CellBuffer.h"
 #include "PerLine.h"
 #include "CharClassify.h"
-#include "CharacterSet.h"
 #include "Decoration.h"
 #include "CaseFolder.h"
 #include "Document.h"
@@ -58,7 +58,7 @@ void LexInterface::Colourise(int start, int end) {
int styleStart = 0;
    	if (start > 0)
-			styleStart = pdoc->StyleAt(start - 1) & pdoc->stylingBitsMask;
+			styleStart = pdoc->StyleAt(start - 1);
if (len > 0) {
    		instance->Lex(start, len, styleStart, pdoc);
@@ -90,9 +90,6 @@ Document::Document() {
 #endif
    dbcsCodePage = 0;
    lineEndBitSet = SC_LINE_END_TYPE_DEFAULT;
-	stylingBits = 5;
-	stylingBitsMask = 0x1F;
-	stylingMask = 0;
    endStyled = 0;
    styleClock = 0;
    enteredModification = 0;
@@ -1712,13 +1709,7 @@ int Document::GetCharsOfClass(CharClassify::cc characterClass, unsigned char *bu
     return charClass.GetCharsOfClass(characterClass, buffer);
 }
-void Document::SetStylingBits(int bits) {
-	stylingBits = bits;
-	stylingBitsMask = (1 << stylingBits) - 1;
-}
-
-void SCI_METHOD Document::StartStyling(int position, char mask) {
-	stylingMask = mask;
+void SCI_METHOD Document::StartStyling(int position, char) {
    endStyled = position;
 }
@@ -1727,9 +1718,8 @@ bool SCI_METHOD Document::SetStyleFor(int length, char style) {
    	return false;
    } else {
    	enteredStyling++;
-		style &= stylingMask;
    	int prevEndStyled = endStyled;
-		if (cb.SetStyleFor(endStyled, length, style, stylingMask)) {
+		if (cb.SetStyleFor(endStyled, length, style)) {
    		DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER,
    		                   prevEndStyled, length);
    		NotifyModified(mh);
@@ -1750,7 +1740,7 @@ bool SCI_METHOD Document::SetStyles(int length, const char *styles) {
    	int endMod = 0;
    	for (int iPos = 0; iPos < length; iPos++, endStyled++) {
    		PLATFORM_ASSERT(endStyled < Length());
-			if (cb.SetStyleAt(endStyled, styles[iPos], stylingMask)) {
+			if (cb.SetStyleAt(endStyled, styles[iPos])) {
    			if (!didChange) {
    				startMod = endStyled;
    			}
@@ -2080,7 +2070,7 @@ int Document::BraceMatch(int position, int /*maxReStyle*/) {
    char chSeek = BraceOpposite(chBrace);
    if (chSeek == '\0')
    	return - 1;
-	char styBrace = static_cast<char>(StyleAt(position) & stylingBitsMask);
+	char styBrace = static_cast<char>(StyleAt(position));
    int direction = -1;
    if (chBrace == '(' || chBrace == '[' || chBrace == '{' || chBrace == '<')
    	direction = 1;
@@ -2088,7 +2078,7 @@ int Document::BraceMatch(int position, int /*maxReStyle*/) {
    position = NextPosition(position, direction);
    while ((position >= 0) && (position < Length())) {
    	char chAtPos = CharAt(position);
-		char styAtPos = static_cast<char>(StyleAt(position) & stylingBitsMask);
+		char styAtPos = static_cast<char>(StyleAt(position));
    	if ((position > GetEndStyled()) || (styAtPos == styBrace)) {
    		if (chAtPos == chBrace)
    			depth++;
Modified: scintilla/src/Document.h
9 lines changed, 4 insertions(+), 5 deletions(-)
===================================================================
@@ -39,6 +39,10 @@ class Range {
    	start(start_), end(end_) {
    }
+	bool operator==(const Range &other) const {
+		return (start == other.start) && (end == other.end);
+	}
+
    bool Valid() const {
    	return (start != invalidPosition) && (end != invalidPosition);
    }
@@ -206,7 +210,6 @@ class Document : PerLine, public IDocumentWithLineEnd, public ILoader {
    CellBuffer cb;
    CharClassify charClass;
    CaseFolder *pcf;
-	char stylingMask;
    int endStyled;
    int styleClock;
    int enteredModification;
@@ -229,9 +232,6 @@ class Document : PerLine, public IDocumentWithLineEnd, public ILoader {
LexInterface *pli;
-	int stylingBits;
-	int stylingBitsMask;
-
    int eolMode;
    /// Can also be SC_CP_UTF8 to enable UTF-8 mode
    int dbcsCodePage;
@@ -369,7 +369,6 @@ class Document : PerLine, public IDocumentWithLineEnd, public ILoader {
    void SetDefaultCharClasses(bool includeWordClass);
    void SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass);
    int GetCharsOfClass(CharClassify::cc charClass, unsigned char *buffer);
-	void SetStylingBits(int bits);
    void SCI_METHOD StartStyling(int position, char mask);
    bool SCI_METHOD SetStyleFor(int length, char style);
    bool SCI_METHOD SetStyles(int length, const char *styles);
Modified: scintilla/src/Editor.cxx
343 lines changed, 128 insertions(+), 215 deletions(-)
===================================================================
@@ -8,9 +8,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <math.h>
 #include <assert.h>
+#include <ctype.h>
#include <string>
 #include <vector>
@@ -220,8 +220,7 @@ Editor::Editor() {
convertPastes = true;
-	hsStart = -1;
-	hsEnd = -1;
+	hotspot = Range(invalidPosition);
llc.SetLevel(LineLayoutCache::llcCaret);
    posCache.SetSize(0x400);
@@ -885,9 +884,8 @@ bool Editor::RangeContainsProtected(int start, int end) const {
    		start = end;
    		end = t;
    	}
-		int mask = pdoc->stylingBitsMask;
    	for (int pos = start; pos < end; pos++) {
-			if (vs.styles[pdoc->StyleAt(pos) & mask].IsProtected())
+			if (vs.styles[pdoc->StyleAt(pos)].IsProtected())
    			return true;
    	}
    }
@@ -916,17 +914,16 @@ SelectionPosition Editor::MovePositionOutsideChar(SelectionPosition pos, int mov
    if (posMoved != pos.Position())
    	pos.SetPosition(posMoved);
    if (vs.ProtectionActive()) {
-		int mask = pdoc->stylingBitsMask;
    	if (moveDir > 0) {
-			if ((pos.Position() > 0) && vs.styles[pdoc->StyleAt(pos.Position() - 1) & mask].IsProtected()) {
+			if ((pos.Position() > 0) && vs.styles[pdoc->StyleAt(pos.Position() - 1)].IsProtected()) {
    			while ((pos.Position() < pdoc->Length()) &&
-				        (vs.styles[pdoc->StyleAt(pos.Position()) & mask].IsProtected()))
+				        (vs.styles[pdoc->StyleAt(pos.Position())].IsProtected()))
    				pos.Add(1);
    		}
    	} else if (moveDir < 0) {
-			if (vs.styles[pdoc->StyleAt(pos.Position()) & mask].IsProtected()) {
+			if (vs.styles[pdoc->StyleAt(pos.Position())].IsProtected()) {
    			while ((pos.Position() > 0) &&
-				        (vs.styles[pdoc->StyleAt(pos.Position() - 1) & mask].IsProtected()))
+				        (vs.styles[pdoc->StyleAt(pos.Position() - 1)].IsProtected()))
    				pos.Add(-1);
    		}
    	}
@@ -1741,7 +1738,7 @@ int Editor::SubstituteMarkerIfEmpty(int markerCheck, int markerDefault) const {
    return markerCheck;
 }
-bool ValidStyledText(ViewStyle &vs, size_t styleOffset, const StyledText &st) {
+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]))
@@ -1754,7 +1751,7 @@ bool ValidStyledText(ViewStyle &vs, size_t styleOffset, const StyledText &st) {
    return true;
 }
-static int WidthStyledText(Surface *surface, ViewStyle &vs, int styleOffset,
+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;
@@ -1763,14 +1760,15 @@ static int WidthStyledText(Surface *surface, ViewStyle &vs, int styleOffset,
    	size_t endSegment = start;
    	while ((endSegment+1 < len) && (static_cast<size_t>(styles[endSegment+1]) == style))
    		endSegment++;
-		width += static_cast<int>(surface->WidthText(vs.styles[style + styleOffset].font, text + start,
+		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, ViewStyle &vs, int styleOffset, const StyledText &st) {
+static int WidestLineWidth(Surface *surface, const ViewStyle &vs, int styleOffset, const StyledText &st) {
    int widthMax = 0;
    size_t start = 0;
    while (start < st.length) {
@@ -1779,7 +1777,8 @@ static int WidestLineWidth(Surface *surface, ViewStyle &vs, int styleOffset, con
    	if (st.multipleStyles) {
    		widthSubLine = WidthStyledText(surface, vs, styleOffset, st.text + start, st.styles + start, lenLine);
    	} else {
-			widthSubLine = static_cast<int>(surface->WidthText(vs.styles[styleOffset + st.style].font,
+			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)
@@ -1789,7 +1788,13 @@ static int WidestLineWidth(Surface *surface, ViewStyle &vs, int styleOffset, con
    return widthMax;
 }
-void DrawStyledText(Surface *surface, ViewStyle &vs, int styleOffset, PRectangle rcText, int ascent,
+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) {
@@ -1797,30 +1802,25 @@ void DrawStyledText(Surface *surface, ViewStyle &vs, int styleOffset, PRectangle
    	size_t i = 0;
    	while (i < length) {
    		size_t end = i;
-			int style = st.styles[i + start];
+			size_t style = st.styles[i + start];
    		while (end < length-1 && st.styles[start+end+1] == style)
    			end++;
    		style += styleOffset;
-			int width = static_cast<int>(surface->WidthText(vs.styles[style].font,
+			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);
-			surface->DrawTextNoClip(rcSegment, vs.styles[style].font,
-					static_cast<XYPOSITION>(ascent), st.text + start + i,
-					static_cast<int>(end - i + 1),
-					vs.styles[style].fore,
-					vs.styles[style].back);
+			DrawTextInStyle(surface, rcSegment, vs.styles[style], rcText.top + vs.maxAscent,
+				st.text + start + i, end - i + 1);
    		x += width;
    		i = end + 1;
    	}
    } else {
-		size_t style = st.style + styleOffset;
-		surface->DrawTextNoClip(rcText, vs.styles[style].font,
-				rcText.top + vs.maxAscent, st.text + start,
-				static_cast<int>(length),
-				vs.styles[style].fore,
-				vs.styles[style].back);
+		const size_t style = st.style + styleOffset;
+		DrawTextInStyle(surface, rcText, vs.styles[style], rcText.top + vs.maxAscent,
+			st.text + start, length);
    }
 }
@@ -1832,6 +1832,13 @@ void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) {
    RefreshStyleData();
    RefreshPixMaps(surfWindow);
+	// On GTK+ with Ubuntu overlay scroll bars, the surface may have been finished
+	// at this point. The Initialised call checks for this case and sets the status
+	// to be bad which avoids crashes in following calls.
+	if (!surfWindow->Initialised()) {
+		return;
+	}
+
    PRectangle rcMargin = GetClientRectangle();
    Point ptOrigin = GetVisibleOriginInMain();
    rcMargin.Move(0, -ptOrigin.y);
@@ -2057,10 +2064,8 @@ void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) {
    					XYPOSITION width = surface->WidthText(vs.styles[STYLE_LINENUMBER].font, number, istrlen(number));
    					XYPOSITION xpos = rcNumber.right - width - vs.marginNumberPadding;
    					rcNumber.left = xpos;
-						surface->DrawTextNoClip(rcNumber, vs.styles[STYLE_LINENUMBER].font,
-								rcNumber.top + vs.maxAscent, number, istrlen(number),
-								vs.styles[STYLE_LINENUMBER].fore,
-								vs.styles[STYLE_LINENUMBER].back);
+						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;
@@ -2077,7 +2082,7 @@ void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) {
    							int width = WidestLineWidth(surface, vs, vs.marginStyleOffset, stMargin);
    							rcMarker.left = rcMarker.right - width - 3;
    						}
-							DrawStyledText(surface, vs, vs.marginStyleOffset, rcMarker, static_cast<int>(rcMarker.top) + vs.maxAscent,
+							DrawStyledText(surface, vs, vs.marginStyleOffset, rcMarker,
    							stMargin, 0, stMargin.length);
    					}
    				}
@@ -2157,8 +2162,7 @@ LineLayout *Editor::RetrieveLineLayout(int lineNumber) {
  * 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, ViewStyle &vstyle, LineLayout *ll, int width) {
-//void LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll, int width, Document *pdoc, PositionCache &posCache, SpecialRepresentations &reprs) {
+void Editor::LayoutLine(int line, Surface *surface, const ViewStyle &vstyle, LineLayout *ll, int width) {
    if (!ll)
    	return;
@@ -2178,7 +2182,6 @@ void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayou
    	if (lineLength == ll->numCharsInLine) {
    		// See if chars, styles, indicators, are all the same
    		bool allSame = true;
-			const int styleMask = pdoc->stylingBitsMask;
    		// Check base line layout
    		char styleByte = 0;
    		int numCharsInLine = 0;
@@ -2187,9 +2190,7 @@ void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayou
    			char chDoc = pdoc->CharAt(charInDoc);
    			styleByte = pdoc->StyleAt(charInDoc);
    			allSame = allSame &&
-				        (ll->styles[numCharsInLine] == static_cast<unsigned char>(styleByte & styleMask));
-				allSame = allSame &&
-				        (ll->indicators[numCharsInLine] == static_cast<char>(styleByte & ~styleMask));
+				        (ll->styles[numCharsInLine] == static_cast<unsigned char>(styleByte));
    			if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseMixed)
    				allSame = allSame &&
    				        (ll->chars[numCharsInLine] == chDoc);
@@ -2223,8 +2224,6 @@ void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayou
    		ll->edgeColumn = -1;
    	}
-		const int styleMask = pdoc->stylingBitsMask;
-		ll->styleBitsSet = 0;
    	// Fill base line layout
    	const int lineLength = posLineEnd - posLineStart;
    	pdoc->GetCharRange(ll->chars, posLineStart, lineLength);
@@ -2233,11 +2232,9 @@ void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayou
    	const int numCharsInLine = (vstyle.viewEOL) ? lineLength : numCharsBeforeEOL;
    	for (int styleInLine = 0; styleInLine < numCharsInLine; styleInLine++) {
    		const unsigned char styleByte = ll->styles[styleInLine];
-			ll->styleBitsSet |= styleByte;
-			ll->styles[styleInLine] = styleByte & styleMask;
-			ll->indicators[styleInLine] = static_cast<char>(styleByte & ~styleMask);
+			ll->styles[styleInLine] = styleByte;
    	}
-		const unsigned char styleByteLast = ((lineLength > 0) ? ll->styles[lineLength-1] : 0) & styleMask;
+		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];
@@ -2251,14 +2248,13 @@ void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayou
    	// 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
-		ll->indicators[numCharsInLine] = 0;
// 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, 0, numCharsInLine, posLineStart, 0, false, pdoc, &reprs);
+		BreakFinder bfLayout(ll, NULL, 0, numCharsInLine, posLineStart, 0, false, pdoc, &reprs);
    	while (bfLayout.More()) {
const TextSegment ts = bfLayout.Next();
@@ -2390,14 +2386,14 @@ void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayou
    }
 }
-ColourDesired Editor::SelectionBackground(ViewStyle &vsDraw, bool main) const {
+ColourDesired Editor::SelectionBackground(const ViewStyle &vsDraw, bool main) const {
    return main ?
    	(primarySelection ? vsDraw.selColours.back : vsDraw.selBackground2) :
    	vsDraw.selAdditionalBackground;
 }
-ColourDesired Editor::TextBackground(ViewStyle &vsDraw, bool overrideBackground,
-        ColourDesired background, int inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll) const {
+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);
@@ -2414,7 +2410,7 @@ ColourDesired Editor::TextBackground(ViewStyle &vsDraw, bool overrideBackground,
    	if (inHotspot && vsDraw.hotspotColours.back.isSet)
    		return vsDraw.hotspotColours.back;
    }
-	if (overrideBackground && (styleMain != STYLE_BRACELIGHT) && (styleMain != STYLE_BRACEBAD)) {
+	if (background.isSet && (styleMain != STYLE_BRACELIGHT) && (styleMain != STYLE_BRACEBAD)) {
    	return background;
    } else {
    	return vsDraw.styles[styleMain].back;
@@ -2478,12 +2474,12 @@ static void SimpleAlphaRectangle(Surface *surface, PRectangle rc, ColourDesired
    }
 }
-void DrawTextBlob(Surface *surface, ViewStyle &vsDraw, PRectangle rcSegment,
+void DrawTextBlob(Surface *surface, const ViewStyle &vsDraw, PRectangle rcSegment,
    			  const char *s, ColourDesired textBack, ColourDesired textFore, bool twoPhaseDraw) {
    if (!twoPhaseDraw) {
    	surface->FillRectangle(rcSegment, textBack);
    }
-	Font &ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
+	FontAlias ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
    int normalCharHeight = static_cast<int>(surface->Ascent(ctrlCharsFont) -
            surface->InternalLeading(ctrlCharsFont));
    PRectangle rcCChar = rcSegment;
@@ -2502,13 +2498,11 @@ void DrawTextBlob(Surface *surface, ViewStyle &vsDraw, PRectangle rcSegment,
            textBack, textFore);
 }
-void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
+void Editor::DrawEOL(Surface *surface, const ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
         int line, int lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,
-        bool overrideBackground, ColourDesired background,
-        bool drawWrapMarkEnd, ColourDesired wrapColour) {
+        ColourOptional background) {
const int posLineStart = pdoc->LineStart(line);
-	const int styleMask = pdoc->stylingBitsMask;
    PRectangle rcSegment = rcLine;
const bool lastSubLine = subLine == (ll->lines - 1);
@@ -2523,7 +2517,7 @@ void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, Lin
    if (virtualSpace) {
    	rcSegment.left = xEol + xStart;
    	rcSegment.right = xEol + xStart + virtualSpace;
-		surface->FillRectangle(rcSegment, overrideBackground ? background : vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back);
+		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++) {
@@ -2564,11 +2558,11 @@ void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, Lin
    		const char *ctrlChar;
    		unsigned char chEOL = ll->chars[eolPos];
    		int styleMain = ll->styles[eolPos];
-			ColourDesired textBack = TextBackground(vsDraw, overrideBackground, background, eolInSelection, false, styleMain, eolPos, ll);
+			ColourDesired textBack = TextBackground(vsDraw, background, eolInSelection, false, styleMain, eolPos, ll);
    		if (UTF8IsAscii(chEOL)) {
    			ctrlChar = ControlCharacterString(chEOL);
    		} else {
-				Representation *repr = reprs.RepresentationFromCharacter(ll->chars + eolPos, ll->numCharsInLine - eolPos);
+				const Representation *repr = reprs.RepresentationFromCharacter(ll->chars + eolPos, ll->numCharsInLine - eolPos);
    			if (repr) {
    				ctrlChar = repr->stringRep.c_str();
    				eolPos = ll->numCharsInLine;
@@ -2604,12 +2598,12 @@ void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, Lin
    if (eolInSelection && vsDraw.selColours.back.isSet && (line < pdoc->LinesTotal() - 1) && (alpha == SC_ALPHA_NOALPHA)) {
    	surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1));
    } else {
-		if (overrideBackground) {
+		if (background.isSet) {
    		surface->FillRectangle(rcSegment, background);
    	} else if (line < pdoc->LinesTotal() - 1) {
-			surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back);
-		} else if (vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].eolFilled) {
-			surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back);
+			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);
    	}
@@ -2627,10 +2621,10 @@ void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, Lin
    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 (overrideBackground) {
+		if (background.isSet) {
    		surface->FillRectangle(rcSegment, background);
-		} else if (vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].eolFilled) {
-			surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].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);
    	}
@@ -2639,6 +2633,14 @@ void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, Lin
    	}
    }
+	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;
@@ -2650,11 +2652,11 @@ void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, Lin
    		rcPlace.right = rcLine.right;
    		rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
    	}
-		DrawWrapMarker(surface, rcPlace, true, wrapColour);
+		DrawWrapMarker(surface, rcPlace, true, vsDraw.WrapColour());
    }
 }
-void Editor::DrawIndicator(int indicNum, int startPos, int endPos, Surface *surface, ViewStyle &vsDraw,
+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(
@@ -2665,45 +2667,13 @@ void Editor::DrawIndicator(int indicNum, int startPos, int endPos, Surface *surf
    vsDraw.indicators[indicNum].Draw(surface, rcIndic, rcLine);
 }
-void Editor::DrawIndicators(Surface *surface, ViewStyle &vsDraw, int line, int xStart,
+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;
-	if (!under) {
-		// Draw indicators
-		// foreach indicator...
-		for (int indicnum = 0, mask = 1 << pdoc->stylingBits; mask < 0x100; indicnum++) {
-			if (!(mask & ll->styleBitsSet)) {
-				mask <<= 1;
-				continue;
-			}
-			int startPos = -1;
-			// foreach style pos in line...
-			for (int indicPos = lineStart; indicPos <= lineEnd; indicPos++) {
-				// look for starts...
-				if (startPos < 0) {
-					// NOT in indicator run, looking for START
-					if (indicPos < lineEnd && (ll->indicators[indicPos] & mask))
-						startPos = indicPos;
-				}
-				// ... or ends
-				if (startPos >= 0) {
-					// IN indicator run, looking for END
-					if (indicPos >= lineEnd || !(ll->indicators[indicPos] & mask)) {
-						// AT end of indicator run, DRAW it!
-						DrawIndicator(indicnum, startPos, indicPos, surface, vsDraw, xStart, rcLine, ll, subLine);
-						// RESET control var
-						startPos = -1;
-					}
-				}
-			}
-			mask <<= 1;
-		}
-	}
-
    for (Decoration *deco = pdoc->decorations.root; deco; deco = deco->next) {
    	if (under == vsDraw.indicators[deco->indicator].under) {
    		int startPos = posLineStart + lineStart;
@@ -2725,9 +2695,9 @@ void Editor::DrawIndicators(Surface *surface, ViewStyle &vsDraw, int line, int x
    }
// Use indicators to highlight matching braces
-	if ((vs.braceHighlightIndicatorSet && (bracesMatchStyle == STYLE_BRACELIGHT)) ||
-		(vs.braceBadLightIndicatorSet && (bracesMatchStyle == STYLE_BRACEBAD))) {
-		int braceIndicator = (bracesMatchStyle == STYLE_BRACELIGHT) ? vs.braceHighlightIndicator : vs.braceBadLightIndicator;
+	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])) {
@@ -2746,7 +2716,7 @@ void Editor::DrawIndicators(Surface *surface, ViewStyle &vsDraw, int line, int x
    }
 }
-void Editor::DrawAnnotation(Surface *surface, ViewStyle &vsDraw, int line, int xStart,
+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;
@@ -2755,15 +2725,15 @@ void Editor::DrawAnnotation(Surface *surface, ViewStyle &vsDraw, int line, int x
    if (stAnnotation.text && ValidStyledText(vsDraw, vsDraw.annotationStyleOffset, stAnnotation)) {
    	surface->FillRectangle(rcSegment, vsDraw.styles[0].back);
    	rcSegment.left = static_cast<XYPOSITION>(xStart);
-		if (trackLineWidth || (vs.annotationVisible == ANNOTATION_BOXED)) {
+		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 (vs.annotationVisible == ANNOTATION_BOXED) {
+			if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
    			widthAnnotation += static_cast<int>(vsDraw.spaceWidth * 2); // Margins
    		}
    		if (widthAnnotation > lineWidthMaxSeen)
    			lineWidthMaxSeen = widthAnnotation;
-			if (vs.annotationVisible == ANNOTATION_BOXED) {
+			if (vsDraw.annotationVisible == ANNOTATION_BOXED) {
    			rcSegment.left = static_cast<XYPOSITION>(xStart + indent);
    			rcSegment.right = rcSegment.left + widthAnnotation;
    		}
@@ -2778,14 +2748,14 @@ void Editor::DrawAnnotation(Surface *surface, ViewStyle &vsDraw, int line, int x
    		lineInAnnotation++;
    	}
    	PRectangle rcText = rcSegment;
-		if (vs.annotationVisible == ANNOTATION_BOXED) {
+		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, static_cast<int>(rcText.top + vsDraw.maxAscent),
+		DrawStyledText(surface, vsDraw, vsDraw.annotationStyleOffset, rcText,
    		stAnnotation, start, lengthAnnotation);
-		if (vs.annotationVisible == ANNOTATION_BOXED) {
+		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));
@@ -2803,7 +2773,7 @@ void Editor::DrawAnnotation(Surface *surface, ViewStyle &vsDraw, int line, int x
    }
 }
-void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart,
+void Editor::DrawLine(Surface *surface, const ViewStyle &vsDraw, int line, int lineVisible, int xStart,
         PRectangle rcLine, LineLayout *ll, int subLine) {
if (subLine >= ll->lines) {
@@ -2816,49 +2786,13 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    // 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.
-	Font &ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
-
-	// See if something overrides the line background color:  Either if caret is on the line
-	// and background color is set for that, or if a marker is defined that forces its background
-	// color onto the line, or if a marker is defined but has no selection margin in which to
-	// display itself (as long as it's not an SC_MARK_EMPTY marker).  These are checked in order
-	// with the earlier taking precedence.  When multiple markers cause background override,
-	// the color for the highest numbered one is used.
-	bool overrideBackground = false;
-	ColourDesired background;
-	if ((caret.active || vsDraw.alwaysShowCaretLineBackground) && vsDraw.showCaretLineBackground && (vsDraw.caretLineAlpha == SC_ALPHA_NOALPHA) && ll->containsCaret) {
-		overrideBackground = true;
-		background = vsDraw.caretLineBackground;
-	}
-	if (!overrideBackground) {
-		int marks = pdoc->GetMark(line);
-		for (int markBit = 0; (markBit < 32) && marks; markBit++) {
-			if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND) &&
-			        (vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
-				background = vsDraw.markers[markBit].back;
-				overrideBackground = true;
-			}
-			marks >>= 1;
-		}
-	}
-	if (!overrideBackground) {
-		if (vsDraw.maskInLine) {
-			int marksMasked = pdoc->GetMark(line) & vsDraw.maskInLine;
-			if (marksMasked) {
-				for (int markBit = 0; (markBit < 32) && marksMasked; markBit++) {
-					if ((marksMasked & 1) && (vsDraw.markers[markBit].markType != SC_MARK_EMPTY) &&
-					        (vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
-						overrideBackground = true;
-						background = vsDraw.markers[markBit].back;
-					}
-					marksMasked >>= 1;
-				}
-			}
-		}
-	}
+	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) &&
-	        (!overrideBackground) && (vsDraw.whitespaceColours.back.isSet);
+	        (!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;
@@ -2878,16 +2812,6 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    	}
    }
-	const ColourDesired wrapColour = vsDraw.WrapColour();
-
-	bool drawWrapMarkEnd = false;
-
-	if (vsDraw.wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
-		if (subLine + 1 < ll->lines) {
-			drawWrapMarkEnd = ll->LineStart(subLine + 1) != 0;
-		}
-	}
-
    if (ll->wrapIndent != 0) {
bool continuedWrapLine = false;
@@ -2903,7 +2827,7 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    		rcPlace.right = rcPlace.left + ll->wrapIndent;
// default bgnd here..
-			surface->FillRectangle(rcSegment, overrideBackground ? background :
+			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
@@ -2918,7 +2842,7 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    			else
    				rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
-				DrawWrapMarker(surface, rcPlace, false, wrapColour);
+				DrawWrapMarker(surface, rcPlace, false, vsDraw.WrapColour());
    		}
xStart += static_cast<int>(ll->wrapIndent);
@@ -2931,10 +2855,8 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    // Does not take margin into account but not significant
    const int xStartVisible = static_cast<int>(subLineStart) - xStart;
-	ll->psel = &sel;
-
    if (twoPhaseDraw) {
-		BreakFinder bfBack(ll, lineStart, lineEnd, posLineStart, xStartVisible, selBackDrawn, pdoc, &reprs);
+		BreakFinder bfBack(ll, &sel, lineStart, lineEnd, posLineStart, xStartVisible, selBackDrawn, pdoc, &reprs);
// Background drawing loop
    	while (bfBack.More()) {
@@ -2955,8 +2877,8 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    				rcSegment.right = rcLine.right;
const int inSelection = hideSelection ? 0 : sel.CharacterInSelection(iDoc);
-				const bool inHotspot = (ll->hsStart != -1) && (iDoc >= ll->hsStart) && (iDoc < ll->hsEnd);
-				ColourDesired textBack = TextBackground(vsDraw, overrideBackground, background, inSelection,
+				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') {
@@ -2997,8 +2919,7 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    	}
DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd,
-		        xStart, subLine, subLineStart, overrideBackground, background,
-		        drawWrapMarkEnd, wrapColour);
+		        xStart, subLine, subLineStart, background);
    }
DrawIndicators(surface, vsDraw, line, xStart, rcLine, ll, subLine, lineEnd, true);
@@ -3027,7 +2948,7 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
inIndentation = subLine == 0;	// Do not handle indentation except on first subline.
    // Foreground drawing loop
-	BreakFinder bfFore(ll, lineStart, lineEnd, posLineStart, xStartVisible,
+	BreakFinder bfFore(ll, &sel, lineStart, lineEnd, posLineStart, xStartVisible,
    	((!twoPhaseDraw && selBackDrawn) || vsDraw.selColours.fore.isSet), pdoc, &reprs);
while (bfFore.More()) {
@@ -3043,9 +2964,10 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    	if (rcSegment.Intersects(rcLine)) {
    		int styleMain = ll->styles[i];
    		ColourDesired textFore = vsDraw.styles[styleMain].fore;
-			Font &textFont = vsDraw.styles[styleMain].font;
+			FontAlias textFont = vsDraw.styles[styleMain].font;
    		//hotspot foreground
-			if (ll->hsStart != -1 && iDoc >= ll->hsStart && iDoc < hsEnd) {
+			const bool inHotspot = (ll->hotspot.Valid()) && ll->hotspot.ContainsCharacter(iDoc);
+			if (inHotspot) {
    			if (vsDraw.hotspotColours.fore.isSet)
    				textFore = vsDraw.hotspotColours.fore;
    		}
@@ -3053,8 +2975,7 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    		if (inSelection && (vsDraw.selColours.fore.isSet)) {
    			textFore = (inSelection == 1) ? vsDraw.selColours.fore : vsDraw.selAdditionalForeground;
    		}
-			const bool inHotspot = (ll->hsStart != -1) && (iDoc >= ll->hsStart) && (iDoc < ll->hsEnd);
-			ColourDesired textBack = TextBackground(vsDraw, overrideBackground, background, inSelection, inHotspot, styleMain, i, ll);
+			ColourDesired textBack = TextBackground(vsDraw, background, inSelection, inHotspot, styleMain, i, ll);
    		if (ts.representation) {
    			if (ll->chars[i] == '\t') {
    				// Tab display
@@ -3130,8 +3051,8 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    								}
    								PRectangle rcDot(xmid + xStart - static_cast<XYPOSITION>(subLineStart),
    									rcSegment.top + vsDraw.lineHeight / 2, 0.0f, 0.0f);
-									rcDot.right = rcDot.left + vs.whitespaceSize;
-									rcDot.bottom = rcDot.top + vs.whitespaceSize;
+									rcDot.right = rcDot.left + vsDraw.whitespaceSize;
+									rcDot.bottom = rcDot.top + vsDraw.whitespaceSize;
    								surface->FillRectangle(rcDot, textFore);
    							}
    						}
@@ -3152,7 +3073,7 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    				}
    			}
    		}
-			if (ll->hsStart != -1 && vsDraw.hotspotUnderline && iDoc >= ll->hsStart && iDoc < ll->hsEnd) {
+			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;
@@ -3225,8 +3146,7 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    // End of the drawing of the current line
    if (!twoPhaseDraw) {
    	DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd,
-		        xStart, subLine, subLineStart, overrideBackground, background,
-		        drawWrapMarkEnd, wrapColour);
+		        xStart, subLine, subLineStart, background);
    }
    if (!hideSelection && ((vsDraw.selAlpha != SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha != SC_ALPHA_NOALPHA))) {
    	// For each selection draw
@@ -3289,8 +3209,8 @@ void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVis
    }
 }
-void Editor::DrawBlockCaret(Surface *surface, ViewStyle &vsDraw, LineLayout *ll, int subLine,
-							int xStart, int offset, int posCaret, PRectangle rcCaret, ColourDesired caretColour) {
+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;
@@ -3348,7 +3268,8 @@ void Editor::DrawBlockCaret(Surface *surface, ViewStyle &vsDraw, LineLayout *ll,
    // This character is where the caret block is, we override the colours
    // (inversed) for drawing the caret here.
    int styleMain = ll->styles[offsetFirstChar];
-	surface->DrawTextClipped(rcCaret, vsDraw.styles[styleMain].font,
+	FontAlias fontText = vsDraw.styles[styleMain].font;
+	surface->DrawTextClipped(rcCaret, fontText,
            rcCaret.top + vsDraw.maxAscent, ll->chars + offsetFirstChar,
            numCharsToDraw, vsDraw.styles[styleMain].back,
            caretColour);
@@ -3422,7 +3343,7 @@ void Editor::RefreshPixMaps(Surface *surfaceWindow) {
    }
 }
-void Editor::DrawCarets(Surface *surface, ViewStyle &vsDraw, int lineDoc, int xStart,
+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();
@@ -3654,7 +3575,7 @@ void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
    				ll->containsCaret = false;
    			}
-				GetHotSpotRange(ll->hsStart, ll->hsEnd);
+				ll->hotspot = GetHotSpotRange();
PRectangle rcLine = rcTextArea;
    			rcLine.top = static_cast<XYPOSITION>(ypos);
@@ -6536,7 +6457,7 @@ void Editor::ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, b
 }
bool Editor::PositionIsHotspot(int position) const {
-	return vs.styles[pdoc->StyleAt(position) & pdoc->stylingBitsMask].hotspot;
+	return vs.styles[pdoc->StyleAt(position)].hotspot;
 }
bool Editor::PointIsHotspot(Point pt) {
@@ -6553,35 +6474,28 @@ void Editor::SetHotSpotRange(Point *pt) {
    	// If we don't limit this to word characters then the
    	// range can encompass more than the run range and then
    	// the underline will not be drawn properly.
-		int hsStart_ = pdoc->ExtendStyleRange(pos, -1, vs.hotspotSingleLine);
-		int hsEnd_ = pdoc->ExtendStyleRange(pos, 1, vs.hotspotSingleLine);
+		Range hsNew;
+		hsNew.start = pdoc->ExtendStyleRange(pos, -1, vs.hotspotSingleLine);
+		hsNew.end = pdoc->ExtendStyleRange(pos, 1, vs.hotspotSingleLine);
// Only invalidate the range if the hotspot range has changed...
-		if (hsStart_ != hsStart || hsEnd_ != hsEnd) {
-			if (hsStart != -1) {
-				InvalidateRange(hsStart, hsEnd);
+		if (!(hsNew == hotspot)) {
+			if (hotspot.Valid()) {
+				InvalidateRange(hotspot.start, hotspot.end);
    		}
-			hsStart = hsStart_;
-			hsEnd = hsEnd_;
-			InvalidateRange(hsStart, hsEnd);
+			hotspot = hsNew;
+			InvalidateRange(hotspot.start, hotspot.end);
    	}
    } else {
-		if (hsStart != -1) {
-			int hsStart_ = hsStart;
-			int hsEnd_ = hsEnd;
-			hsStart = -1;
-			hsEnd = -1;
-			InvalidateRange(hsStart_, hsEnd_);
-		} else {
-			hsStart = -1;
-			hsEnd = -1;
+		if (hotspot.Valid()) {
+			InvalidateRange(hotspot.start, hotspot.end);
    	}
+		hotspot = Range(invalidPosition);
    }
 }
-void Editor::GetHotSpotRange(int &hsStart_, int &hsEnd_) const {
-	hsStart_ = hsStart;
-	hsEnd_ = hsEnd;
+Range Editor::GetHotSpotRange() const {
+	return hotspot;
 }
void Editor::ButtonMoveWithModifiers(Point pt, int modifiers) {
@@ -6668,7 +6582,7 @@ void Editor::ButtonMoveWithModifiers(Point pt, int modifiers) {
    	}
    	EnsureCaretVisible(false, false, true);
-		if (hsStart != -1 && !PointIsHotspot(pt))
+		if (hotspot.Valid() && !PointIsHotspot(pt))
    		SetHotSpotRange(NULL);
if (hotSpotClickPos != INVALID_POSITION && PositionFromLocation(pt,true,true) != hotSpotClickPos) {
@@ -8647,12 +8561,11 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
    	InvalidateStyleRedraw();
    	break;
    case SCI_SETSTYLEBITS:
-		vs.EnsureStyle((1 << wParam) - 1);
-		pdoc->SetStylingBits(static_cast<int>(wParam));
+		vs.EnsureStyle(0xff);
    	break;
case SCI_GETSTYLEBITS:
-		return pdoc->stylingBits;
+		return 8;
case SCI_SETLINESTATE:
    	return pdoc->SetLineState(static_cast<int>(wParam), static_cast<int>(lParam));
@@ -9293,7 +9206,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
    	break;
case SCI_GETREPRESENTATION: {
-			Representation *repr = reprs.RepresentationFromCharacter(
+			const Representation *repr = reprs.RepresentationFromCharacter(
    			reinterpret_cast<const char *>(wParam), UTF8MaxBytes);
    		if (repr) {
    			return StringResult(lParam, repr->stringRep.c_str());
Modified: scintilla/src/Editor.h
30 lines changed, 14 insertions(+), 16 deletions(-)
===================================================================
@@ -309,8 +309,7 @@ class Editor : public DocWatcher {
    ContractionState cs;
// Hotspot support
-	int hsStart;
-	int hsEnd;
+	Range hotspot;
// Wrapping support
    int wrapWidth;
@@ -435,27 +434,26 @@ class Editor : public DocWatcher {
    int SubstituteMarkerIfEmpty(int markerCheck, int markerDefault) const;
    void PaintSelMargin(Surface *surface, PRectangle &rc);
    LineLayout *RetrieveLineLayout(int lineNumber);
-	void LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll,
+	void LayoutLine(int line, Surface *surface, const ViewStyle &vstyle, LineLayout *ll,
    	int width=LineLayout::wrapWidthInfinite);
-	ColourDesired SelectionBackground(ViewStyle &vsDraw, bool main) const;
-	ColourDesired TextBackground(ViewStyle &vsDraw, bool overrideBackground, ColourDesired background, int inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll) const;
+	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, ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
+	void DrawEOL(Surface *surface, const ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
    	int line, int lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,
-		bool overrideBackground, ColourDesired background,
-		bool drawWrapMark, ColourDesired wrapColour);
-	static void DrawIndicator(int indicNum, int startPos, int endPos, Surface *surface, ViewStyle &vsDraw,
+		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, ViewStyle &vsDraw, int line, int xStart,
+	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, ViewStyle &vsDraw, int line, int xStart,
+	void DrawAnnotation(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
         PRectangle rcLine, LineLayout *ll, int subLine);
-	void DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart,
+	void DrawLine(Surface *surface, const ViewStyle &vsDraw, int line, int lineVisible, int xStart,
    	PRectangle rcLine, LineLayout *ll, int subLine);
-	void DrawBlockCaret(Surface *surface, ViewStyle &vsDraw, LineLayout *ll, int subLine,
-		int xStart, int offset, int posCaret, PRectangle rcCaret, ColourDesired caretColour);
-	void DrawCarets(Surface *surface, ViewStyle &vsDraw, int line, int xStart,
+	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);
@@ -623,7 +621,7 @@ class Editor : public DocWatcher {
    bool PositionIsHotspot(int position) const;
    bool PointIsHotspot(Point pt);
    void SetHotSpotRange(Point *pt);
-	void GetHotSpotRange(int &hsStart, int &hsEnd) const;
+	Range GetHotSpotRange() const;
int CodePage() const;
    virtual bool ValidCodePage(int /* codePage */) const { return true; }
Modified: scintilla/src/ExternalLexer.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -8,8 +8,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <assert.h>
+#include <ctype.h>
#include <string>
Modified: scintilla/src/Indicator.cxx
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -11,8 +11,8 @@
 #include "Platform.h"
#include "Scintilla.h"
-#include "XPM.h"
 #include "Indicator.h"
+#include "XPM.h"
#ifdef SCI_NAMESPACE
 using namespace Scintilla;
@@ -23,7 +23,7 @@ static PRectangle PixelGridAlign(const PRectangle &rc) {
    return PRectangle::FromInts(int(rc.left + 0.5), int(rc.top), int(rc.right + 0.5), int(rc.bottom));
 }
-void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine) {
+void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine) const {
    surface->PenColour(fore);
    int ymid = static_cast<int>(rc.bottom + rc.top) / 2;
    if (style == INDIC_SQUIGGLE) {
Modified: scintilla/src/Indicator.h
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -23,7 +23,7 @@ class Indicator {
    int outlineAlpha;
    Indicator() : style(INDIC_PLAIN), under(false), fore(ColourDesired(0,0,0)), fillAlpha(30), outlineAlpha(50) {
    }
-	void Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine);
+	void Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine) const;
 };
#ifdef SCI_NAMESPACE
Modified: scintilla/src/LineMarker.cxx
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -71,7 +71,7 @@ static void DrawMinus(Surface *surface, int centreX, int centreY, int armSize, C
    surface->FillRectangle(rcH, fore);
 }
-void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharacter, typeOfFold tFold, int marginStyle) {
+void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharacter, typeOfFold tFold, int marginStyle) const {
    ColourDesired head = back;
    ColourDesired body = back;
    ColourDesired tail = back;
Modified: scintilla/src/LineMarker.h
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -66,7 +66,7 @@ class LineMarker {
    void SetXPM(const char *textForm);
    void SetXPM(const char *const *linesForm);
    void SetRGBAImage(Point sizeRGBAImage, float scale, const unsigned char *pixelsRGBAImage);
-	void Draw(Surface *surface, PRectangle &rc, Font &fontForCharacter, typeOfFold tFold, int marginStyle);
+	void Draw(Surface *surface, PRectangle &rc, Font &fontForCharacter, typeOfFold tFold, int marginStyle) const;
 };
#ifdef SCI_NAMESPACE
Modified: scintilla/src/PositionCache.cxx
41 lines changed, 18 insertions(+), 23 deletions(-)
===================================================================
@@ -17,6 +17,7 @@
#include "Platform.h"
+#include "ILexer.h"
 #include "Scintilla.h"
#include "SplitVector.h"
@@ -32,7 +33,6 @@
 #include "ViewStyle.h"
 #include "CharClassify.h"
 #include "Decoration.h"
-#include "ILexer.h"
 #include "CaseFolder.h"
 #include "Document.h"
 #include "UniConversion.h"
@@ -54,16 +54,12 @@ LineLayout::LineLayout(int maxLineLength_) :
    validity(llInvalid),
    xHighlightGuide(0),
    highlightColumn(0),
-	psel(NULL),
    containsCaret(false),
    edgeColumn(0),
    chars(0),
    styles(0),
-	styleBitsSet(0),
-	indicators(0),
    positions(0),
-	hsStart(0),
-	hsEnd(0),
+	hotspot(0,0),
    widthLine(wrapWidthInfinite),
    lines(1),
    wrapIndent(0) {
@@ -81,7 +77,6 @@ void LineLayout::Resize(int maxLineLength_) {
    	Free();
    	chars = new char[maxLineLength_ + 1];
    	styles = new unsigned char[maxLineLength_ + 1];
-		indicators = new char[maxLineLength_ + 1];
    	// Extra position allocated as sometimes the Windows
    	// GetTextExtentExPoint API writes an extra element.
    	positions = new XYPOSITION[maxLineLength_ + 1 + 1];
@@ -94,8 +89,6 @@ void LineLayout::Free() {
    chars = 0;
    delete []styles;
    styles = 0;
-	delete []indicators;
-	indicators = 0;
    delete []positions;
    positions = 0;
    delete []lineStarts;
@@ -153,7 +146,7 @@ void LineLayout::SetLineStart(int line, int start) {
    lineStarts[line] = start;
 }
-void LineLayout::SetBracesHighlight(Range rangeLine, Position braces[],
+void LineLayout::SetBracesHighlight(Range rangeLine, const Position braces[],
                                     char bracesMatchStyle, int xHighlight, bool ignoreStyle) {
    if (!ignoreStyle && rangeLine.ContainsCharacter(braces[0])) {
    	int braceOffset = braces[0] - rangeLine.start;
@@ -175,7 +168,7 @@ void LineLayout::SetBracesHighlight(Range rangeLine, Position braces[],
    }
 }
-void LineLayout::RestoreBracesHighlight(Range rangeLine, Position braces[], bool ignoreStyle) {
+void LineLayout::RestoreBracesHighlight(Range rangeLine, const Position braces[], bool ignoreStyle) {
    if (!ignoreStyle && rangeLine.ContainsCharacter(braces[0])) {
    	int braceOffset = braces[0] - rangeLine.start;
    	if (braceOffset < numCharsInLine) {
@@ -410,11 +403,11 @@ void SpecialRepresentations::ClearRepresentation(const char *charBytes) {
    }
 }
-Representation *SpecialRepresentations::RepresentationFromCharacter(const char *charBytes, size_t len) {
+const Representation *SpecialRepresentations::RepresentationFromCharacter(const char *charBytes, size_t len) const {
    PLATFORM_ASSERT(len <= 4);
    if (!startByteHasReprs[static_cast<unsigned char>(charBytes[0])])
    	return 0;
-	MapRepresentation::iterator it = mapReprs.find(KeyFromString(charBytes, len));
+	MapRepresentation::const_iterator it = mapReprs.find(KeyFromString(charBytes, len));
    if (it != mapReprs.end()) {
    	return &(it->second);
    }
@@ -445,8 +438,8 @@ void BreakFinder::Insert(int val) {
    }
 }
-BreakFinder::BreakFinder(LineLayout *ll_, int lineStart_, int lineEnd_, int posLineStart_,
-	int xStart, bool breakForSelection, Document *pdoc_, SpecialRepresentations *preprs_) :
+BreakFinder::BreakFinder(const LineLayout *ll_, const Selection *psel, int lineStart_, int lineEnd_, int posLineStart_,
+	int xStart, bool breakForSelection, const Document *pdoc_, const SpecialRepresentations *preprs_) :
    ll(ll_),
    lineStart(lineStart_),
    lineEnd(lineEnd_),
@@ -472,8 +465,8 @@ BreakFinder::BreakFinder(LineLayout *ll_, int lineStart_, int lineEnd_, int posL
    	SelectionPosition posStart(posLineStart);
    	SelectionPosition posEnd(posLineStart + lineEnd);
    	SelectionSegment segmentLine(posStart, posEnd);
-		for (size_t r=0; r<ll->psel->Count(); r++) {
-			SelectionSegment portion = ll->psel->Range(r).Intersect(segmentLine);
+		for (size_t r=0; r<psel->Count(); r++) {
+			SelectionSegment portion = psel->Range(r).Intersect(segmentLine);
    		if (!(portion.start == portion.end)) {
    			if (portion.start.IsValid())
    				Insert(portion.start.Position() - posLineStart);
@@ -500,7 +493,7 @@ TextSegment BreakFinder::Next() {
    			charWidth = UTF8DrawBytes(reinterpret_cast<unsigned char *>(ll->chars) + nextBreak, lineEnd - nextBreak);
    		else if (encodingFamily == efDBCS)
    			charWidth = pdoc->IsDBCSLeadByte(ll->chars[nextBreak]) ? 2 : 1;
-			Representation *repr = preprs->RepresentationFromCharacter(ll->chars + nextBreak, charWidth);
+			const Representation *repr = preprs->RepresentationFromCharacter(ll->chars + nextBreak, charWidth);
    		if (((nextBreak > 0) && (ll->styles[nextBreak] != ll->styles[nextBreak - 1])) ||
    				repr ||
    				(nextBreak == saeNext)) {
@@ -565,7 +558,7 @@ void PositionCacheEntry::Set(unsigned int styleNumber_, const char *s_,
    	for (unsigned int i=0; i<len; i++) {
    		positions[i] = positions_[i];
    	}
-		memcpy(reinterpret_cast<char *>(positions + len), s_, len);
+		memcpy(reinterpret_cast<char *>(reinterpret_cast<void *>(positions + len)), s_, len);
    }
 }
@@ -584,7 +577,7 @@ void PositionCacheEntry::Clear() {
 bool PositionCacheEntry::Retrieve(unsigned int styleNumber_, const char *s_,
    unsigned int len_, XYPOSITION *positions_) const {
    if ((styleNumber == styleNumber_) && (len == len_) &&
-		(memcmp(reinterpret_cast<char *>(positions + len), s_, len)== 0)) {
+		(memcmp(reinterpret_cast<char *>(reinterpret_cast<void *>(positions + len)), s_, len)== 0)) {
    	for (unsigned int i=0; i<len; i++) {
    		positions_[i] = positions[i];
    	}
@@ -642,7 +635,7 @@ void PositionCache::SetSize(size_t size_) {
    pces.resize(size_);
 }
-void PositionCache::MeasureWidths(Surface *surface, ViewStyle &vstyle, unsigned int styleNumber,
+void PositionCache::MeasureWidths(Surface *surface, const ViewStyle &vstyle, unsigned int styleNumber,
    const char *s, unsigned int len, XYPOSITION *positions, Document *pdoc) {
allClear = false;
@@ -672,7 +665,8 @@ void PositionCache::MeasureWidths(Surface *surface, ViewStyle &vstyle, unsigned
    	XYPOSITION xStartSegment = 0;
    	while (startSegment < len) {
    		unsigned int lenSegment = pdoc->SafeSegment(s + startSegment, len - startSegment, BreakFinder::lengthEachSubdivision);
-			surface->MeasureWidths(vstyle.styles[styleNumber].font, s + startSegment, lenSegment, positions + startSegment);
+			FontAlias fontStyle = vstyle.styles[styleNumber].font;
+			surface->MeasureWidths(fontStyle, s + startSegment, lenSegment, positions + startSegment);
    		for (unsigned int inSeg = 0; inSeg < lenSegment; inSeg++) {
    			positions[startSegment + inSeg] += xStartSegment;
    		}
@@ -680,7 +674,8 @@ void PositionCache::MeasureWidths(Surface *surface, ViewStyle &vstyle, unsigned
    		startSegment += lenSegment;
    	}
    } else {
-		surface->MeasureWidths(vstyle.styles[styleNumber].font, s, len, positions);
+		FontAlias fontStyle = vstyle.styles[styleNumber].font;
+		surface->MeasureWidths(fontStyle, s, len, positions);
    }
    if (probe < pces.size()) {
    	// Store into cache
Modified: scintilla/src/PositionCache.h
28 lines changed, 12 insertions(+), 16 deletions(-)
===================================================================
@@ -34,19 +34,15 @@ class LineLayout {
    enum validLevel { llInvalid, llCheckTextAndStyle, llPositions, llLines } validity;
    int xHighlightGuide;
    bool highlightColumn;
-	Selection *psel;
    bool containsCaret;
    int edgeColumn;
    char *chars;
    unsigned char *styles;
-	int styleBitsSet;
-	char *indicators;
    XYPOSITION *positions;
    char bracePreviousStyles[2];
// Hotspot support
-	int hsStart;
-	int hsEnd;
+	Range hotspot;
// Wrapped line support
    int widthLine;
@@ -63,9 +59,9 @@ class LineLayout {
    Range SubLineRange(int line) const;
    bool InLine(int offset, int line) const;
    void SetLineStart(int line, int start);
-	void SetBracesHighlight(Range rangeLine, Position braces[],
+	void SetBracesHighlight(Range rangeLine, const Position braces[],
    	char bracesMatchStyle, int xHighlight, bool ignoreStyle);
-	void RestoreBracesHighlight(Range rangeLine, Position braces[], bool ignoreStyle);
+	void RestoreBracesHighlight(Range rangeLine, const Position braces[], bool ignoreStyle);
    int FindBefore(XYPOSITION x, int lower, int upper) const;
    int FindPositionFromX(XYPOSITION x, Range range, bool charPosition) const;
    Point PointFromPosition(int posInLine, int lineHeight) const;
@@ -132,7 +128,7 @@ class SpecialRepresentations {
    SpecialRepresentations();
    void SetRepresentation(const char *charBytes, const char *value);
    void ClearRepresentation(const char *charBytes);
-	Representation *RepresentationFromCharacter(const char *charBytes, size_t len);
+	const Representation *RepresentationFromCharacter(const char *charBytes, size_t len) const;
    bool Contains(const char *charBytes, size_t len) const;
    void Clear();
 };
@@ -140,8 +136,8 @@ class SpecialRepresentations {
 struct TextSegment {
    int start;
    int length;
-	Representation *representation;
-	TextSegment(int start_=0, int length_=0, Representation *representation_=0) :
+	const Representation *representation;
+	TextSegment(int start_=0, int length_=0, const Representation *representation_=0) :
    	start(start_), length(length_), representation(representation_) {
    }
    int end() const {
@@ -151,7 +147,7 @@ struct TextSegment {
// Class to break a line of text into shorter runs at sensible places.
 class BreakFinder {
-	LineLayout *ll;
+	const LineLayout *ll;
    int lineStart;
    int lineEnd;
    int posLineStart;
@@ -160,9 +156,9 @@ class BreakFinder {
    unsigned int saeCurrentPos;
    int saeNext;
    int subBreak;
-	Document *pdoc;
+	const Document *pdoc;
    EncodingFamily encodingFamily;
-	SpecialRepresentations *preprs;
+	const SpecialRepresentations *preprs;
    void Insert(int val);
    // Private so BreakFinder objects can not be copied
    BreakFinder(const BreakFinder &);
@@ -172,8 +168,8 @@ class BreakFinder {
    enum { lengthStartSubdivision = 300 };
    // Try to make each subdivided run lengthEachSubdivision or shorter.
    enum { lengthEachSubdivision = 100 };
-	BreakFinder(LineLayout *ll_, int lineStart_, int lineEnd_, int posLineStart_,
-		int xStart, bool breakForSelection, Document *pdoc_, SpecialRepresentations *preprs_);
+	BreakFinder(const LineLayout *ll_, const Selection *psel, int lineStart_, int lineEnd_, int posLineStart_,
+		int xStart, bool breakForSelection, const Document *pdoc_, const SpecialRepresentations *preprs_);
    ~BreakFinder();
    TextSegment Next();
    bool More() const;
@@ -191,7 +187,7 @@ class PositionCache {
    void Clear();
    void SetSize(size_t size_);
    size_t GetSize() const { return pces.size(); }
-	void MeasureWidths(Surface *surface, ViewStyle &vstyle, unsigned int styleNumber,
+	void MeasureWidths(Surface *surface, const ViewStyle &vstyle, unsigned int styleNumber,
    	const char *s, unsigned int len, XYPOSITION *positions, Document *pdoc);
 };
Modified: scintilla/src/ScintillaBase.cxx
56 lines changed, 42 insertions(+), 14 deletions(-)
===================================================================
@@ -8,8 +8,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <assert.h>
+#include <ctype.h>
#include <string>
 #include <vector>
@@ -21,12 +21,17 @@
 #include "ILexer.h"
 #include "Scintilla.h"
-#include "PropSetSimple.h"
 #ifdef SCI_LEXER
 #include "SciLexer.h"
+#endif
+
+#include "PropSetSimple.h"
+
+#ifdef SCI_LEXER
 #include "LexerModule.h"
 #include "Catalogue.h"
 #endif
+
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
@@ -39,7 +44,6 @@
 #include "LineMarker.h"
 #include "Style.h"
 #include "ViewStyle.h"
-#include "AutoComplete.h"
 #include "CharClassify.h"
 #include "Decoration.h"
 #include "CaseFolder.h"
@@ -47,6 +51,7 @@
 #include "Selection.h"
 #include "PositionCache.h"
 #include "Editor.h"
+#include "AutoComplete.h"
 #include "ScintillaBase.h"
#ifdef SCI_NAMESPACE
@@ -57,6 +62,7 @@ ScintillaBase::ScintillaBase() {
    displayPopupMenu = true;
    listType = 0;
    maxListWidth = 0;
+	multiAutoCMode = SC_MULTIAUTOC_ONCE;
 }
ScintillaBase::~ScintillaBase() {
@@ -197,9 +203,30 @@ void ScintillaBase::AutoCompleteDoubleClick(void *p) {
void ScintillaBase::AutoCompleteInsert(Position startPos, int removeLen, const char *text, int textLen) {
    UndoGroup ug(pdoc);
-	pdoc->DeleteChars(startPos, removeLen);
-	const int lengthInserted = pdoc->InsertString(startPos, text, textLen);
-	SetEmptySelection(startPos + lengthInserted);
+	if (multiAutoCMode == SC_MULTIAUTOC_ONCE) {
+		pdoc->DeleteChars(startPos, removeLen);
+		const int lengthInserted = pdoc->InsertString(startPos, text, textLen);
+		SetEmptySelection(startPos + lengthInserted);
+	} else {
+		// SC_MULTIAUTOC_EACH
+		for (size_t r=0; r<sel.Count(); r++) {
+			if (!RangeContainsProtected(sel.Range(r).Start().Position(),
+				sel.Range(r).End().Position())) {
+				int positionInsert = sel.Range(r).Start().Position();
+				positionInsert = InsertSpace(positionInsert, sel.Range(r).caret.VirtualSpace());
+				if (positionInsert - removeLen >= 0) {
+					positionInsert -= removeLen;
+					pdoc->DeleteChars(positionInsert, removeLen);
+				}
+				const int lengthInserted = pdoc->InsertString(positionInsert, text, textLen);
+				if (lengthInserted > 0) {
+					sel.Range(r).caret.SetPosition(positionInsert + lengthInserted);
+					sel.Range(r).anchor.SetPosition(positionInsert + lengthInserted);
+				}
+				sel.Range(r).ClearVirtualSpace();
+			}
+		}
+	}
 }
void ScintillaBase::AutoCompleteStart(int lenEntered, const char *list) {
@@ -492,7 +519,6 @@ class LexState : public LexInterface {
    void SetLexerLanguage(const char *languageName);
    const char *DescribeWordListSets();
    void SetWordList(int n, const char *wl);
-	int GetStyleBitsNeeded() const;
    const char *GetName() const;
    void *PrivateCall(int operation, void *pointer);
    const char *PropertyNames();
@@ -594,10 +620,6 @@ void LexState::SetWordList(int n, const char *wl) {
    }
 }
-int LexState::GetStyleBitsNeeded() const {
-	return lexCurrent ? lexCurrent->GetStyleBitsNeeded() : 5;
-}
-
 const char *LexState::GetName() const {
    return lexCurrent ? lexCurrent->languageName : "";
 }
@@ -740,8 +762,7 @@ void ScintillaBase::NotifyStyleToNeeded(int endStyleNeeded) {
void ScintillaBase::NotifyLexerChanged(Document *, void *) {
 #ifdef SCI_LEXER
-	int bits = DocumentLexState()->GetStyleBitsNeeded();
-	vs.EnsureStyle((1 << bits) - 1);
+	vs.EnsureStyle(0xff);
 #endif
 }
@@ -819,6 +840,13 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
    case SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR:
    	return ac.ignoreCaseBehaviour;
+	case SCI_AUTOCSETMULTI:
+		multiAutoCMode = static_cast<int>(wParam);
+		break;
+
+	case SCI_AUTOCGETMULTI:
+		return multiAutoCMode;
+
    case SCI_AUTOCSETORDER:
    	ac.autoSort = static_cast<int>(wParam);
    	break;
@@ -982,7 +1010,7 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
    		DocumentLexState()->PrivateCall(wParam, reinterpret_cast<void *>(lParam)));
case SCI_GETSTYLEBITSNEEDED:
-		return DocumentLexState()->GetStyleBitsNeeded();
+		return 8;
case SCI_PROPERTYNAMES:
    	return StringResult(lParam, DocumentLexState()->PropertyNames());
Modified: scintilla/src/ScintillaBase.h
1 lines changed, 1 insertions(+), 0 deletions(-)
===================================================================
@@ -46,6 +46,7 @@ class ScintillaBase : public Editor {
int listType;			///< 0 is an autocomplete list
    int maxListWidth;		/// Maximum width of list, in average character widths
+	int multiAutoCMode; /// Mode for autocompleting when multiple selections are present
#ifdef SCI_LEXER
    LexState *DocumentLexState();
Modified: scintilla/src/Selection.cxx
8 lines changed, 8 insertions(+), 0 deletions(-)
===================================================================
@@ -226,10 +226,18 @@ SelectionRange &Selection::Range(size_t r) {
    return ranges[r];
 }
+const SelectionRange &Selection::Range(size_t r) const {
+	return ranges[r];
+}
+
 SelectionRange &Selection::RangeMain() {
    return ranges[mainRange];
 }
+const SelectionRange &Selection::RangeMain() const {
+	return ranges[mainRange];
+}
+
 SelectionPosition Selection::Start() const {
    if (IsRectangular()) {
    	return rangeRectangular.Start();
Modified: scintilla/src/Selection.h
2 lines changed, 2 insertions(+), 0 deletions(-)
===================================================================
@@ -156,7 +156,9 @@ class Selection {
    size_t Main() const;
    void SetMain(size_t r);
    SelectionRange &Range(size_t r);
+	const SelectionRange &Range(size_t r) const;
    SelectionRange &RangeMain();
+	const SelectionRange &RangeMain() const;
    SelectionPosition Start() const;
    bool MoveExtends() const;
    void SetMoveExtends(bool moveExtends_);
Modified: scintilla/src/Style.cxx
4 lines changed, 4 insertions(+), 0 deletions(-)
===================================================================
@@ -19,6 +19,10 @@ using namespace Scintilla;
 FontAlias::FontAlias() {
 }
+FontAlias::FontAlias(const FontAlias &other) : Font() {
+	SetID(other.fid);
+}
+
 FontAlias::~FontAlias() {
    SetID(0);
    // ~Font will not release the actual font resource since it is now 0
Modified: scintilla/src/Style.h
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -33,11 +33,11 @@ struct FontSpecification {
// Just like Font but only has a copy of the FontID so should not delete it
 class FontAlias : public Font {
-	// Private so FontAlias objects can not be copied
-	FontAlias(const FontAlias &);
+	// Private so FontAlias objects can not be assigned except for intiialization
    FontAlias &operator=(const FontAlias &);
 public:
    FontAlias();
+	FontAlias(const FontAlias &);
    virtual ~FontAlias();
    void MakeAlias(Font &fontOrigin);
    void ClearFont();
Modified: scintilla/src/ViewStyle.cxx
37 lines changed, 37 insertions(+), 0 deletions(-)
===================================================================
@@ -434,6 +434,43 @@ void ViewStyle::CalcLargestMarkerHeight() {
    }
 }
+// See if something overrides the line background color:  Either if caret is on the line
+// and background color is set for that, or if a marker is defined that forces its background
+// color onto the line, or if a marker is defined but has no selection margin in which to
+// display itself (as long as it's not an SC_MARK_EMPTY marker).  These are checked in order
+// with the earlier taking precedence.  When multiple markers cause background override,
+// the color for the highest numbered one is used.
+ColourOptional ViewStyle::Background(int marksOfLine, bool caretActive, bool lineContainsCaret) const {
+	ColourOptional background;
+	if ((caretActive || alwaysShowCaretLineBackground) && showCaretLineBackground && (caretLineAlpha == SC_ALPHA_NOALPHA) && lineContainsCaret) {
+		background = ColourOptional(caretLineBackground, true);
+	}
+	if (!background.isSet && marksOfLine) {
+		int marks = marksOfLine;
+		for (int markBit = 0; (markBit < 32) && marks; markBit++) {
+			if ((marks & 1) && (markers[markBit].markType == SC_MARK_BACKGROUND) &&
+				(markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
+				background = ColourOptional(markers[markBit].back, true);
+			}
+			marks >>= 1;
+		}
+	}
+	if (!background.isSet && maskInLine) {
+		int marksMasked = marksOfLine & maskInLine;
+		if (marksMasked) {
+			for (int markBit = 0; (markBit < 32) && marksMasked; markBit++) {
+				if ((marksMasked & 1) && (markers[markBit].markType != SC_MARK_EMPTY) &&
+					(markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
+					background = ColourOptional(markers[markBit].back, true);
+				}
+				marksMasked >>= 1;
+			}
+		}
+	}
+	return background;
+}
+
+
 ColourDesired ViewStyle::WrapColour() const {
    if (whitespaceColours.fore.isSet)
    	return whitespaceColours.fore;
Modified: scintilla/src/ViewStyle.h
3 lines changed, 2 insertions(+), 1 deletions(-)
===================================================================
@@ -157,7 +157,7 @@ class ViewStyle {
    ViewStyle();
    ViewStyle(const ViewStyle &source);
    ~ViewStyle();
-	void Init(size_t stylesSize_=64);
+	void Init(size_t stylesSize_=256);
    void Refresh(Surface &surface, int tabInChars);
    void ReleaseAllExtendedStyles();
    int AllocateExtendedStyles(int numberStyles);
@@ -169,6 +169,7 @@ class ViewStyle {
    int ExternalMarginWidth() const;
    bool ValidStyle(size_t styleIndex) const;
    void CalcLargestMarkerHeight();
+	ColourOptional Background(int marksOfLine, bool caretActive, bool lineContainsCaret) const;
    ColourDesired WrapColour() const;
    bool SetWrapState(int wrapState_);
    bool SetWrapVisualFlags(int wrapVisualFlags_);
Modified: scintilla/version.txt
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -1 +1 @@
-342
+344
--------------
This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

    