下面列出了com.intellij.psi.PsiStatement#com.intellij.openapi.editor.markup.HighlighterTargetArea 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private static void highlightPsiElement(PsiElement psiElement, boolean openInEditor) {
if (openInEditor) {
EditorHelper.openInEditor(psiElement);
}
Editor editor = FileEditorManager.getInstance(psiElement.getProject()).getSelectedTextEditor();
if (editor == null) {
return;
}
TextAttributes attributes = EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
editor.getMarkupModel().addRangeHighlighter(
psiElement.getTextRange().getStartOffset(),
psiElement.getTextRange().getEndOffset(),
HighlighterLayer.SELECTION,
attributes,
HighlighterTargetArea.EXACT_RANGE
);
}
private void createMarkers(Editor editor, Document document, List<Diagnostic> diagnostics) {
RangeHighlighter[] rangeHighlighters = new RangeHighlighter[diagnostics.size()];
int index = 0;
for(Diagnostic diagnostic : diagnostics) {
int startOffset = LSPIJUtils.toOffset(diagnostic.getRange().getStart(), document);
int endOffset = LSPIJUtils.toOffset(diagnostic.getRange().getEnd(), document);
if (endOffset > document.getLineEndOffset(document.getLineCount() - 1)) {
endOffset = document.getLineEndOffset(document.getLineCount() - 1);
}
int layer = getLayer(diagnostic.getSeverity());
EffectType effectType = getEffectType(diagnostic.getSeverity());
Color color = getColor(diagnostic.getSeverity());
RangeHighlighter rangeHighlighter = editor.getMarkupModel().addRangeHighlighter(startOffset, endOffset, layer, new TextAttributes(editor.getColorsScheme().getDefaultForeground(), editor.getColorsScheme().getDefaultBackground(), color, effectType, Font.PLAIN), HighlighterTargetArea.EXACT_RANGE);
rangeHighlighter.setErrorStripeTooltip(diagnostic);
rangeHighlighters[index++] = rangeHighlighter;
}
Map<String, RangeHighlighter[]> allMarkers = getAllMarkers(editor);
allMarkers.put(languageServerId, rangeHighlighters);
}
@Override
protected void changedUpdateImpl(@Nonnull DocumentEvent e) {
// todo Denis Zhdanov
DocumentEventImpl event = (DocumentEventImpl)e;
final boolean shouldTranslateViaDiff = isValid() && PersistentRangeMarkerUtil.shouldTranslateViaDiff(event, getStartOffset(), getEndOffset());
boolean wasTranslatedViaDiff = shouldTranslateViaDiff;
if (shouldTranslateViaDiff) {
wasTranslatedViaDiff = translatedViaDiff(e, event);
}
if (!wasTranslatedViaDiff) {
super.changedUpdateImpl(e);
if (isValid()) {
myLine = getDocument().getLineNumber(getStartOffset());
int endLine = getDocument().getLineNumber(getEndOffset());
if (endLine != myLine) {
setIntervalEnd(getDocument().getLineEndOffset(myLine));
}
}
}
if (isValid() && getTargetArea() == HighlighterTargetArea.LINES_IN_RANGE) {
setIntervalStart(DocumentUtil.getFirstNonSpaceCharOffset(getDocument(), myLine));
setIntervalEnd(getDocument().getLineEndOffset(myLine));
}
}
public void testRangeHighlighterLinesInRangeForLongLinePerformance() throws Exception {
final int N = 50000;
Document document = EditorFactory.getInstance().createDocument(StringUtil.repeatSymbol('x', 2 * N));
final MarkupModelEx markupModel = (MarkupModelEx)DocumentMarkupModel.forDocument(document, ourProject, true);
for (int i=0; i<N-1;i++) {
markupModel.addRangeHighlighter(2*i, 2*i+1, 0, null, HighlighterTargetArea.EXACT_RANGE);
}
markupModel.addRangeHighlighter(N / 2, N / 2 + 1, 0, null, HighlighterTargetArea.LINES_IN_RANGE);
PlatformTestUtil.startPerformanceTest("slow highlighters lookup", (int)(N*Math.log(N)/1000), new ThrowableRunnable() {
@Override
public void run() {
List<RangeHighlighterEx> list = new ArrayList<RangeHighlighterEx>();
CommonProcessors.CollectProcessor<RangeHighlighterEx> coll = new CommonProcessors.CollectProcessor<RangeHighlighterEx>(list);
for (int i=0; i<N-1;i++) {
list.clear();
markupModel.processRangeHighlightersOverlappingWith(2*i, 2*i+1, coll);
assertEquals(2, list.size()); // 1 line plus one exact range marker
}
}
}).assertTiming();
}
private static void updateAttributes(final DesktopEditorImpl editor, final int offset, final List<? extends TextAttributes> attributes) {
final List<RangeHighlighterEx> list1 = new ArrayList<>();
final List<RangeHighlighterEx> list2 = new ArrayList<>();
final Processor<RangeHighlighterEx> processor = highlighter -> {
if (!highlighter.isValid()) return true;
final boolean isLineHighlighter = highlighter.getTargetArea() == HighlighterTargetArea.LINES_IN_RANGE;
if (isLineHighlighter || highlighter.getStartOffset() < offset) {
list1.add(highlighter);
}
if (isLineHighlighter || highlighter.getEndOffset() > offset || (highlighter.getEndOffset() == offset && (highlighter.isGreedyToRight()))) {
list2.add(highlighter);
}
return true;
};
editor.getFilteredDocumentMarkupModel().processRangeHighlightersOverlappingWith(Math.max(0, offset - 1), offset, processor);
editor.getMarkupModel().processRangeHighlightersOverlappingWith(Math.max(0, offset - 1), offset, processor);
updateAttributes(editor, attributes.get(0), list1);
updateAttributes(editor, attributes.get(1), list2);
}
private static void linkFollowed(Editor editor, Collection<? extends RangeHighlighter> ranges, final RangeHighlighter link) {
MarkupModelEx markupModel = (MarkupModelEx)editor.getMarkupModel();
for (RangeHighlighter range : ranges) {
TextAttributes oldAttr = range.getUserData(OLD_HYPERLINK_TEXT_ATTRIBUTES);
if (oldAttr != null) {
markupModel.setRangeHighlighterAttributes(range, oldAttr);
range.putUserData(OLD_HYPERLINK_TEXT_ATTRIBUTES, null);
}
if (range == link) {
range.putUserData(OLD_HYPERLINK_TEXT_ATTRIBUTES, range.getTextAttributes());
markupModel.setRangeHighlighterAttributes(range, getFollowedHyperlinkAttributes(range));
}
}
//refresh highlighter text attributes
markupModel.addRangeHighlighter(0, 0, link.getLayer(), getHyperlinkAttributes(), HighlighterTargetArea.EXACT_RANGE).dispose();
}
private void applyHighlightingPasses(Project project, final EditorEx editor, Document document, final EditorColorsScheme colorsScheme, final TextRange rangeMarker) {
final int startOffset = rangeMarker.getStartOffset();
final int endOffset = rangeMarker.getEndOffset();
DaemonCodeAnalyzerEx.processHighlights(document, project, null, startOffset, endOffset, info -> {
if (info.getStartOffset() >= startOffset && info.getEndOffset() <= endOffset) {
HighlightSeverity highlightSeverity = info.getSeverity();
if (highlightSeverity == HighlightSeverity.ERROR ||
highlightSeverity == HighlightSeverity.WARNING ||
highlightSeverity == HighlightSeverity.WEAK_WARNING ||
highlightSeverity == HighlightSeverity.GENERIC_SERVER_ERROR_OR_WARNING) {
return true;
}
TextAttributes textAttributes = info.forcedTextAttributes != null ? info.forcedTextAttributes : colorsScheme.getAttributes(info.forcedTextAttributesKey);
editor.getMarkupModel().addRangeHighlighter(info.getActualStartOffset() - rangeMarker.getStartOffset(), info.getActualEndOffset() - rangeMarker.getStartOffset(), 1000, textAttributes,
HighlighterTargetArea.EXACT_RANGE);
return true;
}
else {
return true;
}
});
}
@Nonnull
private static JComponent setupEditorComponent(@Nonnull EditorEx editor, @Nonnull String text, @Nonnull SpeedSearch speedSearch, @Nonnull EditorColorsScheme colorsScheme, boolean selected) {
Iterable<TextRange> ranges = speedSearch.matchingFragments(text);
if (ranges != null) {
selectSearchResultsInEditor(editor, ranges.iterator());
}
else {
RecentLocationsAction.clearSelectionInEditor(editor);
}
editor.setBackgroundColor(getBackgroundColor(colorsScheme, selected));
editor.setBorder(JBUI.Borders.empty(0, 4, 6, 0));
if (EMPTY_FILE_TEXT.equals(editor.getDocument().getText())) {
editor.getMarkupModel().addRangeHighlighter(0, EMPTY_FILE_TEXT.length(), HighlighterLayer.SYNTAX, createEmptyTextForegroundTextAttributes(colorsScheme), HighlighterTargetArea.EXACT_RANGE);
}
return editor.getComponent();
}
private void createStatusHighlighter() {
int line1 = myPatchDeletionRange.start;
int line2 = myPatchInsertionRange.end;
Color color = getStatusColor();
if (isResolved()) {
color = ColorUtil.mix(color, myViewer.getPatchEditor().getGutterComponentEx().getBackground(), 0.6f);
}
String tooltip = getStatusText();
EditorEx patchEditor = myViewer.getPatchEditor();
Document document = patchEditor.getDocument();
MarkupModelEx markupModel = patchEditor.getMarkupModel();
TextRange textRange = DiffUtil.getLinesRange(document, line1, line2);
RangeHighlighter highlighter = markupModel.addRangeHighlighter(textRange.getStartOffset(), textRange.getEndOffset(),
HighlighterLayer.LAST, null, HighlighterTargetArea.LINES_IN_RANGE);
PairConsumer<Editor, MouseEvent> clickHandler = getResultRange() != null ?
(e, event) -> myViewer.scrollToChange(this, Side.RIGHT, false) :
null;
highlighter.setLineMarkerRenderer(LineStatusMarkerRenderer.createRenderer(line1, line2, color, tooltip, clickHandler));
myHighlighters.add(highlighter);
}
@Nullable
private MyGutterOperation createOperation(@Nonnull OperationType type) {
if (isResolved()) return null;
EditorEx editor = myViewer.getPatchEditor();
Document document = editor.getDocument();
int line = getPatchRange().start;
int offset = line == DiffUtil.getLineCount(document) ? document.getTextLength() : document.getLineStartOffset(line);
RangeHighlighter highlighter = editor.getMarkupModel().addRangeHighlighter(offset, offset,
HighlighterLayer.ADDITIONAL_SYNTAX,
null,
HighlighterTargetArea.LINES_IN_RANGE);
return new MyGutterOperation(highlighter, type);
}
/**
* Patches attributes to be visible under debugger active line
*/
@SuppressWarnings("UseJBColor")
public static TextAttributes patchAttributesColor(TextAttributes attributes, @Nonnull TextRange range, @Nonnull 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;
}
@Nonnull
private HighlightersSet installHighlighterSet(@Nonnull Info info, @Nonnull EditorEx editor, boolean highlighterOnly) {
editor.getContentComponent().addKeyListener(myEditorKeyListener);
editor.getScrollingModel().addVisibleAreaListener(myVisibleAreaListener);
if (info.isNavigatable()) {
editor.setCustomCursor(CtrlMouseHandler.class, Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
}
List<RangeHighlighter> highlighters = new ArrayList<>();
if (!highlighterOnly || info.isNavigatable()) {
TextAttributes attributes = info.isNavigatable()
? EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.REFERENCE_HYPERLINK_COLOR)
: new TextAttributes(null, HintUtil.getInformationColor(), null, null, Font.PLAIN);
for (TextRange range : info.getRanges()) {
TextAttributes attr = NavigationUtil.patchAttributesColor(attributes, range, editor);
final RangeHighlighter highlighter = editor.getMarkupModel().addRangeHighlighter(range.getStartOffset(), range.getEndOffset(), HighlighterLayer.HYPERLINK, attr, HighlighterTargetArea.EXACT_RANGE);
highlighters.add(highlighter);
}
}
return new HighlightersSet(highlighters, editor, info);
}
/**
* Opens definition of method and highlights statements, which should be extracted.
*
* @param sourceMethod method from which code is proposed to be extracted into separate method.
* @param scope scope of the current project.
* @param slice computation slice.
*/
private static void openDefinition(@Nullable PsiMethod sourceMethod, AnalysisScope scope, ASTSlice slice) {
new Task.Backgroundable(scope.getProject(), "Search Definition") {
@Override
public void run(@NotNull ProgressIndicator indicator) {
indicator.setIndeterminate(true);
}
@Override
public void onSuccess() {
if (sourceMethod != null) {
Set<SmartPsiElementPointer<PsiElement>> statements = slice.getSliceStatements();
PsiStatement psiStatement = (PsiStatement) statements.iterator().next().getElement();
if (psiStatement != null && psiStatement.isValid()) {
EditorHelper.openInEditor(psiStatement);
Editor editor = FileEditorManager.getInstance(sourceMethod.getProject()).getSelectedTextEditor();
if (editor != null) {
TextAttributes attributes = EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
editor.getMarkupModel().removeAllHighlighters();
statements.stream()
.filter(statement -> statement.getElement() != null)
.forEach(statement ->
editor.getMarkupModel().addRangeHighlighter(statement.getElement().getTextRange().getStartOffset(),
statement.getElement().getTextRange().getEndOffset(), HighlighterLayer.SELECTION,
attributes, HighlighterTargetArea.EXACT_RANGE));
}
}
}
}
}.queue();
}
public Pair<RangeHighlighter, RangeHighlighter> highlightPair(BracePair bracePair) {
final Brace leftBrace = bracePair.getLeftBrace();
final Brace rightBrace = bracePair.getRightBrace();
final int leftBraceOffset = leftBrace.getOffset();
final int rightBraceOffset = rightBrace.getOffset();
final String leftBraceText = leftBrace.getText();
final String rightBraceText = rightBrace.getText();
if (leftBraceOffset == NON_OFFSET ||
rightBraceOffset == NON_OFFSET)
return null;
// try to get the text attr by element type
TextAttributesKey textAttributesKey =
HighlightBracketPairSettingsPage.getTextAttributesKeyByToken(leftBrace.getElementType());
// if not found, get the text attr by brace text
if (textAttributesKey == null) {
textAttributesKey = HighlightBracketPairSettingsPage.getTextAttributesKeyByText(leftBraceText);
}
final TextAttributes textAttributes = editor.getColorsScheme().getAttributes(textAttributesKey);
RangeHighlighter leftHighlighter = markupModelEx.addRangeHighlighter(
leftBraceOffset,
leftBraceOffset + leftBraceText.length(),
HighlighterLayer.SELECTION + HIGHLIGHT_LAYER_WEIGHT,
textAttributes,
HighlighterTargetArea.EXACT_RANGE);
RangeHighlighter rightHighlighter = markupModelEx.addRangeHighlighter(
rightBraceOffset,
rightBraceOffset + rightBraceText.length(),
HighlighterLayer.SELECTION + HIGHLIGHT_LAYER_WEIGHT,
textAttributes,
HighlighterTargetArea.EXACT_RANGE);
return new Pair<>(leftHighlighter, rightHighlighter);
}
@NotNull
private static RangeHighlighter createHighlighter(MarkupModel mm, TextRange range) {
final RangeHighlighter highlighter =
mm.addRangeHighlighter(range.getStartOffset(), range.getEndOffset(), 0, null, HighlighterTargetArea.EXACT_RANGE);
highlighter.setCustomRenderer(RENDERER);
return highlighter;
}
@NotNull
private static RangeHighlighter createHighlighter(MarkupModel mm, TextRange range) {
final RangeHighlighter highlighter =
mm.addRangeHighlighter(range.getStartOffset(), range.getEndOffset(), 0, null, HighlighterTargetArea.EXACT_RANGE);
highlighter.setCustomRenderer(RENDERER);
return highlighter;
}
public final void addHighlighting(final List<Integer> linesForHighlighting,
final Document document) {
TextAttributes attributes = new TextAttributes();
JBColor color = JBColor.GREEN;
attributes.setEffectColor(color);
attributes.setEffectType(EffectType.SEARCH_MATCH);
attributes.setBackgroundColor(HIGHLIGHTING_COLOR);
Editor projectEditor =
FileEditorManager.getInstance(windowObjects.getProject()).getSelectedTextEditor();
if (projectEditor != null) {
PsiFile psiFile =
PsiDocumentManager.getInstance(windowObjects.getProject()).
getPsiFile(projectEditor.getDocument());
MarkupModel markupModel = projectEditor.getMarkupModel();
if (markupModel != null) {
markupModel.removeAllHighlighters();
for (int line : linesForHighlighting) {
line = line - 1;
if (line < document.getLineCount()) {
int startOffset = document.getLineStartOffset(line);
int endOffset = document.getLineEndOffset(line);
String lineText =
document.getCharsSequence().
subSequence(startOffset, endOffset).toString();
int lineStartOffset =
startOffset + lineText.length() - lineText.trim().length();
markupModel.addRangeHighlighter(lineStartOffset, endOffset,
HighlighterLayer.ERROR, attributes,
HighlighterTargetArea.EXACT_RANGE);
if (psiFile != null && psiFile.findElementAt(lineStartOffset) != null) {
HighlightUsagesHandler.doHighlightElements(projectEditor,
new PsiElement[]{psiFile.findElementAt(lineStartOffset)},
attributes, false);
}
}
}
}
}
}
/**
* Highlights given text ranges in {@link #preview} content.
*
* @param pairs text ranges
*/
private void highlightWords(@NotNull List<Pair<Integer, Integer>> pairs) {
final TextAttributes attr = new TextAttributes();
attr.setBackgroundColor(UIUtil.getTreeSelectionBackground(true));
attr.setForegroundColor(UIUtil.getTreeSelectionForeground(true));
for (Pair<Integer, Integer> pair : pairs) {
preview.getMarkupModel().addRangeHighlighter(pair.first, pair.second, 0, attr,
HighlighterTargetArea.EXACT_RANGE);
}
}
@Nullable
private MyGutterOperation createOperation(@Nonnull ThreeSide side, @Nonnull OperationType type) {
if (isResolved(side)) return null;
EditorEx editor = myViewer.getEditor(side);
Document document = editor.getDocument();
int line = getStartLine(side);
int offset = line == DiffUtil.getLineCount(document) ? document.getTextLength() : document.getLineStartOffset(line);
RangeHighlighter highlighter =
editor.getMarkupModel().addRangeHighlighter(offset, offset, HighlighterLayer.ADDITIONAL_SYNTAX, null, HighlighterTargetArea.LINES_IN_RANGE);
return new MyGutterOperation(side, highlighter, type);
}
@Nonnull
private MyGutterOperation createOperation(@Nonnull Side sourceSide) {
int offset = myEditor.getDocument().getLineStartOffset(myLine1);
RangeHighlighter highlighter = myEditor.getMarkupModel().addRangeHighlighter(offset, offset,
HighlighterLayer.ADDITIONAL_SYNTAX,
null,
HighlighterTargetArea.LINES_IN_RANGE);
return new MyGutterOperation(sourceSide, highlighter);
}
@Nonnull
private MyGutterOperation createOperation(@Nonnull Side side) {
int offset = side.getStartOffset(myFragment);
EditorEx editor = myViewer.getEditor(side);
RangeHighlighter highlighter = editor.getMarkupModel().addRangeHighlighter(offset, offset,
HighlighterLayer.ADDITIONAL_SYNTAX,
null,
HighlighterTargetArea.LINES_IN_RANGE);
return new MyGutterOperation(side, highlighter);
}
@Nonnull
RangeHighlighterEx addRangeHighlighterAndChangeAttributes(int startOffset,
int endOffset,
int layer,
TextAttributes textAttributes,
@Nonnull HighlighterTargetArea targetArea,
boolean isPersistent,
Consumer<? super RangeHighlighterEx> changeAttributesAction);
@Nonnull
@Override
public RangeHighlighterEx addRangeHighlighterAndChangeAttributes(int startOffset,
int endOffset,
int layer,
TextAttributes textAttributes,
@Nonnull HighlighterTargetArea targetArea,
boolean isPersistent,
Consumer<? super RangeHighlighterEx> changeAttributesAction) {
throw new ProcessCanceledException();
}
static PersistentRangeHighlighterImpl create(@Nonnull MarkupModelImpl model,
int offset,
int layer,
@Nonnull HighlighterTargetArea target,
@Nullable TextAttributes textAttributes,
boolean normalizeStartOffset) {
int line = model.getDocument().getLineNumber(offset);
int startOffset = normalizeStartOffset ? model.getDocument().getLineStartOffset(line) : offset;
return new PersistentRangeHighlighterImpl(model, startOffset, line, layer, target, textAttributes);
}
@Override
@Nonnull
public RangeHighlighter addLineHighlighter(int lineNumber, int layer, TextAttributes textAttributes) {
if (isNotValidLine(lineNumber)) {
throw new IndexOutOfBoundsException("lineNumber:" + lineNumber + ". Must be in [0, " + (getDocument().getLineCount() - 1) + "]");
}
int offset = DocumentUtil.getFirstNonSpaceCharOffset(getDocument(), lineNumber);
return addRangeHighlighter(offset, offset, layer, textAttributes, HighlighterTargetArea.LINES_IN_RANGE);
}
@Override
@Nullable
public RangeHighlighterEx addPersistentLineHighlighter(int lineNumber, int layer, TextAttributes textAttributes) {
if (isNotValidLine(lineNumber)) {
return null;
}
int offset = DocumentUtil.getFirstNonSpaceCharOffset(getDocument(), lineNumber);
return addRangeHighlighter(PersistentRangeHighlighterImpl.create(this, offset, layer, HighlighterTargetArea.LINES_IN_RANGE, textAttributes, false), null);
}
@Nonnull
@Override
public RangeHighlighterEx addRangeHighlighterAndChangeAttributes(int startOffset,
int endOffset,
int layer,
TextAttributes textAttributes,
@Nonnull HighlighterTargetArea targetArea,
boolean isPersistent,
@Nullable Consumer<? super RangeHighlighterEx> changeAttributesAction) {
return addRangeHighlighter(isPersistent
? PersistentRangeHighlighterImpl.create(this, startOffset, layer, targetArea, textAttributes, true)
: new RangeHighlighterImpl(this, startOffset, endOffset, layer, targetArea, textAttributes, false, false), changeAttributesAction);
}
@Nonnull
@Override
public RangeHighlighterEx addRangeHighlighterAndChangeAttributes(int startOffset,
int endOffset,
int layer,
TextAttributes textAttributes,
@Nonnull HighlighterTargetArea targetArea,
boolean isPersistent,
Consumer<? super RangeHighlighterEx> changeAttributesAction) {
TextRange hostRange = myDocument.injectedToHost(new ProperTextRange(startOffset, endOffset));
return myHostModel.addRangeHighlighterAndChangeAttributes(hostRange.getStartOffset(), hostRange.getEndOffset(), layer, textAttributes, targetArea, isPersistent, changeAttributesAction);
}
public void testRangeHighlightersRecreateBug() throws Exception {
Document document = EditorFactory.getInstance().createDocument("[xxxxxxxxxxxxxx]");
MarkupModel markupModel = DocumentMarkupModel.forDocument(document, ourProject, true);
for (int i=0; i<2; i++) {
RangeMarker m = markupModel.addRangeHighlighter(1, 6, 0, null, HighlighterTargetArea.EXACT_RANGE);
RangeMarker m2 = markupModel.addRangeHighlighter(2, 7, 0, null, HighlighterTargetArea.EXACT_RANGE);
RangeMarker m3 = markupModel.addRangeHighlighter(1, 6, 0, null, HighlighterTargetArea.EXACT_RANGE);
markupModel.removeAllHighlighters();
}
}
public void testRangeHighlighterDisposeVsRemoveAllConflict() throws Exception {
Document document = EditorFactory.getInstance().createDocument("[xxxxxxxxxxxxxx]");
MarkupModel markupModel = DocumentMarkupModel.forDocument(document, ourProject, true);
RangeMarker m = markupModel.addRangeHighlighter(1, 6, 0, null, HighlighterTargetArea.EXACT_RANGE);
assertTrue(m.isValid());
markupModel.removeAllHighlighters();
assertFalse(m.isValid());
assertEmpty(markupModel.getAllHighlighters());
m.dispose();
assertFalse(m.isValid());
}