public static Task <RefactoringSymbolInfo> GetSymbolInfoAsync(DocumentContext document, Ide.Editor.TextEditor editor, CancellationToken cancellationToken = default(CancellationToken))
 {
     if (editor.IsSomethingSelected)
     {
         var selectionRange = editor.SelectionRange;
         if (editor.GetTextAt(selectionRange).Any(ch => !char.IsLetterOrDigit(ch) && ch != '_'))
         {
             return(Task.FromResult(RefactoringSymbolInfo.Empty));
         }
         return(GetSymbolInfoAsync(document, selectionRange.Offset, cancellationToken));
     }
     return(GetSymbolInfoAsync(document, editor.CaretOffset, cancellationToken));
 }
Esempio n. 2
0
        public bool FixLineStart(Ide.Editor.TextEditor textEditorData, ICSharpCode.NRefactory6.CSharp.IStateMachineIndentEngine stateTracker, int lineNumber)
        {
            if (lineNumber > 1)
            {
                var line = textEditorData.GetLine(lineNumber);
                if (line == null)
                {
                    return(false);
                }

                var prevLine = textEditorData.GetLine(lineNumber - 1);
                if (prevLine == null)
                {
                    return(false);
                }
                string trimmedPreviousLine = textEditorData.GetTextAt(prevLine).TrimStart();

                //xml doc comments
                //check previous line was a doc comment
                //check there's a following line?
                if (trimmedPreviousLine.StartsWith("///", StringComparison.Ordinal))
                {
                    if (textEditorData.GetTextAt(line.Offset, line.Length).TrimStart().StartsWith("///", StringComparison.Ordinal))
                    {
                        return(false);
                    }
                    //check that the newline command actually inserted a newline
                    textEditorData.EnsureCaretIsNotVirtual();
                    var    nextLineSegment = textEditorData.GetLine(lineNumber + 1);
                    string nextLine        = nextLineSegment != null?textEditorData.GetTextAt(nextLineSegment).TrimStart() : "";

                    if (trimmedPreviousLine.Length > "///".Length || nextLine.StartsWith("///", StringComparison.Ordinal))
                    {
                        var insertionPoint = textEditorData.CaretOffset;
                        textEditorData.InsertText(insertionPoint, "/// ");
                        textEditorData.CaretOffset = insertionPoint + "/// ".Length;
                        return(true);
                    }
                    //multi-line comments
                }
                else if (stateTracker.IsInsideMultiLineComment)
                {
                    if (textEditorData.GetTextAt(line.Offset, line.Length).TrimStart().StartsWith("*", StringComparison.Ordinal))
                    {
                        return(false);
                    }
                    textEditorData.EnsureCaretIsNotVirtual();
                    string commentPrefix = string.Empty;
                    if (trimmedPreviousLine.StartsWith("* ", StringComparison.Ordinal))
                    {
                        commentPrefix = "* ";
                    }
                    else if (trimmedPreviousLine.StartsWith("/**", StringComparison.Ordinal) || trimmedPreviousLine.StartsWith("/*", StringComparison.Ordinal))
                    {
                        commentPrefix = " * ";
                    }
                    else if (trimmedPreviousLine.StartsWith("*", StringComparison.Ordinal))
                    {
                        commentPrefix = "*";
                    }

                    int indentSize   = line.GetIndentation(textEditorData).Length;
                    var insertedText = prevLine.GetIndentation(textEditorData) + commentPrefix;
                    textEditorData.ReplaceText(line.Offset, indentSize, insertedText);
                    textEditorData.CaretOffset = line.Offset + insertedText.Length;
                    return(true);
                }
                else if (wasInStringLiteral)
                {
                    var lexer = new ICSharpCode.NRefactory.CSharp.Completion.CSharpCompletionEngineBase.MiniLexer(textEditorData.GetTextAt(0, prevLine.EndOffset).TrimEnd());
                    lexer.Parse();
                    if (!lexer.IsInString)
                    {
                        return(false);
                    }
                    textEditorData.EnsureCaretIsNotVirtual();
                    var insertedText = "\" +";
                    textEditorData.InsertText(prevLine.Offset + prevLine.Length, insertedText);
                    var lineOffset = line.Offset + insertedText.Length;
                    int indentSize = textEditorData.CaretOffset - lineOffset;
                    insertedText = prevLine.GetIndentation(textEditorData) + (trimmedPreviousLine.StartsWith("\"", StringComparison.Ordinal) ? "" : "\t") + "\"";
                    textEditorData.ReplaceText(lineOffset, indentSize, insertedText);
                    return(true);
                }
            }
            return(false);
        }
