protected override void Colorize(ITextRunConstructionContext context)
		{
			// if SelectionForeground is null, keep the existing foreground color
			if (textArea.SelectionForeground == null)
				return;
			
			int lineStartOffset = context.VisualLine.FirstDocumentLine.Offset;
			int lineEndOffset = context.VisualLine.LastDocumentLine.Offset + context.VisualLine.LastDocumentLine.TotalLength;
			
			foreach (SelectionSegment segment in textArea.Selection.Segments) {
				int segmentStart = segment.StartOffset;
				int segmentEnd = segment.EndOffset;
				if (segmentEnd <= lineStartOffset)
					continue;
				if (segmentStart >= lineEndOffset)
					continue;
				int startColumn;
				if (segmentStart < lineStartOffset)
					startColumn = 0;
				else
					startColumn = context.VisualLine.ValidateVisualColumn(segment.StartOffset, segment.StartVisualColumn, textArea.Selection.EnableVirtualSpace);
				
				int endColumn;
				if (segmentEnd > lineEndOffset)
					endColumn = textArea.Selection.EnableVirtualSpace ? int.MaxValue : context.VisualLine.VisualLengthWithEndOfLineMarker;
				else
					endColumn = context.VisualLine.ValidateVisualColumn(segment.EndOffset, segment.EndVisualColumn, textArea.Selection.EnableVirtualSpace);
				
				ChangeVisualElements(
					startColumn, endColumn,
					element => {
						element.TextRunProperties.SetForegroundBrush(textArea.SelectionForeground);
					});
			}
		}

        protected override void Colorize(ITextRunConstructionContext context)
        {
            // if SelectionForeground is null, keep the existing foreground color
            if (textArea.SelectionForeground == null)
                return;

            int lineStartOffset = context.VisualLine.FirstDocumentLine.Offset;
            int lineEndOffset = context.VisualLine.LastDocumentLine.Offset + context.VisualLine.LastDocumentLine.TotalLength;

            foreach (ISegment segment in textArea.Selection.Segments) {
                int segmentStart = segment.Offset;
                int segmentEnd = segment.Offset + segment.Length;
                if (segmentEnd <= lineStartOffset)
                    continue;
                if (segmentStart >= lineEndOffset)
                    continue;
                int startColumn = context.VisualLine.GetVisualColumn(Math.Max(0, segmentStart - lineStartOffset));
                int endColumn = context.VisualLine.GetVisualColumn(segmentEnd - lineStartOffset);
                ChangeVisualElements(
                    startColumn, endColumn,
                    element => {
                        element.TextRunProperties.SetForegroundBrush(textArea.SelectionForeground);
                    });
            }
        }

        /// <inheritdoc/>
        public override TextRun CreateTextRun(int startVisualColumn, ITextRunConstructionContext context)
        {
            if (context == null)
                throw new ArgumentNullException("context");

            return new InlineObjectRun(1, this.TextRunProperties, this.Element);
        }

 public override TextRun CreateTextRun(int startVisualColumn, ITextRunConstructionContext context)
 {
     this.TextRunProperties.SetTextDecorations(TextDecorations.Underline);
     if (this._options.ErrorDecoration != null && !this._options.ErrorDecoration.Equals(String.Empty))
     {
         switch (this._options.ErrorDecoration)
         {
             case "Baseline":
                 this.TextRunProperties.SetTextDecorations(TextDecorations.Baseline);
                 break;
             case "OverLine":
                 this.TextRunProperties.SetTextDecorations(TextDecorations.OverLine);
                 break;
             case "Strikethrough":
                 this.TextRunProperties.SetTextDecorations(TextDecorations.Strikethrough);
                 break;
             case "Underline":
                 this.TextRunProperties.SetTextDecorations(TextDecorations.Underline);
                 break;
         }
         
     }
     this.TextRunProperties.SetBackgroundBrush(new SolidColorBrush(this._options.ErrorBackground));
     this.TextRunProperties.SetForegroundBrush(new SolidColorBrush(this._options.ErrorForeground));
     if (this._options.ErrorFontFace != null)
     {
         this.TextRunProperties.SetTypeface(new Typeface(this._options.ErrorFontFace, new FontStyle(), new FontWeight(), new FontStretch()));
     }
     return base.CreateTextRun(startVisualColumn, context);
 }

 /// <inheritdoc/>
 public override TextRun CreateTextRun(int startVisualColumn, ITextRunConstructionContext context)
 {
     this.TextRunProperties.SetForegroundBrush(context.TextView.LinkTextForegroundBrush);
     this.TextRunProperties.SetBackgroundBrush(context.TextView.LinkTextBackgroundBrush);
     this.TextRunProperties.SetTextDecorations(TextDecorations.Underline);
     return base.CreateTextRun(startVisualColumn, context);
 }

        /// <inheritdoc/>
        protected override void Colorize(ITextRunConstructionContext context)
        {
            if (context == null)
                throw new ArgumentNullException(nameof(context));
            CurrentContext = context;

            currentDocumentLine = context.VisualLine.FirstDocumentLine;
            firstLineStart = currentDocumentLineStartOffset = currentDocumentLine.Offset;
            currentDocumentLineEndOffset = currentDocumentLineStartOffset + currentDocumentLine.Length;

            if (context.VisualLine.FirstDocumentLine == context.VisualLine.LastDocumentLine)
            {
                ColorizeLine(currentDocumentLine);
            }
            else
            {
                ColorizeLine(currentDocumentLine);
                // ColorizeLine modifies the visual line elements, loop through a copy of the line elements
                foreach (VisualLineElement e in context.VisualLine.Elements.ToArray())
                {
                    int elementOffset = firstLineStart + e.RelativeTextOffset;
                    if (elementOffset >= currentDocumentLineEndOffset)
                    {
                        currentDocumentLine = context.Document.GetLineByOffset(elementOffset);
                        currentDocumentLineStartOffset = currentDocumentLine.Offset;
                        currentDocumentLineEndOffset = currentDocumentLineStartOffset + currentDocumentLine.Length;
                        ColorizeLine(currentDocumentLine);
                    }
                }
            }
            currentDocumentLine = null;
            CurrentContext = null;
        }

		/// <summary>
		/// Gets the color of the brush.
		/// </summary>
		/// <param name="context">The construction context. context can be null!</param>
		public virtual Color? GetColor(ITextRunConstructionContext context)
		{
			SolidColorBrush scb = GetBrush(context) as SolidColorBrush;
			if (scb != null)
				return scb.Color;
			else
				return null;
		}

        /// <inheritdoc/>
        public override TextRun CreateTextRun(int startVisualColumn, ITextRunConstructionContext context)
        {
            if (context == null)
                throw new ArgumentNullException("context");

            int relativeOffset = startVisualColumn - VisualColumn;
            string text = context.Document.GetText(context.VisualLine.FirstDocumentLine.Offset + RelativeTextOffset + relativeOffset, DocumentLength - relativeOffset);
            return new TextCharacters(text, 0, text.Length, this.TextRunProperties);
        }

		/// <inheritdoc/>
		public override TextRun CreateTextRun(int startVisualColumn, ITextRunConstructionContext context)
		{
			if (textLine == null) {
				var formatter = TextFormatterFactory.Create(context.TextView);
				textLine = PrepareText(formatter, this.text, this.TextRunProperties);
				this.text = null;
			}
			return new FormattedTextRun(this, this.TextRunProperties);
		}

        /// <inheritdoc/>
        public override TextSpan<CultureSpecificCharacterBufferRange> GetPrecedingText(int visualColumnLimit, ITextRunConstructionContext context)
        {
            if (context == null)
                throw new ArgumentNullException(nameof(context));

            int relativeOffset = visualColumnLimit - VisualColumn;
            StringSegment text = context.GetText(context.VisualLine.FirstDocumentLine.Offset + RelativeTextOffset, relativeOffset);
            CharacterBufferRange range = new CharacterBufferRange(text.Text, text.Offset, text.Count);
            return new TextSpan<CultureSpecificCharacterBufferRange>(range.Length, new CultureSpecificCharacterBufferRange(TextRunProperties.CultureInfo, range));
        }

		/// <inheritdoc/>
		public override void StartGeneration(ITextRunConstructionContext context)
		{
			base.StartGeneration(context);
			if (foldingManager != null) {
				if (!foldingManager.textViews.Contains(context.TextView))
					throw new ArgumentException("Invalid TextView");
				if (context.Document != foldingManager.document)
					throw new ArgumentException("Invalid document");
			}
		}

        private bool LineIsCode(ITextRunConstructionContext context, SortedList<int, object> content)
        {
            if (content.IsNull())
                return false;

            var codeLines = content.Where(x => !(x.Value is string)).Select(x => x.Key);
            var line = context.VisualLine.LastDocumentLine.LineNumber;
            if (codeLines.Contains(line))
                return true;
            
            return false;
        }

		/// <inheritdoc/>
		public override TextRun CreateTextRun(int startVisualColumn, ITextRunConstructionContext context)
		{
			if (context == null)
				throw new ArgumentNullException("context");
			
			// remove inline object if its already added, can happen e.g. when recreating textrun for word-wrapping
			// TODO: certainly the text view should handle this internally? external code might want to use InlineObjectRun,
			// but doesn't have access to textLayer.RemoveInlineObject
			context.TextView.textLayer.RemoveInlineObject(this.Element);
			
			return new InlineObjectRun(1, this.TextRunProperties, this.Element);
		}

		/// <summary>
		/// <see cref="IVisualLineTransformer.Transform"/> implementation.
		/// Sets <see cref="CurrentElements"/> and calls <see cref="Colorize"/>.
		/// </summary>
		public void Transform(ITextRunConstructionContext context, IList<VisualLineElement> elements)
		{
			if (elements == null)
				throw new ArgumentNullException("elements");
			if (this.CurrentElements != null)
				throw new InvalidOperationException("Recursive Transform() call");
			this.CurrentElements = elements;
			try {
				Colorize(context);
			} finally {
				this.CurrentElements = null;
			}
		}

 public void Transform(ITextRunConstructionContext context, IList<VisualLineElement> elements)
 {
     foreach (VisualLineElement element in elements)
     {
         //if (element is EscapeSequenceElement)
         //{
         //    currentEscapeSequence = (EscapeSequenceElement)element;
         //}
         //else if (currentEscapeSequence != null)
         //{
         //    element.TextRunProperties.SetForegroundBrush(currentEscapeSequence.ForegroundBrush);
         //}
     }
 }

		internal void ConstructVisualElements(ITextRunConstructionContext context, VisualLineElementGenerator[] generators)
		{
			foreach (VisualLineElementGenerator g in generators) {
				g.StartGeneration(context);
			}
			elements = new List<VisualLineElement>();
			PerformVisualElementConstruction(generators);
			foreach (VisualLineElementGenerator g in generators) {
				g.FinishGeneration();
			}
			
			this.Elements = elements.AsReadOnly();
			CalculateOffsets(context.GlobalTextRunProperties);
		}

		public TextLine GetTextForNonPrintableCharacter(string text, ITextRunConstructionContext context)
		{
			if (nonPrintableCharacterTexts == null)
				nonPrintableCharacterTexts = new Dictionary<string, TextLine>();
			TextLine textLine;
			if (!nonPrintableCharacterTexts.TryGetValue(text, out textLine)) {
				var p = new VisualLineElementTextRunProperties(context.GlobalTextRunProperties);
				p.SetForegroundBrush(context.TextView.NonPrintableCharacterBrush);
				if (formatter == null)
					formatter = TextFormatterFactory.Create(context.TextView);
				textLine = FormattedTextElement.PrepareText(formatter, text, p);
				nonPrintableCharacterTexts[text] = textLine;
			}
			return textLine;
		}

		public TextLine GetSimpleLightGrayText(string text, ITextRunConstructionContext context)
		{
			if (simpleLightGrayTexts == null)
				simpleLightGrayTexts = new Dictionary<string, TextLine>();
			TextLine textLine;
			if (!simpleLightGrayTexts.TryGetValue(text, out textLine)) {
				var p = new VisualLineElementTextRunProperties(context.GlobalTextRunProperties);
				p.SetForegroundBrush(Brushes.LightGray);
				if (formatter == null)
					formatter = TextFormatterFactory.Create(context.TextView);
				textLine = FormattedTextElement.PrepareText(formatter, text, p);
				simpleLightGrayTexts[text] = textLine;
			}
			return textLine;
		}

		internal void ConstructVisualElements(ITextRunConstructionContext context, VisualLineElementGenerator[] generators)
		{
			foreach (VisualLineElementGenerator g in generators) {
				g.StartGeneration(context);
			}
			elements = new List<VisualLineElement>();
			PerformVisualElementConstruction(generators);
			foreach (VisualLineElementGenerator g in generators) {
				g.FinishGeneration();
			}
			
//			if (FirstDocumentLine.Length != 0)
//				elements.Add(new VisualLineText(FirstDocumentLine.Text, FirstDocumentLine.Length));
//			//elements.Add(new VisualNewLine(VisualNewLine.NewLineType.Lf));
			this.Elements = elements.AsReadOnly();
			CalculateOffsets(context.GlobalTextRunProperties);
		}

 /// <inheritdoc/>
 protected override void Colorize(ITextRunConstructionContext context)
 {
     this.lastColorizedLine = null;
     base.Colorize(context);
     if (this.lastColorizedLine != context.VisualLine.LastDocumentLine) {
         IHighlighter highlighter = context.TextView.Services.GetService(typeof(IHighlighter)) as IHighlighter;
         if (highlighter != null) {
             // In some cases, it is possible that we didn't highlight the last document line within the visual line
             // (e.g. when the line ends with a fold marker).
             // But even if we didn't highlight it, we'll have to update the highlighting state for it so that the
             // proof inside TextViewDocumentHighlighter.OnHighlightStateChanged holds.
             lineNumberBeingColorized = context.VisualLine.LastDocumentLine.LineNumber;
             highlighter.GetSpanStack(lineNumberBeingColorized);
             lineNumberBeingColorized = 0;
         }
     }
     this.lastColorizedLine = null;
 }