C# ITrackingPoint.GetPosition方法代码示例

    public static SyntaxNode GetAnyCallNodeAboveTriggerPoint(ITrackingPoint triggerPoint, ITextSnapshot snapshot, SyntaxTree parseTree) {
      Contract.Requires(snapshot != null);
      Contract.Requires(parseTree != null);
      Contract.Requires(triggerPoint != null);

      SyntaxNode syntaxRoot;
      if (!parseTree.TryGetRoot(out syntaxRoot))
        return null;

      var leafNode = syntaxRoot.FindToken(triggerPoint.GetPosition(snapshot), false);
      if (leafNode.IsKind(SyntaxKind.None))
        return null;

      //Is anyone in our ancestry a call node?
      var nodeInQuestion = leafNode.Parent;
      SyntaxNode ptn = null;

      while (nodeInQuestion != null) {
        //Is the node in question a node call?
        var asCall = nodeInQuestion as InvocationExpressionSyntax;
        if (asCall != null) {
          ptn = asCall;
          break;
        }

        var asCtorCall = nodeInQuestion as ObjectCreationExpressionSyntax;
        if (asCtorCall != null) {
          ptn = asCtorCall;
          break;
        }

        //Climb higher up our ancestry for the next iteration
        nodeInQuestion = nodeInQuestion.Parent;
      }

      //Did we successfully find a call node?
      return ptn;
    }

 private static bool IsSpaceCompletion(ITextSnapshot snapshot, ITrackingPoint loc) {
     var pos = loc.GetPosition(snapshot);
     if (pos > 0) {
         return snapshot.GetText(pos - 1, 1) == " ";
     }
     return false;
 }

 /// <summary>
 /// Returns the applicable span at the provided position.
 /// </summary>
 /// <returns>A tracking span, or null if there is no token at the
 /// provided position.</returns>
 internal static ITrackingSpan GetApplicableSpan(ITextSnapshot snapshot, ITrackingPoint point) {
     return GetApplicableSpan(snapshot, point.GetPosition(snapshot));
 }

        private void DrawSingleSyncPoint(ITrackingPoint trackPoint)
        {
            var position = trackPoint.GetPosition(m_textView.TextSnapshot);
            if (position > m_textView.TextSnapshot.Length)
                return;

            var point = trackPoint.GetPoint(m_textView.TextSnapshot);
            if (position == m_textView.TextSnapshot.Length)
                point -= 1;

            var span = new SnapshotSpan(point, 1);

            var brush = Brushes.DarkGray;
            var geom = m_textView.TextViewLines.GetLineMarkerGeometry(span);
            var drawing = new GeometryDrawing(brush, null, geom);

            if (drawing.Bounds.IsEmpty)
                return;

            Rectangle rect = new Rectangle()
            {
                Fill = brush,
                Width = drawing.Bounds.Width / 6,
                Height = drawing.Bounds.Height - 4,
                Margin = new System.Windows.Thickness(0, 2, 0, 0)
            };

            Canvas.SetLeft(rect, position == m_textView.TextSnapshot.Length ? geom.Bounds.Right : geom.Bounds.Left);
            Canvas.SetTop(rect, geom.Bounds.Top);

            m_adornmentLayer.AddAdornment(AdornmentPositioningBehavior.TextRelative, span, "MultiEditLayer", rect, null);
        }

        private void DrawSingleSyncPoint(ITrackingPoint trackPoint)
        {
            if (trackPoint.GetPosition(m_textView.TextSnapshot) >= m_textView.TextSnapshot.Length)
                return;

            SnapshotSpan span = new SnapshotSpan(trackPoint.GetPoint(m_textView.TextSnapshot), 1);
            var brush = Brushes.DarkGray;
            var geom = m_textView.TextViewLines.GetMarkerGeometry(span);
            GeometryDrawing drawing = new GeometryDrawing(brush, null, geom);

            if (drawing.Bounds.IsEmpty)
                return;

            Rectangle rect = new Rectangle()
            {
                Fill = brush,
                Width = 1,
                Height = drawing.Bounds.Height - 1,
                Margin = new Thickness(),
            };

            Canvas.SetLeft(rect, geom.Bounds.Left);
            Canvas.SetTop(rect, geom.Bounds.Top);
            m_adornmentLayer.AddAdornment(AdornmentPositioningBehavior.TextRelative, span, "MultiEditLayer", rect, null);
        }

    public static SyntaxNode GetTargetAtTriggerPoint(ITrackingPoint triggerPoint, ITextSnapshot snapshot, SyntaxTree parseTree)
    {
      Contract.Requires(snapshot != null);
      Contract.Requires(parseTree != null);
      Contract.Requires(triggerPoint != null);

      SyntaxNode syntaxRoot;
      if (!parseTree.TryGetRoot(out syntaxRoot))
        return null;

      var leafToken = syntaxRoot.FindToken(triggerPoint.GetPosition(snapshot), false);
      if (leafToken.IsKind(SyntaxKind.None))
        return null;

      var leafNode = leafToken.Parent;

      var asPropDecl = leafNode as PropertyDeclarationSyntax;
      if (asPropDecl != null)
      {
          return asPropDecl;
      }

      //Is our leaf node a name?
      var asName = leafNode as IdentifierNameSyntax;
      if (asName == null)
        return null;

      //Is anyone in our ancestry a call node?
      var nodeInQuestion = leafNode;
      var lastNonBinaryOperatorNode = leafNode;
      var lastNode = leafNode;
      while (nodeInQuestion != null) {

        //Is the node in question a node call?
        var asCall = nodeInQuestion as InvocationExpressionSyntax;
        if (asCall != null) {

          //Make sure we aren't on the right side of the call
          if (asCall.Expression == leafNode)
            return asCall;

          MemberAccessExpressionSyntax memberAccessExpression = asCall.Expression as MemberAccessExpressionSyntax;
          if (memberAccessExpression != null && memberAccessExpression.Name == leafNode)
            return asCall;

          GenericNameSyntax genericNameSyntax = asCall.Expression as GenericNameSyntax;
          if (genericNameSyntax != null && genericNameSyntax.Identifier == leafToken)
            return asCall;

          return null;
        }

        var asProp = nodeInQuestion as MemberAccessExpressionSyntax;
        if (asProp != null)
        {
            //Make sure we aren't on the left side of the dot
            if (asProp.Name == lastNode && asProp.Name is IdentifierNameSyntax)
            {
                return asProp;
            }
        }

        var asCtorCall = nodeInQuestion as ObjectCreationExpressionSyntax;
        if (asCtorCall != null)
        {
            return asCtorCall;
        }

        var declNode = nodeInQuestion as MemberDeclarationSyntax;
        if (declNode != null)
        {
            if (lastNode == leafNode) { return declNode; }
            return null;
        }

#warning What exactly is this doing?
#if false
        NamedAssignmentNode na = nodeInQuestion as NamedAssignmentNode;
        if (na != null)
        {
            if (na.Identifier == asName)
            {
                return na;
            }
        }
#endif

        //Is our parent a binary operator?
        var asBinaryOperator = nodeInQuestion as BinaryExpressionSyntax;
        if (asBinaryOperator != null) {

          //Make sure we are always on the rightmost of any binary operator
          if (asBinaryOperator.Right != lastNonBinaryOperatorNode)
            return null;

        } else
          lastNonBinaryOperatorNode = nodeInQuestion;

        //Climb higher up our ancestry for the next iteration
        lastNode = nodeInQuestion;
//.........这里部分代码省略.........

        internal async Task RequestQuickInfo(ITextView textView, ITrackingPoint triggerPoint)
        {
            JavaEditor javaEditor = null;
            if (TextBuffer.Properties.TryGetProperty<JavaEditor>(typeof(JavaEditor), out javaEditor) &&
                javaEditor.TypeRootIdentifier != null)
            {
                var textReader = new TextSnapshotToTextReader(TextBuffer.CurrentSnapshot) as TextReader;
                var position = triggerPoint.GetPosition(TextBuffer.CurrentSnapshot);
                var quickInfoRequest = ProtocolHandlers.CreateQuickInfoRequest(textReader, javaEditor.TypeRootIdentifier, position);
                var quickInfoResponse = await javaEditor.JavaPkgServer.Send(javaEditor, quickInfoRequest);

                if (quickInfoResponse.responseType == Protocol.Response.ResponseType.QuickInfo &&
                    quickInfoResponse.quickInfoResponse != null)
                {
                    foreach(var element in quickInfoResponse.quickInfoResponse.elements)
                    {
                        QuickInfoContent.Add(element.definition); // TODO: Better javadoc rendering + "\n\n" + element.javaDoc;
                    }
                }
            }
        }