public void OnNewLine()
{
if (editor.cursor.posY <= 0)
{
return;
}
UIDELine line = editor.doc.LineAt(editor.cursor.posY);
UIDELine previousLine = editor.doc.GetLastNoneWhitespaceOrCommentLine(editor.cursor.posY - 1);
if (previousLine == null)
{
return;
}
UIDEElement firstElement = previousLine.GetFirstNonWhitespaceElement();
int previousLineStartPos = previousLine.GetElementStartPos(firstElement);
int screenPos = previousLine.GetScreenPosition(previousLineStartPos);
UIDEElement lastElement = previousLine.GetLastNonWhitespaceElement();
string originalText = line.rawText;
int tabCount = screenPos / 4;
if (lastElement != null && lastElement.rawText == "{")
{
tabCount += 1;
}
line.rawText = line.GetTrimmedWhitespaceText();
for (int i = 0; i < tabCount; i++)
{
line.rawText = "\t" + line.rawText;
}
line.RebuildElements();
Vector2 oldCursorPos = editor.cursor.GetVectorPosition();
editor.cursor.posX = tabCount;
Vector2 newCursorPos = editor.cursor.GetVectorPosition();
//add another undo with the same name as the previous one so it gets grouped.
if (editor.undoManager.undos.Count > 0)
{
string undoName = editor.undoManager.undos[editor.undoManager.undos.Count - 1].groupID;
editor.undoManager.RegisterUndo(undoName, UIDEUndoType.LineModify, line.index, originalText, line.rawText, oldCursorPos, newCursorPos);
}
}
public void OnCloseCurly()
{
if (editor.cursor.posY <= 0)
{
return;
}
UIDELine line = editor.doc.LineAt(editor.cursor.posY);
UIDELine previousLine = editor.doc.GetLastNoneWhitespaceOrCommentLine(editor.cursor.posY - 1);
if (previousLine == line)
{
return;
}
if (!line.IsLineWhitespace())
{
return;
}
UIDEElement firstElement = previousLine.GetFirstNonWhitespaceElement();
int previousLineStartPos = previousLine.GetElementStartPos(firstElement);
int screenPos = previousLine.GetScreenPosition(previousLineStartPos);
UIDEElement lastElement = previousLine.GetLastNonWhitespaceElement();
int tabCount = screenPos / 4;
if (lastElement != null)
{
if (lastElement.tokenDef.HasType("LineEnd"))
{
tabCount -= 1;
}
}
tabCount = Mathf.Max(tabCount, 0);
line.rawText = line.GetTrimmedWhitespaceText();
for (int i = 0; i < tabCount; i++)
{
line.rawText = "\t" + line.rawText;
}
//line.rawText += startingText;
line.RebuildElements();
editor.cursor.posX = tabCount;
}
public void OnColon()
{
UIDELine line = editor.doc.RealLineAt((int)editor.cursor.posY);
if (line == null)
{
return;
}
if (editor.cursor.posY < line.rawText.Length)
{
return;
}
UIDEElement firstElement = line.GetFirstNonWhitespaceElement();
if (firstElement == null)
{
return;
}
if (firstElement.tokenDef.HasType("Word") && firstElement.rawText == "case")
{
if (line.rawText[0] == '\t')
{
//string originalText = lines[i].rawText;
line.rawText = line.rawText.Substring(1);
line.RebuildElements();
}
else if (line.rawText[0] == ' ')
{
int tabSize = editor.editorWindow.textSettings.GetTabSize();
//string originalText = lines[i].rawText;
for (int j = 0; j < tabSize; j++)
{
if (line.rawText.Length <= 0 || line.rawText[0] != ' ')
{
break;
}
line.rawText = line.rawText.Substring(1);
}
line.RebuildElements();
}
editor.cursor.posX = line.rawText.Length;
}
}
public void OnSubmit()
{
HideBox();
UIDEElement element = GetCursorElement();
if (element != null && selectedIndex >= 0 && selectedIndex < itemList.Count)
{
Vector2 oldCursorPos = editor.cursor.GetVectorPosition();
string originalText = element.line.rawText;
if (element.tokenDef.HasType("WhiteSpace"))
{
string newText = itemList[selectedIndex].displayName;
newText = element.line.rawText.Insert(editor.cursor.posX, newText);
element.line.rawText = newText;
editor.cursor.posX += itemList[selectedIndex].displayName.Length;
}
else
{
string newText = itemList[selectedIndex].displayName;
if (element.rawText.Length == 1 && element.tokenDef.HasType("Dot"))
{
newText = element.rawText + newText;
}
int lengthDif = newText.Length - element.rawText.Length;
element.line.SetElementText(element, newText);
editor.cursor.posX += lengthDif;
}
element.line.RebuildElements();
UIDEUndoManager undoManager = editor.undoManager;
Vector2 newCursorPos = editor.cursor.GetVectorPosition();
string undoName = "AutoComplete Submit " + undoManager.GetUniqueID();
undoManager.RegisterUndo(undoName, UIDEUndoType.LineModify, element.line.index, originalText, element.line.rawText, oldCursorPos, newCursorPos);
}
}
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 void OnPostRenderLine(UIDELine line)
{
if (!show) return;
if (findTerm != "") {
string lineText = line.rawText;
string actualFindTerm = findTerm;
string actualLineText = line.rawText;
if (!useCase) {
actualFindTerm = actualFindTerm.ToLower();
actualLineText = actualLineText.ToLower();
}
List<int> searchIndexes = AllIndexesOf(actualLineText,actualFindTerm);
if (searchIndexes.Count > 0) {
float yPos = line.index*editor.charSize.y;
GUIStyle hoverHighlightStyle = editor.editorWindow.theme.GetStyle("CursorHoverHighlight");
//float contentHeight = hoverHighlightStyle.CalcHeight(new GUIContent("#YOLO"),100);
for (int i = 0; i < searchIndexes.Count; i++) {
int index = searchIndexes[i];
int charXPos = line.GetScreenPosition(index);
float xPos = charXPos*editor.charSize.x;
//float xEndPos = line.GetScreenPosition(index+findTerm.Length)*editor.charSize.x;
bool isSameAsSelection = false;
if (editor.cursor.selection.actualStart == new Vector2(index,line.index) && editor.cursor.selection.actualEnd == new Vector2(index+findTerm.Length,line.index)) {
isSameAsSelection = true;
}
string inlineText = lineText.Substring(index,findTerm.Length);
if (!isSameAsSelection) {
UIDEElement element = new UIDEElement();
element.rawText = inlineText;
element.line = line;
editor.RenderElement(element, new Vector2(xPos,yPos),index,hoverHighlightStyle,false);
//float width = xEndPos-xPos;
//Rect r = new Rect(xPos,yPos,width,contentHeight);
//GUI.Box(r,"",hoverHighlightStyle);
}
}
}
}
}
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());
}