// Token: 0x06003C07 RID: 15367 RVA: 0x0011500C File Offset: 0x0011320C internal TextSegment(ITextPointer startPosition, ITextPointer endPosition, bool preserveLogicalDirection) { ValidationHelper.VerifyPositionPair(startPosition, endPosition); if (startPosition.CompareTo(endPosition) == 0) { this._start = startPosition.GetFrozenPointer(startPosition.LogicalDirection); this._end = this._start; return; } Invariant.Assert(startPosition.CompareTo(endPosition) < 0); this._start = startPosition.GetFrozenPointer(preserveLogicalDirection ? startPosition.LogicalDirection : LogicalDirection.Backward); this._end = endPosition.GetFrozenPointer(preserveLogicalDirection ? endPosition.LogicalDirection : LogicalDirection.Forward); }
// Token: 0x06005B55 RID: 23381 RVA: 0x0019C11A File Offset: 0x0019A31A internal SpellingError(Speller speller, ITextPointer start, ITextPointer end) { Invariant.Assert(start.CompareTo(end) < 0); this._speller = speller; this._start = start.GetFrozenPointer(LogicalDirection.Forward); this._end = end.GetFrozenPointer(LogicalDirection.Backward); }
//----------------------------------------------------- // // Constructors // //----------------------------------------------------- #region Constructors // Creates a new instance. internal SpellingError(Speller speller, ITextPointer start, ITextPointer end) { Invariant.Assert(start.CompareTo(end) < 0); _speller = speller; _start = start.GetFrozenPointer(LogicalDirection.Forward); _end = end.GetFrozenPointer(LogicalDirection.Backward); }
// Token: 0x060037C2 RID: 14274 RVA: 0x000F9046 File Offset: 0x000F7246 internal TextContainerChangeEventArgs(ITextPointer textPosition, int count, int charCount, TextChangeType textChange, DependencyProperty property, bool affectsRenderOnly) { this._textPosition = textPosition.GetFrozenPointer(LogicalDirection.Forward); this._count = count; this._charCount = charCount; this._textChange = textChange; this._property = property; this._affectsRenderOnly = affectsRenderOnly; }
internal TextContainerChangeEventArgs(ITextPointer textPosition, int count, int charCount, TextChangeType textChange, DependencyProperty property, bool affectsRenderOnly) { _textPosition = textPosition.GetFrozenPointer(LogicalDirection.Forward); _count = count; _charCount = charCount; _textChange = textChange; _property = property; _affectsRenderOnly = affectsRenderOnly; }
/// <summary> /// Constructor. /// </summary> /// <param name="startPosition"> /// Position preceeding the TextSegment's content. /// </param> /// <param name="endPosition"> /// Position following the TextSegment's content. /// </param> /// <param name="preserveLogicalDirection"> /// Whether preserves LogicalDirection of start and end positions. /// </param> internal TextSegment(ITextPointer startPosition, ITextPointer endPosition, bool preserveLogicalDirection) { ValidationHelper.VerifyPositionPair(startPosition, endPosition); if (startPosition.CompareTo(endPosition) == 0) { // To preserve segment emptiness // we use the same instance of a pointer // for both segment ends. _start = startPosition.GetFrozenPointer(startPosition.LogicalDirection); _end = _start; } else { Invariant.Assert(startPosition.CompareTo(endPosition) < 0); _start = startPosition.GetFrozenPointer(preserveLogicalDirection ? startPosition.LogicalDirection : LogicalDirection.Backward); _end = endPosition.GetFrozenPointer(preserveLogicalDirection ? endPosition.LogicalDirection : LogicalDirection.Forward); } }
/// <summary> /// Constructor. /// </summary> /// <param name="startPosition"> /// Position preceeding the TextSegment's content. /// </param> /// <param name="endPosition"> /// Position following the TextSegment's content. /// </param> /// <param name="preserveLogicalDirection"> /// Whether preserves LogicalDirection of start and end positions. /// </param> internal TextSegment(ITextPointer startPosition, ITextPointer endPosition, bool preserveLogicalDirection) { ValidationHelper.VerifyPositionPair(startPosition, endPosition); if (startPosition.CompareTo(endPosition) == 0) { // To preserve segment emptiness // we use the same instance of a pointer // for both segment ends. _start = startPosition.GetFrozenPointer(startPosition.LogicalDirection); _end = _start; } else { Invariant.Assert(startPosition.CompareTo(endPosition) < 0); _start = startPosition.GetFrozenPointer(preserveLogicalDirection ? startPosition.LogicalDirection : LogicalDirection.Backward); _end = endPosition.GetFrozenPointer(preserveLogicalDirection ? endPosition.LogicalDirection : LogicalDirection.Forward); } }
// Token: 0x06002FC0 RID: 12224 RVA: 0x000D6E30 File Offset: 0x000D5030 internal void SetCompositionPositions(ITextPointer start, ITextPointer end, string text) { Invariant.Assert(start != null); Invariant.Assert(end != null); Invariant.Assert(text != null); this._compositionStart = start.GetFrozenPointer(LogicalDirection.Backward); this._compositionEnd = end.GetFrozenPointer(LogicalDirection.Forward); this._resultStart = null; this._resultEnd = null; base.Text = string.Empty; base.CompositionText = text; this._offset = ((this._compositionStart == null) ? -1 : this._compositionStart.Offset); this._length = ((this._compositionStart == null) ? -1 : this._compositionStart.GetOffsetToPosition(this._compositionEnd)); }
// Set composition string to TextComposition. internal void SetCompositionPositions(ITextPointer start, ITextPointer end, string text) { Invariant.Assert(start != null); Invariant.Assert(end != null); Invariant.Assert(text != null); // We need to have another instances of TextPointer since we don't want to // freeze original TextPointers. _compositionStart = start.GetFrozenPointer(LogicalDirection.Backward); _compositionEnd = end.GetFrozenPointer(LogicalDirection.Forward); _resultStart = null; _resultEnd = null; this.Text = String.Empty; this.CompositionText = text; // We must cache integer offsets -- public listeners won't expect // them to float like TextPointers if the document changes. _offset = (_compositionStart == null) ? -1 : _compositionStart.Offset; _length = (_compositionStart == null) ? -1 : _compositionStart.GetOffsetToPosition(_compositionEnd); }
/// <summary> /// <see cref="ITextView.GetPositionAtNextLine"/> /// </summary> ITextPointer ITextView.GetPositionAtNextLine(ITextPointer position, double suggestedX, int count, out double newSuggestedX, out int linesMoved) { Invariant.Assert(this.IsLayoutValid); Invariant.Assert(Contains(position)); newSuggestedX = suggestedX; int lineIndex = GetLineIndexFromPosition(position); int nextLineIndex = Math.Max(0, Math.Min(_lineMetrics.Count - 1, lineIndex + count)); linesMoved = nextLineIndex - lineIndex; ITextPointer nextLinePosition; if (linesMoved == 0) { nextLinePosition = position.GetFrozenPointer(position.LogicalDirection); } else if (DoubleUtil.IsNaN(suggestedX)) { nextLinePosition = _host.TextContainer.CreatePointerAtOffset(_lineMetrics[lineIndex + linesMoved].Offset, LogicalDirection.Forward); } else { suggestedX -= GetTextAlignmentCorrection(this.CalculatedTextAlignment, GetWrappingWidth(this.RenderSize.Width)); nextLinePosition = GetTextPositionFromDistance(nextLineIndex, suggestedX); } nextLinePosition.Freeze(); return nextLinePosition; }
internal Run(ITextPointer position, RunType runType) { _position = position.GetFrozenPointer(LogicalDirection.Backward); _runType = runType; }
// Creates a new instance. // contextStart/End refer to the whole run of text. // contentStart/End are a subset of the text, which is what // the engine will actually tag with errors. // The space between context and content is used by the engine // to correctly analyze multiple word phrase like "Los Angeles" // that could otherwise be truncated and incorrectly tagged. internal TextMap(ITextPointer contextStart, ITextPointer contextEnd, ITextPointer contentStart, ITextPointer contentEnd) { ITextPointer position; int maxChars; int inlineCount; int runCount; int i; int distance; Invariant.Assert(contextStart.CompareTo(contentStart) <= 0); Invariant.Assert(contextEnd.CompareTo(contentEnd) >= 0); _basePosition = contextStart.GetFrozenPointer(LogicalDirection.Backward); position = contextStart.CreatePointer(); maxChars = contextStart.GetOffsetToPosition(contextEnd); _text = new char[maxChars]; _positionMap = new int[maxChars+1]; _textLength = 0; inlineCount = 0; _contentStartOffset = 0; _contentEndOffset = 0; // Iterate over the run, building up a matching plain text buffer // and a table that tells us how to map back to the original text. while (position.CompareTo(contextEnd) < 0) { if (position.CompareTo(contentStart) == 0) { _contentStartOffset = _textLength; } if (position.CompareTo(contentEnd) == 0) { _contentEndOffset = _textLength; } switch (position.GetPointerContext(LogicalDirection.Forward)) { case TextPointerContext.Text: runCount = position.GetTextRunLength(LogicalDirection.Forward); runCount = Math.Min(runCount, _text.Length - _textLength); runCount = Math.Min(runCount, position.GetOffsetToPosition(contextEnd)); position.GetTextInRun(LogicalDirection.Forward, _text, _textLength, runCount); for (i = _textLength; i < _textLength + runCount; i++) { _positionMap[i] = i + inlineCount; } distance = position.GetOffsetToPosition(contentStart); if (distance >= 0 && distance <= runCount) { _contentStartOffset = _textLength + position.GetOffsetToPosition(contentStart); } distance = position.GetOffsetToPosition(contentEnd); if (distance >= 0 && distance <= runCount) { _contentEndOffset = _textLength + position.GetOffsetToPosition(contentEnd); } position.MoveByOffset(runCount); _textLength += runCount; break; case TextPointerContext.ElementStart: case TextPointerContext.ElementEnd: if (IsAdjacentToFormatElement(position)) { // Filter out formatting tags from the plain text. inlineCount++; } else { // Stick in a word break to account for the block element. _text[_textLength] = ' '; _positionMap[_textLength] = _textLength + inlineCount; _textLength++; } position.MoveToNextContextPosition(LogicalDirection.Forward); break; case TextPointerContext.EmbeddedElement: _text[_textLength] = '\xf8ff'; // Unicode private use. _positionMap[_textLength] = _textLength + inlineCount; _textLength++; position.MoveToNextContextPosition(LogicalDirection.Forward); break; } } if (position.CompareTo(contentEnd) == 0) { _contentEndOffset = _textLength; } if (_textLength > 0) { _positionMap[_textLength] = _positionMap[_textLength - 1] + 1; } else { _positionMap[0] = 0; } Invariant.Assert(_contentStartOffset <= _contentEndOffset); }
/// <summary> /// <see cref="ITextView.GetBackspaceCaretUnitPosition"/> /// </summary> ITextPointer ITextView.GetBackspaceCaretUnitPosition(ITextPointer position) { Invariant.Assert(this.IsLayoutValid); Invariant.Assert(Contains(position)); // Special case document start. if (position.Offset == 0) { return position.GetFrozenPointer(LogicalDirection.Forward); } int lineIndex = GetLineIndexFromPosition(position, LogicalDirection.Backward); CharacterHit sourceCharacterHit = new CharacterHit(position.Offset, 0); CharacterHit backspaceCharacterHit; using (TextBoxLine line = GetFormattedLine(lineIndex)) { backspaceCharacterHit = line.GetBackspaceCaretCharacterHit(sourceCharacterHit); } LogicalDirection logicalDirection; if (backspaceCharacterHit.FirstCharacterIndex + backspaceCharacterHit.TrailingLength == _lineMetrics[lineIndex].Offset) { // Going backward brought us to the start of a line, context must be backward for previous line if (lineIndex == 0) { // First line, so we will stay forward. logicalDirection = LogicalDirection.Forward; } else { logicalDirection = LogicalDirection.Backward; } } else { logicalDirection = (backspaceCharacterHit.TrailingLength > 0) ? LogicalDirection.Backward : LogicalDirection.Forward; } ITextPointer backspaceUnitPosition = _host.TextContainer.CreatePointerAtOffset(backspaceCharacterHit.FirstCharacterIndex + backspaceCharacterHit.TrailingLength, logicalDirection); backspaceUnitPosition.Freeze(); return backspaceUnitPosition; }
/// <summary> /// <see cref="ITextView.GetNextCaretUnitPosition"/> /// </summary> ITextPointer ITextView.GetNextCaretUnitPosition(ITextPointer position, LogicalDirection direction) { Invariant.Assert(this.IsLayoutValid); Invariant.Assert(Contains(position)); // Special case document start/end. if (position.Offset == 0 && direction == LogicalDirection.Backward) { return position.GetFrozenPointer(LogicalDirection.Forward); } else if (position.Offset == _host.TextContainer.SymbolCount && direction == LogicalDirection.Forward) { return position.GetFrozenPointer(LogicalDirection.Backward); } int lineIndex = GetLineIndexFromPosition(position); CharacterHit sourceCharacterHit = new CharacterHit(position.Offset, 0); CharacterHit nextCharacterHit; using (TextBoxLine line = GetFormattedLine(lineIndex)) { if (direction == LogicalDirection.Forward) { // Get the next caret position from the line nextCharacterHit = line.GetNextCaretCharacterHit(sourceCharacterHit); } else { // Get previous caret position from the line nextCharacterHit = line.GetPreviousCaretCharacterHit(sourceCharacterHit); } } // Determine logical direction for next caret index and create TextPointer from it. LogicalDirection logicalDirection; if (nextCharacterHit.FirstCharacterIndex + nextCharacterHit.TrailingLength == _lineMetrics[lineIndex].EndOffset && direction == LogicalDirection.Forward) { // Going forward brought us to the end of a line, context must be forward for next line. if (lineIndex == _lineMetrics.Count - 1) { // Last line so context must stay backward. logicalDirection = LogicalDirection.Backward; } else { logicalDirection = LogicalDirection.Forward; } } else if (nextCharacterHit.FirstCharacterIndex + nextCharacterHit.TrailingLength == _lineMetrics[lineIndex].Offset && direction == LogicalDirection.Backward) { // Going backward brought us to the start of a line, context must be backward for previous line. if (lineIndex == 0) { // First line, so we will stay forward. logicalDirection = LogicalDirection.Forward; } else { logicalDirection = LogicalDirection.Backward; } } else { logicalDirection = (nextCharacterHit.TrailingLength > 0) ? LogicalDirection.Backward : LogicalDirection.Forward; } ITextPointer nextCaretUnitPosition = _host.TextContainer.CreatePointerAtOffset(nextCharacterHit.FirstCharacterIndex + nextCharacterHit.TrailingLength, logicalDirection); nextCaretUnitPosition.Freeze(); return nextCaretUnitPosition; }
// Token: 0x06008593 RID: 34195 RVA: 0x00249D84 File Offset: 0x00247F84 internal Run(ITextPointer position, SpellerStatusTable.RunType runType) { this._position = position.GetFrozenPointer(LogicalDirection.Backward); this._runType = runType; }
// Helper for OnSelectDownByLine. Updates the selection moving position // during select down by line. private static void AdjustMovingPositionForSelectDownByLine(TextEditor This, ITextPointer newMovingPosition, ITextPointer originalMovingPosition, double suggestedX) { int newComparedToOld = newMovingPosition.CompareTo(originalMovingPosition); // Note: we compare orientations of equal positions to handle a case // when original position was at the end of line (after its linebreak with backward orientation) // as a result of Shift+End selection; and the new position is in the beginning of the next line, // which is essentially the same position but oriented differently. // In such a case the new position is good enough to go there. // We certainly don't want to go to the end of the document in this case. if (newComparedToOld > 0 || newComparedToOld == 0 && newMovingPosition.LogicalDirection != originalMovingPosition.LogicalDirection) { // We have another line in a given direction; move to it // If the destination exactly preceeds a line break, expand to include // the line break if we haven't reached our desired suggestedX. if (TextPointerBase.IsNextToAnyBreak(newMovingPosition, LogicalDirection.Forward) || newMovingPosition.GetNextInsertionPosition(LogicalDirection.Forward) == null) { double newPositionX = GetAbsoluteXOffset(This.TextView, newMovingPosition); FlowDirection paragraphFlowDirection = GetScopingParagraphFlowDirection(newMovingPosition); FlowDirection controlFlowDirection = This.UiScope.FlowDirection; if ((paragraphFlowDirection == controlFlowDirection && newPositionX < suggestedX) || (paragraphFlowDirection != controlFlowDirection && newPositionX > suggestedX)) { newMovingPosition = newMovingPosition.GetInsertionPosition(LogicalDirection.Forward); newMovingPosition = newMovingPosition.GetNextInsertionPosition(LogicalDirection.Forward); // If we're at the last Paragraph, move to document end to include // the final paragraph break. if (newMovingPosition == null) { newMovingPosition = originalMovingPosition.TextContainer.End; } newMovingPosition = newMovingPosition.GetFrozenPointer(LogicalDirection.Backward); } } ExtendSelectionAndBringIntoView(newMovingPosition, This); } else { // Remember where we were so that we can return if a line up follows. if (This._NextLineAdvanceMovingPosition == null) { This._NextLineAdvanceMovingPosition = originalMovingPosition; This._IsNextLineAdvanceMovingPositionAtDocumentHead = false; } // No more lines in this direction. Move to end of current line. newMovingPosition = GetPositionAtLineEnd(originalMovingPosition); if (newMovingPosition.GetNextInsertionPosition(LogicalDirection.Forward) == null) { // Move to the final implicit line at end-of-doc. newMovingPosition = newMovingPosition.TextContainer.End; } ExtendSelectionAndBringIntoView(newMovingPosition, This); } }
// Set composition string to TextComposition. internal void SetCompositionPositions(ITextPointer start, ITextPointer end, string text) { Invariant.Assert(start != null); Invariant.Assert(end != null); Invariant.Assert(text != null); // We need to have another instances of TextPointer since we don't want to // freeze original TextPointers. _compositionStart = start.GetFrozenPointer(LogicalDirection.Backward); _compositionEnd = end.GetFrozenPointer(LogicalDirection.Forward); _resultStart = null; _resultEnd = null; this.Text = String.Empty; this.CompositionText = text; // We must cache integer offsets -- public listeners won't expect // them to float like TextPointers if the document changes. _offset = (_compositionStart == null) ? -1 : _compositionStart.Offset; _length = (_compositionStart == null) ? -1 : _compositionStart.GetOffsetToPosition(_compositionEnd); }
internal Run(ITextPointer position, RunType runType) { _position = position.GetFrozenPointer(LogicalDirection.Backward); _runType = runType; }