/// <summary> Add object to cache, optionally adding extra memory tracking </summary>
public void AddParsedObject(AXmlObject obj, int?maxTouchedLocation)
{
if (!(obj.Length > 0 || obj is AXmlDocument))
{
AXmlParser.Assert(false, string.Format(CultureInfo.InvariantCulture, "Invalid object {0}. It has zero length.", obj));
}
// // Expensive check
// if (obj is AXmlContainer) {
// int objStartOffset = obj.StartOffset;
// int objEndOffset = obj.EndOffset;
// foreach(AXmlObject child in ((AXmlContainer)obj).Children) {
// AXmlParser.Assert(objStartOffset <= child.StartOffset && child.EndOffset <= objEndOffset, "Wrong nesting");
// }
// }
segments.Add(obj);
AddSyntaxErrorsOf(obj);
obj.IsCached = true;
if (maxTouchedLocation != null)
{
// location is assumed to be read so the range ends at (location + 1)
// For example eg for "a_" it is (0-2)
TouchedRange range = new TouchedRange()
{
StartOffset = obj.StartOffset,
EndOffset = maxTouchedLocation.Value + 1,
TouchedByObject = obj
};
segments.Add(range);
AXmlParser.Log("{0} touched range ({1}-{2})", obj, range.StartOffset, range.EndOffset);
}
}
public TextMarker TryCreate(int startOffset, int length)
{
if (_markers == null)
{
throw new InvalidOperationException("Cannot create a marker when not attached to a document");
}
var textLength = _document.TextLength;
if (startOffset < 0 || startOffset > textLength)
{
return(null);
}
if (length < 0 || startOffset + length > textLength)
{
return(null);
}
var marker = new TextMarker(this, startOffset, length);
_markers.Add(marker);
return(marker);
}
private void ModifySelectedLines(Action <int, int> action)
{
var selection = TextArea.Selection;
var startLine = Document.GetLineByOffset(CaretOffset).LineNumber;
var endLine = startLine;
if (selection.Length > 0)
{
startLine = selection.StartPosition.Line;
endLine = selection.EndPosition.Line;
}
var selectionSegment = GetSelectionSegment();
var caretSegment = new TextSegment()
{
StartOffset = CaretOffset, EndOffset = CaretOffset
};
var anchors = new TextSegmentCollection <TextSegment>(Document);
anchors.Add(selectionSegment);
anchors.Add(caretSegment);
action(startLine, endLine);
SetSelection(selectionSegment);
CaretOffset = caretSegment.StartOffset;
Focus();
}
public void Add(TextMarker m)
{
if (markers.Contains(m))
{
return;
}
markers.Add(m);
}
public void WriteDefinition(string text, object definition, TextTokenType tokenType, bool isLocal)
{
WriteIndent();
int start = this.TextLength;
Append(tokenType, text);
int end = this.TextLength;
this.DefinitionLookup.AddDefinition(definition, this.TextLength);
references.Add(new ReferenceSegment {
StartOffset = start, EndOffset = end, Reference = definition, IsLocal = isLocal, IsLocalTarget = true
});
}
private void LanguageService_DiagnosticsUpdated(object sender, DiagnosticsUpdatedEventArgs e)
{
if (e.AssociatedSourceFile == SourceFile)
{
_diagnosticMarkersRenderer?.RemoveAll(marker => Equals(marker.Tag, e.Tag));
var collection = new TextSegmentCollection <Diagnostic>(Document);
foreach (var diagnostic in e.Diagnostics)
{
collection.Add(diagnostic);
}
if (e.Kind == DiagnosticsUpdatedKind.DiagnosticsCreated)
{
_diagnosticMarkersRenderer?.SetDiagnostics(e.Tag, collection);
if (e.DiagnosticHighlights != null)
{
_textColorizer.SetTransformations(e.Tag, e.DiagnosticHighlights);
}
}
_contextActionsRenderer.OnDiagnosticsUpdated();
}
_shell.UpdateDiagnostics(e);
TextArea.TextView.Redraw();
}
public void Create(int offset, int length, string message)
{
var marker = new ErrorTextMarker(offset, length, message, Colors.Red);
markers.Add(marker);
textEditor.TextArea.TextView.Redraw(marker);
}
public void SetTransformations(SyntaxHighlightDataList highlightData)
{
Dispatcher.UIThread.InvokeAsync(() =>
{
var transformations = new TextSegmentCollection <TextTransformation>(document);
foreach (var transform in highlightData)
{
if (transform.Type != HighlightType.None)
{
transformations.Add(new TextTransformation
{
Foreground = GetBrush(transform.Type),
StartOffset = transform.Start,
EndOffset = transform.Start + transform.Length
});
}
}
TextTransformations = transformations;
if (DataChanged != null)
{
DataChanged(this, new EventArgs());
}
});
}
private void ProcessTokens(int lineNumber, List <TMToken> tokens)
{
for (int i = 0; i < tokens.Count; i++)
{
var token = tokens[i];
var nextToken = (i + 1) < tokens.Count ? tokens[i + 1] : null;
var startIndex = token.StartIndex;
var endIndex = nextToken?.StartIndex ?? _model.GetLines().GetLineLength(lineNumber - 1);
if (startIndex >= endIndex || token.Scopes == null || token.Scopes.Count == 0)
{
continue;
}
var lineOffset = _document.GetLineByNumber(lineNumber).Offset;
foreach (var themeRule in _theme.Match(token.Scopes))
{
if (themeRule.foreground > 0 && _brushes.ContainsKey(themeRule.foreground))
{
_transformations.Add(new ForegroundTextTransformation(this, lineOffset + startIndex,
lineOffset + endIndex, themeRule.foreground));
break;
}
}
}
}
public TextMarker TryCreate(int startOffset, int length)
{
if (_markers == null)
{
throw new InvalidOperationException("Cannot create a marker when not attached to a document");
}
var textLength = _document.TextLength;
if (startOffset < 0 || startOffset > textLength)
{
return(null);
}
//throw new ArgumentOutOfRangeException(nameof(startOffset), startOffset, "Value must be between 0 and " + textLength);
if (length < 0 || startOffset + length > textLength)
{
return(null);
}
//throw new ArgumentOutOfRangeException(nameof(length), length, "length must not be negative and startOffset+length must not be after the end of the document");
var marker = new TextMarker(this, startOffset, length);
_markers.Add(marker);
return(marker);
}
private void GenerateDiagnostics(IEnumerable <ClangDiagnostic> clangDiagnostics, ClangTranslationUnit translationUnit, IProject project, TextSegmentCollection <Diagnostic> result)
{
foreach (var diagnostic in clangDiagnostics)
{
if (diagnostic.Location.IsFromMainFile)
{
var diag = new Diagnostic
{
Project = project,
StartOffset = diagnostic.Location.FileLocation.Offset,
Line = diagnostic.Location.FileLocation.Line,
Spelling = diagnostic.Spelling,
File = diagnostic.Location.FileLocation.File.FileName,
Level = (DiagnosticLevel)diagnostic.Severity
};
var cursor = translationUnit.GetCursor(diagnostic.Location);
var tokens = translationUnit.Tokenize(cursor.CursorExtent);
foreach (var token in tokens.Tokens)
{
if (token.Location == diagnostic.Location)
{
diag.EndOffset = diag.StartOffset + token.Spelling.Length;
}
}
result.Add(diag);
tokens.Dispose();
}
}
}
public ITextMarker Create(int startOffset, int length)
{
if (markers == null)
{
throw new InvalidOperationException("Cannot create a marker when not attached to a document");
}
var textLength = document.TextLength;
if (startOffset < 0 || startOffset > textLength)
{
throw new ArgumentOutOfRangeException("startOffset", startOffset,
"Value must be between 0 and " + textLength);
}
if (length < 0 || startOffset + length > textLength)
{
throw new ArgumentOutOfRangeException("length", length,
"length must not be negative and startOffset+length must not be after the end of the document");
}
var m = new TextMarker(this, startOffset, length);
markers.Add(m);
// no need to mark segment for redraw: the text marker is invisible until a property is set
return(m);
}
public ITextMarker Create(int startOffset, int length)
{
TextMarker m = new TextMarker(this, startOffset, length);
markers.Add(m);
// no need to mark segment for redraw: the text marker is invisible until a property is set
return(m);
}
public void AddMarker(int offset, int length, string message)
{
var m = new TextMarker(offset, length);
_markers.Add(m);
m.ToolTip = message;
Redraw(m);
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (Issues == null)
{
return;
}
var segments = new TextSegmentCollection <IssueMarker>();
foreach (var issue in Issues)
{
segments.Add(new IssueMarker(Theme, issue));
}
var visualLines = textView.VisualLines;
if (visualLines.Count == 0)
{
return;
}
int viewStart = visualLines.First().FirstDocumentLine.Offset;
int viewEnd = visualLines.Last().LastDocumentLine.EndOffset;
foreach (var marker in segments.FindOverlappingSegments(viewStart, viewEnd - viewStart))
{
var brush = marker.Brush;
var usedPen = new Pen(brush, 1);
usedPen.Freeze();
if (brush == null)
{
continue;
}
foreach (var r in BackgroundGeometryBuilder.GetRectsForSegment(textView, marker))
{
var startPoint = r.BottomLeft;
var endPoint = r.BottomRight;
double offset = 2.5;
int count = Math.Max((int)((endPoint.X - startPoint.X) / offset) + 1, 4);
var geometry = new StreamGeometry();
using (StreamGeometryContext ctx = geometry.Open())
{
ctx.BeginFigure(startPoint, false, false);
ctx.PolyLineTo(CreatePoints(startPoint, offset, count), true, false);
}
geometry.Freeze();
drawingContext.DrawGeometry(Brushes.Transparent, usedPen, geometry);
}
}
}
public void Create(int offset, int length, string message)
{
var m = new TextMarker(offset, length);
markers.Add(m);
m.MarkerColor = Colors.Red;
m.ToolTip = message;
Redraw(m);
}
public void Create(int offset, int length, Action <TextMarker> func)
{
var m = new TextMarker(offset, length);
func?.Invoke(m);
markers.Add(m);
Redraw(m);
}
/// <summary>
/// Creates a folding for the specified text section.
/// </summary>
public FoldingSection CreateFolding(int startOffset, int endOffset)
{
if (startOffset >= endOffset)
{
throw new ArgumentException("startOffset must be less than endOffset");
}
FoldingSection fs = new FoldingSection(this, startOffset, endOffset);
foldings.Add(fs);
textView.Redraw();
return(fs);
}
public void WriteReference(Decompiler.Disassembler.OpCodeInfo opCode)
{
WriteIndent();
int start = this.TextLength;
b.Append(opCode.Name);
int end = this.TextLength;
references.Add(new ReferenceSegment {
StartOffset = start, EndOffset = end, Reference = opCode
});
}
private void GenerateDiagnostics(IEnumerable <ClangDiagnostic> clangDiagnostics, ClangTranslationUnit translationUnit, IProject project, TextSegmentCollection <Diagnostic> result, TextMarkerService service)
{
foreach (var diagnostic in clangDiagnostics)
{
if (diagnostic.Location.IsFromMainFile)
{
var diag = new Diagnostic
{
Project = project,
StartOffset = diagnostic.Location.FileLocation.Offset,
Line = diagnostic.Location.FileLocation.Line,
Spelling = diagnostic.Spelling,
File = diagnostic.Location.FileLocation.File.FileName,
Level = (DiagnosticLevel)diagnostic.Severity
};
var cursor = translationUnit.GetCursor(diagnostic.Location);
var tokens = translationUnit.Tokenize(cursor.CursorExtent);
foreach (var token in tokens.Tokens)
{
if (token.Location == diagnostic.Location)
{
diag.EndOffset = diag.StartOffset + token.Spelling.Length;
}
}
result.Add(diag);
tokens.Dispose();
Color markerColor;
switch (diag.Level)
{
case DiagnosticLevel.Error:
case DiagnosticLevel.Fatal:
markerColor = Color.FromRgb(253, 45, 45);
break;
case DiagnosticLevel.Warning:
markerColor = Color.FromRgb(255, 207, 40);
break;
default:
markerColor = Color.FromRgb(0, 42, 74);
break;
}
service.Create(diag.StartOffset, diag.Length, diag.Spelling, markerColor);
}
}
}
public void WriteReference(string text, object reference)
{
WriteIndent();
int start = this.TextLength;
b.Append(text);
int end = this.TextLength;
references.Add(new ReferenceSegment {
StartOffset = start, EndOffset = end, Reference = reference
});
}
public void WriteReference(Decompiler.Disassembler.OpCodeInfo opCode, bool omitSuffix = false)
{
WriteIndent();
int start = this.TextLength;
if (omitSuffix)
{
int lastDot = opCode.Name.LastIndexOf('.');
if (lastDot > 0)
{
b.Append(opCode.Name.Remove(lastDot + 1));
}
}
else
{
b.Append(opCode.Name);
}
int end = this.TextLength - 1;
references.Add(new ReferenceSegment {
StartOffset = start, EndOffset = end, Reference = opCode
});
}
public void SetTransformations(SyntaxHighlightDataList highlightData)
{
Dispatcher.UIThread.InvokeAsync(() =>
{
var transformations = new TextSegmentCollection <TextTransformation>(document);
foreach (var transform in highlightData)
{
if (transform.Type != HighlightType.None)
{
if (transform is LineColumnSyntaxHighlightingData)
{
var trans = transform as LineColumnSyntaxHighlightingData;
transformations.Add(new TextTransformation
{
Foreground = GetBrush(transform.Type),
StartOffset = document.GetOffset(trans.StartLine, trans.StartColumn),
EndOffset = document.GetOffset(trans.EndLine, trans.EndColumn)
});
}
else
{
transformations.Add(new TextTransformation
{
Foreground = GetBrush(transform.Type),
StartOffset = transform.Start,
EndOffset = transform.Start + transform.Length
});
}
}
}
TextTransformations = transformations;
});
}
public ITextMarker Create(int startOffset, int length)
{
int textLength = codeEditor.Document.TextLength;
if (startOffset < 0 || startOffset > textLength)
{
throw new ArgumentOutOfRangeException("startOffset", startOffset, "Value must be between 0 and " + textLength);
}
if (length < 0 || startOffset + length > textLength)
{
throw new ArgumentOutOfRangeException("length", length, "length must not be negative and startOffset+length must not be after the end of the document");
}
TextMarker m = new TextMarker(this, startOffset, length);
markers.Add(m);
// no need to mark segment for redraw: the text marker is invisible until a property is set
return(m);
}
public void UnComment()
{
if (Model?.LanguageService != null && Model.Editor != null)
{
var selection = GetSelection();
if (selection != null)
{
var anchors = new TextSegmentCollection <TextSegment>(TextDocument);
anchors.Add(selection);
CaretIndex = Model.LanguageService.UnComment(TextDocument, selection, CaretIndex);
SetSelection(selection);
}
Model.Editor.Focus();
}
}
private void ProcessTokens(int lineNumber, List <TMToken> tokens)
{
for (int i = 0; i < tokens.Count; i++)
{
var token = tokens[i];
var nextToken = (i + 1) < tokens.Count ? tokens[i + 1] : null;
var startIndex = token.StartIndex;
var endIndex = nextToken?.StartIndex ?? _model.GetLines().GetLineLength(lineNumber - 1);
if (startIndex >= endIndex || token.Scopes == null || token.Scopes.Count == 0)
{
continue;
}
var lineOffset = _document.GetLineByNumber(lineNumber).Offset;
int foreground = 0;
int background = 0;
int fontStyle = 0;
foreach (var themeRule in _theme.Match(token.Scopes))
{
if (foreground == 0 && themeRule.foreground > 0)
{
foreground = themeRule.foreground;
}
if (background == 0 && themeRule.background > 0)
{
background = themeRule.background;
}
if (fontStyle == 0 && themeRule.fontStyle > 0)
{
fontStyle = themeRule.fontStyle;
}
}
_transformations.Add(new ForegroundTextTransformation(this, _exceptionHandler, lineOffset + startIndex,
lineOffset + endIndex, foreground, background, fontStyle));
}
}
public void SetTransformations(SyntaxHighlightDataList highlightData)
{
Dispatcher.UIThread.InvokeAsync(() =>
{
var transformations = new TextSegmentCollection<TextTransformation>(document);
foreach (var transform in highlightData)
{
if (transform.Type != HighlightType.None)
{
if (transform is LineColumnSyntaxHighlightingData)
{
var trans = transform as LineColumnSyntaxHighlightingData;
transformations.Add(new TextTransformation
{
Foreground = GetBrush(transform.Type),
StartOffset = document.GetOffset(trans.StartLine, trans.StartColumn),
EndOffset = document.GetOffset(trans.EndLine, trans.EndColumn)
});
}
else
{
transformations.Add(new TextTransformation
{
Foreground = GetBrush(transform.Type),
StartOffset = transform.Start,
EndOffset = transform.Start + transform.Length
});
}
}
}
TextTransformations = transformations;
if (DataChanged != null)
{
DataChanged(this, new EventArgs());
}
});
}
private void TransformSelectedLines(Action <IDocumentLine> transformLine)
{
var selection = GetSelectionAsSegment();
var lines = VisualLineGeometryBuilder.GetLinesForSegmentInDocument(TextDocument, selection);
if (lines.Count() > 0)
{
var anchors = new TextSegmentCollection <TextSegment>(TextDocument);
anchors.Add(selection);
TextDocument.BeginUpdate();
foreach (var line in lines)
{
transformLine(line);
}
TextDocument.EndUpdate();
SetSelection(selection);
}
}
private void TransformSelectedLines(Action<IDocumentLine> transformLine)
{
var selection = GetSelectionAsSegment();
var lines = VisualLineGeometryBuilder.GetLinesForSegmentInDocument(TextDocument, selection);
if (lines.Count() > 0)
{
var anchors = new TextSegmentCollection<TextSegment>(TextDocument);
anchors.Add(selection);
// TODO Add an achor to the caret index...
TextDocument.BeginUpdate();
foreach (var line in lines)
{
transformLine(line);
}
TextDocument.EndUpdate();
SetSelection(selection);
}
}
public void InsertionPossibleBeforeReadOnlySegment()
{
segments.Add(new TextSegment {
StartOffset = 10, EndOffset = 15
});
Assert.IsTrue(provider.CanInsert(5));
}
public void AddSegment(DiffSegment segment)
{
diffSegments.Add(segment);
}
internal IEnumerable <ISearchResult> Search(SearchQuery query, int offset, int length)
{
// Clear previous search results.
_searchResults.Clear();
// Determine the start offset.
int caretOffset = 0;
if (query.IsRelative)
{
var textEditor = this.GetLastActiveTextEditor();
if (textEditor != null)
{
caretOffset = textEditor.SelectionStart; // SelectionStart returns CaretOffsets if nothing is selected.
}
}
if (caretOffset < offset)
{
caretOffset = offset;
}
else if (caretOffset > offset + length)
{
caretOffset = offset + length;
}
// Perform search.
var searchResults = GetSearchResults(query, offset, length);
if (searchResults == null || searchResults.Count == 0)
{
return(Enumerable.Empty <ISearchResult>());
}
// Save search results in TextSegmentCollection. (The TextSegmentCollection will
// automatically update the offsets of the search results when the document changes.)
foreach (var searchResult in searchResults)
{
_searchResults.Add(searchResult);
}
// Order search results. (The search query determines the search direction.
// The search results should start at the caret position.)
if (query.SearchBackwards)
{
int numberOfSearchResults = searchResults.Count;
int movedSearchResults = 0;
for (int i = 0; i < numberOfSearchResults; i++)
{
var searchResult = searchResults[i];
if (searchResult.EndOffset < caretOffset)
{
searchResults.Add(searchResult);
movedSearchResults++;
}
else
{
break;
}
}
searchResults.RemoveRange(0, movedSearchResults);
searchResults.Reverse();
}
else
{
int numberOfSearchResults = searchResults.Count;
int movedSearchResults = 0;
for (int i = 0; i < numberOfSearchResults; i++)
{
var searchResult = searchResults[i];
if (searchResult.StartOffset < caretOffset)
{
searchResults.Add(searchResult);
movedSearchResults++;
}
else
{
break;
}
}
searchResults.RemoveRange(0, movedSearchResults);
}
return(searchResults);
}
