internal HighFidelityTrackingPoint(ITextVersion version, int position, PointTrackingMode trackingMode, TrackingFidelityMode fidelity)
: base(version, position, trackingMode)
{
if (fidelity != TrackingFidelityMode.UndoRedo && fidelity != TrackingFidelityMode.Backward)
{
throw new ArgumentOutOfRangeException(nameof(fidelity));
}
List <VersionNumberPosition> initialHistory = null;
if (fidelity == TrackingFidelityMode.UndoRedo && version.VersionNumber > 0)
{
// The system may perform undo operations that reach prior to the initial version; if any of
// those transitions are noninvertible, then redoing back to the initial version will give the
// wrong answer. Thus we save the state of the point for the initial version, unless the
// initial version happens to be version zero (in which case we could not undo past it).
initialHistory = new List <VersionNumberPosition>();
if (version.VersionNumber != version.ReiteratedVersionNumber)
{
Debug.Assert(version.ReiteratedVersionNumber < version.VersionNumber);
// If the current version and reiterated version differ, also remember the position
// using the reiterated version number, since when undoing back to this point it
// will be the key that is used.
initialHistory.Add(new VersionNumberPosition(version.ReiteratedVersionNumber, position));
}
initialHistory.Add(new VersionNumberPosition(version.VersionNumber, position));
}
this.cachedPosition = new VersionPositionHistory(version, position, initialHistory);
this.fidelity = fidelity;
}
public MockTrackingPoint(MockTextSnapshot snapshot, int position, PointTrackingMode mode = PointTrackingMode.Positive, TrackingFidelityMode fidelity = TrackingFidelityMode.Forward)
{
_position = position;
_snapshot = snapshot;
_mode = mode;
_fidelity = fidelity;
}
private SnapshotPoint?CheckedMapUpToBuffer(SnapshotPoint point, PointTrackingMode trackingMode, Predicate <ITextSnapshot> match, PositionAffinity affinity)
{
if (point.Snapshot == null)
{
throw new ArgumentNullException("point");
}
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException("trackingMode");
}
if (affinity < PositionAffinity.Predecessor || affinity > PositionAffinity.Successor)
{
throw new ArgumentOutOfRangeException("affinity");
}
if (!this.importingProjectionBufferMap.ContainsKey(point.Snapshot.TextBuffer))
{
return(null);
}
else
{
SnapshotPoint currentPoint = point.TranslateTo(point.Snapshot.TextBuffer.CurrentSnapshot, trackingMode);
return(MapUpToBufferGuts(currentPoint, affinity, match));
}
}
public CustomTrackingSpan WithEndTrackingMode(PointTrackingMode endTrackingMode)
{
var snapshot = TextBuffer.CurrentSnapshot;
var newEnd = snapshot.CreateTrackingPoint(end.GetPosition(snapshot), endTrackingMode);
return(new CustomTrackingSpan(start, newEnd));
}
public SnapshotPoint?MapDownToInsertionPoint(SnapshotPoint position, PointTrackingMode trackingMode, Predicate <ITextSnapshot> match)
{
var snapshot = position.Snapshot;
var buffer = snapshot.TextBuffer;
int pos = position.TranslateTo(snapshot, trackingMode);
while (!match(snapshot))
{
var projBuffer = buffer as IProjectionBufferBase;
if (projBuffer == null)
{
return(null);
}
var projSnapshot = projBuffer.CurrentSnapshot;
if (projSnapshot.SourceSnapshots.Count == 0)
{
return(null);
}
var pt = projSnapshot.MapToSourceSnapshot(pos);
pos = pt.Position;
snapshot = pt.Snapshot;
buffer = snapshot.TextBuffer;
}
return(new SnapshotPoint(snapshot, pos));
}
public TrackingPointMock(ITextBuffer textBuffer, int position, PointTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
_position = position;
TextBuffer = textBuffer;
TrackingFidelity = trackingFidelity;
TrackingMode = trackingMode;
}
public IMappingPoint CreateMappingPoint(SnapshotPoint point, PointTrackingMode trackingMode)
{
if (point.Snapshot is null)
{
throw new ArgumentException();
}
return(new MappingPoint(this, point, trackingMode));
}
public ITrackingPoint CreateTrackingPoint(int position, PointTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
if (trackingFidelity == TrackingFidelityMode.UndoRedo)
{
throw new NotSupportedException();
}
return(new TrackingPoint(this, position, trackingMode, trackingFidelity));
}
public TrackingPointMock(ITextBuffer textBuffer, int position, PointTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
_position = position;
TextBuffer = textBuffer;
TrackingFidelity = trackingFidelity;
TrackingMode = trackingMode;
}
public SnapshotPoint?MapUpToFirstMatch(SnapshotPoint point, PointTrackingMode trackingMode, Predicate <ITextSnapshot> match, PositionAffinity affinity)
{
if (match == null)
{
throw new ArgumentNullException("match");
}
return(CheckedMapUpToBuffer(point, trackingMode, match, affinity));
}
public VersionedPosition TranslateTo(ITextImageVersion other, PointTrackingMode mode)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
return(new VersionedPosition(other, other.TrackTo(this, mode)));
}
public MappingPoint(SnapshotPoint snapshotPoint, PointTrackingMode trackingMode)
{
if (snapshotPoint.Snapshot == null)
{
throw new ArgumentException();
}
this.snapshotPoint = snapshotPoint;
this.trackingMode = trackingMode;
}
public MappingPoint(IBufferGraph bufferGraph, SnapshotPoint snapshotPoint, PointTrackingMode trackingMode) {
if (bufferGraph == null)
throw new ArgumentNullException(nameof(bufferGraph));
if (snapshotPoint.Snapshot == null)
throw new ArgumentException();
BufferGraph = bufferGraph;
this.snapshotPoint = snapshotPoint;
this.trackingMode = trackingMode;
}
public SnapshotPoint?MapDownToFirstMatch(SnapshotPoint position, PointTrackingMode trackingMode, Predicate <ITextSnapshot> match, PositionAffinity affinity)
{
var buffer = _buffers.FirstOrDefault(b => match(b.CurrentSnapshot));
if (buffer != null)
{
return(position.TranslateTo(buffer.CurrentSnapshot, trackingMode));
}
return(null);
}
public MappingPoint(IBufferGraph bufferGraph, SnapshotPoint snapshotPoint, PointTrackingMode trackingMode)
{
if (snapshotPoint.Snapshot == null)
{
throw new ArgumentException();
}
BufferGraph = bufferGraph ?? throw new ArgumentNullException(nameof(bufferGraph));
this.snapshotPoint = snapshotPoint;
this.trackingMode = trackingMode;
}
public ITrackingPoint CreateTrackingPoint(int position, PointTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
if (trackingFidelity == TrackingFidelityMode.Forward)
{
return(new ForwardFidelityTrackingPoint(this, position, trackingMode));
}
else
{
return(new HighFidelityTrackingPoint(this, position, trackingMode, trackingFidelity));
}
}
public SnapshotPoint? MapDownToSnapshot(SnapshotPoint position, PointTrackingMode trackingMode, ITextSnapshot targetSnapshot, PositionAffinity affinity) {
if (position.Snapshot == null)
throw new ArgumentException();
if (targetSnapshot == null)
throw new ArgumentNullException(nameof(targetSnapshot));
var res = MapDownToBuffer(position, trackingMode, targetSnapshot.TextBuffer, affinity);
if (res == null)
return null;
return res.Value.TranslateTo(targetSnapshot, trackingMode);
}
public TrackingPoint(ITextVersion textVersion, int position, PointTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) {
if (textVersion == null)
throw new ArgumentNullException(nameof(textVersion));
if ((uint)position > (uint)textVersion.Length)
throw new ArgumentOutOfRangeException(nameof(position));
TextBuffer = textVersion.TextBuffer;
TrackingMode = trackingMode;
TrackingFidelity = trackingFidelity;
this.textVersion = textVersion;
this.position = position;
}
public SnapshotPoint? MapDownToBuffer(SnapshotPoint position, PointTrackingMode trackingMode, ITextBuffer targetBuffer, PositionAffinity affinity) {
if (position.Snapshot == null)
throw new ArgumentException();
if (targetBuffer == null)
throw new ArgumentNullException(nameof(targetBuffer));
if (position.Snapshot.TextBuffer != TopBuffer)
return null;
if (TopBuffer != targetBuffer)
return null;
return position.TranslateTo(targetBuffer.CurrentSnapshot, trackingMode);
}
public static int TrackPositionBackwardInTime(PointTrackingMode trackingMode,
int currentPosition,
ITextImageVersion currentVersion,
ITextImageVersion targetVersion)
{
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException("trackingMode");
}
if (currentVersion == null)
{
throw new ArgumentNullException("currentVersion");
}
if (targetVersion == null)
{
throw new ArgumentNullException("targetVersion");
}
if (targetVersion.Identifier != currentVersion.Identifier)
{
throw new ArgumentException("currentVersion and targetVersion must be from the same ITextImage");
}
if (targetVersion.VersionNumber > currentVersion.VersionNumber)
{
throw new ArgumentOutOfRangeException("targetVersion");
}
if (currentPosition < 0 || currentPosition > currentVersion.Length)
{
throw new ArgumentOutOfRangeException("currentPosition");
}
// track backwards in time
INormalizedTextChangeCollection[] textChangesStack = new INormalizedTextChangeCollection[currentVersion.VersionNumber - targetVersion.VersionNumber];
int top = 0;
{
ITextImageVersion roverVersion = targetVersion;
while (roverVersion != currentVersion)
{
textChangesStack[top++] = roverVersion.Changes;
roverVersion = roverVersion.Next;
}
}
while (top > 0)
{
currentPosition = TrackPositionBackwardInTime(trackingMode,
currentPosition,
textChangesStack[--top]);
}
return(currentPosition);
}
public SnapshotPoint?MapUpToBuffer(SnapshotPoint point, PointTrackingMode trackingMode, PositionAffinity affinity, ITextBuffer targetBuffer)
{
int position = 0;
for (int i = 0; i < _buffers.Count; i++)
{
if (_buffers[i] == targetBuffer)
{
return(new SnapshotPoint(point.Snapshot, position + point.Position));
}
position += _buffers[i].CurrentSnapshot.Length;
}
return(null);
}
public int TrackTo(VersionedPosition other, PointTrackingMode mode)
{
if (other.Version == null)
{
throw new ArgumentException(nameof(other));
}
if (other.Version.VersionNumber == VersionNumber)
{
return(other.Position);
}
if (other.Version.VersionNumber > VersionNumber)
{
return(Tracking.TrackPositionForwardInTime(mode, other.Position, this, other.Version));
}
return(Tracking.TrackPositionBackwardInTime(mode, other.Position, this, other.Version));
}
public TrackingPoint(ITextVersion textVersion, int position, PointTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
if (textVersion == null)
{
throw new ArgumentNullException(nameof(textVersion));
}
if ((uint)position > (uint)textVersion.Length)
{
throw new ArgumentOutOfRangeException(nameof(position));
}
TextBuffer = textVersion.TextBuffer;
TrackingMode = trackingMode;
TrackingFidelity = trackingFidelity;
this.textVersion = textVersion;
this.position = position;
}
public SnapshotPoint?MapUpToSnapshot(SnapshotPoint position, PointTrackingMode trackingMode, PositionAffinity affinity, ITextSnapshot targetSnapshot)
{
if (targetSnapshot == null)
{
throw new ArgumentNullException("targetSnapshot");
}
SnapshotPoint?result = MapUpToBuffer(position, trackingMode, affinity, targetSnapshot.TextBuffer);
if (result.HasValue && (result.Value.Snapshot != targetSnapshot))
{
result = result.Value.TranslateTo(targetSnapshot, trackingMode);
}
return(result);
}
protected TrackingPoint(ITextVersion version, int position, PointTrackingMode trackingMode)
{
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (position <0 | position> version.Length)
{
throw new ArgumentOutOfRangeException(nameof(position));
}
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException(nameof(trackingMode));
}
this.trackingMode = trackingMode;
}
public SnapshotPoint?MapDownToFirstMatch(SnapshotPoint position, PointTrackingMode trackingMode, Predicate <ITextSnapshot> match, PositionAffinity affinity)
{
if (position.Snapshot == null)
{
throw new ArgumentNullException("position");
}
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException("trackingMode");
}
if (match == null)
{
throw new ArgumentNullException("match");
}
if (affinity < PositionAffinity.Predecessor || affinity > PositionAffinity.Successor)
{
throw new ArgumentOutOfRangeException("affinity");
}
if (!this.importingProjectionBufferMap.ContainsKey(position.Snapshot.TextBuffer))
{
return(null);
}
ITextBuffer currentBuffer = position.Snapshot.TextBuffer;
ITextSnapshot currentSnapshot = currentBuffer.CurrentSnapshot;
int currentPosition = position.TranslateTo(currentSnapshot, trackingMode).Position;
while (!match(currentSnapshot))
{
IProjectionBufferBase projBuffer = currentBuffer as IProjectionBufferBase;
if (projBuffer == null)
{
return(null);
}
IProjectionSnapshot projSnap = projBuffer.CurrentSnapshot;
if (projSnap.SourceSnapshots.Count == 0)
{
return(null);
}
SnapshotPoint currentPoint = projSnap.MapToSourceSnapshot(currentPosition, affinity);
currentPosition = currentPoint.Position;
currentSnapshot = currentPoint.Snapshot;
currentBuffer = currentSnapshot.TextBuffer;
}
return(new SnapshotPoint(currentSnapshot, currentPosition));
}
public MappingPoint(SnapshotPoint anchorPoint, PointTrackingMode trackingMode, IBufferGraph bufferGraph)
{
if (anchorPoint.Snapshot == null)
{
throw new ArgumentNullException("anchorPoint");
}
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException("trackingMode");
}
if (bufferGraph == null)
{
throw new ArgumentNullException("bufferGraph");
}
this.anchorPoint = anchorPoint;
this.trackingMode = trackingMode;
this.bufferGraph = bufferGraph;
}
private MappingPointSnapshot(ITextSnapshot root, SnapshotPoint anchor, PointTrackingMode trackingMode, IBufferGraph graph)
{
//Anchor and root are expected to be from concurrent snapshots
ITextSnapshot correspondingAnchorSnapshot = MappingHelper.FindCorrespondingSnapshot(root, anchor.Snapshot.TextBuffer);
_root = root;
if (correspondingAnchorSnapshot != null)
{
_anchor = anchor.TranslateTo(correspondingAnchorSnapshot, trackingMode);
}
else
{
_anchor = anchor;
_unmappable = true;
}
_trackingMode = trackingMode;
_graph = graph;
}
public SnapshotPoint?MapUpToSnapshot(SnapshotPoint point, PointTrackingMode trackingMode, PositionAffinity affinity, ITextSnapshot targetSnapshot)
{
if (point.Snapshot is null)
{
throw new ArgumentException();
}
if (targetSnapshot is null)
{
throw new ArgumentNullException(nameof(targetSnapshot));
}
var res = MapUpToBuffer(point, trackingMode, affinity, targetSnapshot.TextBuffer);
if (res is null)
{
return(null);
}
return(res.Value.TranslateTo(targetSnapshot, trackingMode));
}
public SnapshotPoint?MapDownToBuffer(SnapshotPoint position, PointTrackingMode trackingMode, ITextBuffer targetBuffer, PositionAffinity affinity)
{
if (position.Snapshot == null)
{
throw new ArgumentNullException("position");
}
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException("trackingMode");
}
if (targetBuffer == null)
{
throw new ArgumentNullException("targetBuffer");
}
if (affinity < PositionAffinity.Predecessor || affinity > PositionAffinity.Successor)
{
throw new ArgumentOutOfRangeException("affinity");
}
ITextBuffer currentBuffer = position.Snapshot.TextBuffer;
ITextSnapshot currentSnapshot = currentBuffer.CurrentSnapshot;
int currentPosition = position.TranslateTo(currentSnapshot, trackingMode).Position;
while (currentBuffer != targetBuffer)
{
IProjectionBufferBase projBuffer = currentBuffer as IProjectionBufferBase;
if (projBuffer == null)
{
return(null);
}
IProjectionSnapshot projSnap = projBuffer.CurrentSnapshot;
if (projSnap.SourceSnapshots.Count == 0)
{
return(null);
}
SnapshotPoint currentPoint = projSnap.MapToSourceSnapshot(currentPosition, affinity);
currentPosition = currentPoint.Position;
currentSnapshot = currentPoint.Snapshot;
currentBuffer = currentSnapshot.TextBuffer;
}
return(new SnapshotPoint(currentSnapshot, currentPosition));
}
public static int TrackPositionForwardInTime(PointTrackingMode trackingMode,
int currentPosition,
ITextImageVersion currentVersion,
ITextImageVersion targetVersion)
{
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException("trackingMode");
}
if (currentVersion == null)
{
throw new ArgumentNullException("currentVersion");
}
if (targetVersion == null)
{
throw new ArgumentNullException("targetVersion");
}
if (targetVersion.Identifier != currentVersion.Identifier)
{
throw new ArgumentException("currentVersion and targetVersion must be from the same ITextImage");
}
if (targetVersion.VersionNumber < currentVersion.VersionNumber)
{
throw new ArgumentOutOfRangeException("targetVersion");
}
if (currentPosition < 0 || currentPosition > currentVersion.Length)
{
throw new ArgumentOutOfRangeException("currentPosition");
}
// track forward in time
while (currentVersion != targetVersion)
{
currentPosition = TrackPositionForwardInTime(trackingMode,
currentPosition,
currentVersion.Changes);
currentVersion = currentVersion.Next;
}
Debug.Assert(currentPosition >= 0 && currentPosition <= currentVersion.Length);
return(currentPosition);
}
internal TrackingPoint(ITextVersion version, int position, PointTrackingMode trackingMode)
{
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (position < 0 || position > version.Length)
{
throw new ArgumentOutOfRangeException(nameof(position));
}
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException(nameof(trackingMode));
}
_textVersion = version;
_position = position;
TextBuffer = version.TextBuffer;
TrackingMode = trackingMode;
}
public SnapshotPoint? MapDownToInsertionPoint(SnapshotPoint position, PointTrackingMode trackingMode, Predicate<ITextSnapshot> match) {
var snapshot = position.Snapshot;
var buffer = snapshot.TextBuffer;
int pos = position.TranslateTo(snapshot, trackingMode);
while (!match(snapshot)) {
var projBuffer = buffer as IProjectionBufferBase;
if (projBuffer == null) {
return null;
}
var projSnapshot = projBuffer.CurrentSnapshot;
if (projSnapshot.SourceSnapshots.Count == 0) {
return null;
}
var pt = projSnapshot.MapToSourceSnapshot(pos);
pos = pt.Position;
snapshot = pt.Snapshot;
buffer = snapshot.TextBuffer;
}
return new SnapshotPoint(snapshot, pos);
}
public SnapshotPoint?MapDownToInsertionPoint(SnapshotPoint position, PointTrackingMode trackingMode, Predicate <ITextSnapshot> match)
{
if (position.Snapshot is null)
{
throw new ArgumentException();
}
if (match is null)
{
throw new ArgumentNullException(nameof(match));
}
if (position.Snapshot.TextBuffer != TopBuffer)
{
return(null);
}
if (!match(TopBuffer.CurrentSnapshot))
{
return(null);
}
return(position.TranslateTo(TopBuffer.CurrentSnapshot, trackingMode));
}
public SnapshotPoint?MapUpToFirstMatch(SnapshotPoint point, PointTrackingMode trackingMode, Predicate <ITextSnapshot> match, PositionAffinity affinity)
{
if (point.Snapshot is null)
{
throw new ArgumentException();
}
if (match is null)
{
throw new ArgumentNullException(nameof(match));
}
if (point.Snapshot.TextBuffer != TopBuffer)
{
return(null);
}
if (!match(TopBuffer.CurrentSnapshot))
{
return(null);
}
return(point.TranslateTo(TopBuffer.CurrentSnapshot, trackingMode));
}
public SnapshotPoint?MapDownToBuffer(SnapshotPoint position, PointTrackingMode trackingMode, ITextBuffer targetBuffer, PositionAffinity affinity)
{
if (position.Snapshot is null)
{
throw new ArgumentException();
}
if (targetBuffer is null)
{
throw new ArgumentNullException(nameof(targetBuffer));
}
if (position.Snapshot.TextBuffer != TopBuffer)
{
return(null);
}
if (TopBuffer != targetBuffer)
{
return(null);
}
return(position.TranslateTo(targetBuffer.CurrentSnapshot, trackingMode));
}
public IMappingPoint CreateMappingPoint(SnapshotPoint point, PointTrackingMode trackingMode) {
throw new NotImplementedException();
}
public SnapshotPoint? MapUpToSnapshot(SnapshotPoint point, PointTrackingMode trackingMode, PositionAffinity affinity, ITextSnapshot targetSnapshot) {
throw new NotImplementedException();
}
public SnapshotPoint? MapUpToBuffer(SnapshotPoint point, PointTrackingMode trackingMode, PositionAffinity affinity, ITextBuffer targetBuffer) {
return point;
}
public SnapshotPoint? MapDownToInsertionPoint(SnapshotPoint position, PointTrackingMode trackingMode, Predicate<ITextSnapshot> match) {
throw new NotImplementedException();
}
public IMappingPoint CreateMappingPoint(SnapshotPoint point, PointTrackingMode trackingMode) {
if (point.Snapshot == null)
throw new ArgumentException();
return new MappingPoint(this, point, trackingMode);
}
public ITrackingPoint CreateTrackingPoint(int position, PointTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) => Version.CreateTrackingPoint(position, trackingMode, trackingFidelity);
public SnapshotPoint? MapDownToFirstMatch(SnapshotPoint position, PointTrackingMode trackingMode, Predicate<ITextSnapshot> match, PositionAffinity affinity) {
if (position.Snapshot == null)
throw new ArgumentException();
if (match == null)
throw new ArgumentNullException(nameof(match));
if (position.Snapshot.TextBuffer != TopBuffer)
return null;
if (!match(TopBuffer.CurrentSnapshot))
return null;
return position.TranslateTo(TopBuffer.CurrentSnapshot, trackingMode);
}
public ITrackingPoint CreateTrackingPoint(int position, PointTrackingMode trackingMode) {
return new MockTrackingPoint(this, position);
}
public ITrackingPoint CreateTrackingPoint(int position, PointTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
throw new NotImplementedException();
}
public ITrackingPoint CreateTrackingPoint(Int32 position, PointTrackingMode trackingMode)
{
throw new NotImplementedException();
}
public ITrackingPoint CreateTrackingPoint(int position, PointTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) {
return new MockTrackingPoint(this, position, trackingMode, trackingFidelity);
}
public SnapshotPoint? MapDownToSnapshot(SnapshotPoint position, PointTrackingMode trackingMode, ITextSnapshot targetSnapshot, PositionAffinity affinity) {
return position;
}
public SnapshotPoint? MapDownToBuffer(SnapshotPoint position, PointTrackingMode trackingMode, ITextBuffer targetBuffer, PositionAffinity affinity) {
throw new NotImplementedException();
}
public CustomTrackingSpan(ITextSnapshot snapshot, Span span, PointTrackingMode startTracking, PointTrackingMode endTracking) {
_start = snapshot.CreateTrackingPoint(span.Start, startTracking);
_end = snapshot.CreateTrackingPoint(span.End, endTracking);
}
public SnapshotPoint? MapDownToFirstMatch(SnapshotPoint position, PointTrackingMode trackingMode, Predicate<ITextSnapshot> match, PositionAffinity affinity) {
return position;
}
public SnapshotPoint GetNearestPointInVisualSnapshot(SnapshotPoint editBufferPoint, ITextSnapshot targetVisualSnapshot, PointTrackingMode trackingMode) => editBufferPoint.TranslateTo(targetVisualSnapshot, trackingMode);
public ITrackingPoint CreateTrackingPoint(int position, PointTrackingMode trackingMode) => Version.CreateTrackingPoint(position, trackingMode);
public ITrackingPoint CreateTrackingPoint(int position, PointTrackingMode trackingMode)
{
return TextBuffer.CurrentSnapshot.CreateTrackingPoint(position, trackingMode);
}
public CustomTrackingSpan(ITextSnapshot snapshot, Span span, PointTrackingMode startTrackingMode, PointTrackingMode endTrackingMode) {
_buffer = snapshot.TextBuffer;
_start = snapshot.CreateTrackingPoint(span.Start, startTrackingMode);
_end = snapshot.CreateTrackingPoint(span.End, endTrackingMode);
}
public SnapshotPoint? MapUpToBuffer(SnapshotPoint point, PointTrackingMode trackingMode, PositionAffinity affinity, ITextBuffer targetBuffer) {
int position = 0;
for (int i = 0; i < _buffers.Count; i++) {
if (_buffers[i] == targetBuffer) {
return new SnapshotPoint(point.Snapshot, position + point.Position);
}
position += _buffers[i].CurrentSnapshot.Length;
}
return null;
}
public SnapshotPoint GetNearestPointInVisualSnapshot(SnapshotPoint editBufferPoint, ITextSnapshot targetVisualSnapshot, PointTrackingMode trackingMode) {
throw new NotImplementedException();
}
public SnapshotPoint? MapUpToFirstMatch(SnapshotPoint point, PointTrackingMode trackingMode, Predicate<ITextSnapshot> match, PositionAffinity affinity) {
throw new NotImplementedException();
}
public SnapshotPoint? MapUpToSnapshot(SnapshotPoint point, PointTrackingMode trackingMode, PositionAffinity affinity, ITextSnapshot targetSnapshot) {
return point;
}
public ReplSpan WithEndTrackingMode(PointTrackingMode endTrackingMode)
{
return new ReplSpan(((CustomTrackingSpan)this.Span).WithEndTrackingMode(endTrackingMode), this.Kind);
}
