/**
* Calculates number of unmatched left braces before the given offset.
*
* @param editor target editor
* @param offset target offset
* @param fileType target file type
* @return number of unmatched braces before the given offset; negative value if it's not possible
* to perform the calculation or if there are no unmatched left braces before the given offset
*/
protected static int getUnmatchedLBracesNumberBefore(
Editor editor, int offset, FileType fileType) {
if (offset == 0) {
return -1;
}
CharSequence chars = editor.getDocument().getCharsSequence();
if (chars.charAt(offset - 1) != '{') {
return -1;
}
EditorHighlighter highlighter = ((EditorEx) editor).getHighlighter();
HighlighterIterator iterator = highlighter.createIterator(offset - 1);
BraceMatcher braceMatcher = BraceMatchingUtil.getBraceMatcher(fileType, iterator);
if (!braceMatcher.isLBraceToken(iterator, chars, fileType)
|| !braceMatcher.isStructuralBrace(iterator, chars, fileType)) {
return -1;
}
Language language = iterator.getTokenType().getLanguage();
iterator = highlighter.createIterator(0);
int lBracesBeforeOffset = 0;
int lBracesAfterOffset = 0;
int rBracesBeforeOffset = 0;
int rBracesAfterOffset = 0;
for (; !iterator.atEnd(); iterator.advance()) {
IElementType tokenType = iterator.getTokenType();
if (!tokenType.getLanguage().equals(language)
|| !braceMatcher.isStructuralBrace(iterator, chars, fileType)) {
continue;
}
boolean beforeOffset = iterator.getStart() < offset;
if (braceMatcher.isLBraceToken(iterator, chars, fileType)) {
if (beforeOffset) {
lBracesBeforeOffset++;
} else {
lBracesAfterOffset++;
}
} else if (braceMatcher.isRBraceToken(iterator, chars, fileType)) {
if (beforeOffset) {
rBracesBeforeOffset++;
} else {
rBracesAfterOffset++;
}
}
}
return lBracesBeforeOffset - rBracesBeforeOffset - (rBracesAfterOffset - lBracesAfterOffset);
}
private static void init(final AbstractFileType abstractFileType) {
SyntaxTable table = abstractFileType.getSyntaxTable();
CompletionUtil.registerCompletionData(abstractFileType, new SyntaxTableCompletionData(table));
if (!isEmpty(table.getStartComment()) && !isEmpty(table.getEndComment())
|| !isEmpty(table.getLineComment())) {
abstractFileType.setCommenter(new MyCommenter(abstractFileType));
}
if (table.isHasBraces() || table.isHasBrackets() || table.isHasParens()) {
BraceMatchingUtil.registerBraceMatcher(abstractFileType, new CustomFileTypeBraceMatcher());
}
TypedHandler.registerQuoteHandler(abstractFileType, new CustomFileTypeQuoteHandler());
}
/** Calculates line indents for the {@link #myDocument target document}. */
void calculate() {
final FileType fileType = myFile.getFileType();
int prevLineIndent = -1;
for (int line = 0; line < lineIndents.length; line++) {
ProgressManager.checkCanceled();
int lineStart = myDocument.getLineStartOffset(line);
int lineEnd = myDocument.getLineEndOffset(line);
final int nonWhitespaceOffset =
CharArrayUtil.shiftForward(myChars, lineStart, lineEnd, " \t");
if (nonWhitespaceOffset == lineEnd) {
lineIndents[line] = -1; // Blank line marker
} else {
final int column =
((EditorImpl) myEditor).calcColumnNumber(nonWhitespaceOffset, line, true, myChars);
if (prevLineIndent > 0 && prevLineIndent > column) {
lineIndents[line] = calcIndent(line, nonWhitespaceOffset, lineEnd, column);
} else {
lineIndents[line] = column;
}
prevLineIndent = lineIndents[line];
}
}
int topIndent = 0;
for (int line = 0; line < lineIndents.length; line++) {
ProgressManager.checkCanceled();
if (lineIndents[line] >= 0) {
topIndent = lineIndents[line];
} else {
int startLine = line;
while (line < lineIndents.length && lineIndents[line] < 0) {
//noinspection AssignmentToForLoopParameter
line++;
}
int bottomIndent = line < lineIndents.length ? lineIndents[line] : topIndent;
int indent = Math.min(topIndent, bottomIndent);
if (bottomIndent < topIndent) {
int lineStart = myDocument.getLineStartOffset(line);
int lineEnd = myDocument.getLineEndOffset(line);
int nonWhitespaceOffset =
CharArrayUtil.shiftForward(myChars, lineStart, lineEnd, " \t");
HighlighterIterator iterator =
myEditor.getHighlighter().createIterator(nonWhitespaceOffset);
if (BraceMatchingUtil.isRBraceToken(iterator, myChars, fileType)) {
indent = topIndent;
}
}
for (int blankLine = startLine; blankLine < line; blankLine++) {
assert lineIndents[blankLine] == -1;
lineIndents[blankLine] = Math.min(topIndent, indent);
}
//noinspection AssignmentToForLoopParameter
line--; // will be incremented back at the end of the loop;
}
}
}
protected boolean handleBackspace(
Editor editor, Caret caret, DataContext dataContext, boolean toWordStart) {
Project project = CommonDataKeys.PROJECT.getData(dataContext);
if (project == null) return false;
PsiFile file = PsiUtilBase.getPsiFileInEditor(editor, project);
if (file == null) return false;
if (editor.getSelectionModel().hasSelection()) return false;
int offset = editor.getCaretModel().getOffset() - 1;
if (offset < 0) return false;
CharSequence chars = editor.getDocument().getCharsSequence();
char c = chars.charAt(offset);
final Editor injectedEditor =
TypedHandler.injectedEditorIfCharTypedIsSignificant(c, editor, file);
final Editor originalEditor = editor;
if (injectedEditor != editor) {
int injectedOffset = injectedEditor.getCaretModel().getOffset();
if (isOffsetInsideInjected(injectedEditor, injectedOffset)) {
file = PsiDocumentManager.getInstance(project).getPsiFile(injectedEditor.getDocument());
editor = injectedEditor;
offset = injectedOffset - 1;
}
}
final BackspaceHandlerDelegate[] delegates =
Extensions.getExtensions(BackspaceHandlerDelegate.EP_NAME);
if (!toWordStart) {
for (BackspaceHandlerDelegate delegate : delegates) {
delegate.beforeCharDeleted(c, file, editor);
}
}
FileType fileType = file.getFileType();
final QuoteHandler quoteHandler = TypedHandler.getQuoteHandler(file, editor);
HighlighterIterator hiterator = ((EditorEx) editor).getHighlighter().createIterator(offset);
boolean wasClosingQuote =
quoteHandler != null && quoteHandler.isClosingQuote(hiterator, offset);
myOriginalHandler.execute(originalEditor, caret, dataContext);
if (!toWordStart) {
for (BackspaceHandlerDelegate delegate : delegates) {
if (delegate.charDeleted(c, file, editor)) {
return true;
}
}
}
if (offset >= editor.getDocument().getTextLength()) return true;
chars = editor.getDocument().getCharsSequence();
if ((c == '(' || c == '[' || c == '{')
&& CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET) {
char c1 = chars.charAt(offset);
if (c1 != getRightChar(c)) return true;
HighlighterIterator iterator = ((EditorEx) editor).getHighlighter().createIterator(offset);
BraceMatcher braceMatcher = BraceMatchingUtil.getBraceMatcher(fileType, iterator);
if (!braceMatcher.isLBraceToken(iterator, chars, fileType)
&& !braceMatcher.isRBraceToken(iterator, chars, fileType)) {
return true;
}
int rparenOffset =
BraceMatchingUtil.findRightmostRParen(iterator, iterator.getTokenType(), chars, fileType);
if (rparenOffset >= 0) {
iterator = ((EditorEx) editor).getHighlighter().createIterator(rparenOffset);
boolean matched = BraceMatchingUtil.matchBrace(chars, fileType, iterator, false);
if (matched) return true;
}
editor.getDocument().deleteString(offset, offset + 1);
} else if ((c == '"' || c == '\'' || c == '`')
&& CodeInsightSettings.getInstance().AUTOINSERT_PAIR_QUOTE) {
char c1 = chars.charAt(offset);
if (c1 != c) return true;
if (wasClosingQuote) return true;
HighlighterIterator iterator = ((EditorEx) editor).getHighlighter().createIterator(offset);
if (quoteHandler == null || !quoteHandler.isOpeningQuote(iterator, offset)) return true;
editor.getDocument().deleteString(offset, offset + 1);
}
return true;
}
public Result beforeCharTyped(
final char c,
final Project project,
final Editor editor,
final PsiFile editedFile,
final FileType fileType) {
final XmlEditorOptions xmlEditorOptions = XmlEditorOptions.getInstance();
if (c == '>'
&& xmlEditorOptions != null
&& xmlEditorOptions.isAutomaticallyInsertClosingTag()
&& (editedFile.getLanguage() instanceof XMLLanguage
|| editedFile.getViewProvider().getBaseLanguage() instanceof XMLLanguage)) {
PsiDocumentManager.getInstance(project).commitAllDocuments();
PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
FileViewProvider provider = editedFile.getViewProvider();
int offset = editor.getCaretModel().getOffset();
PsiElement element, elementAtCaret = null;
if (offset < editor.getDocument().getTextLength()) {
elementAtCaret = element = provider.findElementAt(offset, XMLLanguage.class);
if (!(element instanceof PsiWhiteSpace)) {
boolean nonAcceptableDelimiter = true;
if (element instanceof XmlToken) {
IElementType tokenType = ((XmlToken) element).getTokenType();
if (tokenType == XmlTokenType.XML_START_TAG_START
|| tokenType == XmlTokenType.XML_END_TAG_START) {
if (offset > 0) {
PsiElement previousElement = provider.findElementAt(offset - 1, XMLLanguage.class);
if (previousElement instanceof XmlToken) {
tokenType = ((XmlToken) previousElement).getTokenType();
element = previousElement;
nonAcceptableDelimiter = false;
}
}
} else if (tokenType == XmlTokenType.XML_NAME) {
if (element.getNextSibling() instanceof PsiErrorElement) {
nonAcceptableDelimiter = false;
}
}
if (tokenType == XmlTokenType.XML_TAG_END
|| tokenType == XmlTokenType.XML_EMPTY_ELEMENT_END
&& element.getTextOffset() == offset - 1) {
editor.getCaretModel().moveToOffset(offset + 1);
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
return Result.STOP;
}
}
if (nonAcceptableDelimiter) return Result.CONTINUE;
} else {
// check if right after empty end
PsiElement previousElement = provider.findElementAt(offset - 1, XMLLanguage.class);
if (previousElement instanceof XmlToken) {
final IElementType tokenType = ((XmlToken) previousElement).getTokenType();
if (tokenType == XmlTokenType.XML_EMPTY_ELEMENT_END) {
return Result.STOP;
}
}
}
PsiElement parent = element.getParent();
if (parent instanceof XmlText) {
final String text = parent.getText();
// check /
final int index = offset - parent.getTextOffset() - 1;
if (index >= 0 && text.charAt(index) == '/') {
return Result.CONTINUE; // already seen /
}
element = parent.getPrevSibling();
} else if (parent instanceof XmlTag && !(element.getPrevSibling() instanceof XmlTag)) {
element = parent;
} else if (parent instanceof XmlAttributeValue) {
element = parent;
}
} else {
element =
provider.findElementAt(editor.getDocument().getTextLength() - 1, XMLLanguage.class);
if (element == null) return Result.CONTINUE;
element = element.getParent();
}
if (offset > 0 && offset <= editor.getDocument().getTextLength()) {
if (editor.getDocument().getCharsSequence().charAt(offset - 1)
== '/') { // Some languages (e.g. GSP) allow character '/' in tag name.
return Result.CONTINUE;
}
}
if (element instanceof XmlAttributeValue) {
element = element.getParent().getParent();
}
while (element instanceof PsiWhiteSpace) element = element.getPrevSibling();
if (element instanceof XmlDocument) { // hack for closing tags in RHTML
element = element.getLastChild();
}
if (element == null) return Result.CONTINUE;
if (!(element instanceof XmlTag)) {
if (element instanceof XmlTokenImpl
&& element.getPrevSibling() != null
&& element.getPrevSibling().getText().equals("<")) {
// tag is started and there is another text in the end
editor.getDocument().insertString(offset, "</" + element.getText() + ">");
}
return Result.CONTINUE;
}
XmlTag tag = (XmlTag) element;
if (XmlUtil.getTokenOfType(tag, XmlTokenType.XML_TAG_END) != null) return Result.CONTINUE;
if (XmlUtil.getTokenOfType(tag, XmlTokenType.XML_EMPTY_ELEMENT_END) != null)
return Result.CONTINUE;
final XmlToken startToken = XmlUtil.getTokenOfType(tag, XmlTokenType.XML_START_TAG_START);
if (startToken == null || !startToken.getText().equals("<")) return Result.CONTINUE;
String name = tag.getName();
if (elementAtCaret instanceof XmlToken
&& ((XmlToken) elementAtCaret).getTokenType() == XmlTokenType.XML_NAME) {
name = name.substring(0, offset - elementAtCaret.getTextOffset());
}
if (tag instanceof HtmlTag && HtmlUtil.isSingleHtmlTag(name)) return Result.CONTINUE;
if ("".equals(name)) return Result.CONTINUE;
int tagOffset = tag.getTextRange().getStartOffset();
final XmlToken nameToken = XmlUtil.getTokenOfType(tag, XmlTokenType.XML_NAME);
if (nameToken != null && nameToken.getTextRange().getStartOffset() > offset)
return Result.CONTINUE;
HighlighterIterator iterator = ((EditorEx) editor).getHighlighter().createIterator(tagOffset);
if (BraceMatchingUtil.matchBrace(
editor.getDocument().getCharsSequence(),
editedFile.getFileType(),
iterator,
true,
true)) {
PsiElement parent = tag.getParent();
boolean hasBalance = true;
while (parent instanceof XmlTag && name.equals(((XmlTag) parent).getName())) {
ASTNode astNode = XmlChildRole.CLOSING_TAG_NAME_FINDER.findChild(parent.getNode());
if (astNode == null) {
hasBalance = false;
break;
}
parent = parent.getParent();
}
if (hasBalance) {
hasBalance = false;
for (ASTNode node = parent.getNode().getLastChildNode();
node != null;
node = node.getTreePrev()) {
ASTNode leaf = node;
if (leaf.getElementType() == TokenType.ERROR_ELEMENT) {
ASTNode firstChild = leaf.getFirstChildNode();
if (firstChild != null) leaf = firstChild;
else {
PsiElement psiElement = PsiTreeUtil.nextLeaf(leaf.getPsi());
leaf = psiElement != null ? psiElement.getNode() : null;
}
if (leaf != null && leaf.getElementType() == TokenType.WHITE_SPACE) {
PsiElement psiElement = PsiTreeUtil.nextLeaf(leaf.getPsi());
if (psiElement != null) leaf = psiElement.getNode();
}
}
if (leaf != null && leaf.getElementType() == XmlTokenType.XML_END_TAG_START) {
ASTNode treeNext = leaf.getTreeNext();
IElementType treeNextType;
if (treeNext != null
&& ((treeNextType = treeNext.getElementType()) == XmlTokenType.XML_NAME
|| treeNextType == XmlTokenType.XML_TAG_NAME)) {
if (name.equals(treeNext.getText())) {
ASTNode parentEndName =
parent instanceof XmlTag
? XmlChildRole.CLOSING_TAG_NAME_FINDER.findChild(parent.getNode())
: null;
hasBalance =
!(parent instanceof XmlTag)
|| parentEndName != null && !parentEndName.getText().equals(name);
break;
}
}
}
}
}
if (hasBalance) return Result.CONTINUE;
}
TextRange cdataReformatRange = null;
final XmlElementDescriptor descriptor = tag.getDescriptor();
if (descriptor instanceof XmlElementDescriptorWithCDataContent) {
final XmlElementDescriptorWithCDataContent cDataContainer =
(XmlElementDescriptorWithCDataContent) descriptor;
if (cDataContainer.requiresCdataBracesInContext(tag)) {
int rangeStart = offset;
@NonNls final String cDataStart = "><![CDATA[";
final String inserted = cDataStart + "\n]]>";
editor.getDocument().insertString(offset, inserted);
final int newoffset = offset + cDataStart.length();
editor.getCaretModel().moveToOffset(newoffset);
offset += inserted.length();
cdataReformatRange = new TextRange(rangeStart, offset + 1);
}
}
editor.getDocument().insertString(offset, "</" + name + ">");
if (cdataReformatRange != null) {
PsiDocumentManager.getInstance(project).commitDocument(editor.getDocument());
try {
CodeStyleManager.getInstance(project)
.reformatText(
file, cdataReformatRange.getStartOffset(), cdataReformatRange.getEndOffset());
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
return cdataReformatRange != null ? Result.STOP : Result.CONTINUE;
}
return Result.CONTINUE;
}