C# AnchorMovementType类代码示例

		/// <summary>
		/// Gets the new offset where the specified offset moves after this document change.
		/// </summary>
		public override int GetNewOffset(int offset, AnchorMovementType movementType = AnchorMovementType.Default)
		{
			if (offsetChangeMap != null)
				return offsetChangeMap.GetNewOffset(offset, movementType);
			else
				return CreateSingleChangeMapEntry().GetNewOffset(offset, movementType);
		}

		/// <summary>
		/// Gets the new offset where the specified offset moves after this document change.
		/// </summary>
		public virtual int GetNewOffset(int offset, AnchorMovementType movementType = AnchorMovementType.Default)
		{
			if (offset >= this.Offset && offset <= this.Offset + this.RemovalLength) {
				if (movementType == AnchorMovementType.BeforeInsertion)
					return this.Offset;
				else
					return this.Offset + this.InsertionLength;
			} else if (offset > this.Offset) {
				return offset + this.InsertionLength - this.RemovalLength;
			} else {
				return offset;
			}
		}

			public int MoveOffsetTo(ITextBufferVersion other, int oldOffset, AnchorMovementType movement)
			{
				SnapshotVersion otherVersion = other as SnapshotVersion;
				if (otherVersion == null)
					throw new ArgumentException("Does not belong to same document");
				switch (movement) {
					case AnchorMovementType.AfterInsertion:
						return checkpoint.MoveOffsetTo(otherVersion.checkpoint, oldOffset, ICSharpCode.AvalonEdit.Document.AnchorMovementType.AfterInsertion);
					case AnchorMovementType.BeforeInsertion:
						return checkpoint.MoveOffsetTo(otherVersion.checkpoint, oldOffset, ICSharpCode.AvalonEdit.Document.AnchorMovementType.BeforeInsertion);
					default:
						throw new NotSupportedException();
				}
			}

			public int MoveOffsetTo(ITextSourceVersion other, int oldOffset, AnchorMovementType movement)
			{
				int offset = oldOffset;
				foreach (var e in GetChangesTo(other)) {
					offset = e.GetNewOffset(offset, movement);
				}
				return offset;
			}

		public void Replace(int offset, int length, string newText, AnchorMovementType defaultAnchorMovementType)
		{
			document.Replace(offset, length, newText);
		}

		public void Insert(int offset, string text, AnchorMovementType defaultAnchorMovementType)
		{
			if (defaultAnchorMovementType == AnchorMovementType.BeforeInsertion) {
				document.Replace(offset, 0, text, OffsetChangeMappingType.KeepAnchorBeforeInsertion);
			} else {
				document.Insert(offset, text);
			}
		}

		/// <summary>
		///     Gets the new offset where the specified offset moves after this document change.
		/// </summary>
		public virtual int GetNewOffset(int offset, AnchorMovementType movementType = AnchorMovementType.Default)
		{
			if (offset >= Offset && offset <= Offset + RemovalLength)
			{
				if (movementType == AnchorMovementType.BeforeInsertion)
					return Offset;
				return Offset + InsertionLength;
			}
			if (offset > Offset)
			{
				return offset + InsertionLength - RemovalLength;
			}
			return offset;
		}

		/// <inheritdoc/>
		public void Insert(int offset, string text, AnchorMovementType defaultAnchorMovementType)
		{
			if (offset < 0 || offset > this.TextLength)
				throw new ArgumentOutOfRangeException("offset");
			if (text == null)
				throw new ArgumentNullException("text");
			if (defaultAnchorMovementType == AnchorMovementType.BeforeInsertion)
				PerformChange(new InsertionWithMovementBefore(offset, text));
			else
				Replace(offset, 0, text);
		}

		void IDocument.Insert(int offset, ITextSource text, AnchorMovementType defaultAnchorMovementType)
		{
			throw new NotSupportedException();
		}

 /// <summary>
 /// Inserts text.
 /// </summary>
 /// <param name="offset">The offset at which the text is inserted.</param>
 /// <param name="text">The new text.</param>
 /// <param name="defaultAnchorMovementType">
 /// Anchors positioned exactly at the insertion offset will move according to the anchor's movement type.
 /// For AnchorMovementType.Default, they will move according to the movement type specified by this parameter.
 /// The caret will also move according to the <paramref name="defaultAnchorMovementType"/> parameter.
 /// </param>
 public void Insert(int offset, ITextSource text, AnchorMovementType defaultAnchorMovementType)
 {
     if (defaultAnchorMovementType == AnchorMovementType.BeforeInsertion) {
         Replace(offset, 0, text, OffsetChangeMappingType.KeepAnchorBeforeInsertion);
     } else {
         Replace(offset, 0, text, null);
     }
 }

		public int GetNewOffset(int offset, AnchorMovementType movementType) 
		{ 
			//TODO: DocumentChangeEventArgs.GetNewOffset()
			throw new NotImplementedException();
		}

		public int MoveOffsetTo(ITextSourceVersion other, int oldOffset, AnchorMovementType movement)
		{
			if (this != other)
				throw new ArgumentException("other belongs to different document");
			return oldOffset;
		}

		public DocumentChangeEventArgs (int offset, string removedText, string insertedText, AnchorMovementType anchorMovementType = AnchorMovementType.Default) : base (offset, removedText, insertedText)
		{
			AnchorMovementType = anchorMovementType;
		}

		void ICSharpCode.NRefactory.Editor.IDocument.Insert (int offset, string text, AnchorMovementType anchorMovementType)
		{
			Insert (offset, text, anchorMovementType);
		}

 /// <summary>
 /// Calculates where the offset has moved in the other buffer version.
 /// </summary>
 /// <remarks>This method is thread-safe.</remarks>
 /// <exception cref="ArgumentException">Raised if 'other' belongs to a different document than this checkpoint.</exception>
 public int MoveOffsetTo(ChangeTrackingCheckpoint other, int oldOffset, AnchorMovementType movement)
 {
     int offset = oldOffset;
     foreach (DocumentChangeEventArgs e in GetChangesTo(other)) {
         offset = e.GetNewOffset(offset, movement);
     }
     return offset;
 }