Esempio n. 1
0
        protected async override Task CorrectIndentingImplementationAsync(Ide.Editor.TextEditor editor, DocumentContext context, int startLine, int endLine, CancellationToken cancellationToken)
        {
            if (editor.IndentationTracker == null)
            {
                return;
            }
            var startSegment = editor.GetLine(startLine);

            if (startSegment == null)
            {
                return;
            }
            var endSegment = startLine != endLine?editor.GetLine(endLine) : startSegment;

            if (endSegment == null)
            {
                return;
            }

            try {
                var document = context.AnalysisDocument;

                var formattingService = document.GetLanguageService <IEditorFormattingService> ();
                if (formattingService == null || !formattingService.SupportsFormatSelection)
                {
                    return;
                }

                var formattingRules = new List <AbstractFormattingRule> ();
                formattingRules.Add(ContainedDocumentPreserveFormattingRule.Instance);
                formattingRules.AddRange(Formatter.GetDefaultFormattingRules(document));

                var workspace = document.Project.Solution.Workspace;
                var root      = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);

                var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);

                var changes = Formatter.GetFormattedTextChanges(
                    root, new TextSpan [] { new TextSpan(startSegment.Offset, endSegment.EndOffset - startSegment.Offset) },
                    workspace, options, formattingRules, cancellationToken);

                if (changes == null)
                {
                    return;
                }
                await Runtime.RunInMainThread(delegate {
                    editor.ApplyTextChanges(changes);
                    editor.FixVirtualIndentation();
                });
            } catch (Exception e) {
                LoggingService.LogError("Error while indenting", e);
            }
        }
Esempio n. 2
0
        static CodeFixMenuEntry CreateFixAllMenuEntry(Ide.Editor.TextEditor editor, FixAllState fixState, ref int mnemonic, CancellationToken token)
        {
            var provider = fixState?.FixAllProvider;

            if (provider == null)
            {
                return(null);
            }

            var doc       = editor.DocumentContext;
            var workspace = doc?.RoslynWorkspace;

            if (workspace == null)
            {
                return(null);
            }

            var title = fixState.GetDefaultFixAllTitle();
            var label = mnemonic < 0 ? title : CreateLabel(title, ref mnemonic);

            var item = new CodeFixMenuEntry(label, async delegate {
                // Task.Run here so we don't end up binding the whole document on popping the menu, also there is no cancellation token support

                Microsoft.CodeAnalysis.Text.TextChange[] result = await Task.Run(async() => {
                    var context = fixState.CreateFixAllContext(new RoslynProgressTracker(), token);
                    var fix     = await provider.GetFixAsync(context);

                    var previewOperations = await fix.GetPreviewOperationsAsync(token);
                    return(await Runtime.RunInMainThread(() => {
                        var engine = Xwt.Toolkit.CurrentEngine;                         // NativeEngine
                        return engine.Invoke(async() => {
                            using (var dialog = new FixAllPreviewDialog(string.Join(", ", fixState.DiagnosticIds), doc.Name, fixState.Scope, previewOperations, editor)) {
                                await dialog.InitializeEditor();
                                var parent = Xwt.Toolkit.CurrentEngine.WrapWindow(IdeApp.Workbench.RootWindow);
                                var changes = dialog.Run(parent) == Xwt.Command.Apply ? dialog.GetApplicableChanges().ToArray() : Array.Empty <Microsoft.CodeAnalysis.Text.TextChange> ();
                                return changes;
                            }
                        });
                    }));
                });

                if (result.Length == 0)
                {
                    return;
                }

                editor.ApplyTextChanges(result);
            });

            return(item);
        }
Esempio n. 3
0
        protected override async void OnTheFlyFormatImplementation(Ide.Editor.TextEditor editor, DocumentContext context, int startOffset, int length)
        {
            var doc = context.AnalysisDocument;

            var formattingService = doc.GetLanguageService <IEditorFormattingService> ();

            if (formattingService == null || !formattingService.SupportsFormatSelection)
            {
                return;
            }

            var changes = await formattingService.GetFormattingChangesAsync(doc, new TextSpan (startOffset, length), default(System.Threading.CancellationToken));

            if (changes == null)
            {
                return;
            }
            editor.ApplyTextChanges(changes);
            editor.FixVirtualIndentation();
        }
Esempio n. 4
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);
                        }
                    }
                }
            }
        }