private void writeAttributes(Element attrElements) throws WriteExternalException {
List<TextAttributesKey> list = new ArrayList<TextAttributesKey>(myAttributesMap.keySet());
Collections.sort(list);
for (TextAttributesKey key : list) {
TextAttributes defaultAttr =
myParentScheme != null ? myParentScheme.getAttributes(key) : new TextAttributes();
TextAttributesKey baseKey = key.getFallbackAttributeKey();
TextAttributes defaultFallbackAttr =
baseKey != null && myParentScheme instanceof AbstractColorsScheme
? ((AbstractColorsScheme) myParentScheme).getFallbackAttributes(baseKey)
: null;
TextAttributes value = myAttributesMap.get(key);
if (!value.equals(defaultAttr) || defaultAttr == defaultFallbackAttr) {
Element element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, key.getExternalName());
if (baseKey == null || !value.isFallbackEnabled()) {
Element valueElement = new Element(VALUE_ELEMENT);
value.writeExternal(valueElement);
element.addContent(valueElement);
attrElements.addContent(element);
} else if (defaultAttr != defaultFallbackAttr) {
element.setAttribute(BASE_ATTRIBUTES_ATTR, baseKey.getExternalName());
attrElements.addContent(element);
}
}
}
}
private SchemeTextAttributesDescription(
String name,
String group,
@NotNull TextAttributesKey key,
@NotNull MyColorScheme scheme,
Icon icon,
String toolTip) {
super(name, group, getInitialAttributes(scheme, key).clone(), key, scheme, icon, toolTip);
this.key = key;
myAttributesToApply = getInitialAttributes(scheme, key);
TextAttributesKey fallbackKey = key.getFallbackAttributeKey();
if (fallbackKey != null) {
myFallbackAttributes = scheme.getAttributes(fallbackKey);
myBaseAttributeDescriptor =
ColorSettingsPages.getInstance().getAttributeDescriptor(fallbackKey);
if (myBaseAttributeDescriptor == null) {
myBaseAttributeDescriptor =
new Pair<ColorSettingsPage, AttributesDescriptor>(
null, new AttributesDescriptor(fallbackKey.getExternalName(), fallbackKey));
}
}
myIsInheritedInitial = isInherited(scheme);
setInherited(myIsInheritedInitial);
initCheckedStatus();
}
public static Map<String, TextAttributesKey> createRainbowHLM() {
Map<String, TextAttributesKey> hashMap = new HashMap<>();
hashMap.put(RAINBOW_ANCHOR.getExternalName(), RAINBOW_ANCHOR);
hashMap.put(RAINBOW_GRADIENT_DEMO.getExternalName(), RAINBOW_GRADIENT_DEMO);
for (TextAttributesKey key : RAINBOW_TEMP_KEYS) {
hashMap.put(key.getExternalName(), key);
}
return hashMap;
}
protected TextAttributes getFallbackAttributes(TextAttributesKey fallbackKey) {
if (fallbackKey == null) return null;
TextAttributes fallbackAttributes = getDirectlyDefinedAttributes(fallbackKey);
if (fallbackAttributes != null) {
if (!fallbackAttributes.isFallbackEnabled()
|| fallbackKey.getFallbackAttributeKey() == null) {
return fallbackAttributes;
}
}
return getFallbackAttributes(fallbackKey.getFallbackAttributeKey());
}
@NotNull
public TextAttributesKey[] getRainbowTempKeys() {
TextAttributesKey[] keys = new TextAttributesKey[myRainbowColors.length];
for (int i = 0; i < myRainbowColors.length; ++i) {
//noinspection deprecation
TextAttributesKey key =
TextAttributesKey.createTextAttributesKey(RAINBOW_TEMP_PREF + i, new TextAttributes());
key.getDefaultAttributes().setForegroundColor(myRainbowColors[i]);
keys[i] = key;
}
return keys;
}
/** @author Robert F. Beeger ([email protected]) */ public class ManifestColorsAndFonts { public static final TextAttributesKey HEADER_NAME_KEY = TextAttributesKey.createTextAttributesKey( "manifest.header.name", DefaultLanguageHighlighterColors.KEYWORD); public static final TextAttributesKey HEADER_ASSIGNMENT_KEY = TextAttributesKey.createTextAttributesKey( "manifest.header.assignment", DefaultLanguageHighlighterColors.OPERATION_SIGN); public static final TextAttributesKey HEADER_VALUE_KEY = TextAttributesKey.createTextAttributesKey( "manifest.header.value", DefaultLanguageHighlighterColors.IDENTIFIER); private ManifestColorsAndFonts() {} }
static {
for (int i = 0; i < RAINBOW_JB_COLORS_DEFAULT.length; ++i) {
//noinspection deprecation
RAINBOW_COLOR_KEYS[i] =
TextAttributesKey.createTextAttributesKey(
"RAINBOW_COLOR" + i, createRainbowAttribute(RAINBOW_JB_COLORS_DEFAULT[i]));
}
}
private void migrateErrorStripeColorFrom14(
@NotNull TextAttributesKey name, @NotNull TextAttributes attr) {
if (myVersion >= 141 || myParentScheme == null) return;
Couple<Color> m = DEFAULT_STRIPE_COLORS.get(name.getExternalName());
if (m != null && Comparing.equal(m.first, attr.getErrorStripeColor())) {
attr.setErrorStripeColor(m.second);
}
}
public void readAttributes(@NotNull Element childNode) {
for (Element e : childNode.getChildren(OPTION_ELEMENT)) {
TextAttributesKey name = TextAttributesKey.find(e.getAttributeValue(NAME_ATTR));
Element valueElement = e.getChild(VALUE_ELEMENT);
TextAttributes attr =
valueElement != null ? new TextAttributes(valueElement) : new TextAttributes();
myAttributesMap.put(name, attr);
migrateErrorStripeColorFrom14(name, attr);
}
}
private boolean isInherited(@NotNull MyColorScheme scheme) {
TextAttributes attributes = scheme.getAttributes(key);
TextAttributesKey fallbackKey = key.getFallbackAttributeKey();
if (fallbackKey != null && !scheme.containsKey(key)) {
TextAttributes fallbackAttributes = scheme.getAttributes(fallbackKey);
if (attributes != null && attributes == fallbackAttributes) {
return true;
}
}
return false;
}
@NotNull
public static String generatePaletteExample() {
int stopCount = RAINBOW_COLOR_KEYS.length;
StringBuilder sb = new StringBuilder();
String tagRainbow = RAINBOW_GRADIENT_DEMO.getExternalName();
for (int i = 0; i < RAINBOW_TEMP_KEYS.length; ++i) {
if (sb.length() != 0) {
sb.append(" ");
}
sb.append("<").append(tagRainbow).append(">");
sb.append((i % stopCount == 0) ? "Stop#" + String.valueOf(i / stopCount + 1) : "T");
sb.append("</").append(tagRainbow).append(">");
}
return sb.toString();
}
@Nullable
public Map<String, TextAttributesKey> getAdditionalHighlightingTagToDescriptorMap() {
final Map<String, TextAttributesKey> map = new HashMap<String, TextAttributesKey>();
map.put("string", BashSyntaxHighlighter.STRING);
map.put("heredoc", BashSyntaxHighlighter.HERE_DOC);
map.put("heredocStart", BashSyntaxHighlighter.HERE_DOC_START);
map.put("heredocEnd", BashSyntaxHighlighter.HERE_DOC_END);
map.put("backquote", BashSyntaxHighlighter.BACKQUOTE);
map.put("internalCmd", BashSyntaxHighlighter.INTERNAL_COMMAND);
map.put("externalCmd", BashSyntaxHighlighter.EXTERNAL_COMMAND);
map.put("subshellCmd", BashSyntaxHighlighter.SUBSHELL_COMMAND);
map.put("functionCall", BashSyntaxHighlighter.FUNCTION_CALL);
map.put("varDef", BashSyntaxHighlighter.VAR_DEF);
map.put("internalVar", BashSyntaxHighlighter.VAR_USE_BUILTIN);
map.put("composedVar", BashSyntaxHighlighter.VAR_USE_COMPOSED);
// we need this to be able to insert << in the text
// (relies on the current implementation of JetBrain's HighlightsExtractor class)
map.put("dummy", TextAttributesKey.find("dummy"));
return map;
}
/** @author ilyas */
public class DefaultHighlighter {
@NonNls static final String LINE_COMMENT_ID = "Line comment";
@NonNls static final String BLOCK_COMMENT_ID = "Block comment";
@NonNls static final String DOC_COMMENT_ID = "Groovydoc comment";
@NonNls static final String DOC_COMMENT_TAG_ID = "Groovydoc tag";
@NonNls static final String KEYWORD_ID = "Keyword";
@NonNls static final String NUMBER_ID = "Number";
@NonNls static final String GSTRING_ID = "GString";
@NonNls static final String STRING_ID = "String";
@NonNls static final String BRACES_ID = "Braces";
@NonNls static final String BRACKETS_ID = "Brackets";
@NonNls static final String PARENTHESES_ID = "Parentheses";
@NonNls static final String OPERATION_SIGN_ID = "Operation sign";
@NonNls static final String BAD_CHARACTER_ID = "Bad character";
@NonNls static final String WRONG_STRING_ID = "Wrong string literal";
@NonNls static final String ANNOTATION_ID = "Annotation";
@NonNls static final String INSTANCE_FIELD_ID = "Instance field";
@NonNls static final String STATIC_FIELD_ID = "Static field";
@NonNls static final String METHOD_CALL_ID = "Method call";
@NonNls static final String STATIC_METHOD_ACCESS_ID = "Static method access";
@NonNls static final String CLASS_REFERENCE_ID = "Class";
@NonNls static final String TYPE_PARAMETER_ID = "Type parameter";
@NonNls static final String INSTANCE_PROPERTY_REFERENCE_ID = "Instance property reference ID";
@NonNls static final String STATIC_PROPERTY_REFERENCE_ID = "Static property reference ID";
@NonNls static final String MAP_KEY_ID = "Map key";
@NonNls static final String UNRESOLVED_ACCESS_ID = "Unresolved reference access";
static final String LITERAL_CONVERSION_ID = "List/map to object conversion";
static final String VALID_STRING_ESCAPE_ID = "Valid string escape";
static final String INVALID_STRING_ESCAPE_ID = "Invalid string escape";
@NonNls static final String LABEL_ID = "Label";
public static TextAttributesKey LINE_COMMENT =
TextAttributesKey.createTextAttributesKey(
LINE_COMMENT_ID, SyntaxHighlighterColors.LINE_COMMENT.getDefaultAttributes());
public static TextAttributesKey ANNOTATION =
TextAttributesKey.createTextAttributesKey(
ANNOTATION_ID,
HighlightInfoType.ANNOTATION_NAME.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey LOCAL_VARIABLE =
TextAttributesKey.createTextAttributesKey(
"Groovy var", HighlightInfoType.LOCAL_VARIABLE.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey REASSIGNED_LOCAL_VARIABLE =
TextAttributesKey.createTextAttributesKey(
"Groovy reassigned var",
HighlightInfoType.REASSIGNED_LOCAL_VARIABLE.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey PARAMETER =
TextAttributesKey.createTextAttributesKey(
"Groovy parameter",
HighlightInfoType.PARAMETER.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey REASSIGNED_PARAMETER =
TextAttributesKey.createTextAttributesKey(
"Groovy reassigned parameter",
HighlightInfoType.REASSIGNED_PARAMETER.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey METHOD_DECLARATION =
TextAttributesKey.createTextAttributesKey(
"Groovy method declaration",
HighlightInfoType.METHOD_DECLARATION.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey INSTANCE_FIELD =
TextAttributesKey.createTextAttributesKey(
INSTANCE_FIELD_ID,
HighlightInfoType.INSTANCE_FIELD.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey METHOD_CALL =
TextAttributesKey.createTextAttributesKey(
METHOD_CALL_ID, HighlightInfoType.METHOD_CALL.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey STATIC_FIELD =
TextAttributesKey.createTextAttributesKey(
STATIC_FIELD_ID,
HighlightInfoType.STATIC_FINAL_FIELD.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey STATIC_METHOD_ACCESS =
TextAttributesKey.createTextAttributesKey(
STATIC_METHOD_ACCESS_ID,
HighlightInfoType.STATIC_METHOD.getAttributesKey().getDefaultAttributes());
public static TextAttributesKey BLOCK_COMMENT =
TextAttributesKey.createTextAttributesKey(
BLOCK_COMMENT_ID, SyntaxHighlighterColors.JAVA_BLOCK_COMMENT.getDefaultAttributes());
public static TextAttributesKey DOC_COMMENT_CONTENT =
TextAttributesKey.createTextAttributesKey(
DOC_COMMENT_ID, SyntaxHighlighterColors.DOC_COMMENT.getDefaultAttributes());
public static TextAttributesKey DOC_COMMENT_TAG =
TextAttributesKey.createTextAttributesKey(
DOC_COMMENT_TAG_ID, SyntaxHighlighterColors.DOC_COMMENT_TAG.getDefaultAttributes());
public static TextAttributesKey CLASS_REFERENCE =
TextAttributesKey.createTextAttributesKey(
CLASS_REFERENCE_ID, HighlighterColors.TEXT.getDefaultAttributes().clone());
public static TextAttributesKey TYPE_PARAMETER =
TextAttributesKey.createTextAttributesKey(
TYPE_PARAMETER_ID,
CodeInsightColors.TYPE_PARAMETER_NAME_ATTRIBUTES.getDefaultAttributes().clone());
public static final TextAttributes INSTANCE_PROPERTY_REFERENCE_ATTRIBUTES =
INSTANCE_FIELD.getDefaultAttributes().clone();
public static final TextAttributes STATIC_PROPERTY_REFERENCE_ATTRIBUTES =
STATIC_FIELD.getDefaultAttributes().clone();
static {
INSTANCE_PROPERTY_REFERENCE_ATTRIBUTES.setFontType(Font.PLAIN);
STATIC_PROPERTY_REFERENCE_ATTRIBUTES.setFontType(Font.ITALIC);
}
public static TextAttributesKey INSTANCE_PROPERTY_REFERENCE =
TextAttributesKey.createTextAttributesKey(
INSTANCE_PROPERTY_REFERENCE_ID, INSTANCE_PROPERTY_REFERENCE_ATTRIBUTES);
public static TextAttributesKey STATIC_PROPERTY_REFERENCE =
TextAttributesKey.createTextAttributesKey(
STATIC_PROPERTY_REFERENCE_ID, STATIC_PROPERTY_REFERENCE_ATTRIBUTES);
public static final TextAttributes KEYWORD_ATTRIBUTES =
SyntaxHighlighterColors.KEYWORD.getDefaultAttributes().clone();
static {
KEYWORD_ATTRIBUTES.setForegroundColor(new Color(0, 0, 67));
KEYWORD_ATTRIBUTES.setFontType(Font.BOLD);
}
public static TextAttributesKey KEYWORD =
TextAttributesKey.createTextAttributesKey(
"GROOVY_" + KEYWORD_ID.toUpperCase(), KEYWORD_ATTRIBUTES);
public static TextAttributesKey NUMBER =
TextAttributesKey.createTextAttributesKey(
NUMBER_ID, SyntaxHighlighterColors.NUMBER.getDefaultAttributes());
public static TextAttributesKey GSTRING =
TextAttributesKey.createTextAttributesKey(
GSTRING_ID, SyntaxHighlighterColors.STRING.getDefaultAttributes());
public static TextAttributesKey STRING =
TextAttributesKey.createTextAttributesKey(
STRING_ID, SyntaxHighlighterColors.STRING.getDefaultAttributes());
public static TextAttributesKey BRACES =
TextAttributesKey.createTextAttributesKey(
BRACES_ID, SyntaxHighlighterColors.BRACES.getDefaultAttributes());
public static TextAttributesKey BRACKETS =
TextAttributesKey.createTextAttributesKey(
BRACKETS_ID, SyntaxHighlighterColors.BRACKETS.getDefaultAttributes());
public static TextAttributesKey PARENTHESES =
TextAttributesKey.createTextAttributesKey(
PARENTHESES_ID, SyntaxHighlighterColors.PARENTHS.getDefaultAttributes());
public static TextAttributesKey OPERATION_SIGN =
TextAttributesKey.createTextAttributesKey(
OPERATION_SIGN_ID, SyntaxHighlighterColors.OPERATION_SIGN.getDefaultAttributes());
public static TextAttributesKey BAD_CHARACTER =
TextAttributesKey.createTextAttributesKey(
BAD_CHARACTER_ID, CodeInsightColors.UNMATCHED_BRACE_ATTRIBUTES.getDefaultAttributes());
public static TextAttributesKey WRONG_STRING =
TextAttributesKey.createTextAttributesKey(
WRONG_STRING_ID, SyntaxHighlighterColors.STRING.getDefaultAttributes());
public static final TextAttributes UNRESOLVED_ACCESS_ATTRIBUTES =
HighlighterColors.TEXT.getDefaultAttributes().clone();
static {
UNRESOLVED_ACCESS_ATTRIBUTES.setForegroundColor(Color.BLACK);
UNRESOLVED_ACCESS_ATTRIBUTES.setEffectColor(Color.GRAY);
UNRESOLVED_ACCESS_ATTRIBUTES.setEffectType(EffectType.LINE_UNDERSCORE);
}
public static final TextAttributes LITERAL_CONVERSION_ATTRIBUTES =
HighlighterColors.TEXT.getDefaultAttributes().clone();
static {
LITERAL_CONVERSION_ATTRIBUTES.setForegroundColor(PlatformColors.BLUE);
LITERAL_CONVERSION_ATTRIBUTES.setFontType(Font.BOLD);
}
public static final TextAttributes MAP_KEY_ATTRIBUTES =
HighlighterColors.TEXT.getDefaultAttributes().clone();
public static final Color MAP_KEY_COLOR = new Color(0, 128, 0);
static {
MAP_KEY_ATTRIBUTES.setForegroundColor(MAP_KEY_COLOR);
}
public static TextAttributesKey UNRESOLVED_ACCESS =
TextAttributesKey.createTextAttributesKey(UNRESOLVED_ACCESS_ID, UNRESOLVED_ACCESS_ATTRIBUTES);
public static TextAttributesKey LITERAL_CONVERSION =
TextAttributesKey.createTextAttributesKey(
LITERAL_CONVERSION_ID, LITERAL_CONVERSION_ATTRIBUTES);
public static TextAttributesKey MAP_KEY =
TextAttributesKey.createTextAttributesKey(MAP_KEY_ID, MAP_KEY_ATTRIBUTES);
public static final TextAttributesKey VALID_STRING_ESCAPE =
TextAttributesKey.createTextAttributesKey(
VALID_STRING_ESCAPE_ID,
SyntaxHighlighterColors.VALID_STRING_ESCAPE.getDefaultAttributes());
public static final TextAttributesKey INVALID_STRING_ESCAPE =
TextAttributesKey.createTextAttributesKey(
INVALID_STRING_ESCAPE_ID,
SyntaxHighlighterColors.INVALID_STRING_ESCAPE.getDefaultAttributes());
public static final TextAttributes LABEL_ATTRIBUTES =
HighlighterColors.TEXT.getDefaultAttributes().clone();
public static final TextAttributesKey LABEL =
TextAttributesKey.createTextAttributesKey(LABEL_ID, LABEL_ATTRIBUTES);
private DefaultHighlighter() {}
}
/** Created by IntelliJ IDEA. User: jon Date: Apr 3, 2010 Time: 1:55:00 AM */
public class MoonHighlightingData {
@NonNls static final String KEYWORD_ID = "MOON_KEYWORD";
@NonNls static final String COMMENT_ID = "MOON_COMMENT";
@NonNls static final String LONGCOMMENT_ID = "MOON_LONGCOMMENT";
@NonNls static final String NUMBER_ID = "MOON_NUMBER";
@NonNls static final String STRING_ID = "MOON_STRING";
@NonNls static final String LONGSTRING_ID = "MOON_LONGSTRING";
@NonNls static final String LONGSTRING_BRACES_ID = "MOON_LONGSTRING_BRACES";
@NonNls static final String LONGCOMMENT_BRACES_ID = "MOON_LONGCOMMENT_BRACES";
@NonNls static final String BRACES_ID = "MOON_BRACES";
@NonNls static final String PARENTHS_ID = "MOON_PARENTHS";
@NonNls static final String BRACKETS_ID = "MOON_BRACKETS";
@NonNls static final String BAD_CHARACTER_ID = "MOON_BAD_CHARACTER";
@NonNls static final String IDENTIFIER_ID = "MOON_IDENTIFIER";
@NonNls static final String VAR_ID = "MOON_VAR";
@NonNls static final String COMMA_ID = "MOON_COMMA";
@NonNls static final String SEMICOLON_ID = "MOON_SEMICOLON";
@NonNls static final String SELF_ID = "MOON_SELF";
@NonNls static final String DEFINED_CONSTANTS_ID = "MOON_DEFINED_CONSTANTS";
@NonNls static final String LOCAL_VAR_ID = "MOON_LOCAL_VAR";
@NonNls static final String GLOBAL_VAR_ID = "MOON_GLOBAL_VAR";
@NonNls static final String FIELD_ID = "MOON_FIELD";
@NonNls static final String TAIL_CALL_ID = "MOON_TAIL_CALL";
@NonNls static final String PARAMETER_ID = "MOON_PARAMETER";
@NonNls static final String UPVAL_ID = "MOON_UPVAL";
@NonNls static final String LUADOC_ID = "MOON_LUADOC";
@NonNls static final String LUADOC_TAG_ID = "MOON_LUADOC_TAG";
@NonNls static final String LUADOC_VALUE_ID = "MOON_LUADOC_VALUE";
@NonNls static final String OPERATION_SIGN_ID = "MOON_OPERATION_SIGN";
private static final TextAttributes LUADOC_ATTR =
SyntaxHighlighterColors.DOC_COMMENT.getDefaultAttributes().clone();
public static final TextAttributesKey LUADOC =
TextAttributesKey.createTextAttributesKey(LUADOC_ID, LUADOC_ATTR);
private static TextAttributes LUADOC_TAG_ATTR =
SyntaxHighlighterColors.DOC_COMMENT_TAG.getDefaultAttributes().clone();
public static TextAttributesKey LUADOC_TAG =
TextAttributesKey.createTextAttributesKey(LUADOC_TAG_ID, LUADOC_TAG_ATTR);
private static TextAttributes LUADOC_VALUE_ATTR =
SyntaxHighlighterColors.DOC_COMMENT.getDefaultAttributes().clone();
public static TextAttributesKey LUADOC_VALUE =
TextAttributesKey.createTextAttributesKey(LUADOC_VALUE_ID, LUADOC_VALUE_ATTR);
private static final TextAttributes UPVAL_ATTR =
HighlighterColors.TEXT.getDefaultAttributes().clone();
public static final TextAttributesKey UPVAL =
TextAttributesKey.createTextAttributesKey(UPVAL_ID, UPVAL_ATTR);
private static final TextAttributes LOCAL_VAR_ATTR =
HighlighterColors.TEXT.getDefaultAttributes().clone();
public static final TextAttributesKey LOCAL_VAR =
TextAttributesKey.createTextAttributesKey(LOCAL_VAR_ID, LOCAL_VAR_ATTR);
private static final TextAttributes PARAMETER_ATTR =
HighlighterColors.TEXT.getDefaultAttributes().clone();
public static final TextAttributesKey PARAMETER =
TextAttributesKey.createTextAttributesKey(PARAMETER_ID, PARAMETER_ATTR);
private static final TextAttributes GLOBAL_VAR_ATTR =
HighlighterColors.TEXT.getDefaultAttributes().clone();
public static final TextAttributesKey GLOBAL_VAR =
TextAttributesKey.createTextAttributesKey(GLOBAL_VAR_ID, GLOBAL_VAR_ATTR);
public static final TextAttributesKey FIELD =
TextAttributesKey.createTextAttributesKey(
FIELD_ID, HighlighterColors.TEXT.getDefaultAttributes().clone());
static final TextAttributes TAIL_CALL_ATTR =
HighlighterColors.TEXT.getDefaultAttributes().clone();
public static final TextAttributesKey TAIL_CALL =
TextAttributesKey.createTextAttributesKey(TAIL_CALL_ID, TAIL_CALL_ATTR);
public static final TextAttributesKey KEYWORD =
TextAttributesKey.createTextAttributesKey(
KEYWORD_ID, SyntaxHighlighterColors.KEYWORD.getDefaultAttributes().clone());
public static final TextAttributesKey COMMENT =
TextAttributesKey.createTextAttributesKey(
COMMENT_ID, SyntaxHighlighterColors.LINE_COMMENT.getDefaultAttributes().clone());
public static final TextAttributesKey LONGCOMMENT =
TextAttributesKey.createTextAttributesKey(
LONGCOMMENT_ID,
SyntaxHighlighterColors.JAVA_BLOCK_COMMENT.getDefaultAttributes().clone());
static final TextAttributes LONGCOMMENT_BRACES_ATTR =
SyntaxHighlighterColors.JAVA_BLOCK_COMMENT.getDefaultAttributes().clone();
public static final TextAttributesKey LONGCOMMENT_BRACES =
TextAttributesKey.createTextAttributesKey(LONGCOMMENT_BRACES_ID, LONGCOMMENT_BRACES_ATTR);
public static final TextAttributesKey NUMBER =
TextAttributesKey.createTextAttributesKey(
NUMBER_ID, SyntaxHighlighterColors.NUMBER.getDefaultAttributes().clone());
public static final TextAttributesKey STRING =
TextAttributesKey.createTextAttributesKey(
STRING_ID, SyntaxHighlighterColors.STRING.getDefaultAttributes().clone());
private static final TextAttributes LONGSTRING_ATTR =
SyntaxHighlighterColors.STRING.getDefaultAttributes().clone();
private static final TextAttributes LONGSTRING_BRACES_ATTR =
SyntaxHighlighterColors.STRING.getDefaultAttributes().clone();
public static final TextAttributesKey LONGSTRING =
TextAttributesKey.createTextAttributesKey(LONGSTRING_ID, LONGSTRING_ATTR);
public static final TextAttributesKey LONGSTRING_BRACES =
TextAttributesKey.createTextAttributesKey(LONGSTRING_BRACES_ID, LONGSTRING_BRACES_ATTR);
public static final TextAttributesKey BRACKETS =
TextAttributesKey.createTextAttributesKey(
BRACKETS_ID, SyntaxHighlighterColors.BRACKETS.getDefaultAttributes().clone());
public static final TextAttributesKey BRACES =
TextAttributesKey.createTextAttributesKey(
BRACES_ID, SyntaxHighlighterColors.BRACES.getDefaultAttributes().clone());
public static final TextAttributesKey PARENTHS =
TextAttributesKey.createTextAttributesKey(
PARENTHS_ID, SyntaxHighlighterColors.PARENTHS.getDefaultAttributes().clone());
public static final TextAttributesKey BAD_CHARACTER =
TextAttributesKey.createTextAttributesKey(
BAD_CHARACTER_ID, HighlighterColors.BAD_CHARACTER.getDefaultAttributes().clone());
public static final TextAttributesKey COMMA =
TextAttributesKey.createTextAttributesKey(
COMMA_ID, SyntaxHighlighterColors.COMMA.getDefaultAttributes().clone());
private static final TextAttributes DEFINED_CONSTANTS_ATTR =
SyntaxHighlighterColors.KEYWORD.getDefaultAttributes().clone();
public static final TextAttributesKey DEFINED_CONSTANTS =
TextAttributesKey.createTextAttributesKey(DEFINED_CONSTANTS_ID, DEFINED_CONSTANTS_ATTR);
public static final TextAttributesKey OPERATION_SIGN =
TextAttributesKey.createTextAttributesKey(
OPERATION_SIGN_ID, SyntaxHighlighterColors.OPERATION_SIGN.getDefaultAttributes().clone());
static {
DEFINED_CONSTANTS_ATTR.setForegroundColor(Color.MAGENTA);
UPVAL_ATTR.setFontType(SimpleTextAttributes.STYLE_ITALIC);
LONGSTRING_ATTR.setBackgroundColor(new Color(0xD0, 0xD0, 0xD0));
GLOBAL_VAR_ATTR.setForegroundColor(new Color(128, 0, 0));
LOCAL_VAR_ATTR.setForegroundColor(new Color(0, 153, 153));
PARAMETER_ATTR.setForegroundColor(new Color(153, 102, 255));
LUADOC_ATTR.setForegroundColor(new Color(64, 95, 189));
LUADOC_TAG_ATTR.setForegroundColor(new Color(64, 95, 189));
LUADOC_VALUE_ATTR.setForegroundColor(new Color(64, 95, 189));
}
}
public class CtrlMouseHandler extends AbstractProjectComponent {
private final TextAttributes ourReferenceAttributes;
private HighlightersSet myHighlighter;
private int myStoredModifiers = 0;
private TooltipProvider myTooltipProvider = null;
private final FileEditorManager myFileEditorManager;
private enum BrowseMode {
None,
Declaration,
TypeDeclaration,
Implementation
}
private final KeyListener myEditorKeyListener =
new KeyAdapter() {
public void keyPressed(final KeyEvent e) {
handleKey(e);
}
public void keyReleased(final KeyEvent e) {
handleKey(e);
}
private void handleKey(final KeyEvent e) {
int modifiers = e.getModifiers();
if (modifiers == myStoredModifiers) {
return;
}
BrowseMode browseMode = getBrowseMode(modifiers);
if (browseMode != BrowseMode.None) {
if (myTooltipProvider != null) {
if (browseMode != myTooltipProvider.getBrowseMode()) {
disposeHighlighter();
}
myStoredModifiers = modifiers;
myTooltipProvider.execute(browseMode);
}
} else {
disposeHighlighter();
myTooltipProvider = null;
}
}
};
private final FileEditorManagerListener myFileEditorManagerListener =
new FileEditorManagerAdapter() {
public void selectionChanged(FileEditorManagerEvent e) {
disposeHighlighter();
myTooltipProvider = null;
}
};
private final VisibleAreaListener myVisibleAreaListener =
new VisibleAreaListener() {
public void visibleAreaChanged(VisibleAreaEvent e) {
disposeHighlighter();
myTooltipProvider = null;
}
};
private final EditorMouseAdapter myEditorMouseAdapter =
new EditorMouseAdapter() {
public void mouseReleased(EditorMouseEvent e) {
disposeHighlighter();
myTooltipProvider = null;
}
};
private final EditorMouseMotionListener myEditorMouseMotionListener =
new EditorMouseMotionAdapter() {
public void mouseMoved(final EditorMouseEvent e) {
if (e.isConsumed() || !myProject.isInitialized()) {
return;
}
MouseEvent mouseEvent = e.getMouseEvent();
Editor editor = e.getEditor();
if (editor.getProject() != null && editor.getProject() != myProject) return;
PsiFile psiFile =
PsiDocumentManager.getInstance(myProject).getPsiFile(editor.getDocument());
Point point = new Point(mouseEvent.getPoint());
if (!PsiDocumentManager.getInstance(myProject).isUncommited(editor.getDocument())) {
// when document is committed, try to check injected stuff - it's fast
editor =
InjectedLanguageUtil.getEditorForInjectedLanguageNoCommit(
editor,
psiFile,
editor.logicalPositionToOffset(editor.xyToLogicalPosition(point)));
}
LogicalPosition pos = editor.xyToLogicalPosition(point);
int offset = editor.logicalPositionToOffset(pos);
int selStart = editor.getSelectionModel().getSelectionStart();
int selEnd = editor.getSelectionModel().getSelectionEnd();
myStoredModifiers = mouseEvent.getModifiers();
BrowseMode browseMode = getBrowseMode(myStoredModifiers);
if (myTooltipProvider != null) {
myTooltipProvider.dispose();
}
if (browseMode == BrowseMode.None || offset >= selStart && offset < selEnd) {
disposeHighlighter();
myTooltipProvider = null;
return;
}
myTooltipProvider = new TooltipProvider(editor, pos);
myTooltipProvider.execute(browseMode);
}
};
private static final TextAttributesKey CTRL_CLICKABLE_ATTRIBUTES_KEY =
TextAttributesKey.createTextAttributesKey(
"CTRL_CLICKABLE",
new TextAttributes(Color.blue, null, Color.blue, EffectType.LINE_UNDERSCORE, 0));
public CtrlMouseHandler(
final Project project,
StartupManager startupManager,
EditorColorsManager colorsManager,
FileEditorManager fileEditorManager) {
super(project);
startupManager.registerPostStartupActivity(
new DumbAwareRunnable() {
public void run() {
EditorEventMulticaster eventMulticaster =
EditorFactory.getInstance().getEventMulticaster();
eventMulticaster.addEditorMouseListener(myEditorMouseAdapter, project);
eventMulticaster.addEditorMouseMotionListener(myEditorMouseMotionListener, project);
}
});
ourReferenceAttributes =
colorsManager.getGlobalScheme().getAttributes(CTRL_CLICKABLE_ATTRIBUTES_KEY);
myFileEditorManager = fileEditorManager;
}
@NotNull
public String getComponentName() {
return "CtrlMouseHandler";
}
private static BrowseMode getBrowseMode(final int modifiers) {
if (modifiers != 0) {
final Keymap activeKeymap = KeymapManager.getInstance().getActiveKeymap();
if (matchMouseShortcut(activeKeymap, modifiers, IdeActions.ACTION_GOTO_DECLARATION))
return BrowseMode.Declaration;
if (matchMouseShortcut(activeKeymap, modifiers, IdeActions.ACTION_GOTO_TYPE_DECLARATION))
return BrowseMode.TypeDeclaration;
if (matchMouseShortcut(activeKeymap, modifiers, IdeActions.ACTION_GOTO_IMPLEMENTATION))
return BrowseMode.Implementation;
if (modifiers == InputEvent.CTRL_MASK) return BrowseMode.Declaration;
}
return BrowseMode.None;
}
private static boolean matchMouseShortcut(
final Keymap activeKeymap, final int modifiers, final String actionId) {
final MouseShortcut syntheticShortcut = new MouseShortcut(MouseEvent.BUTTON1, modifiers, 1);
for (Shortcut shortcut : activeKeymap.getShortcuts(actionId)) {
if (shortcut instanceof MouseShortcut) {
final MouseShortcut mouseShortcut = (MouseShortcut) shortcut;
if (mouseShortcut.getModifiers() == syntheticShortcut.getModifiers()) {
return true;
}
}
}
return false;
}
@TestOnly
public static String getInfo(PsiElement element, PsiElement atPointer) {
return generateInfo(element, atPointer);
}
@Nullable
private static String generateInfo(PsiElement element, PsiElement atPointer) {
final DocumentationProvider documentationProvider =
DocumentationManager.getProviderFromElement(element, atPointer);
String info = documentationProvider.getQuickNavigateInfo(element, atPointer);
if (info != null) {
return info;
}
if (element instanceof PsiFile) {
final VirtualFile virtualFile = ((PsiFile) element).getVirtualFile();
if (virtualFile != null) {
return virtualFile.getPresentableUrl();
}
}
info = getQuickNavigateInfo(element);
if (info != null) {
return info;
}
if (element instanceof NavigationItem) {
final ItemPresentation presentation = ((NavigationItem) element).getPresentation();
if (presentation != null) {
return presentation.getPresentableText();
}
}
return null;
}
@Nullable
private static String getQuickNavigateInfo(PsiElement element) {
final String name =
ElementDescriptionUtil.getElementDescription(element, UsageViewShortNameLocation.INSTANCE);
if (StringUtil.isEmpty(name)) return null;
final String typeName =
ElementDescriptionUtil.getElementDescription(element, UsageViewTypeLocation.INSTANCE);
final PsiFile file = element.getContainingFile();
final StringBuilder sb = new StringBuilder();
if (StringUtil.isNotEmpty(typeName)) sb.append(typeName).append(" ");
sb.append("\"").append(name).append("\"");
if (file != null && file.isPhysical()) {
sb.append(" [").append(file.getName()).append("]");
}
return sb.toString();
}
private abstract static class Info {
@NotNull protected final PsiElement myElementAtPointer;
private final List<TextRange> myRanges;
public Info(@NotNull PsiElement elementAtPointer, List<TextRange> ranges) {
myElementAtPointer = elementAtPointer;
myRanges = ranges;
}
public Info(@NotNull PsiElement elementAtPointer) {
this(
elementAtPointer,
Collections.singletonList(
new TextRange(
elementAtPointer.getTextOffset(),
elementAtPointer.getTextOffset() + elementAtPointer.getTextLength())));
}
boolean isSimilarTo(final Info that) {
return Comparing.equal(myElementAtPointer, that.myElementAtPointer)
&& myRanges.equals(that.myRanges);
}
public List<TextRange> getRanges() {
return myRanges;
}
@Nullable
public abstract String getInfo();
public abstract boolean isValid(Document document);
protected boolean rangesAreCorrect(Document document) {
final TextRange docRange = new TextRange(0, document.getTextLength());
for (TextRange range : getRanges()) {
if (!docRange.contains(range)) return false;
}
return true;
}
}
private static void showDumbModeNotification(final Project project) {
DumbService.getInstance(project)
.showDumbModeNotification("Element information is not available during index update");
}
private static class InfoSingle extends Info {
@NotNull private final PsiElement myTargetElement;
public InfoSingle(@NotNull PsiElement elementAtPointer, @NotNull PsiElement targetElement) {
super(elementAtPointer);
myTargetElement = targetElement;
}
public InfoSingle(final PsiReference ref, @NotNull final PsiElement targetElement) {
super(ref.getElement(), ReferenceRange.getAbsoluteRanges(ref));
myTargetElement = targetElement;
}
@Nullable
public String getInfo() {
try {
return generateInfo(myTargetElement, myElementAtPointer);
} catch (IndexNotReadyException e) {
showDumbModeNotification(myTargetElement.getProject());
return null;
}
}
public boolean isValid(Document document) {
if (!myTargetElement.isValid()) return false;
if (myTargetElement == myElementAtPointer
|| myTargetElement == myElementAtPointer.getParent()) return false;
return rangesAreCorrect(document);
}
}
private static class InfoMultiple extends Info {
public InfoMultiple(@NotNull final PsiElement elementAtPointer) {
super(elementAtPointer);
}
public String getInfo() {
return CodeInsightBundle.message("multiple.implementations.tooltip");
}
public boolean isValid(Document document) {
return rangesAreCorrect(document);
}
}
@Nullable
private Info getInfoAt(final Editor editor, PsiFile file, int offset, BrowseMode browseMode) {
PsiElement targetElement = null;
if (browseMode == BrowseMode.TypeDeclaration) {
try {
targetElement = GotoTypeDeclarationAction.findSymbolType(editor, offset);
} catch (IndexNotReadyException e) {
showDumbModeNotification(myProject);
}
} else if (browseMode == BrowseMode.Declaration) {
final PsiReference ref = TargetElementUtilBase.findReference(editor, offset);
final List<PsiElement> resolvedElements =
ref != null ? resolve(ref) : Collections.<PsiElement>emptyList();
final PsiElement resolvedElement =
resolvedElements.size() == 1 ? resolvedElements.get(0) : null;
final PsiElement[] targetElements =
GotoDeclarationAction.findTargetElementsNoVS(myProject, editor, offset);
final PsiElement elementAtPointer = file.findElementAt(offset);
if (targetElements != null) {
if (targetElements.length == 0) {
return null;
} else if (targetElements.length == 1) {
if (targetElements[0] != resolvedElement
&& elementAtPointer != null
&& targetElements[0].isPhysical()) {
return new InfoSingle(elementAtPointer, targetElements[0]);
}
} else {
return elementAtPointer != null ? new InfoMultiple(elementAtPointer) : null;
}
}
if (resolvedElements.size() == 1) {
return new InfoSingle(ref, resolvedElements.get(0));
} else if (resolvedElements.size() > 1) {
return new InfoMultiple(elementAtPointer);
}
} else if (browseMode == BrowseMode.Implementation) {
final PsiElement element =
TargetElementUtilBase.getInstance()
.findTargetElement(editor, ImplementationSearcher.getFlags(), offset);
PsiElement[] targetElements =
new ImplementationSearcher() {
@NotNull
protected PsiElement[] searchDefinitions(final PsiElement element) {
final List<PsiElement> found = new ArrayList<PsiElement>(2);
DefinitionsSearch.search(element)
.forEach(
new Processor<PsiElement>() {
public boolean process(final PsiElement psiElement) {
found.add(psiElement);
return found.size() != 2;
}
});
return PsiUtilBase.toPsiElementArray(found);
}
}.searchImplementations(editor, element, offset);
if (targetElements.length > 1) {
PsiElement elementAtPointer = file.findElementAt(offset);
if (elementAtPointer != null) {
return new InfoMultiple(elementAtPointer);
}
return null;
}
if (targetElements.length == 1) {
Navigatable descriptor = EditSourceUtil.getDescriptor(targetElements[0]);
if (descriptor == null || !descriptor.canNavigate()) {
return null;
}
targetElement = targetElements[0];
}
}
if (targetElement != null && targetElement.isPhysical()) {
PsiElement elementAtPointer = file.findElementAt(offset);
if (elementAtPointer != null) {
return new InfoSingle(elementAtPointer, targetElement);
}
}
return null;
}
private static List<PsiElement> resolve(final PsiReference ref) {
// IDEA-56727 try resolve first as in GotoDeclarationAction
PsiElement resolvedElement = ref.resolve();
if (resolvedElement == null && ref instanceof PsiPolyVariantReference) {
List<PsiElement> result = new ArrayList<PsiElement>();
final ResolveResult[] psiElements = ((PsiPolyVariantReference) ref).multiResolve(false);
for (ResolveResult resolveResult : psiElements) {
if (resolveResult.getElement() != null) {
result.add(resolveResult.getElement());
}
}
return result;
}
return resolvedElement == null
? Collections.<PsiElement>emptyList()
: Collections.singletonList(resolvedElement);
}
private void disposeHighlighter() {
if (myHighlighter != null) {
myHighlighter.uninstall();
HintManager.getInstance().hideAllHints();
myHighlighter = null;
}
}
private class TooltipProvider {
private final Editor myEditor;
private final LogicalPosition myPosition;
private BrowseMode myBrowseMode;
private boolean myDisposed;
public TooltipProvider(Editor editor, LogicalPosition pos) {
myEditor = editor;
myPosition = pos;
}
public void dispose() {
myDisposed = true;
}
public BrowseMode getBrowseMode() {
return myBrowseMode;
}
public void execute(BrowseMode browseMode) {
myBrowseMode = browseMode;
Document document = myEditor.getDocument();
final PsiFile file = PsiDocumentManager.getInstance(myProject).getPsiFile(document);
if (file == null) return;
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
if (TargetElementUtilBase.inVirtualSpace(myEditor, myPosition)) {
return;
}
final int offset = myEditor.logicalPositionToOffset(myPosition);
int selStart = myEditor.getSelectionModel().getSelectionStart();
int selEnd = myEditor.getSelectionModel().getSelectionEnd();
if (offset >= selStart && offset < selEnd) return;
ApplicationManager.getApplication()
.executeOnPooledThread(
new Runnable() {
public void run() {
final ProgressIndicator progressIndicator = new ProgressIndicatorBase();
final ApplicationAdapter listener =
new ApplicationAdapter() {
@Override
public void beforeWriteActionStart(Object action) {
progressIndicator.cancel();
}
};
final Application application = ApplicationManager.getApplication();
try {
application.addApplicationListener(listener);
ProgressManager.getInstance()
.runProcess(
new Runnable() {
@Override
public void run() {
// This read action can possibe last for a long time, we want it to
// stop immediately on the first write access.
// For this purpose we launch it under empty progress and invoke
// progressIndicator#cancel on write access to avoid possible write
// lock delays.
application.runReadAction(
new Runnable() {
public void run() {
doExecute(file, offset);
}
});
}
},
progressIndicator);
} finally {
application.removeApplicationListener(listener);
}
}
});
}
private void doExecute(PsiFile file, int offset) {
final Info info;
try {
info = getInfoAt(myEditor, file, offset, myBrowseMode);
} catch (IndexNotReadyException e) {
showDumbModeNotification(myProject);
return;
}
if (info == null) return;
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
if (myDisposed || myEditor.isDisposed() || !myEditor.getComponent().isShowing())
return;
showHint(info);
}
});
}
private void showHint(Info info) {
if (myDisposed) return;
Component internalComponent = myEditor.getContentComponent();
if (myHighlighter != null) {
if (!info.isSimilarTo(myHighlighter.getStoredInfo())) {
disposeHighlighter();
} else {
// highlighter already set
internalComponent.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
return;
}
}
if (info.isValid(myEditor.getDocument())) {
myHighlighter = installHighlighterSet(info, myEditor);
String text = info.getInfo();
if (text == null) return;
JComponent label = HintUtil.createInformationLabel(text);
final LightweightHint hint = new LightweightHint(label);
final HintManagerImpl hintManager = HintManagerImpl.getInstanceImpl();
Point p = HintManagerImpl.getHintPosition(hint, myEditor, myPosition, HintManager.ABOVE);
hintManager.showEditorHint(
hint,
myEditor,
p,
HintManager.HIDE_BY_ANY_KEY
| HintManager.HIDE_BY_TEXT_CHANGE
| HintManager.HIDE_BY_SCROLLING,
0,
false,
HintManagerImpl.createHintHint(myEditor, p, hint, HintManager.ABOVE)
.setContentActive(false));
}
}
}
private HighlightersSet installHighlighterSet(Info info, Editor editor) {
final JComponent internalComponent = editor.getContentComponent();
internalComponent.addKeyListener(myEditorKeyListener);
editor.getScrollingModel().addVisibleAreaListener(myVisibleAreaListener);
final Cursor cursor = internalComponent.getCursor();
internalComponent.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
myFileEditorManager.addFileEditorManagerListener(myFileEditorManagerListener);
List<RangeHighlighter> highlighters = new ArrayList<RangeHighlighter>();
for (TextRange range : info.getRanges()) {
final RangeHighlighter highlighter =
editor
.getMarkupModel()
.addRangeHighlighter(
range.getStartOffset(),
range.getEndOffset(),
HighlighterLayer.SELECTION + 1,
ourReferenceAttributes,
HighlighterTargetArea.EXACT_RANGE);
highlighters.add(highlighter);
}
return new HighlightersSet(highlighters, editor, cursor, info);
}
private class HighlightersSet {
private final List<RangeHighlighter> myHighlighters;
private final Editor myHighlighterView;
private final Cursor myStoredCursor;
private final Info myStoredInfo;
private HighlightersSet(
List<RangeHighlighter> highlighters,
Editor highlighterView,
Cursor storedCursor,
Info storedInfo) {
myHighlighters = highlighters;
myHighlighterView = highlighterView;
myStoredCursor = storedCursor;
myStoredInfo = storedInfo;
}
public void uninstall() {
for (RangeHighlighter highlighter : myHighlighters) {
highlighter.dispose();
}
Component internalComponent = myHighlighterView.getContentComponent();
internalComponent.setCursor(myStoredCursor);
internalComponent.removeKeyListener(myEditorKeyListener);
myHighlighterView.getScrollingModel().removeVisibleAreaListener(myVisibleAreaListener);
myFileEditorManager.removeFileEditorManagerListener(myFileEditorManagerListener);
}
public Info getStoredInfo() {
return myStoredInfo;
}
}
}
public class NeonSyntaxHighlighter extends SyntaxHighlighterBase {
public static final String UNKNOWN_ID = "Bad character";
public static final TextAttributesKey UNKNOWN =
TextAttributesKey.createTextAttributesKey(
UNKNOWN_ID, HighlighterColors.BAD_CHARACTER.getDefaultAttributes().clone());
public static final String COMMENT_ID = "Comment";
public static final TextAttributesKey COMMENT =
TextAttributesKey.createTextAttributesKey(
COMMENT_ID, SyntaxHighlighterColors.LINE_COMMENT.getDefaultAttributes().clone());
public static final String IDENTIFIER_ID = "Identifier";
public static final TextAttributesKey IDENTIFIER =
TextAttributesKey.createTextAttributesKey(
IDENTIFIER_ID, SyntaxHighlighterColors.KEYWORD.getDefaultAttributes().clone());
public static final String INTERPUNCTION_ID = "Interpunction";
public static final TextAttributesKey INTERPUNCTION =
TextAttributesKey.createTextAttributesKey(
INTERPUNCTION_ID, SyntaxHighlighterColors.DOT.getDefaultAttributes().clone());
public static final String NUMBER_ID = "Number";
public static final TextAttributesKey NUMBER =
TextAttributesKey.createTextAttributesKey(
NUMBER_ID, SyntaxHighlighterColors.NUMBER.getDefaultAttributes().clone());
public static final String KEYWORD_ID = "Keyword";
public static final TextAttributesKey KEYWORD =
TextAttributesKey.createTextAttributesKey(
KEYWORD_ID, SyntaxHighlighterColors.KEYWORD.getDefaultAttributes().clone());
// Groups of IElementType's
public static final TokenSet sBAD = TokenSet.create(NEON_UNKNOWN);
public static final TokenSet sCOMMENTS = TokenSet.create(NEON_COMMENT);
public static final TokenSet sIDENTIFIERS =
TokenSet.create(NEON_KEY); // , NEON_IDENTIFIER, NEON_LITERAL);
public static final TokenSet sINTERPUNCTION =
TokenSet.create(
NEON_BLOCK_INHERITENCE,
NEON_LPAREN,
NEON_RPAREN,
NEON_LBRACE_CURLY,
NEON_RBRACE_CURLY,
NEON_LBRACE_SQUARE,
NEON_RBRACE_SQUARE,
NEON_ITEM_DELIMITER,
NEON_ASSIGNMENT);
public static final TokenSet sNUMBERS = TokenSet.create(NEON_NUMBER);
// Static container
private static final Map<IElementType, TextAttributesKey> ATTRIBUTES =
new HashMap<IElementType, TextAttributesKey>();
// Fill in the map
static {
fillMap(ATTRIBUTES, sBAD, UNKNOWN);
fillMap(ATTRIBUTES, sCOMMENTS, COMMENT);
fillMap(ATTRIBUTES, sIDENTIFIERS, IDENTIFIER);
fillMap(ATTRIBUTES, sINTERPUNCTION, INTERPUNCTION);
fillMap(ATTRIBUTES, sNUMBERS, NUMBER);
}
@NotNull
@Override
public Lexer getHighlightingLexer() {
return new NeonLexer();
}
@NotNull
@Override
public TextAttributesKey[] getTokenHighlights(IElementType type) {
return pack(ATTRIBUTES.get(type));
}
}
/** Syntax highlighter defines token colors. */
public class PropsSyntaxHighlighter extends SyntaxHighlighterBase {
private static final Map<IElementType, TextAttributesKey> keys1;
private static final Map<IElementType, TextAttributesKey> keys2;
@NotNull
public Lexer getHighlightingLexer() {
return new PropsLexer();
}
public static final TextAttributesKey PROP_KEY =
TextAttributesKey.createTextAttributesKey(
"PROPS.KEY", SyntaxHighlighterColors.KEYWORD.getDefaultAttributes());
public static final TextAttributesKey PROP_VALUE =
TextAttributesKey.createTextAttributesKey(
"PROPS.VALUE", SyntaxHighlighterColors.STRING.getDefaultAttributes());
public static final TextAttributesKey PROP_COMMENT =
TextAttributesKey.createTextAttributesKey(
"PROPS.LINE_COMMENT", SyntaxHighlighterColors.LINE_COMMENT.getDefaultAttributes());
public static final TextAttributesKey PROP_KEY_VALUE_SEPARATOR =
TextAttributesKey.createTextAttributesKey(
"PROPS.KEY_VALUE_SEPARATOR",
SyntaxHighlighterColors.OPERATION_SIGN.getDefaultAttributes());
public static final TextAttributesKey PROP_VALID_STRING_ESCAPE =
TextAttributesKey.createTextAttributesKey(
"PROPS.VALID_STRING_ESCAPE",
SyntaxHighlighterColors.VALID_STRING_ESCAPE.getDefaultAttributes());
public static final TextAttributesKey PROP_INVALID_STRING_ESCAPE =
TextAttributesKey.createTextAttributesKey(
"PROPS.INVALID_STRING_ESCAPE",
SyntaxHighlighterColors.INVALID_STRING_ESCAPE.getDefaultAttributes());
public static final TextAttributesKey PROP_SECTION =
TextAttributesKey.createTextAttributesKey(
"PROPS.SECTION", new TextAttributes(new Color(0x660066), null, null, null, Font.BOLD));
public static final TextAttributesKey PROP_MACRO =
TextAttributesKey.createTextAttributesKey(
"PROPS.MACRO", new TextAttributes(new Color(0x0055BB), null, null, null, Font.BOLD));
public static final TextAttributesKey PROP_PROFILE =
TextAttributesKey.createTextAttributesKey(
"PROPS.PROFILE", new TextAttributes(new Color(0x0000FF), null, null, null, Font.BOLD));
static {
keys1 = new HashMap<IElementType, TextAttributesKey>();
keys2 = new HashMap<IElementType, TextAttributesKey>();
keys1.put(PropsTokenTypes.TOKEN_VALUE, PROP_VALUE);
keys1.put(PropsTokenTypes.TOKEN_EOL_COMMENT, PROP_COMMENT);
keys1.put(PropsTokenTypes.TOKEN_KEY, PROP_KEY);
keys1.put(PropsTokenTypes.TOKEN_KEY_VALUE_SEPARATOR, PROP_KEY_VALUE_SEPARATOR);
keys1.put(PropsTokenTypes.TOKEN_SECTION, PROP_SECTION);
keys1.put(PropsTokenTypes.TOKEN_MACRO, PROP_MACRO);
keys1.put(PropsTokenTypes.TOKEN_PROFILE, PROP_PROFILE);
keys1.put(StringEscapesTokenTypes.VALID_STRING_ESCAPE_TOKEN, PROP_VALID_STRING_ESCAPE);
// in fact all back-slashed escapes are allowed
keys1.put(StringEscapesTokenTypes.INVALID_CHARACTER_ESCAPE_TOKEN, PROP_INVALID_STRING_ESCAPE);
keys1.put(StringEscapesTokenTypes.INVALID_UNICODE_ESCAPE_TOKEN, PROP_INVALID_STRING_ESCAPE);
}
@NotNull
public TextAttributesKey[] getTokenHighlights(IElementType tokenType) {
return pack(keys1.get(tokenType), keys2.get(tokenType));
}
public static final Map<TextAttributesKey, Pair<String, HighlightSeverity>> DISPLAY_NAMES =
new HashMap<TextAttributesKey, Pair<String, HighlightSeverity>>(7);
static {
DISPLAY_NAMES.put(PROP_KEY, new Pair<String, HighlightSeverity>("Property key", null));
DISPLAY_NAMES.put(PROP_VALUE, new Pair<String, HighlightSeverity>("Property value", null));
DISPLAY_NAMES.put(
PROP_KEY_VALUE_SEPARATOR, new Pair<String, HighlightSeverity>("Key value separator", null));
DISPLAY_NAMES.put(PROP_COMMENT, new Pair<String, HighlightSeverity>("Comment", null));
DISPLAY_NAMES.put(
PROP_VALID_STRING_ESCAPE, new Pair<String, HighlightSeverity>("String escape", null));
DISPLAY_NAMES.put(
PROP_INVALID_STRING_ESCAPE,
new Pair<String, HighlightSeverity>("String escape (invalid)", HighlightSeverity.WARNING));
DISPLAY_NAMES.put(PROP_SECTION, new Pair<String, HighlightSeverity>("Section", null));
DISPLAY_NAMES.put(PROP_MACRO, new Pair<String, HighlightSeverity>("Macro", null));
DISPLAY_NAMES.put(PROP_PROFILE, new Pair<String, HighlightSeverity>("Profile", null));
}
}
@Override
public int hashCode() {
int result = mySeverity.hashCode();
result = 29 * result + myAttributesKey.hashCode();
return result;
}
/** @author Eugene.Kudelevsky */
public class XmlTagTreeHighlightingPass extends TextEditorHighlightingPass {
private static final Key<List<RangeHighlighter>> TAG_TREE_HIGHLIGHTERS_IN_EDITOR_KEY =
Key.create("TAG_TREE_HIGHLIGHTERS_IN_EDITOR_KEY");
private static final HighlightInfoType TYPE =
new HighlightInfoType.HighlightInfoTypeImpl(
HighlightSeverity.INFORMATION,
TextAttributesKey.createTextAttributesKey("TAG_TREE_HIGHLIGHTING_KEY"));
private final PsiFile myFile;
private final EditorEx myEditor;
private final BreadcrumbsInfoProvider myInfoProvider;
private final List<Pair<TextRange, TextRange>> myPairsToHighlight =
new ArrayList<Pair<TextRange, TextRange>>();
public XmlTagTreeHighlightingPass(@NotNull PsiFile file, @NotNull EditorEx editor) {
super(file.getProject(), editor.getDocument(), true);
myFile = file;
myEditor = editor;
final FileViewProvider viewProvider = file.getManager().findViewProvider(file.getVirtualFile());
myInfoProvider = BreadcrumbsXmlWrapper.findInfoProvider(viewProvider);
}
@Override
public void doCollectInformation(@NotNull ProgressIndicator progress) {
if (ApplicationManager.getApplication().isUnitTestMode()) {
return;
}
if (!WebEditorOptions.getInstance().isTagTreeHighlightingEnabled()) {
return;
}
final PsiElement[] elements =
BreadcrumbsXmlWrapper.getLinePsiElements(
myEditor.getCaretModel().getOffset(),
myFile.getVirtualFile(),
myProject,
myInfoProvider);
if (elements == null || elements.length == 0) {
return;
}
if (!XmlTagTreeHighlightingUtil.containsTagsWithSameName(elements)) {
return;
}
for (int i = elements.length - 1; i >= 0; i--) {
if (elements[i] instanceof XmlTag) {
myPairsToHighlight.add(getTagRanges((XmlTag) elements[i]));
}
}
}
@Nullable
private static Pair<TextRange, TextRange> getTagRanges(XmlTag tag) {
final ASTNode tagNode = tag.getNode();
return new Pair<TextRange, TextRange>(getStartTagRange(tagNode), getEndTagRange(tagNode));
}
@Nullable
private static TextRange getStartTagRange(ASTNode tagNode) {
final ASTNode startTagStart = XmlChildRole.START_TAG_START_FINDER.findChild(tagNode);
if (startTagStart == null) {
return null;
}
ASTNode tagName = startTagStart.getTreeNext();
if (tagName == null || tagName.getElementType() != XmlTokenType.XML_NAME) {
return null;
}
ASTNode next = tagName.getTreeNext();
if (next != null && next.getElementType() == XmlTokenType.XML_TAG_END) {
tagName = next;
}
return new TextRange(startTagStart.getStartOffset(), tagName.getTextRange().getEndOffset());
}
@Nullable
private static TextRange getEndTagRange(ASTNode tagNode) {
final ASTNode endTagStart = XmlChildRole.CLOSING_TAG_START_FINDER.findChild(tagNode);
if (endTagStart == null) {
return null;
}
ASTNode endTagEnd = endTagStart;
while (endTagEnd != null && endTagEnd.getElementType() != XmlTokenType.XML_TAG_END) {
endTagEnd = endTagEnd.getTreeNext();
}
if (endTagEnd == null) {
return null;
}
return new TextRange(endTagStart.getStartOffset(), endTagEnd.getTextRange().getEndOffset());
}
@Override
public void doApplyInformationToEditor() {
final List<HighlightInfo> infos = getHighlights();
UpdateHighlightersUtil.setHighlightersToEditor(
myProject, myDocument, 0, myFile.getTextLength(), infos, getColorsScheme(), getId());
}
public List<HighlightInfo> getHighlights() {
clearLineMarkers(myEditor);
final int count = myPairsToHighlight.size();
final List<HighlightInfo> highlightInfos = new ArrayList<HighlightInfo>(count * 2);
final MarkupModel markupModel = myEditor.getMarkupModel();
final Color[] baseColors = XmlTagTreeHighlightingUtil.getBaseColors();
final Color[] colorsForEditor = toColorsForEditor(baseColors);
final Color[] colorsForLineMarkers = toColorsForLineMarkers(baseColors);
final List<RangeHighlighter> newHighlighters = new ArrayList<RangeHighlighter>();
assert colorsForEditor.length > 0;
for (int i = 0; i < count && i < baseColors.length; i++) {
Pair<TextRange, TextRange> pair = myPairsToHighlight.get(i);
if (pair == null || pair.first == null && pair.second == null) {
continue;
}
Color color = colorsForEditor[i];
if (color == null) {
continue;
}
if (pair.first != null && !pair.first.isEmpty()) {
highlightInfos.add(createHighlightInfo(color, pair.first));
}
if (pair.second != null && !pair.second.isEmpty()) {
highlightInfos.add(createHighlightInfo(color, pair.second));
}
final int start =
pair.first != null ? pair.first.getStartOffset() : pair.second.getStartOffset();
final int end = pair.second != null ? pair.second.getEndOffset() : pair.first.getEndOffset();
final Color lineMarkerColor = colorsForLineMarkers[i];
if (lineMarkerColor != null && start != end) {
final RangeHighlighter highlighter =
createHighlighter(markupModel, new TextRange(start, end), lineMarkerColor);
newHighlighters.add(highlighter);
}
}
myEditor.putUserData(TAG_TREE_HIGHLIGHTERS_IN_EDITOR_KEY, newHighlighters);
return highlightInfos;
}
private static void clearLineMarkers(Editor editor) {
final List<RangeHighlighter> oldHighlighters =
editor.getUserData(TAG_TREE_HIGHLIGHTERS_IN_EDITOR_KEY);
if (oldHighlighters != null) {
final MarkupModelEx markupModel = (MarkupModelEx) editor.getMarkupModel();
for (RangeHighlighter highlighter : oldHighlighters) {
if (markupModel.containsHighlighter(highlighter)) {
highlighter.dispose();
}
}
editor.putUserData(TAG_TREE_HIGHLIGHTERS_IN_EDITOR_KEY, null);
}
}
@NotNull
private static HighlightInfo createHighlightInfo(Color color, @NotNull TextRange range) {
TextAttributes attributes = new TextAttributes(null, color, null, null, Font.PLAIN);
return HighlightInfo.newHighlightInfo(TYPE)
.range(range)
.textAttributes(attributes)
.severity(HighlightSeverity.INFORMATION)
.createUnconditionally();
}
@NotNull
private static RangeHighlighter createHighlighter(
final MarkupModel mm, @NotNull final TextRange range, final Color color) {
final RangeHighlighter highlighter =
mm.addRangeHighlighter(
range.getStartOffset(),
range.getEndOffset(),
0,
null,
HighlighterTargetArea.LINES_IN_RANGE);
highlighter.setLineMarkerRenderer(
new LineMarkerRenderer() {
@Override
public void paint(Editor editor, Graphics g, Rectangle r) {
int height = r.height + editor.getLineHeight();
g.setColor(color);
g.fillRect(r.x, r.y, 2, height);
}
});
return highlighter;
}
private static Color[] toColorsForLineMarkers(Color[] baseColors) {
final Color[] colors = new Color[baseColors.length];
final Color tagBackground = Gray._239;
final double transparency = 0.4;
final double factor = 0.8;
for (int i = 0; i < colors.length; i++) {
final Color color = baseColors[i];
if (color == null) {
colors[i] = null;
continue;
}
int r = (int) (color.getRed() * factor);
int g = (int) (color.getGreen() * factor);
int b = (int) (color.getBlue() * factor);
r = (int) (tagBackground.getRed() * (1 - transparency) + r * transparency);
g = (int) (tagBackground.getGreen() * (1 - transparency) + g * transparency);
b = (int) (tagBackground.getBlue() * (1 - transparency) + b * transparency);
colors[i] = new Color(r, g, b);
}
return colors;
}
private Color[] toColorsForEditor(Color[] baseColors) {
final Color tagBackground = myEditor.getBackgroundColor();
if (tagBackground == null) {
return baseColors;
}
final Color[] resultColors = new Color[baseColors.length];
// todo: make configurable
final double transparency =
WebEditorOptions.getInstance().getTagTreeHighlightingOpacity() * 0.01;
for (int i = 0; i < resultColors.length; i++) {
final Color color = baseColors[i];
final Color color1 =
color != null
? XmlTagTreeHighlightingUtil.makeTransparent(color, tagBackground, transparency)
: null;
resultColors[i] = color1;
}
return resultColors;
}
public static void clearHighlightingAndLineMarkers(
final Editor editor, @NotNull Project project) {
final MarkupModel markupModel =
DocumentMarkupModel.forDocument(editor.getDocument(), project, true);
for (RangeHighlighter highlighter : markupModel.getAllHighlighters()) {
Object tooltip = highlighter.getErrorStripeTooltip();
if (!(tooltip instanceof HighlightInfo)) {
continue;
}
if (((HighlightInfo) tooltip).type == TYPE) {
highlighter.dispose();
}
}
clearLineMarkers(editor);
}
}
public class RainbowHighlighter {
private static final JBColor[] RAINBOW_JB_COLORS_DEFAULT = {
new JBColor(0x9b3b6a, 0x529d52),
new JBColor(0x114d77, 0xbe7070),
new JBColor(0xbc8650, 0x3d7676),
new JBColor(0x005910, 0xbe9970),
new JBColor(0xbc5150, 0x9d527c),
};
public static final TextAttributesKey[] RAINBOW_COLOR_KEYS =
new TextAttributesKey[RAINBOW_JB_COLORS_DEFAULT.length];
private static final int RAINBOW_COLORS_BETWEEN = 4;
private static final String UNIT_TEST_COLORS =
"#000001,#000002,#000003,#000004"; // Do not modify!
private static final String INHERITED = "inherited";
static {
for (int i = 0; i < RAINBOW_JB_COLORS_DEFAULT.length; ++i) {
//noinspection deprecation
RAINBOW_COLOR_KEYS[i] =
TextAttributesKey.createTextAttributesKey(
"RAINBOW_COLOR" + i, createRainbowAttribute(RAINBOW_JB_COLORS_DEFAULT[i]));
}
}
public static final String RAINBOW_TYPE = "rainbow";
private static final String RAINBOW_TEMP_PREF = "RAINBOW_TEMP_";
@SuppressWarnings("deprecation")
public static final TextAttributesKey RAINBOW_ANCHOR =
TextAttributesKey.createTextAttributesKey(RAINBOW_TYPE, new TextAttributes());
@SuppressWarnings("deprecation")
public static final TextAttributesKey RAINBOW_GRADIENT_DEMO =
TextAttributesKey.createTextAttributesKey("rainbow_demo", new TextAttributes());
public static final Boolean DEFAULT_RAINBOW_ON = Boolean.FALSE;
@NotNull private final TextAttributesScheme myColorsScheme;
@NotNull private final Color[] myRainbowColors;
public RainbowHighlighter(@Nullable TextAttributesScheme colorsScheme) {
myColorsScheme =
colorsScheme != null ? colorsScheme : EditorColorsManager.getInstance().getGlobalScheme();
myRainbowColors = generateColorSequence(myColorsScheme);
}
public static final HighlightInfoType RAINBOW_ELEMENT =
new HighlightInfoType.HighlightInfoTypeImpl(
HighlightSeverity.INFORMATION, DefaultLanguageHighlighterColors.CONSTANT);
@Nullable
@Contract("_, null -> !null")
public static Boolean isRainbowEnabled(
@Nullable TextAttributesScheme colorsScheme, @Nullable Language language) {
if (colorsScheme instanceof SchemeMetaInfo) {
String value =
((SchemeMetaInfo) colorsScheme)
.getMetaProperties()
.getProperty(getKey(language), INHERITED);
if (String.valueOf(true).equals(value)) return Boolean.TRUE;
if (String.valueOf(false).equals(value)) return Boolean.FALSE;
return language == null ? DEFAULT_RAINBOW_ON : null;
}
return false;
}
public static boolean isRainbowEnabledWithInheritance(
@Nullable TextAttributesScheme colorsScheme, @Nullable Language language) {
Boolean rainbowEnabled = isRainbowEnabled(colorsScheme, language);
return rainbowEnabled != null ? rainbowEnabled : isRainbowEnabled(colorsScheme, null);
}
public static void setRainbowEnabled(
@NotNull SchemeMetaInfo colorsScheme,
@Nullable Language language,
@Nullable Boolean enabled) {
Properties properties = colorsScheme.getMetaProperties();
String key = getKey(language);
if (enabled == null || (language == null && enabled == DEFAULT_RAINBOW_ON)) {
properties.remove(key);
} else {
properties.setProperty(key, String.valueOf(enabled));
}
}
@NotNull
private static String getKey(@Nullable Language language) {
return RAINBOW_TYPE + " " + (language == null ? "Default language" : language.getID());
}
@NotNull
public static String generatePaletteExample() {
int stopCount = RAINBOW_COLOR_KEYS.length;
StringBuilder sb = new StringBuilder();
String tagRainbow = RAINBOW_GRADIENT_DEMO.getExternalName();
for (int i = 0; i < RAINBOW_TEMP_KEYS.length; ++i) {
if (sb.length() != 0) {
sb.append(" ");
}
sb.append("<").append(tagRainbow).append(">");
sb.append((i % stopCount == 0) ? "Stop#" + String.valueOf(i / stopCount + 1) : "T");
sb.append("</").append(tagRainbow).append(">");
}
return sb.toString();
}
@NotNull
@Contract(pure = true)
private Color calculateForeground(int colorIndex) {
return myRainbowColors[colorIndex];
}
public int getColorsCount() {
return myRainbowColors.length;
}
@NotNull
private static Color[] generateColorSequence(@NotNull TextAttributesScheme colorsScheme) {
String colorDump =
ApplicationManager.getApplication().isUnitTestMode()
? UNIT_TEST_COLORS
: Registry.get("rainbow.highlighter.colors").asString();
final List<String> registryColors = StringUtil.split(colorDump, ",");
if (!registryColors.isEmpty()) {
return registryColors.stream().map(s -> ColorUtil.fromHex(s.trim())).toArray(Color[]::new);
}
List<Color> stopColors =
ContainerUtil.map(
RAINBOW_COLOR_KEYS, key -> colorsScheme.getAttributes(key).getForegroundColor());
List<Color> colors =
ColorGenerator.generateLinearColorSequence(stopColors, RAINBOW_COLORS_BETWEEN);
return colors.toArray(new Color[colors.size()]);
}
@NotNull
public TextAttributesKey[] getRainbowTempKeys() {
TextAttributesKey[] keys = new TextAttributesKey[myRainbowColors.length];
for (int i = 0; i < myRainbowColors.length; ++i) {
//noinspection deprecation
TextAttributesKey key =
TextAttributesKey.createTextAttributesKey(RAINBOW_TEMP_PREF + i, new TextAttributes());
key.getDefaultAttributes().setForegroundColor(myRainbowColors[i]);
keys[i] = key;
}
return keys;
}
public static boolean isRainbowTempKey(TextAttributesKey key) {
return key.getExternalName().startsWith(RAINBOW_TEMP_PREF);
}
public HighlightInfo getInfo(
int colorIndex, @Nullable PsiElement id, @Nullable TextAttributesKey colorKey) {
return id == null ? null : getInfoBuilder(colorIndex, colorKey).range(id).create();
}
public HighlightInfo getInfo(
int colorIndex, int start, int end, @Nullable TextAttributesKey colorKey) {
return getInfoBuilder(colorIndex, colorKey).range(start, end).create();
}
@NotNull
protected HighlightInfo.Builder getInfoBuilder(
int colorIndex, @Nullable TextAttributesKey colorKey) {
if (colorKey == null) {
colorKey = DefaultLanguageHighlighterColors.LOCAL_VARIABLE;
}
return HighlightInfo.newHighlightInfo(RAINBOW_ELEMENT)
.textAttributes(
TextAttributes.fromFlyweight(
myColorsScheme
.getAttributes(colorKey)
.getFlyweight()
.withForeground(calculateForeground(colorIndex))));
}
private static final TextAttributesKey[] RAINBOW_TEMP_KEYS =
new RainbowHighlighter(null).getRainbowTempKeys();
@NotNull
public static TextAttributes createRainbowAttribute(@Nullable Color color) {
TextAttributes ret = new TextAttributes();
ret.setForegroundColor(color);
return ret;
}
public static Map<String, TextAttributesKey> createRainbowHLM() {
Map<String, TextAttributesKey> hashMap = new HashMap<>();
hashMap.put(RAINBOW_ANCHOR.getExternalName(), RAINBOW_ANCHOR);
hashMap.put(RAINBOW_GRADIENT_DEMO.getExternalName(), RAINBOW_GRADIENT_DEMO);
for (TextAttributesKey key : RAINBOW_TEMP_KEYS) {
hashMap.put(key.getExternalName(), key);
}
return hashMap;
}
}
public static boolean isRainbowTempKey(TextAttributesKey key) {
return key.getExternalName().startsWith(RAINBOW_TEMP_PREF);
}
private int extractExpectedHighlight(
final Matcher matcher,
final String text,
final Document document,
final Ref<Integer> textOffset) {
document.deleteString(textOffset.get(), textOffset.get() + matcher.end() - matcher.start());
int groupIdx = 1;
final String marker = matcher.group(groupIdx++);
String descr = matcher.group(groupIdx++);
final String typeString = matcher.group(groupIdx++);
final String foregroundColor = matcher.group(groupIdx++);
final String backgroundColor = matcher.group(groupIdx++);
final String effectColor = matcher.group(groupIdx++);
final String effectType = matcher.group(groupIdx++);
final String fontType = matcher.group(groupIdx++);
final String attrKey = matcher.group(groupIdx++);
final String bundleMessage = matcher.group(groupIdx++);
final boolean closed = matcher.group(groupIdx) != null;
if (descr == null) {
descr = ANY_TEXT; // no descr means any string by default
} else if (descr.equals("null")) {
descr = null; // explicit "null" descr
}
if (descr != null) {
descr =
descr.replaceAll(
"\\\\\\\\\"", "\""); // replace: \\" to ", doesn't check symbol before sequence \\"
descr = descr.replaceAll("\\\\\"", "\"");
}
HighlightInfoType type = WHATEVER;
if (typeString != null) {
try {
type = getTypeByName(typeString);
} catch (Exception e) {
LOG.error(e);
}
LOG.assertTrue(type != null, "Wrong highlight type: " + typeString);
}
TextAttributes forcedAttributes = null;
if (foregroundColor != null) {
//noinspection MagicConstant
forcedAttributes =
new TextAttributes(
Color.decode(foregroundColor),
Color.decode(backgroundColor),
Color.decode(effectColor),
EffectType.valueOf(effectType),
Integer.parseInt(fontType));
}
final int rangeStart = textOffset.get();
final int toContinueFrom;
if (closed) {
toContinueFrom = matcher.end();
} else {
int pos = matcher.end();
final Matcher closingTagMatcher = Pattern.compile("</" + marker + ">").matcher(text);
while (true) {
if (!closingTagMatcher.find(pos)) {
LOG.error("Cannot find closing </" + marker + "> in position " + pos);
}
final int nextTagStart = matcher.find(pos) ? matcher.start() : text.length();
if (closingTagMatcher.start() < nextTagStart) {
textOffset.set(textOffset.get() + closingTagMatcher.start() - pos);
document.deleteString(
textOffset.get(),
textOffset.get() + closingTagMatcher.end() - closingTagMatcher.start());
toContinueFrom = closingTagMatcher.end();
break;
}
textOffset.set(textOffset.get() + nextTagStart - pos);
pos = extractExpectedHighlight(matcher, text, document, textOffset);
}
}
final ExpectedHighlightingSet expectedHighlightingSet = myHighlightingTypes.get(marker);
if (expectedHighlightingSet.enabled) {
TextAttributesKey forcedTextAttributesKey =
attrKey == null ? null : TextAttributesKey.createTextAttributesKey(attrKey);
HighlightInfo.Builder builder =
HighlightInfo.newHighlightInfo(type)
.range(rangeStart, textOffset.get())
.severity(expectedHighlightingSet.severity);
if (forcedAttributes != null) builder.textAttributes(forcedAttributes);
if (forcedTextAttributesKey != null) builder.textAttributes(forcedTextAttributesKey);
if (bundleMessage != null) {
final List<String> split = StringUtil.split(bundleMessage, "|");
final ResourceBundle bundle = ResourceBundle.getBundle(split.get(0));
descr = CommonBundle.message(bundle, split.get(1), split.stream().skip(2).toArray());
}
if (descr != null) {
builder.description(descr);
builder.unescapedToolTip(descr);
}
if (expectedHighlightingSet.endOfLine) builder.endOfLine();
HighlightInfo highlightInfo = builder.createUnconditionally();
expectedHighlightingSet.infos.add(highlightInfo);
}
return toContinueFrom;
}
public void writeExternal(Element element) throws WriteExternalException {
mySeverity.writeExternal(element);
myAttributesKey.writeExternal(element);
}