Esempio n. 3
0
        public override void HandleSpecialSelectionKey(uint unicodeKey)
        {
            string start, end;

            ((SelectionSurroundingProvider)this).GetSelectionSurroundings(unicodeKey, out start, out end);

            if (editor.SelectionMode == SelectionMode.Block)
            {
                var selection = editor.SelectionRegion;
                int startCol  = System.Math.Min(selection.Begin.Column, selection.End.Column) - 1;
                int endCol    = System.Math.Max(selection.Begin.Column, selection.End.Column);

                int minLine = System.Math.Min(selection.Begin.Line, selection.End.Line);
                int maxLine = System.Math.Max(selection.BeginLine, selection.End.Line);

                var changes = new List <TextChange> ();
                for (int lineNumber = minLine; lineNumber <= maxLine; lineNumber++)
                {
                    var lineSegment = editor.GetLine(lineNumber);

                    if (lineSegment.Offset + startCol < lineSegment.EndOffset)
                    {
                        changes.Add(new TextChange(new TextSpan(lineSegment.Offset + startCol, 0), start));
                    }
                    if (lineSegment.Offset + endCol < lineSegment.EndOffset)
                    {
                        changes.Add(new TextChange(new TextSpan(lineSegment.Offset + endCol, 0), end));
                    }
                }

                editor.ApplyTextChanges(changes);

//				textEditorData.MainSelection = new Selection (
//					new DocumentLocation (selection.Anchor.Line, endCol == selection.Anchor.Column ? endCol + start.Length : startCol + 1 + start.Length),
//					new DocumentLocation (selection.Lead.Line, endCol == selection.Anchor.Column ? startCol + 1 + start.Length : endCol + start.Length),
//					MonoDevelop.Ide.Editor.SelectionMode.Block);
            }
            else
            {
                var selectionRange = editor.SelectionRange;
                int anchorOffset   = selectionRange.Offset;
                int leadOffset     = selectionRange.EndOffset;
                var text           = editor.GetTextAt(selectionRange);

                var formattingService = context.AnalysisDocument.GetLanguageService <IEditorFormattingService> ();


                if (editor.Options.GenerateFormattingUndoStep)
                {
                    using (var undo = editor.OpenUndoGroup()) {
                        editor.ReplaceText(selectionRange, start);
                    }
                    using (var undo = editor.OpenUndoGroup()) {
                        editor.ReplaceText(anchorOffset, 1, start + text + end);
                        editor.SetSelection(anchorOffset + start.Length, leadOffset + start.Length + end.Length);
                    }
                    if (unicodeKey == '{')
                    {
                        if (formattingService != null)
                        {
                            var changes = formattingService.GetFormattingChangesAsync(context.AnalysisDocument, TextSpan.FromBounds(anchorOffset + start.Length - 1, leadOffset + start.Length + end.Length), CancellationToken.None).WaitAndGetResult(CancellationToken.None);
                            editor.ApplyTextChanges(changes);
                        }
                    }
                }
                else
                {
                    using (var undo = editor.OpenUndoGroup()) {
                        editor.InsertText(anchorOffset, start);
                        editor.InsertText(leadOffset >= anchorOffset ? leadOffset + start.Length : leadOffset, end);
                        if (unicodeKey == '{')
                        {
                            if (formattingService != null)
                            {
                                var changes = formattingService.GetFormattingChangesAsync(context.AnalysisDocument, TextSpan.FromBounds(anchorOffset + start.Length, leadOffset + start.Length), CancellationToken.None).WaitAndGetResult(CancellationToken.None);
                                editor.ApplyTextChanges(changes);
                            }
                        }
                        else
                        {
                            editor.SetSelection(anchorOffset + start.Length, leadOffset + start.Length + end.Length);
                        }
                    }
                }
            }
        }