void InternalMoveTo(VirtualSnapshotPoint bufferPosition, PositionAffinity caretAffinity, bool captureHorizontalPosition, bool captureVerticalPosition, bool raiseEvent) { int requestedPosition = bufferPosition.Position; ITextSnapshotLine snapshotLine = TextEditor.TextSnapshot.GetLineFromPosition(requestedPosition); int line = snapshotLine.LineNumber + 1; int col; if (bufferPosition.IsInVirtualSpace) { col = bufferPosition.VirtualSpaces; if (!TextEditor.Options.TabsToSpaces) { col = col / TextEditor.Options.TabSize; } } else { col = requestedPosition - snapshotLine.Start; } col += 1; TextEditor.SetCaretTo(line, col, false, false); }
/// <summary> /// Instantiates a new Selection with a zero-width extent at the provided insertion point. /// </summary> /// <param name="insertionPoint">The location where a caret should be rendered and edits performed.</param> /// <param name="insertionPointAffinity"> /// The affinity of the insertion point. This is used in places like word-wrap where one buffer position can represent both the /// end of one line and the beginning of the next. /// </param> public Selection(SnapshotPoint insertionPoint, PositionAffinity insertionPointAffinity = PositionAffinity.Successor) : this(new VirtualSnapshotPoint(insertionPoint), new VirtualSnapshotPoint(insertionPoint), new VirtualSnapshotPoint(insertionPoint), insertionPointAffinity) { }
public SingleSelection(IMapEditToData map, Selection selection) { this.Anchor = new VirtualPoint(map, selection.AnchorPoint); this.Active = new VirtualPoint(map, selection.ActivePoint); this.Insertion = new VirtualPoint(map, selection.InsertionPoint); this.Affinity = selection.InsertionPointAffinity; }
private SnapshotPoint?MapUpToBufferGuts(SnapshotPoint currentPoint, PositionAffinity affinity, Predicate <ITextSnapshot> match) { if (match(currentPoint.Snapshot)) { return(currentPoint); } FrugalList <IProjectionBufferBase> targetBuffers = this.importingProjectionBufferMap[currentPoint.Snapshot.TextBuffer]; if (targetBuffers != null) // targetBuffers will be null if we fell off the top { foreach (IProjectionBufferBase projBuffer in targetBuffers) { SnapshotPoint?position = projBuffer.CurrentSnapshot.MapFromSourceSnapshot(currentPoint, affinity); if (position.HasValue) { position = MapUpToBufferGuts(position.Value, affinity, match); if (position.HasValue) { return(position); } } } } return(null); }
public CaretPosition MoveTo(VirtualSnapshotPoint bufferPosition, PositionAffinity caretAffinity) { _position = bufferPosition.Position.Position; return new CaretPosition(bufferPosition, new MappingPointMock(bufferPosition.Position.Snapshot.TextBuffer, bufferPosition.Position), PositionAffinity.Successor); }
public void MoveTo(VirtualSnapshotPoint point, bool select, PositionAffinity insertionPointAffinity) { this.CheckIsValid(); if (_selection.ActivePoint != point || _selection.InsertionPoint != point || (!select && _selection.AnchorPoint != point) || _selection.InsertionPointAffinity != insertionPointAffinity) { var newSelection = new Selection(point, select ? _selection.AnchorPoint : point, point, insertionPointAffinity); if (_broker.IsOldEditor) { _selection = newSelection; } else { // Using the ternary here to shortcut out if the snapshots are the same. There's a similar check in the // MapSelectionToCurrentSnapshot method to avoid doing unneeded work, but even spinning up the method call can be expensive. _selection = (newSelection.InsertionPoint.Position.Snapshot == this.CurrentSnapshot) ? newSelection : MapSelectionToCurrentSnapshot(newSelection); } _broker.QueueCaretUpdatedEvent(this); } }
public SnapshotPoint? GetPoint(ITextSnapshot targetSnapshot, PositionAffinity affinity) { try { return _trackingPoint.GetPoint(targetSnapshot); } catch (ArgumentException) { return null; } }
public SnapshotPoint? GetPoint(Predicate<ITextBuffer> match, PositionAffinity affinity) { if (match == null) throw new ArgumentNullException(nameof(match)); if (match(AnchorBuffer)) return GetPoint(AnchorBuffer.CurrentSnapshot, affinity); return null; }
public StubTextCaret(StubWpfTextView wpfTextView) { _wpfTextView = wpfTextView; this._textBuffer = wpfTextView.TextBuffer; this._insertionPoint = new VirtualSnapshotPoint(new SnapshotPoint(_textBuffer.CurrentSnapshot, 0)); this._caretAffinity = PositionAffinity.Successor; }
public SnapshotPoint?GetPoint(ITextSnapshot targetSnapshot, PositionAffinity affinity) { if (targetSnapshot == null) { throw new ArgumentNullException(nameof(targetSnapshot)); } return(snapshotPoint.TranslateTo(targetSnapshot, trackingMode)); }
public SnapshotPoint?GetPoint(ITextBuffer targetBuffer, PositionAffinity affinity) { if (targetBuffer == null) { throw new ArgumentNullException(nameof(targetBuffer)); } return(GetPoint(targetBuffer.CurrentSnapshot, affinity)); }
public SnapshotPoint?GetPoint(ITextSnapshot targetSnapshot, PositionAffinity affinity) { try { return(_trackingPoint.GetPoint(targetSnapshot)); } catch (ArgumentException) { return(null); } }
public CaretPosition MoveTo(VirtualSnapshotPoint bufferPosition, PositionAffinity caretAffinity) { _position = bufferPosition.Position.Position; return(new CaretPosition(bufferPosition, new MappingPointMock(bufferPosition.Position.Snapshot.TextBuffer, bufferPosition.Position), PositionAffinity.Successor)); }
public EditorPositionState(PositionAffinity caretAffinity, int caretVirtualSpaces, int caretPosition, double viewportLeft, int topLinePosition, double topLineVerticalDistance) { CaretAffinity = caretAffinity; CaretVirtualSpaces = caretVirtualSpaces; CaretPosition = caretPosition; ViewportLeft = viewportLeft; TopLinePosition = topLinePosition; TopLineVerticalDistance = topLineVerticalDistance; }
/// <summary> /// Initializes a new instance of a <see cref="CaretPosition"/>. /// </summary> /// <param name="bufferPosition">The index of the caret. This corresponds to a gap between two characters in the underlying <see cref="ITextBuffer"/>.</param> /// <param name="mappingPoint">A mapping point for the caret that can be used to find its position in any buffer.</param> /// <param name="caretAffinity">The <see cref="PositionAffinity"/> of the caret. The caret can have an affinity with /// the preceding edge of the gap or the following edge of the gap.</param> public CaretPosition(VirtualSnapshotPoint bufferPosition, IMappingPoint mappingPoint, PositionAffinity caretAffinity) { if (mappingPoint == null) { throw new ArgumentNullException("mappingPoint"); } _bufferPosition = bufferPosition; _mappingPoint = mappingPoint; _affinity = caretAffinity; }
public TextCaret(TextEditor textEditor, ITextView textView) { _textEditor = textEditor; _textView = textView; // Set up initial values _caretAffinity = PositionAffinity.Successor; _insertionPoint = new VirtualSnapshotPoint(new SnapshotPoint(_textView.TextSnapshot, 0)); textEditor.Carets[0].PositionChanged += ImmediateCaretPositionChanged; }
/// <param name="adornmentAffinity">Determines whether adornments based on data tags with zero-length spans /// will stick with preceding or succeeding text characters.</param> protected IntraTextAdornmentTagTransformer( IWpfTextView textView, ITagAggregator <TDataTag> dataTagger, IntraTextAdornmentTaggerDisplayMode mode, PositionAffinity adornmentAffinity = PositionAffinity.Successor) : base(textView) { this.AdornmentAffinity = adornmentAffinity; this.DataTagger = dataTagger; this.DataTagger.TagsChanged += HandleDataTagsChanged; Mode = mode; }
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 override SnapshotPoint MapToSourceSnapshot(int position, PositionAffinity affinity) { if (position < 0 || position > this.totalLength) { throw new ArgumentOutOfRangeException("position"); } if (affinity < PositionAffinity.Predecessor || affinity > PositionAffinity.Successor) { throw new ArgumentOutOfRangeException("affinity"); } return(this.content.MapToSourceSnapshot(this.sourceSnapshot, position, affinity)); }
public override SnapshotPoint?MapFromSourceSnapshot(SnapshotPoint point, PositionAffinity affinity) { if (point.Snapshot != this.sourceSnapshot) { throw new ArgumentException("The point does not belong to a source snapshot of the projection snapshot"); } if (affinity < PositionAffinity.Predecessor || affinity > PositionAffinity.Successor) { throw new ArgumentOutOfRangeException("affinity"); } return(this.content.MapFromSourceSnapshot(this, point.Position)); }
private SnapshotPoint?MapUpToBufferNoTrack(ITextBuffer targetBuffer, PositionAffinity affinity) { ITextSnapshot targetSnapshot = MappingHelper.FindCorrespondingSnapshot(_root, targetBuffer); if (targetSnapshot != null) { //Map _anchor up to targetSnapshot (they should be concurrent snapshots) return(MapUpToSnapshotNoTrack(targetSnapshot, affinity)); } return(null); }
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 SnapshotPoint?GetPoint(Predicate <ITextBuffer> match, PositionAffinity affinity) { if (match == null) { throw new ArgumentNullException(nameof(match)); } if (match(AnchorBuffer)) { return(GetPoint(AnchorBuffer.CurrentSnapshot, affinity)); } return(null); }
private void InternalMoveTo(VirtualSnapshotPoint bufferPosition, PositionAffinity caretAffinity, bool captureHorizontalPosition, bool captureVerticalPosition, bool raiseEvent) { if (bufferPosition.Position.Snapshot != this._wpfTextView.TextSnapshot) { throw new ArgumentException(nameof(bufferPosition)); } _insertionPoint = bufferPosition; _caretAffinity = caretAffinity; //ITextViewLine containingTextViewLine = this.GetContainingTextViewLine(bufferPosition.Position, caretAffinity); //VirtualSnapshotPoint bufferPosition1 = CaretElement.NormalizePosition(bufferPosition, containingTextViewLine); //if (bufferPosition1 != bufferPosition) // raiseEvent = true; //this.InternalMoveCaret(bufferPosition1, caretAffinity, containingTextViewLine, captureHorizontalPosition, captureVerticalPosition, raiseEvent); }
/// <summary> /// Instantiates a new Selection. /// </summary> /// <param name="insertionPoint">The location where a caret should be rendered and edits performed.</param> /// <param name="anchorPoint">The location of the fixed selection endpoint, meaning if a user were to hold shift and click, /// this point would remain where it is.</param> /// <param name="activePoint">location of the movable selection endpoint, meaning if a user were to hold shift and click, /// this point would be changed to the location of the click.</param> /// <param name="insertionPointAffinity"> /// The affinity of the insertion point. This is used in places like word-wrap where one buffer position can represent both the /// end of one line and the beginning of the next. /// </param> public Selection(VirtualSnapshotPoint insertionPoint, VirtualSnapshotPoint anchorPoint, VirtualSnapshotPoint activePoint, PositionAffinity insertionPointAffinity = PositionAffinity.Successor) { if (insertionPoint.Position.Snapshot != anchorPoint.Position.Snapshot || insertionPoint.Position.Snapshot != activePoint.Position.Snapshot) { throw new ArgumentException("All points must be on the same snapshot."); } InsertionPoint = insertionPoint; AnchorPoint = anchorPoint; ActivePoint = activePoint; InsertionPointAffinity = insertionPointAffinity; }
/// <summary> /// Constructs a new selection Element that is bound to the specified editor canvas /// </summary> /// <param name="wpfTextView"> /// The WPF Text View that hosts this caret /// </param> public SkiaTextCaret( SkiaTextView wpfTextView, SkiaTextSelection selection, ISmartIndentationService smartIndentationService, IEditorFormatMap editorFormatMap, //IClassificationFormatMap classificationFormatMap, GuardedOperations guardedOperations) { // Verify Debug.Assert(wpfTextView != null); _regularBrush = new SKPaint() { Color = SKColors.Red, Typeface = wpfTextView.Typeface, TextSize = 24, LcdRenderText = true, IsAntialias = true, SubpixelText = true }; _wpfTextView = wpfTextView; _selection = selection; _guardedOperations = guardedOperations; _smartIndentationService = smartIndentationService; // Set up initial values _caretAffinity = PositionAffinity.Successor; _insertionPoint = new VirtualSnapshotPoint(new SnapshotPoint(_wpfTextView.TextSnapshot, 0)); //// Set the regular caret brush //_editorFormatMap = editorFormatMap; //// store information related to classifications //_classificationFormatMap = classificationFormatMap; this.SubscribeEvents(); this.UpdateDefaultBrushes(); this.UpdateRegularCaretBrush(); this.UpdateOverwriteCaretBrush(); //Set the default values for the caret to be what they should be for a hidden caret that is not in overwrite mode. _caretBrush = _regularBrush; // Get the caret blink time from the system. If the caret is set not to flash, the return value // will be -1 _blinkInterval = CaretBlinkTimeManager.GetCaretBlinkTime(); if (_blinkInterval > 0) { _blinkTimer = new DispatcherTimer(new TimeSpan(0, 0, 0, 0, _blinkInterval), OnTimerElapsed); } this.UpdateBlinkTimer(); }
private void SelectRange(int selectionStart, int selectionEnd) { SnapshotPoint startPoint = new SnapshotPoint(TextView.AdvancedTextView.TextSnapshot, selectionStart); SnapshotPoint endPoint = new SnapshotPoint(TextView.AdvancedTextView.TextSnapshot, selectionEnd); TextSelection.Select(new VirtualSnapshotPoint(startPoint), new VirtualSnapshotPoint(endPoint)); ITextViewLine textViewLine = TextView.AdvancedTextView.GetTextViewLineContainingBufferPosition(endPoint); PositionAffinity affinity = (textViewLine.IsLastTextViewLineForSnapshotLine || (endPoint != textViewLine.End)) ? PositionAffinity.Successor : PositionAffinity.Predecessor; Caret.MoveTo(endPoint, affinity); TextView.AdvancedTextView.ViewScroller.EnsureSpanVisible(TextSelection.StreamSelectionSpan.SnapshotSpan, (selectionStart <= selectionEnd) ? EnsureSpanVisibleOptions.MinimumScroll : (EnsureSpanVisibleOptions.MinimumScroll | EnsureSpanVisibleOptions.ShowStart)); }
public SnapshotPoint?GetPoint(ITextSnapshot targetSnapshot, PositionAffinity affinity) { if (targetSnapshot == null) { throw new ArgumentNullException("targetSnapshot"); } SnapshotPoint?result = GetPoint(targetSnapshot.TextBuffer, affinity); if (result.HasValue && (result.Value.Snapshot != targetSnapshot)) { result = result.Value.TranslateTo(targetSnapshot, this.trackingMode); } return(result); }
private void InternalMoveCaretToTextViewLine(ITextViewLine textLine, double xCoordinate, bool allowPlacementInVirtualSpace, bool captureHorizontalPosition, bool captureVerticalPosition, bool raiseEvent) { VirtualSnapshotPoint bufferPosition = textLine.GetInsertionBufferPositionFromXCoordinate(xCoordinate); // if placement in virtual space is not allowed, then pin the point to the closest // real position if (!allowPlacementInVirtualSpace) { bufferPosition = new VirtualSnapshotPoint(bufferPosition.Position); } //determine caret affinity. In general this is successor affinity unless the caret is at the end of a line that is word wrapped (in which case it is predecessor affinity so //it will be placed at the end of the word wrapped line). PositionAffinity caretAffinity = ((!textLine.IsLastTextViewLineForSnapshotLine) && bufferPosition.Position == textLine.End) ? PositionAffinity.Predecessor : PositionAffinity.Successor; this.InternalMoveCaret(bufferPosition, caretAffinity, textLine, captureHorizontalPosition, captureVerticalPosition, raiseEvent); }
public CaretPosition MoveTo(VirtualSnapshotPoint bufferPosition, PositionAffinity caretAffinity, bool captureHorizontalPosition) { if (bufferPosition.Position.Snapshot != textView.TextSnapshot) { throw new ArgumentException(); } Affinity = caretAffinity; // Don't call FilterColumn() or pressing END on an empty line won't indent it to a virtual column //bufferPosition = FilterColumn(bufferPosition); SetExplicitPosition(bufferPosition); if (captureHorizontalPosition) { preferredXCoordinate = Left; } SavePreferredYCoordinate(); return(Position); }
public GeneralBeforeTextBufferChangeUndoPrimitive(ITextUndoHistory undoHistory, int oldCaretIndex, PositionAffinity oldCaretAffinity, int oldCaretVirtualSpaces, int oldSelectionAnchorIndex, int oldSelectionAnchorVirtualSpaces, int oldSelectionActiveIndex, int oldSelectionActiveVirtualSpaces, TextSelectionMode oldSelectionMode) : base(undoHistory, oldCaretIndex, oldCaretAffinity) { _oldCaretVirtualSpaces = oldCaretVirtualSpaces; _oldSelectionAnchorIndex = oldSelectionAnchorIndex; _oldSelectionAnchorVirtualSpaces = oldSelectionAnchorVirtualSpaces; _oldSelectionActiveIndex = oldSelectionActiveIndex; _oldSelectionActiveVirtualSpaces = oldSelectionActiveVirtualSpaces; _oldSelectionMode = oldSelectionMode; }
public GeneralAfterTextBufferChangeUndoPrimitive(ITextUndoHistory undoHistory, int newCaretIndex, PositionAffinity newCaretAffinity, int newCaretVirtualSpaces, int newSelectionAnchorIndex, int newSelectionAnchorVirtualSpaces, int newSelectionActiveIndex, int newSelectionActiveVirtualSpaces, TextSelectionMode newSelectionMode) : base(undoHistory, newCaretIndex, newCaretAffinity) { _newCaretVirtualSpaces = newCaretVirtualSpaces; _newSelectionAnchorIndex = newSelectionAnchorIndex; _newSelectionAnchorVirtualSpaces = newSelectionAnchorVirtualSpaces; _newSelectionActiveIndex = newSelectionActiveIndex; _newSelectionActiveVirtualSpaces = newSelectionActiveVirtualSpaces; _newSelectionMode = newSelectionMode; }
private void InternalMoveTo(VirtualSnapshotPoint bufferPosition, PositionAffinity caretAffinity, bool captureHorizontalPosition, bool captureVerticalPosition, bool raiseEvent) { int requestedPosition = bufferPosition.Position; ITextSnapshotLine snapshotLine = _textView.TextSnapshot.GetLineFromPosition(requestedPosition); int line = snapshotLine.LineNumber + 1; int col; if (bufferPosition.IsInVirtualSpace) { col = bufferPosition.VirtualSpaces; } else { col = requestedPosition - snapshotLine.Start + 1; } _textEditor.SetCaretLocation(line, col, false, false); }
public SnapshotPoint?GetPoint(ITextSnapshot targetSnapshot, PositionAffinity affinity) { if (targetSnapshot == null) { throw new ArgumentNullException(nameof(targetSnapshot)); } if (_unmappable) { return(null); } SnapshotPoint?mappedPoint = this.GetPoint(targetSnapshot.TextBuffer, affinity); if (mappedPoint.HasValue && (mappedPoint.Value.Snapshot != targetSnapshot)) { mappedPoint = mappedPoint.Value.TranslateTo(targetSnapshot, _trackingMode); } return(mappedPoint); }
public SnapshotPoint?GetPoint(Predicate <ITextBuffer> match, PositionAffinity affinity) { if (match == null) { throw new ArgumentNullException("match"); } ITextBuffer anchorBuffer = this.AnchorBuffer; SnapshotPoint currentPoint = this.anchorPoint.TranslateTo(anchorBuffer.CurrentSnapshot, this.trackingMode); if (match(anchorBuffer)) { return(currentPoint); } if (anchorBuffer == this.bufferGraph.TopBuffer) { // the only way to go is down return(this.bufferGraph.MapDownToFirstMatch(currentPoint, this.trackingMode, snapshot => (match(snapshot.TextBuffer)), affinity)); } else { // guess which way to go if (anchorBuffer is IProjectionBufferBase) { SnapshotPoint?tentative = this.bufferGraph.MapDownToFirstMatch(currentPoint, this.trackingMode, snapshot => (match(snapshot.TextBuffer)), affinity); if (tentative.HasValue) { return(tentative); } } // go the other way. if (match(this.bufferGraph.TopBuffer)) { return(this.bufferGraph.MapUpToBuffer(currentPoint, this.trackingMode, affinity, this.bufferGraph.TopBuffer)); } else { return(this.bufferGraph.MapUpToFirstMatch(currentPoint, this.trackingMode, snapshot => (match(snapshot.TextBuffer)), affinity)); } } }
public SnapshotPoint? GetPoint(ITextSnapshot targetSnapshot, PositionAffinity affinity) { if (targetSnapshot == null) throw new ArgumentNullException(nameof(targetSnapshot)); return snapshotPoint.TranslateTo(targetSnapshot, trackingMode); }
ITextViewLine GetLine(SnapshotPoint bufferPosition, PositionAffinity affinity) { bufferPosition = bufferPosition.TranslateTo(textView.TextSnapshot, GetPointTrackingMode(affinity)); var line = textView.GetTextViewLineContainingBufferPosition(bufferPosition); if (line == null) return null; if (affinity == PositionAffinity.Successor) return line; if (line.Start.Position == 0 || line.Start != bufferPosition) return line; if (bufferPosition.GetContainingLine().Start == bufferPosition) return line; return textView.GetTextViewLineContainingBufferPosition(bufferPosition - 1); }
public SnapshotPoint? MapUpToSnapshot(SnapshotPoint point, PointTrackingMode trackingMode, PositionAffinity affinity, ITextSnapshot targetSnapshot) { return point; }
public SnapshotPoint? MapDownToBuffer(SnapshotPoint position, PointTrackingMode trackingMode, ITextBuffer targetBuffer, PositionAffinity affinity) { throw new NotImplementedException(); }
public SnapshotPoint? MapUpToFirstMatch(SnapshotPoint point, PointTrackingMode trackingMode, Predicate<ITextSnapshot> match, PositionAffinity affinity) { throw new NotImplementedException(); }
public SnapshotPoint? GetPoint(ITextBuffer targetBuffer, PositionAffinity affinity) { return GetPoint(targetBuffer.CurrentSnapshot, affinity); }
public CaretPosition MoveTo(SnapshotPoint bufferPosition, PositionAffinity caretAffinity, bool captureHorizontalPosition) => MoveTo(new VirtualSnapshotPoint(bufferPosition), caretAffinity, captureHorizontalPosition);
public SnapshotPoint? GetPoint(Predicate<ITextBuffer> match, PositionAffinity affinity) { throw new NotImplementedException(); }
public bool IsPointInVisualBuffer(SnapshotPoint editBufferPoint, PositionAffinity affinity) => true;
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 CaretPosition MoveTo(VirtualSnapshotPoint bufferPosition, PositionAffinity caretAffinity) => MoveTo(bufferPosition, caretAffinity, true);
public SnapshotPoint? GetPoint(ITextBuffer targetBuffer, PositionAffinity affinity) { if (targetBuffer == null) throw new ArgumentNullException(nameof(targetBuffer)); return GetPoint(targetBuffer.CurrentSnapshot, affinity); }
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 CaretPosition MoveTo(SnapshotPoint bufferPosition, PositionAffinity caretAffinity) => MoveTo(new VirtualSnapshotPoint(bufferPosition), caretAffinity);
public SnapshotPoint? MapUpToSnapshot(SnapshotPoint point, PointTrackingMode trackingMode, PositionAffinity affinity, ITextSnapshot targetSnapshot) { throw new NotImplementedException(); }
public bool IsPointInVisualBuffer(SnapshotPoint editBufferPoint, PositionAffinity affinity) { throw new NotImplementedException(); }
public SnapshotPoint? MapDownToFirstMatch(SnapshotPoint position, PointTrackingMode trackingMode, Predicate<ITextSnapshot> match, PositionAffinity affinity) { return position; }
public CaretPosition MoveTo(SnapshotPoint bufferPosition, PositionAffinity caretAffinity, bool captureHorizontalPosition) { return MoveTo(bufferPosition, caretAffinity); }
public SnapshotPoint? MapUpToBuffer(SnapshotPoint point, PointTrackingMode trackingMode, PositionAffinity affinity, ITextBuffer targetBuffer) { return point; }
public SnapshotPoint? GetPoint(ITextBuffer targetBuffer, PositionAffinity affinity) { return point; }
public SnapshotPoint? GetPoint(ITextSnapshot targetSnapshot, PositionAffinity affinity) { return point; }
public SnapshotPoint? GetPoint(Predicate<ITextBuffer> match, PositionAffinity affinity) { return point; }
public CaretPosition MoveTo(VirtualSnapshotPoint bufferPosition, PositionAffinity caretAffinity, bool captureHorizontalPosition) { if (bufferPosition.Position.Snapshot != textView.TextSnapshot) throw new ArgumentException(); Affinity = caretAffinity; // Don't call FilterColumn() or pressing END on an empty line won't indent it to a virtual column //bufferPosition = FilterColumn(bufferPosition); SetExplicitPosition(bufferPosition); if (captureHorizontalPosition) preferredXCoordinate = Left; SavePreferredYCoordinate(); return Position; }
static PointTrackingMode GetPointTrackingMode(PositionAffinity affinity) => affinity == PositionAffinity.Predecessor ? PointTrackingMode.Negative : PointTrackingMode.Positive;