C# IDocument.PositionToOffset方法代码示例

		protected override void RemoveFieldDeclaration(IDocument document, IField field)
		{
			// In VB, the field region begins at the start of the declaration
			// and ends on the first column of the line following the declaration.
			int startOffset = document.PositionToOffset(field.Region.BeginLine, 1);
			int endOffset   = document.PositionToOffset(field.Region.EndLine, 1);
			document.Remove(startOffset, endOffset - startOffset);
		}

		protected override void ReplaceFieldDeclaration(IDocument document, IField oldField, string newFieldDeclaration)
		{
			// In VB, the field region begins at the start of the declaration
			// and ends on the first column of the line following the declaration.
			int startOffset = document.PositionToOffset(oldField.Region.BeginLine, 1);
			int endOffset   = document.PositionToOffset(oldField.Region.EndLine, 1);
			document.Replace(startOffset, endOffset - startOffset, tabs + newFieldDeclaration + Environment.NewLine);
		}

 /// <summary>
 /// Builds converter from <c>DomRegion</c> and <c>IDocument</c>.
 /// </summary>
 /// <param name="region">DomRegion</param>
 /// <param name="doc">Document</param>
 /// <returns>Convertor</returns>
 public static LineOffsetConverter BuildConverter(DomRegion region, IDocument doc)
 {
     LineOffsetConverter lineCon = new LineOffsetConverter();
     lineCon.startLine = region.BeginLine;
     int stOffset = doc.PositionToOffset(region.BeginLine,0);
     for(int i = region.BeginLine;i <= region.EndLine; i++){
         lineCon.lineOffsets.Add(doc.PositionToOffset(i,0) - stOffset);
     }
     return lineCon;
 }

		public void AddMarker(IDocument document, CodeCoverageSequencePoint sequencePoint)
		{
			if (!IsValidSequencePoint(document, sequencePoint)) {
				return;
			}
			
			ITextMarkerService markerService = document.GetService(typeof(ITextMarkerService)) as ITextMarkerService;
			if (markerService != null) {
				int startOffset = document.PositionToOffset(sequencePoint.Line, sequencePoint.Column);
				int endOffset = document.PositionToOffset(sequencePoint.EndLine, sequencePoint.EndColumn);
				ITextMarker marker = markerService.Create(startOffset, endOffset - startOffset);
				marker.Tag = typeof(CodeCoverageHighlighter);
				marker.BackgroundColor = GetSequencePointColor(sequencePoint);
				marker.ForegroundColor = GetSequencePointForeColor(sequencePoint);
			}
		}

 /// <summary>
 /// Attempts to resolve a reference to a resource.
 /// </summary>
 /// <param name="fileName">The name of the file that contains the expression to be resolved.</param>
 /// <param name="document">The document that contains the expression to be resolved.</param>
 /// <param name="caretLine">The 0-based line in the file that contains the expression to be resolved.</param>
 /// <param name="caretColumn">The 0-based column position of the expression to be resolved.</param>
 /// <param name="charTyped">The character that has been typed at the caret position but is not yet in the buffer (this is used when invoked from code completion), or <c>null</c>.</param>
 /// <returns>A <see cref="ResourceResolveResult"/> that describes which resource is referenced by the expression at the specified position in the specified file, or <c>null</c> if that expression does not reference a (known) resource or if the specified position is invalid.</returns>
 public ResourceResolveResult Resolve(string fileName, IDocument document, int caretLine, int caretColumn, char? charTyped)
 {
     if (fileName == null || document == null) {
         LoggingService.Debug("ResourceToolkit: "+this.GetType().ToString()+".Resolve called with null fileName or document argument");
         return null;
     }
     if (caretLine < 0 || caretColumn < 0 || caretLine >= document.TotalNumberOfLines || caretColumn >= document.GetLine(caretLine + 1).TotalLength) {
         LoggingService.Debug("ResourceToolkit: "+this.GetType().ToString()+".Resolve called with invalid position arguments");
         return null;
     }
     return this.Resolve(fileName, document, caretLine, caretColumn, document.PositionToOffset(caretLine + 1, caretColumn + 1), charTyped);
 }

		internal void AttachTo(IDocument document)
		{
			if (isDeleted)
				return;
			Debug.Assert(currentDocument == null && document != null);
			this.currentDocument = document;
			line = Math.Min(line, document.TotalNumberOfLines);
			column = Math.Min(column, document.GetLine(line).Length + 1);
			baseAnchor = document.CreateAnchor(document.PositionToOffset(line, column));
			baseAnchor.MovementType = movementType;
			baseAnchor.SurviveDeletion = surviveDeletion;
			baseAnchor.Deleted += baseAnchor_Deleted;
		}

		XElement GetInnermostElement(XElement parent, IDocument document, int offset)
		{
			int startOffset = document.PositionToOffset(parent.GetLineNumber(), parent.GetLinePosition());
			int endOffset = parent.ToString().Length + startOffset;
			
			if (startOffset > offset || endOffset < offset)
				return null;
			
			foreach (XElement element in parent.Elements()) {
				XElement innermostElement = GetInnermostElement(element, document, offset);
				if (innermostElement != null)
					return innermostElement;
			}
			
			return parent;
		}

		protected override int GetCursorLine(IDocument document, IMethod method)
		{
			if (document == null)
				throw new ArgumentNullException("document");
			if (method == null)
				throw new ArgumentNullException("method");
			
			DomRegion r = method.BodyRegion;
			int offset = document.PositionToOffset(new TextLocation(r.BeginColumn - 1, r.BeginLine - 1));
			while (offset < document.TextLength) {
				char c = document.GetCharAt(offset++);
				if (c == '{') {
					return r.BeginLine + 1;
				}
				if (c != ' ') {
					break;
				}
			}
			return r.BeginLine + 2;
		}

		/// <summary>
		/// Replaces a field declaration in the source code document.
		/// </summary>
		/// <remarks>
		/// The default implementation assumes that the field region starts at the very beginning
		/// of the line of the field declaration and ends at the end of that line.
		/// Override this method if that is not the case in a specific language.
		/// </remarks>
		protected virtual void ReplaceFieldDeclaration(IDocument document, IField oldField, string newFieldDeclaration)
		{
			int startOffset = document.PositionToOffset(oldField.Region.BeginLine, 1);
			int endOffset   = document.PositionToOffset(oldField.Region.EndLine + 1, 1);
			document.Replace(startOffset, endOffset - startOffset, tabs + newFieldDeclaration + Environment.NewLine);
		}

		/// <summary>
		/// Gets the start offset of the region.
		/// </summary>
		static int GetStartOffset(IDocument document, DomRegion region)
		{
			return document.PositionToOffset(region.BeginLine, region.BeginColumn);			
		}

		/// <summary>
		/// Swaps 2 ranges of text in a document.
		/// </summary>
		static void SwapText(IDocument document, Location start1, Location end1, Location start2, Location end2)
		{
			if (start1 > start2) {
				Location sw;
				sw = start1; start1 = start2; start2 = sw;
				sw = end1; end1 = end2; end2 = sw;
			}
			if (end1 >= start2)
				throw new InvalidOperationException("Cannot swap overlaping segments");
			int offset1 = document.PositionToOffset(start1);
			int len1 = document.PositionToOffset(end1) - offset1;
			int offset2 = document.PositionToOffset(start2);
			int len2 = document.PositionToOffset(end2) - offset2;
			
			string text1 = document.GetText(offset1, len1);
			string text2 = document.GetText(offset2, len2);
			
			using (var undoGroup = document.OpenUndoGroup()) {
				document.Replace(offset2, len2, text1);
				document.Replace(offset1, len1, text2);
			}
		}

		static bool IsWhitespaceBetween(IDocument document, Location startPos, Location endPos)
		{
			int startOffset = document.PositionToOffset(startPos);
			int endOffset = document.PositionToOffset(endPos);
			return string.IsNullOrWhiteSpace(document.GetText(startOffset, endOffset - startOffset));
		}

		static int FindBeginStatement(IDocument document, VBStatement statement, Location endLocation, out int length)
		{
			ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, document.CreateReader());
			
			Token currentToken = null;
			Token prevToken = null;
			
			int lookFor = statement.StatementToken;
			Stack<Token> tokens = new Stack<Token>();
			
			if (statement.EndStatement == "Next") {
				lookFor = Tokens.For;
			}
			
			Token result = null;
