public override void OnArrowKeyMoveCursor(Vector2 pos)
        {
            UIDELine line = editor.doc.RealLineAt((int)pos.y);

            if (line == null)
            {
                return;
            }
            UIDEElement element = line.GetElementAt((int)pos.x);

            if (element == null)
            {
                return;
            }
            if (element.tokenDef.isActualCode == true)
            {
                char c = (char)0;
                if (pos.x < line.rawText.Length)
                {
                    c = line.rawText[(int)pos.x];
                }
                if (c == ';' || c == '{' || c == '}')
                {
                    UpdateChainResolver();
                }
            }
            if (conservativeParsing && editor.lastModifyTime > lastReparseTime)
            {
                Reparse();
            }
        }
Exemplo n.º 2
0
        public UIDEElement GetCursorElement(int offset)
        {
            UIDELine line = editor.doc.LineAt(editor.cursor.posY);

            if (line != null)
            {
                UIDEElement element = line.GetElementAt(editor.cursor.posX - 1);
                return(element);
            }
            return(null);
        }
Exemplo n.º 3
0
        public void UpdateAutoComplete(string text, bool isBackspace)
        {
            if (!isEnabled)
            {
                return;
            }
            if (text == "\n" || text == "\b" || (text == "" && !isBackspace))
            {
                return;
            }

            if (text.Length > 1)
            {
                HideBox();
                return;
            }

            UIDELine    line    = editor.doc.LineAt(editor.cursor.posY);
            UIDEElement element = GetCursorElement();

            if (!genericMode)
            {
                if (text == "(")
                {
                    StartShowTooltip(editor.cursor.GetVectorPosition(), true);
                    dontShowToolTipAgain = true;
                    cancelTooltip        = false;
                }
                if (text == ")" || isBackspace)
                {
                    if (isShowingMethodOverloadTooltip)
                    {
                        HideToolTip();
                    }
                    if (!isBackspace)
                    {
                        cancelTooltip = true;
                    }
                }
                if (text == " " && (editor.extension == ".cs" || editor.extension == ".js"))
                {
                    Vector2 lastWordPos = editor.doc.IncrementPosition(editor.cursor.GetVectorPosition(), -1);
                    lastWordPos = editor.doc.IncrementPosition(lastWordPos, -1);
                    //lastWordPos = editor.doc.GoToEndOfWhitespace(lastWordPos,-1);
                    UIDEElement newElement = editor.doc.GetElementAt(lastWordPos);
                    if (newElement != null && newElement.rawText == "new")
                    {
                        Vector2 newWordStart = lastWordPos;
                        newWordStart.x = line.GetElementStartPos(newElement);
                        Vector2 leadingCharPos = editor.doc.IncrementPosition(newWordStart, -1);
                        leadingCharPos = editor.doc.GoToEndOfWhitespace(leadingCharPos, -1);
                        char leadingChar = editor.doc.GetCharAt(leadingCharPos);
                        if (leadingChar == '=')
                        {
                            Vector2 wordStartPos = editor.doc.IncrementPosition(leadingCharPos, -1);
                            wordStartPos = editor.doc.GoToEndOfWhitespace(wordStartPos, -1);
                            string      str = "";
                            UIDEElement firstNonWhitespaceElement = line.GetFirstNonWhitespaceElement();
                            if (editor.extension == ".js" && firstNonWhitespaceElement != null && firstNonWhitespaceElement.rawText == "var")
                            {
                                Vector2 typeStart = editor.doc.GoToNextRealChar(wordStartPos, ':', -1);
                                if (typeStart.y == wordStartPos.y)
                                {
                                    typeStart = editor.doc.IncrementPosition(typeStart, 1);
                                    typeStart = editor.doc.GoToEndOfWhitespace(typeStart, 1);

                                    if (typeStart.x < wordStartPos.x)
                                    {
                                        str = line.rawText.Substring((int)typeStart.x, (int)wordStartPos.x - (int)typeStart.x + 1);
                                        str = str.Replace(" ", "");
                                        str = str.Replace("\t", "");
                                        str = str.Replace(".<", "<");
                                    }
                                }
                            }
                            else
                            {
                                str = editor.syntaxRule.ResolveExpressionAt(wordStartPos, -1);
                            }
                            ChainResolver sigChainResolver = new ChainResolver(editor, editor.cursor.GetVectorPosition());

                            ChainItem item = null;
                            item = sigChainResolver.ResolveChain(str, false);

                            if (item != null && item.finalLinkType != null)
                            {
                                CompletionItem cItem = new CompletionItem(item.finalLinkType);
                                if (cItem != null)
                                {
                                    string[] usingNamespaces = editor.syntaxRule.GetNamespacesVisibleInCurrentScope(editor.cursor.GetVectorPosition());
                                    string[] chainNamespaces = editor.syntaxRule.GetNamespaceChain(editor.cursor.GetVectorPosition());
                                    cItem.name = cItem.PrettyFormatType(false, usingNamespaces, chainNamespaces);
                                    //Debug.Log(cItem.genericArguments[0].resultingType);
                                    itemList = new List <CompletionItem>();
                                    itemList.Add(cItem);
                                    selectedIndex = 0;
                                    ShowBox();
                                }
                            }

                            return;
                        }
                    }
                }
            }

            if (element != null)
            {
                isDot        = element.tokenDef.HasType("Dot");
                isWord       = element.tokenDef.HasType("Word");
                isWhiteSpace = element.tokenDef.HasType("WhiteSpace");
                bool isDotOrWord = isDot || isWord;

                autoCompleteKey = element.rawText;
                int  elementPos = line.GetElementStartPos(element);
                bool isChain    = false;

                if (isDot)
                {
                    isChain = true;
                }
                else
                {
                    if (elementPos > 0 && isWord)
                    {
                        UIDEElement previousElement = line.GetElementAt(elementPos - 1);
                        if (previousElement != null)
                        {
                            if (previousElement.tokenDef.HasType("Dot"))
                            {
                                isChain = true;
                            }
                        }
                    }
                }

                if (genericMode)
                {
                    isChain = false;
                }

                //bool newCharIsWhitespace = text == " "||text == "\t";

                if (visible && isWord)
                {
                    //continue an existing autocomplete
                }
                if (!visible && isDotOrWord && !isBackspace)
                {
                    TryStartUpdateAutoCompleteList(isChain);
                }
                if (visible && !isDotOrWord)
                {
                    HideBox();
                }
                if (visible && isBackspace && !isDotOrWord)
                {
                    HideBox();
                }
                //For performance on OSX.
                if (Application.platform == RuntimePlatform.OSXEditor)
                {
                    if (visible && isBackspace)
                    {
                        HideBox();
                        visible = false;
                    }
                }
                if (visible && autoCompleteKey != "")
                {
                    TryStartUpdateAutoCompleteList(isChain);
                }
                if (visible && isDot)
                {
                    UpdateRect();
                }
                //TryStartUpdateAutoCompleteList();
            }
            else
            {
                if (visible)
                {
                    HideBox();
                }
            }

            editor.editorWindow.Repaint();
        }
        public override CompletionItem[] GetChainCompletionItems()
        {
            if (parserInterface.lastSourceFile == null)
            {
                Reparse();
            }

            if (conservativeParsing && isCreatingChainResolver)
            {
                int i = 0;
                while (isCreatingChainResolver && i < 100)
                {
                    Thread.Sleep(10);
                    i++;
                }
            }

            if (conservativeParsing)
            {
                UpdateChainResolverActual(null);
            }

            List <CompletionItem> items = new List <CompletionItem>();

            Vector2 previousCharPos = editor.cursor.GetVectorPosition();

            previousCharPos = editor.doc.IncrementPosition(previousCharPos, -1);

            UIDELine    line    = editor.doc.RealLineAt((int)previousCharPos.y);
            UIDEElement element = line.GetElementAt((int)previousCharPos.x);

            Vector2 expressionStartPos = previousCharPos;

            bool lastCharIsDot = element.tokenDef.HasType("Dot");

            if (lastCharIsDot)
            {
                expressionStartPos = editor.doc.IncrementPosition(expressionStartPos, -1);
            }
            else
            {
                int elementPos = line.GetElementStartPos(element);
                if (elementPos >= 2)
                {
                    element = line.GetElementAt(elementPos - 1);
                    if (element.tokenDef.HasType("Dot"))
                    {
                        expressionStartPos.x = elementPos - 2;
                    }
                }
            }

            ChainItem item = null;
            string    str  = ResolveExpressionAt(expressionStartPos, -1);

            if (useUnityscript)
            {
                str = str.Replace(".<", "<");
            }
            //Debug.Log(str);

            VerifyChainResolver();

            item = chainResolver.ResolveChain(str);

            if (item != null)
            {
                items = item.autoCompleteItems;
            }

            return(items.ToArray());
        }