private void highlightInjectedSyntax(final PsiFile injectedPsi, HighlightInfoHolder holder) {
List<Trinity<IElementType, PsiLanguageInjectionHost, TextRange>> tokens =
InjectedLanguageUtil.getHighlightTokens(injectedPsi);
if (tokens == null) return;
final Language injectedLanguage = injectedPsi.getLanguage();
Project project = injectedPsi.getProject();
SyntaxHighlighter syntaxHighlighter =
SyntaxHighlighterFactory.getSyntaxHighlighter(
injectedLanguage, project, injectedPsi.getVirtualFile());
final TextAttributes defaultAttrs = myGlobalScheme.getAttributes(HighlighterColors.TEXT);
for (Trinity<IElementType, PsiLanguageInjectionHost, TextRange> token : tokens) {
ProgressManager.checkCanceled();
IElementType tokenType = token.getFirst();
PsiLanguageInjectionHost injectionHost = token.getSecond();
TextRange textRange = token.getThird();
TextAttributesKey[] keys = syntaxHighlighter.getTokenHighlights(tokenType);
if (textRange.getLength() == 0) continue;
TextRange annRange = textRange.shiftRight(injectionHost.getTextRange().getStartOffset());
// force attribute colors to override host' ones
TextAttributes attributes = null;
for (TextAttributesKey key : keys) {
TextAttributes attrs2 = myGlobalScheme.getAttributes(key);
if (attrs2 != null) {
attributes = attributes == null ? attrs2 : TextAttributes.merge(attributes, attrs2);
}
}
TextAttributes forcedAttributes;
if (attributes == null || attributes.isEmpty() || attributes.equals(defaultAttrs)) {
forcedAttributes = TextAttributes.ERASE_MARKER;
} else {
Color back =
attributes.getBackgroundColor() == null
? myGlobalScheme.getDefaultBackground()
: attributes.getBackgroundColor();
Color fore =
attributes.getForegroundColor() == null
? myGlobalScheme.getDefaultForeground()
: attributes.getForegroundColor();
forcedAttributes =
new TextAttributes(
fore,
back,
attributes.getEffectColor(),
attributes.getEffectType(),
attributes.getFontType());
}
HighlightInfo info =
HighlightInfo.createHighlightInfo(
HighlightInfoType.INJECTED_LANGUAGE_FRAGMENT, annRange, null, null, forcedAttributes);
holder.add(info);
}
}
private void merge(TextAttributes attributes) {
Color myBackground = myMergedAttributes.getBackgroundColor();
if (myBackground == null || myDefaultBackground.equals(myBackground)) {
myMergedAttributes.setBackgroundColor(attributes.getBackgroundColor());
}
Color myForeground = myMergedAttributes.getForegroundColor();
if (myForeground == null || myDefaultForeground.equals(myForeground)) {
myMergedAttributes.setForegroundColor(attributes.getForegroundColor());
}
if (myMergedAttributes.getFontType() == Font.PLAIN) {
myMergedAttributes.setFontType(attributes.getFontType());
}
}
private static TextAttributes mergeAttributes(TextAttributes primary, TextAttributes secondary) {
if (primary == null) return secondary;
if (secondary == null) return primary;
return new TextAttributes(
primary.getForegroundColor() == null
? secondary.getForegroundColor()
: primary.getForegroundColor(),
primary.getBackgroundColor() == null
? secondary.getBackgroundColor()
: primary.getBackgroundColor(),
primary.getEffectColor() == null ? secondary.getEffectColor() : primary.getEffectColor(),
primary.getEffectType() == null ? secondary.getEffectType() : primary.getEffectType(),
primary.getFontType() == Font.PLAIN ? secondary.getFontType() : primary.getFontType());
}
/** Patches attributes to be visible under debugger active line */
@SuppressWarnings("UseJBColor")
private static TextAttributes patchAttributesColor(
TextAttributes attributes, TextRange range, Editor editor) {
int line = editor.offsetToLogicalPosition(range.getStartOffset()).line;
for (RangeHighlighter highlighter : editor.getMarkupModel().getAllHighlighters()) {
if (!highlighter.isValid()) continue;
if (highlighter.getTargetArea() == HighlighterTargetArea.LINES_IN_RANGE
&& editor.offsetToLogicalPosition(highlighter.getStartOffset()).line == line) {
TextAttributes textAttributes = highlighter.getTextAttributes();
if (textAttributes != null) {
Color color = textAttributes.getBackgroundColor();
if (color != null
&& color.getBlue() > 128
&& color.getRed() < 128
&& color.getGreen() < 128) {
TextAttributes clone = attributes.clone();
clone.setForegroundColor(Color.orange);
clone.setEffectColor(Color.orange);
return clone;
}
}
}
}
return attributes;
}
public static void printToConsole(
@NotNull final LanguageConsoleImpl console,
@NotNull final String string,
@NotNull final ConsoleViewContentType mainType,
@Nullable ConsoleViewContentType additionalType) {
final TextAttributes mainAttributes = mainType.getAttributes();
final TextAttributes attributes;
if (additionalType == null) {
attributes = mainAttributes;
} else {
attributes = additionalType.getAttributes().clone();
attributes.setBackgroundColor(mainAttributes.getBackgroundColor());
}
Application application = ApplicationManager.getApplication();
if (application.isDispatchThread()) {
console.printToHistory(string, attributes);
} else {
application.invokeLater(
new Runnable() {
public void run() {
console.printToHistory(string, attributes);
}
},
ModalityState.stateForComponent(console.getComponent()));
}
}
/** Patches attributes to be visible under debugger active line */
@SuppressWarnings("UseJBColor")
public static TextAttributes patchAttributesColor(
TextAttributes attributes, @NotNull TextRange range, @NotNull Editor editor) {
if (attributes.getForegroundColor() == null && attributes.getEffectColor() == null)
return attributes;
MarkupModel model =
DocumentMarkupModel.forDocument(editor.getDocument(), editor.getProject(), false);
if (model != null) {
if (!((MarkupModelEx) model)
.processRangeHighlightersOverlappingWith(
range.getStartOffset(),
range.getEndOffset(),
highlighter -> {
if (highlighter.isValid()
&& highlighter.getTargetArea() == HighlighterTargetArea.LINES_IN_RANGE) {
TextAttributes textAttributes = highlighter.getTextAttributes();
if (textAttributes != null) {
Color color = textAttributes.getBackgroundColor();
return !(color != null
&& color.getBlue() > 128
&& color.getRed() < 128
&& color.getGreen() < 128);
}
}
return true;
})) {
TextAttributes clone = attributes.clone();
clone.setForegroundColor(Color.orange);
clone.setEffectColor(Color.orange);
return clone;
}
}
return attributes;
}
private void highlightUsages() {
if (mySearchResults.getEditor() == null) return;
if (mySearchResults.getMatchesCount() >= mySearchResults.getMatchesLimit()) return;
for (FindResult range : mySearchResults.getOccurrences()) {
TextAttributes attributes =
EditorColorsManager.getInstance()
.getGlobalScheme()
.getAttributes(EditorColors.TEXT_SEARCH_RESULT_ATTRIBUTES);
if (range.getLength() == 0) {
attributes = attributes.clone();
attributes.setEffectType(EffectType.BOXED);
attributes.setEffectColor(attributes.getBackgroundColor());
}
if (mySearchResults.isExcluded(range)) {
highlightRange(range, strikout(attributes), myHighlighters);
} else {
highlightRange(range, attributes, myHighlighters);
}
}
updateInSelectionHighlighters();
if (!myListeningSelection) {
mySearchResults.getEditor().getSelectionModel().addSelectionListener(this);
myListeningSelection = true;
}
}
@Override
public TextAttributes getTextAttributes() {
TextAttributes ta = myIterators[0].iterator.getTextAttributes();
myMergedAttributes.setAttributes(
ta.getForegroundColor(), ta.getBackgroundColor(), null, null, null, ta.getFontType());
for (int i = 1; i < overlappingRangesCount; i++) {
merge(myIterators[i].iterator.getTextAttributes());
}
return myMergedAttributes;
}
@Nullable
public Color getPolygonColor(Editor editor) {
if (isApplied()) {
return getLegendColor(editor.getColorsScheme());
} else if (isInlineWrapper()) {
return getBgColorForFragmentContainingInlines((EditorEx) editor);
} else {
TextAttributes attributes = getTextAttributes(editor);
return attributes == null ? null : attributes.getBackgroundColor();
}
}
@Nullable
private Color getBgColorForFragmentContainingInlines(@NotNull EditorEx editor) {
TextAttributes originalAttrs = getTextAttributes(editor.getColorsScheme());
if (originalAttrs == null) {
return null;
}
Color fg = originalAttrs.getBackgroundColor();
if (fg == null) {
return null;
}
Color bg = editor.getBackgroundColor();
return getMiddleColor(fg, bg, MIDDLE_COLOR_FACTOR);
}
public void advance() {
if (mySegmentIterator.atEnd()) {
myRangeIterator.advance();
TextAttributes textAttributes = myRangeIterator.getTextAttributes();
myCurrentFontStyle = textAttributes == null ? Font.PLAIN : textAttributes.getFontType();
myCurrentForegroundColor =
textAttributes == null ? null : textAttributes.getForegroundColor();
myCurrentBackgroundColor =
textAttributes == null ? null : textAttributes.getBackgroundColor();
mySegmentIterator.reset(
myRangeIterator.getRangeStart(), myRangeIterator.getRangeEnd(), myCurrentFontStyle);
}
mySegmentIterator.advance();
}
private void findNextSuitableRange() {
myNextAttributes = null;
while (myIterator.hasNext()) {
RangeHighlighterEx highlighter = myIterator.next();
if (highlighter == null
|| !highlighter.isValid()
|| !isInterestedInLayer(highlighter.getLayer())) {
continue;
}
// LINES_IN_RANGE highlighters are not supported currently
myNextStart = Math.max(highlighter.getStartOffset(), myStartOffset);
myNextEnd = Math.min(highlighter.getEndOffset(), myEndOffset);
if (myNextStart >= myEndOffset) {
break;
}
if (myNextStart < myCurrentEnd) {
continue; // overlapping ranges withing document markup model are not supported currently
}
TextAttributes attributes = null;
Object tooltip = highlighter.getErrorStripeTooltip();
if (tooltip instanceof HighlightInfo) {
HighlightInfo info = (HighlightInfo) tooltip;
TextAttributesKey key = info.forcedTextAttributesKey;
if (key == null) {
HighlightInfoType type = info.type;
key = type.getAttributesKey();
}
if (key != null) {
attributes = myColorsScheme.getAttributes(key);
}
}
if (attributes == null) {
continue;
}
Color foreground = attributes.getForegroundColor();
Color background = attributes.getBackgroundColor();
if ((foreground == null || myDefaultForeground.equals(foreground))
&& (background == null || myDefaultBackground.equals(background))
&& attributes.getFontType() == Font.PLAIN) {
continue;
}
myNextAttributes = attributes;
break;
}
}
private static void highlightSearchLines(
@NotNull Editor editor,
@NotNull String pattern,
int startLine,
int endLine,
boolean ignoreCase) {
final TextAttributes color =
editor.getColorsScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
Collection<RangeHighlighter> highlighters = EditorData.getLastHighlights(editor);
if (highlighters == null) {
highlighters = new ArrayList<RangeHighlighter>();
EditorData.setLastHighlights(editor, highlighters);
}
for (TextRange range : findAll(editor, pattern, startLine, endLine, ignoreCase)) {
final RangeHighlighter highlighter =
highlightMatch(editor, range.getStartOffset(), range.getEndOffset());
highlighter.setErrorStripeMarkColor(color.getBackgroundColor());
highlighter.setErrorStripeTooltip(pattern);
highlighters.add(highlighter);
}
}
private RangeHighlighter createRangeHighlighter(
final long date,
final MarkupModel markupModel,
final boolean coverageByTestApplicable,
final TreeMap<Integer, LineData> executableLines,
@Nullable final String className,
final int line,
final int lineNumberInCurrent,
@NotNull final CoverageSuitesBundle coverageSuite,
Object[] lines) {
EditorColorsScheme scheme = EditorColorsManager.getInstance().getGlobalScheme();
final TextAttributes attributes =
scheme.getAttributes(CoverageLineMarkerRenderer.getAttributesKey(line, executableLines));
TextAttributes textAttributes = null;
if (attributes.getBackgroundColor() != null) {
textAttributes = attributes;
}
final int startOffset = myDocument.getLineStartOffset(lineNumberInCurrent);
final int endOffset = myDocument.getLineEndOffset(lineNumberInCurrent);
final RangeHighlighter highlighter =
markupModel.addRangeHighlighter(
startOffset,
endOffset,
HighlighterLayer.SELECTION - 1,
textAttributes,
HighlighterTargetArea.LINES_IN_RANGE);
final Function<Integer, Integer> newToOldConverter =
newLine -> {
if (myEditor == null) return -1;
final TIntIntHashMap oldLineMapping = getNewToOldLineMapping(date);
return oldLineMapping != null
? oldLineMapping.get(newLine.intValue())
: newLine.intValue();
};
final Function<Integer, Integer> oldToNewConverter =
newLine -> {
if (myEditor == null) return -1;
final TIntIntHashMap newLineMapping = getOldToNewLineMapping(date);
return newLineMapping != null
? newLineMapping.get(newLine.intValue())
: newLine.intValue();
};
final CoverageLineMarkerRenderer markerRenderer =
coverageSuite
.getCoverageEngine()
.getLineMarkerRenderer(
line,
className,
executableLines,
coverageByTestApplicable,
coverageSuite,
newToOldConverter,
oldToNewConverter,
CoverageDataManager.getInstance(myProject).isSubCoverageActive());
highlighter.setLineMarkerRenderer(markerRenderer);
final LineData lineData = className != null ? (LineData) lines[line + 1] : null;
if (lineData != null && lineData.getStatus() == LineCoverage.NONE) {
highlighter.setErrorStripeMarkColor(markerRenderer.getErrorStripeColor(myEditor));
highlighter.setThinErrorStripeMark(true);
highlighter.setGreedyToLeft(true);
highlighter.setGreedyToRight(true);
}
return highlighter;
}
@Nullable
public Color getTextBackground(Editor editor) {
TextAttributes attributes = getTextAttributes(editor);
return attributes != null ? attributes.getBackgroundColor() : null;
}
@Nullable
private static Color getScrollMarkColor(@NotNull TextAttributes attributes) {
if (attributes.getErrorStripeColor() != null) return attributes.getErrorStripeColor();
if (attributes.getBackgroundColor() != null) return attributes.getBackgroundColor().darker();
return null;
}
@Nullable
public Color getLegendColor(EditorColorsScheme colorScheme) {
TextAttributes attributes = colorScheme.getAttributes(myAttributesKey);
return attributes != null ? attributes.getBackgroundColor() : null;
}
private void paintBackground(
Graphics2D g, TextAttributes attributes, float x, int y, float width) {
if (attributes == null) return;
paintBackground(g, attributes.getBackgroundColor(), x, y, width);
}