//			Token firstModifier = null;
			
			while ((currentToken = lexer.NextToken()).Kind != Tokens.EOF) {
				if (prevToken == null)
					prevToken = currentToken;
				
//				if (IsModifier(currentToken)) {
//					if (firstModifier == null)
//						firstModifier = currentToken;
//				} else
//					firstModifier = null;
				
				
				if (VBNetFormattingStrategy.IsBlockStart(lexer, currentToken, prevToken)) {
					tokens.Push(currentToken);
				}
				if (VBNetFormattingStrategy.IsBlockEnd(currentToken, prevToken)) {
					while (tokens.Count > 0 && !VBNetFormattingStrategy.IsMatchingEnd(tokens.Peek(), currentToken))
						tokens.Pop();
					if (tokens.Count > 0) {
						Token t = tokens.Pop();
						if (currentToken.Location.Line == endLocation.Line) {
							result = t;
							break;
						}
					}
				}
				
				prevToken = currentToken;
			}
			
			if (result != null) {
				int endOffset = document.PositionToOffset(result.EndLocation.Line, result.EndLocation.Column);
				int offset = document.PositionToOffset(result.Location.Line, result.Location.Column);
				length = endOffset - offset;
				return offset;
			}
			
			length = 0;
			
			return -1;
		}

		/// <summary>
		/// If the text at startPos is preceded by any of the prefixes, moves the start backwards to include one prefix
		/// (the rightmost one).
		/// </summary>
		Location ExtendLeft(Location startPos, IDocument document, params String[] prefixes)
		{
			int startOffset = document.PositionToOffset(startPos);
			foreach (string prefix in prefixes) {
				if (startOffset < prefix.Length) continue;
				string realPrefix = document.GetText(startOffset - prefix.Length, prefix.Length);
				if (realPrefix == prefix) {
					return document.OffsetToPosition(startOffset - prefix.Length);
				}
			}
			// no prefixes -> do not extend
			return startPos;
		}

		bool IsWhitespaceBetween(IDocument document, Location startPos, Location endPos)
		{
			int startOffset = document.PositionToOffset(startPos);
			int endOffset = document.PositionToOffset(endPos);
			if (startOffset > endOffset) {
				throw new ArgumentException("Invalid range for (startPos, endPos)");
			}
			return string.IsNullOrWhiteSpace(document.GetText(startOffset, endOffset - startOffset));
		}