예제 #1
0
        internal async Task FormatText()
        {
            Document   newDocument = EditorControl.Document;
            SyntaxTree tree        = await EditorControl.GetSyntaxTree();

            await EditorControl.SetText(Formatter.Format(tree.GetRoot(), newDocument.Project.Solution.Workspace).GetText());

            int caretOffset = EditorControl.CaretOffset;

            int initialCaretOffset = caretOffset;

            IEnumerable <TextChange> textChanges = await EditorControl.Document.GetTextChangesAsync(newDocument);

            foreach (TextChange change in from el in textChanges where el.Span.End <= initialCaretOffset select el)
            {
                caretOffset -= change.Span.Length - change.NewText.Length;
            }

            EditorControl.SetSelection(caretOffset, 0);
        }
예제 #2
0
        public async Task OnPreviewKeyDown(KeyEventArgs e)
        {
            if (OwnerEditor.SymbolToolTip.IsVisible)
            {
                OwnerEditor.SymbolToolTip.IsVisible = false;
            }

            if (e.Key.IsNavigation())
            {
                CompletionCurrentlyDisabled = false;
            }

            if (e.Key == Key.LeftCtrl || e.Key == Key.RightCtrl)
            {
                IsCtrlPressed = true;
            }
            else if (e.Key == Avalonia.Input.Key.Up)
            {
                if (CompletionWindow.IsVisible)
                {
                    if (CompletionWindow.SelectedIndex >= 0)
                    {
                        _ = CompletionWindow.UpdateSelectedIndex(-1);
                    }
                    e.Handled = true;
                }
                else if (MethodOverloadList.IsVisible)
                {
                    MethodOverloadList.SelectedIndex = Math.Max(MethodOverloadList.SelectedIndex - 1, 0);
                    await MethodOverloadList.RenderDescription(MethodOverloadList.Items[MethodOverloadList.SelectedIndex]);

                    e.Handled = true;
                }
            }
            else if (e.Key == Avalonia.Input.Key.Down)
            {
                if (CompletionWindow.IsVisible)
                {
                    _         = CompletionWindow.UpdateSelectedIndex(1);
                    e.Handled = true;
                }
                else if (MethodOverloadList.IsVisible)
                {
                    MethodOverloadList.SelectedIndex = Math.Min(MethodOverloadList.SelectedIndex + 1, MethodOverloadList.Items.Count - 1);
                    await MethodOverloadList.RenderDescription(MethodOverloadList.Items[MethodOverloadList.SelectedIndex]);

                    e.Handled = true;
                }
            }
            if (e.Key == Avalonia.Input.Key.PageUp)
            {
                if (CompletionWindow.IsVisible)
                {
                    if (CompletionWindow.SelectedIndex >= 0)
                    {
                        _ = CompletionWindow.UpdateSelectedIndex(-(int)(CompletionWindow.Height - 33) / 20);
                    }

                    e.Handled = true;
                }
                else if (MethodOverloadList.IsVisible)
                {
                    MethodOverloadList.SelectedIndex = Math.Max(MethodOverloadList.SelectedIndex - 1, 0);
                    await MethodOverloadList.RenderDescription(MethodOverloadList.Items[MethodOverloadList.SelectedIndex]);

                    e.Handled = true;
                }
            }
            else if (e.Key == Avalonia.Input.Key.PageDown)
            {
                if (CompletionWindow.IsVisible)
                {
                    _         = CompletionWindow.UpdateSelectedIndex((int)(CompletionWindow.Height - 33) / 20);
                    e.Handled = true;
                }
                else if (MethodOverloadList.IsVisible)
                {
                    MethodOverloadList.SelectedIndex = Math.Min(MethodOverloadList.SelectedIndex + 1, MethodOverloadList.Items.Count - 1);
                    await MethodOverloadList.RenderDescription(MethodOverloadList.Items[MethodOverloadList.SelectedIndex]);

                    e.Handled = true;
                }
            }
            else if (e.Key == Key.Tab)
            {
                if (CompletionWindow.IsVisible)
                {
                    await CompletionWindow.Commit();

                    CompletionWindow.IsVisible = false;
                    e.Handled = true;
                }
                else if (MethodOverloadList.IsVisible)
                {
                    MethodOverloadList.IsVisible = false;
                }
            }
            else if (e.Key == Key.Escape)
            {
                if (CompletionWindow.IsVisible)
                {
                    CompletionWindow.IsVisible  = false;
                    CompletionCurrentlyDisabled = true;
                    e.Handled = true;
                }
                else if (MethodOverloadList.IsVisible)
                {
                    MethodOverloadList.IsVisible = false;
                    e.Handled = true;
                }
            }
            else if (e.Key == Key.Delete)
            {
                if (CompletionWindow.IsVisible)
                {
                    CompletionWindow.IsVisible  = false;
                    CompletionCurrentlyDisabled = true;
                }

                if (MethodOverloadList.IsVisible)
                {
                    MethodOverloadList.IsVisible = false;
                }
            }
            else if ((e.Key == Key.Left || e.Key == Key.Right || e.Key == Key.Home || e.Key == Key.End))
            {
                if (CompletionWindow.IsVisible)
                {
                    CompletionWindow.IsVisible = false;
                }

                if (MethodOverloadList.IsVisible)
                {
                    MethodOverloadList.IsVisible = false;
                }
            }
            else if (e.Key == Key.S && e.KeyModifiers == Utils.ControlCmdModifier)
            {
                this.OwnerEditor.Save();
            }
            else if (e.Key == Key.J && e.KeyModifiers == Utils.ControlCmdModifier)
            {
                e.Handled = true;

                if (!EditorControl.IsReadOnly)
                {
                    await OpenCompletion(true);
                }
            }
            else if (e.Key == Key.K && e.KeyModifiers == Utils.ControlCmdModifier)
            {
                e.Handled = true;
                if (EditorControl.CaretOffset > 0)
                {
                    char inserted = EditorControl.Text.ToString()[EditorControl.CaretOffset - 1];
                    await OpenMethodOverloads(inserted);
                }
            }
            else if (e.Key == Key.L && e.KeyModifiers == Utils.ControlCmdModifier)
            {
                e.Handled = true;
                await OwnerEditor.CompilationErrorChecker.CheckCompilation();
            }
            else if ((e.Key == Key.E || e.Key == Key.D) && e.KeyModifiers == Utils.ControlCmdModifier)
            {
                if (!EditorControl.IsReadOnly)
                {
                    await OwnerEditor.FormatText();
                }
                e.Handled = true;
            }
            else if (e.Key == Key.F9)
            {
                TextLine line = EditorControl.Text.Lines.GetLineFromPosition(EditorControl.CaretOffset);
                Editor.BreakpointToggleResult result = await OwnerEditor.TryToggleBreakpoint(line.Start, line.End);

                if (result == Editor.BreakpointToggleResult.Added)
                {
                    EditorControl.CaretOffset = EditorControl.Text.Lines[line.LineNumber].End;
                }
                else if (result == Editor.BreakpointToggleResult.Removed)
                {
                    EditorControl.CaretOffset = EditorControl.Text.Lines[line.LineNumber].Start;
                }
                e.Handled = true;
            }
            else if (e.Key == Key.F12)
            {
                ISymbol symbol = await SymbolFinder.FindSymbolAtPositionAsync(EditorControl.Document, EditorControl.CaretOffset);

                if (symbol != null)
                {
                    SyntaxNode declaration = symbol.DeclaringSyntaxReferences.Select(el => el.GetSyntax()).FirstOrDefault();

                    if (declaration != null)
                    {
                        PropertyInfo identifierProperty = declaration.GetType().GetProperty("Identifier", typeof(SyntaxToken));

                        if (identifierProperty != null)
                        {
                            SyntaxToken identifierToken = (SyntaxToken)identifierProperty.GetValue(declaration);
                            EditorControl.SetSelection(identifierToken.Span.Start, identifierToken.Span.Length);
                        }
                        else
                        {
                            EditorControl.SetSelection(declaration.Span.Start, declaration.Span.Length);
                        }
                    }
                }
            }
            else if (e.Key == Key.F5 && OwnerEditor.BreakpointPanel.IsVisible)
            {
                OwnerEditor.BreakpointPanel.InvokeResumeClicked();
                e.Handled = true;
            }
        }