C# SnapshotPoint.GetContainingLine方法代码示例

        private static void CommentRegion(ITextView view, SnapshotPoint start, SnapshotPoint end)
        {
            using (var edit = view.TextBuffer.CreateEdit()) {
                int minColumn = Int32.MaxValue;
                // first pass, determine the position to place the comment
                for (int i = start.GetContainingLine().LineNumber; i <= end.GetContainingLine().LineNumber; i++) {
                    var curLine = view.TextBuffer.CurrentSnapshot.GetLineFromLineNumber(i);
                    var text = curLine.GetText();

                    minColumn = Math.Min(GetMinimumColumn(text), minColumn);
                }

                // second pass, place the comment
                for (int i = start.GetContainingLine().LineNumber; i <= end.GetContainingLine().LineNumber; i++) {
                    var curLine = view.TextBuffer.CurrentSnapshot.GetLineFromLineNumber(i);
                    if (curLine.Length < minColumn) {
                        // need extra white space
                        edit.Insert(curLine.Start.Position + curLine.Length, new String(' ', minColumn - curLine.Length) + "#");
                    } else {
                        edit.Insert(curLine.Start.Position + minColumn, "#");
                    }
                }

                edit.Apply();
            }

            // select the full region we just commented
            UpdateSelection(view, start, end);
        }

		private static string GetIndentationPrependText(SnapshotPoint startPoint)
		{
			if (startPoint.Position <= startPoint.GetContainingLine().Start.Position)
			{
				return string.Empty;
			}
			int num = startPoint.Position - startPoint.GetContainingLine().Start.Position;
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < num; i++)
			{
				stringBuilder.Append(' ');
			}
			return stringBuilder.ToString();
		}

		static SnapshotSpan GetWordSpan(SnapshotPoint currentPosition, WordKind kind) {
			Debug.Assert(GetWordKind(currentPosition) == kind);
			var line = currentPosition.GetContainingLine();
			int column = currentPosition.Position - line.Start.Position;
			var start = GetStartSpanBefore(line, column, kind);
			var end = GetEndSpanAfter(line, column, kind);
			return new SnapshotSpan(start, end);
		}

        private static SnapshotSpan? GetExtentOfWord(SnapshotPoint point)
        {
            var line = point.GetContainingLine();

            if (line == null) return null;

            var text = line.GetText();
            var index = point - line.Start;

            var start = index;
            var length = 0;

            if (index > 0 && index < line.Length)
            {
                for (var i = index; i >= 0; i--)
                {
                    var current = text[i];
                    if (current == '$')
                    {
                        start = i;
                        length++;
                        break;
                    }

                    if (current != '_' && char.IsLetterOrDigit(current) == false) break;

                    start = i;
                    length++;
                }
            }

            if (length > 0)
            {
                index++;

                if (index < line.Length)
                {
                    for (var i = index; i < line.Length; i++)
                    {
                        var current = text[i];
                        if (current != '_' && char.IsLetterOrDigit(current) == false) break;

                        length++;
                    }
                }

                var span = new SnapshotSpan(point.Snapshot, start + line.Start, length);

                //Log.Debug("[" + span.GetText() + "]");

                return span;
            }

            return null;
        }

        private ITrackingSpan GetApplicableToSpan(ITextSnapshot snapshot, SnapshotPoint triggerPoint)
        {
            var line = triggerPoint.GetContainingLine();

            SnapshotPoint start = triggerPoint;
            while (start > line.Start && !char.IsWhiteSpace((start - 1).GetChar()))
            {
                start -= 1;
            }

            return snapshot.CreateTrackingSpan(new SnapshotSpan(start, line.End), SpanTrackingMode.EdgeInclusive);
        }

		public static string GetLineBreak(this IEditorOptions editorOptions, SnapshotPoint pos) {
			if (editorOptions.GetReplicateNewLineCharacter()) {
				var line = pos.GetContainingLine();
				if (line.LineBreakLength != 0)
					return pos.Snapshot.GetText(line.Extent.End.Position, line.LineBreakLength);
				if (line.LineNumber != 0) {
					line = pos.Snapshot.GetLineFromLineNumber(line.LineNumber - 1);
					return pos.Snapshot.GetText(line.Extent.End.Position, line.LineBreakLength);
				}
			}
			var linebreak = editorOptions.GetNewLineCharacter();
			return linebreak.Length != 0 ? linebreak : Environment.NewLine;
		}

        public static int GetIndentation(this IndentationResult result, ITextView textView, ITextSnapshotLine lineToBeIndented)
        {
            var position = new SnapshotPoint(lineToBeIndented.Snapshot, result.BasePosition);
            var pointInSurfaceSnapshot = textView.BufferGraph.MapUpToSnapshot(position, PointTrackingMode.Positive, PositionAffinity.Successor, textView.TextSnapshot);
            if (!pointInSurfaceSnapshot.HasValue)
            {
                return position.GetContainingLine().GetColumnOfFirstNonWhitespaceCharacterOrEndOfLine(textView.Options);
            }

            var lineInSurfaceSnapshot = pointInSurfaceSnapshot.Value.Snapshot.GetLineFromPosition(pointInSurfaceSnapshot.Value.Position);
            var offsetInLine = pointInSurfaceSnapshot.Value.Position - lineInSurfaceSnapshot.Start.Position;
            return lineInSurfaceSnapshot.GetColumnFromLineOffset(offsetInLine, textView.Options) + result.Offset;
        }

        private CodeElement GetCodeElement(DTE dte, SnapshotPoint  point, CodeElements codeElements, vsCMElement elementType)
        {
            foreach (CodeElement ce in codeElements)
            {
                if (ce.Kind.ToString() == "vsCMElementImportStmt")
                {
                    continue;
                }
                try
                {
                    _log.Debug("Searching " + ce.Name);
                    Debug.WriteLine(string.Format("Searching {0}:{1}", ce.Kind.ToString(), ce.Name));
                }
                catch (Exception e)
                {
                    Debug.WriteLine("Exception getting object name: " + e.Message );
                }

                var sp = getStartPoint(ce);
                var pointLine = point.GetContainingLine().LineNumber;

                if (sp != null)
                {
                    if (sp.Line > pointLine )
                    {
                        // code element starts after the droplocation, ignore it
                    }
                    else if (ce.EndPoint.Line  < pointLine )
                    {
                        // code element finishes before the droplocation, ignore it
                    }
                    else
                    {

                        if (elementType == ce.Kind)
                        {

                            return ce;
                        }

                        var childElements = getCodeElements(ce);
                        if (childElements != null)
                        {
                            var ret = GetCodeElement(dte, point, childElements, elementType);
                            if (ret != null) return ret;
                        }
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// Displays completion after typing a space after a step keyword
        /// </summary>
        protected override bool ShouldCompletionBeDiplayed(SnapshotPoint caret)
        {
            var lineStart = caret.GetContainingLine().Start.Position;
            var lineBeforeCaret = caret.Snapshot.GetText(lineStart, caret.Position - lineStart);

            if (lineBeforeCaret.Length > 0 &&
                char.IsWhiteSpace(lineBeforeCaret[lineBeforeCaret.Length - 1]))
            {
                string keyword = lineBeforeCaret.Substring(0, lineBeforeCaret.Length - 1).TrimStart();
                var languageService = GherkinProcessorServices.GetLanguageService(caret.Snapshot.TextBuffer);
                return languageService.IsStepKeyword(keyword);
            }

            return false;
        }

        /// <summary>
        /// Displays completion after typing a space after a step keyword
        /// </summary>
        protected override bool ShouldCompletionBeDiplayed(SnapshotPoint caret)
        {
            var lineStart = caret.GetContainingLine().Start.Position;
            var lineBeforeCaret = caret.Snapshot.GetText(lineStart, caret.Position - lineStart);

            if (lineBeforeCaret.Length > 0 &&
                char.IsWhiteSpace(lineBeforeCaret[lineBeforeCaret.Length - 1]))
            {
                string keyword = lineBeforeCaret.Substring(0, lineBeforeCaret.Length - 1).TrimStart();

                var fileScope = languageService.GetFileScope(waitForParsingSnapshot: caret.Snapshot);
                if (fileScope != null && fileScope.GherkinDialect != null)
                    return fileScope.GherkinDialect.IsStepKeyword(keyword);
            }

            return false;
        }

        private bool IsReplCommandLocation(SnapshotPoint characterPoint)
        {
            // TODO(cyrusn): We don't need to do this textually.  We could just defer this to
            // IsTriggerCharacter and just check the syntax tree.
            var line = characterPoint.GetContainingLine();
            var text = characterPoint.Snapshot.GetText(line.Start.Position, characterPoint.Position - line.Start.Position);

            // TODO (tomat): REPL commands should have their own handlers:
            if (characterPoint.Snapshot.ContentType.IsOfType(ContentTypeNames.CSharpContentType))
            {
                if (s_referenceRegex.IsMatch(text))
                {
                    return true;
                }
            }

            return false;
        }

        // Inspired by NodejsTools
        /// <summary>
        /// Enumerates the classifications in the first code line preceding a point.
        /// Skips blank lines or comment-only lines.
        /// </summary>
        private static IEnumerable<ClassificationSpan> EnumeratePrecedingLineTokens(SnapshotPoint start)
        {
            var tagger = start.Snapshot.TextBuffer.Properties.GetProperty<ITagger<ClassificationTag>>(jsTaggerType);

            var curLine = start.GetContainingLine();
            if (curLine.LineNumber == 0)
                yield break;

            bool foundCode = false;
            do
            {
                curLine = start.Snapshot.GetLineFromLineNumber(curLine.LineNumber - 1);
                var classifications = tagger.GetTags(new NormalizedSnapshotSpanCollection(curLine.Extent));
                foreach (var tag in classifications.Where(c => !c.Tag.ClassificationType.IsOfType("comment")))
                {
                    foundCode = true;
                    yield return new ClassificationSpan(tag.Span, tag.Tag.ClassificationType);
                }
            }
            while (!foundCode && curLine.LineNumber > 0);
        }

        private static string GetVariableNameAndSpan(SnapshotPoint point, out SnapshotSpan span)
        {
            var line = point.GetContainingLine();
            var hoveredIndex = point.Position - line.Start.Position;

            var c = point.GetChar();
            if (!Char.IsDigit(c) && !Char.IsLetter(c) && (c != '_'))
            {
                span = new SnapshotSpan();
                return null;
            }

            // Find the name of the variable under the mouse pointer (ex: 'gesture.Pose.Name' when the mouse is hovering over the 'o' of pose)
            var match = m_variableExtractor.Matches(line.GetText()).OfType<Match>().SingleOrDefault(x => x.Index <= hoveredIndex && (x.Index + x.Length) >= hoveredIndex);
            if ((match == null) || (match.Value.Length == 0))
            {
                span = new SnapshotSpan();
                return null;
            }
            var name = match.Value;

            // Find the first '.' after the hoveredIndex and cut it off
            int relativeIndex = hoveredIndex - match.Index;
            var lastIndex = name.IndexOf('.', relativeIndex);
            if (lastIndex >= 0)
            {
                name = name.Substring(0, lastIndex);
            }
            else
            {
                lastIndex = name.Length;
            }

            var matchStartIndex = name.LastIndexOf('.', relativeIndex) + 1;
            span = new SnapshotSpan(line.Start.Add(match.Index + matchStartIndex), lastIndex - matchStartIndex);

            return name;
        }

        private void HandlePreprocessor(IQuickInfoSession session, SnapshotPoint point, Selector item, IList<object> qiContent)
        {
            if (item == null || !session.TextView.Properties.ContainsProperty("CssSourceMap"))
                return;

            CssSourceMap sourceMap;

            if (!session.TextView.Properties.TryGetProperty<CssSourceMap>("CssSourceMap", out sourceMap))
                return;

            var line = point.GetContainingLine().LineNumber;
            var column = item.Start - point.Snapshot.GetLineFromPosition(item.Start).Start;

            var node = sourceMap.MapNodes.FirstOrDefault(s =>
                           s.SourceFilePath == _buffer.GetFileName() &&
                           s.OriginalLine == line &&
                           s.OriginalColumn == column);

            if (node == null)
                return;

            qiContent.Add(GenerateContent(node.GeneratedSelector));
        }

        static private string GetFirstWord(SnapshotPoint triggerPoint)
        {
            var line = triggerPoint.GetContainingLine();
            SnapshotPoint start = line.Start;
            ForwardWhile(ref start, triggerPoint, p => char.IsWhiteSpace(p.GetChar()));
            SnapshotPoint end = start;
            ForwardWhile(ref end, triggerPoint, p => !char.IsWhiteSpace(p.GetChar()));
            if (start >= end)
                return null;

            return triggerPoint.Snapshot.GetText(start, end.Position - start);
        }