Example #1
0
        public override void InsertCompletionText(CompletionListWindow window, ref KeyActions ka, Gdk.Key closeChar, char keyChar, Gdk.ModifierType modifier)
        {
            string text        = CompletionText;
            string partialWord = GetCurrentWord(window);
            int    skipChars   = 0;
            bool   runParameterCompletionCommand = false;

            if (keyChar == '(' && !IsDelegateExpected && Entity is IMethod && !HasNonMethodMembersWithSameName((IMember)Entity))
            {
                var    line      = Editor.GetLine(Editor.Caret.Line);
                var    method    = (IMethod)Entity;
                var    start     = window.CodeCompletionContext.TriggerOffset + partialWord.Length + 2;
                var    end       = line.Offset + line.Length;
                string textToEnd = start < end?Editor.GetTextBetween(start, end) : "";

                if (Policy.BeforeMethodCallParentheses)
                {
                    text += " ";
                }

                int exprStart = window.CodeCompletionContext.TriggerOffset - 1;
                while (exprStart > line.Offset)
                {
                    char ch = Editor.GetCharAt(exprStart);
                    if (ch != '.' && ch != '_' && /*ch != '<' && ch != '>' && */ !char.IsLetterOrDigit(ch))
                    {
                        break;
                    }
                    exprStart--;
                }
                string textBefore      = Editor.GetTextBetween(line.Offset, exprStart);
                bool   insertSemicolon = false;
                if (string.IsNullOrEmpty((textBefore + textToEnd).Trim()))
                {
                    insertSemicolon = true;
                }



                int pos;
                if (SearchBracket(window.CodeCompletionContext.TriggerOffset + partialWord.Length, out pos))
                {
                    window.CompletionWidget.SetCompletionText(window.CodeCompletionContext, partialWord, text);
                    ka |= KeyActions.Ignore;
                    int bracketOffset = pos + text.Length - partialWord.Length;

                    // correct white space before method call.
                    char charBeforeBracket = bracketOffset > 1 ? Editor.GetCharAt(bracketOffset - 2) : '\0';
                    if (Policy.BeforeMethodCallParentheses)
                    {
                        if (charBeforeBracket != ' ')
                        {
                            Editor.Insert(bracketOffset - 1, " ");
                            bracketOffset++;
                        }
                    }
                    else
                    {
                        if (char.IsWhiteSpace(charBeforeBracket))
                        {
                            while (bracketOffset > 1 && char.IsWhiteSpace(Editor.GetCharAt(bracketOffset - 2)))
                            {
                                Editor.Remove(bracketOffset - 1, 1);
                                bracketOffset--;
                            }
                        }
                    }
                    Editor.Caret.Offset = bracketOffset;
                    if (insertSemicolon && Editor.GetCharAt(bracketOffset) == ')')
                    {
                        Editor.Insert(bracketOffset + 1, ";");
                        // Need to reinsert the ')' as skip char because we inserted the ';' after the ')' and skip chars get deleted
                        // when an insert after the skip char position occur.
                        Editor.SetSkipChar(bracketOffset, ')');
                        Editor.SetSkipChar(bracketOffset + 1, ';');
                    }
                    if (runParameterCompletionCommand)
                    {
                        editorCompletion.RunParameterCompletionCommand();
                    }
                    return;
                }

                if (HasAnyOverloadWithParameters(method))
                {
                    if (insertSemicolon)
                    {
                        text     += "(|);";
                        skipChars = 2;
                    }
                    else
                    {
                        text     += "(|)";
                        skipChars = 1;
                    }
                    runParameterCompletionCommand = true;
                }
                else
                {
                    if (insertSemicolon)
                    {
                        text += "();|";
                    }
                    else
                    {
                        text += "()|";
                    }
                }
                if (keyChar == '(')
                {
                    var skipChar = Editor.SkipChars.LastOrDefault();
                    if (skipChar != null && skipChar.Offset == (window.CodeCompletionContext.TriggerOffset + partialWord.Length) && skipChar.Char == ')')
                    {
                        Editor.Remove(skipChar.Offset, 1);
                    }
                }

                ka |= KeyActions.Ignore;
            }

            window.CompletionWidget.SetCompletionText(window.CodeCompletionContext, partialWord, text);
            int offset = Editor.Caret.Offset;

            for (int i = 0; i < skipChars; i++)
            {
                Editor.SetSkipChar(offset, Editor.GetCharAt(offset));
                offset++;
            }

            if (runParameterCompletionCommand)
            {
                editorCompletion.RunParameterCompletionCommand();
            }
        }
Example #2
0
        public void InsertCompletionText(CompletionListWindow window, ref KeyActions ka, Gdk.Key closeChar, char keyChar, Gdk.ModifierType modifier, bool addParens, bool addOpeningOnly)
        {
            string text        = CompletionText;
            string partialWord = GetCurrentWord(window);
            int    skipChars   = 0;
            bool   runParameterCompletionCommand = false;
            var    method = Entity as IMethod;

            if (addParens && !IsDelegateExpected && method != null && !HasNonMethodMembersWithSameName((IMember)Entity) && !IsBracketAlreadyInserted(method))
            {
                var    line      = Editor.GetLine(Editor.Caret.Line);
                var    start     = window.CodeCompletionContext.TriggerOffset + partialWord.Length + 2;
                var    end       = line.Offset + line.Length;
                string textToEnd = start < end?Editor.GetTextBetween(start, end) : "";

                bool addSpace = Policy.BeforeMethodCallParentheses && CSharpTextEditorIndentation.OnTheFlyFormatting;

                int exprStart = window.CodeCompletionContext.TriggerOffset - 1;
                while (exprStart > line.Offset)
                {
                    char ch = Editor.GetCharAt(exprStart);
                    if (ch != '.' && ch != '_' && /*ch != '<' && ch != '>' && */ !char.IsLetterOrDigit(ch))
                    {
                        break;
                    }
                    exprStart--;
                }
                bool insertSemicolon = InsertSemicolon(exprStart);
                if (Entity.SymbolKind == SymbolKind.Constructor)
                {
                    insertSemicolon = false;
                }
                //int pos;

                Gdk.Key[] keys = new [] { Gdk.Key.Return, Gdk.Key.Tab, Gdk.Key.space, Gdk.Key.KP_Enter, Gdk.Key.ISO_Enter };
                if (keys.Contains(closeChar) || keyChar == '.')
                {
                    if (HasAnyOverloadWithParameters(method))
                    {
                        if (addOpeningOnly)
                        {
                            text     += RequireGenerics(method) ? "<|" : (addSpace ? " (|" : "(|");
                            skipChars = 0;
                        }
                        else
                        {
                            if (keyChar == '.')
                            {
                                if (RequireGenerics(method))
                                {
                                    text += addSpace ? "<> ()" : "<>()";
                                }
                                else
                                {
                                    text += addSpace ? " ()" : "()";
                                }
                                skipChars = 0;
                            }
                            else
                            {
                                if (insertSemicolon)
                                {
                                    if (RequireGenerics(method))
                                    {
                                        text     += addSpace ? "<|> ();" : "<|>();";
                                        skipChars = addSpace ? 5 : 4;
                                    }
                                    else
                                    {
                                        text     += addSpace ? " (|);" : "(|);";
                                        skipChars = 2;
                                    }
                                }
                                else
                                {
                                    if (RequireGenerics(method))
                                    {
                                        text     += addSpace ? "<|> ()" :  "<|>()";
                                        skipChars = addSpace ? 4 : 3;
                                    }
                                    else
                                    {
                                        text     += addSpace ? " (|)" : "(|)";
                                        skipChars = 1;
                                    }
                                }
                            }
                        }
                        runParameterCompletionCommand = true;
                    }
                    else
                    {
                        if (addOpeningOnly)
                        {
                            text     += RequireGenerics(method) ? "<|" : (addSpace ? " (|" : "(|");
                            skipChars = 0;
                        }
                        else
                        {
                            if (keyChar == '.')
                            {
                                if (RequireGenerics(method))
                                {
                                    text += addSpace ? "<> ().|" : "<>().|";
                                }
                                else
                                {
                                    text += addSpace ? " ().|" : "().|";
                                }
                                skipChars = 0;
                            }
                            else
                            {
                                if (insertSemicolon)
                                {
                                    if (RequireGenerics(method))
                                    {
                                        text += addSpace ? "<|> ();" : "<|>();";
                                    }
                                    else
                                    {
                                        text += addSpace ? " ();|" : "();|";
                                    }
                                }
                                else
                                {
                                    if (RequireGenerics(method))
                                    {
                                        text += addSpace ? "<|> ()" : "<|>()";
                                    }
                                    else
                                    {
                                        text += addSpace ? " ()|" : "()|";
                                    }
                                }
                            }
                        }
                    }
                    if (keyChar == '(')
                    {
                        var skipChar = Editor.SkipChars.LastOrDefault();
                        if (skipChar != null && skipChar.Offset == (window.CodeCompletionContext.TriggerOffset + partialWord.Length) && skipChar.Char == ')')
                        {
                            Editor.Remove(skipChar.Offset, 1);
                        }
                    }
                }
                ka |= KeyActions.Ignore;
            }
            if ((DisplayFlags & DisplayFlags.NamedArgument) == DisplayFlags.NamedArgument &&
                (closeChar == Gdk.Key.Tab ||
                 closeChar == Gdk.Key.KP_Tab ||
                 closeChar == Gdk.Key.ISO_Left_Tab ||
                 closeChar == Gdk.Key.Return ||
                 closeChar == Gdk.Key.KP_Enter ||
                 closeChar == Gdk.Key.ISO_Enter))
            {
                if (Policy.AroundAssignmentParentheses)
                {
                    text += " ";
                }
                text += "=";
                if (Policy.AroundAssignmentParentheses)
                {
                    text += " ";
                }
            }
            window.CompletionWidget.SetCompletionText(window.CodeCompletionContext, partialWord, text);
            int offset = Editor.Caret.Offset;

            for (int i = 0; i < skipChars; i++)
            {
                Editor.SetSkipChar(offset, Editor.GetCharAt(offset));
                offset++;
            }

            if (runParameterCompletionCommand)
            {
                editorCompletion.RunParameterCompletionCommand();
            }
        }