editor: extract Editor RangeHighlighter filters into separate markup model

2026-09-27 10:03:11 +07:00 · 2016-01-28 17:43:26 +03:00
parent af143a0209
commit b0b849795c
14 changed files with 286 additions and 57 deletions
@@ -98,7 +98,8 @@ public interface Editor extends UserDataHolder {
   * (for example, highlighters added by "Highlight usages in file"), which are painted in addition
   * to the highlighters contained in the markup model for the document.
   * <p>
-   * See also {@link com.intellij.openapi.editor.impl.DocumentMarkupModel.forDocument(Document, Project, boolean)}.
+   * See also {@link com.intellij.openapi.editor.impl.DocumentMarkupModel.forDocument(Document, Project, boolean)}
+   *          {@link com.intellij.openapi.editor.ex.EditorEx#getFilteredDocumentMarkupModel()}.
   *
   * @return the markup model instance.
   */
@@ -457,8 +457,6 @@ public class LivePreview extends DocumentAdapter implements SearchResults.Search
      new Processor<RangeHighlighterEx>() {
        @Override
        public boolean process(RangeHighlighterEx highlighter) {
-          if (!highlighter.getEditorFilter().avaliableIn(mySearchResults.getEditor())) return true;
-
          TextAttributes textAttributes =
            highlighter.getTextAttributes();
          if (highlighter.getUserData(SEARCH_MARKER) != null &&
@@ -73,6 +73,7 @@ public class EditorWindowImpl extends UserDataHolderBase implements EditorWindow
  private static final List<EditorWindowImpl> allEditors = new WeakList<EditorWindowImpl>();
  private boolean myDisposed;
  private final MarkupModelWindow myMarkupModelDelegate;
+  private final MarkupModelWindow myDocumentMarkupModelDelegate;
  private final FoldingModelWindow myFoldingModelWindow;
  private final SoftWrapModelWindow mySoftWrapModel;

@@ -110,6 +111,7 @@ public class EditorWindowImpl extends UserDataHolderBase implements EditorWindow
    myCaretModelDelegate = new CaretModelWindow(myDelegate.getCaretModel(), this);
    mySelectionModelDelegate = new SelectionModelWindow(myDelegate, myDocumentWindow,this);
    myMarkupModelDelegate = new MarkupModelWindow(myDelegate.getMarkupModel(), myDocumentWindow);
+    myDocumentMarkupModelDelegate = new MarkupModelWindow(myDelegate.getFilteredDocumentMarkupModel(), myDocumentWindow);
    myFoldingModelWindow = new FoldingModelWindow(delegate.getFoldingModel(), documentWindow, this);
    mySoftWrapModel = new SoftWrapModelWindow(this);
  }
@@ -254,6 +256,12 @@ public class EditorWindowImpl extends UserDataHolderBase implements EditorWindow
    return myMarkupModelDelegate;
  }

+  @NotNull
+  @Override
+  public MarkupModelEx getFilteredDocumentMarkupModel() {
+    return myDocumentMarkupModelDelegate;
+  }
+
  @Override
  @NotNull
  public FoldingModelEx getFoldingModel() {
@@ -184,8 +184,7 @@ public class EditorHyperlinkSupport {
                                                        new FilteringProcessor<RangeHighlighterEx>(new Condition<RangeHighlighterEx>() {
                                                          @Override
                                                          public boolean value(RangeHighlighterEx rangeHighlighterEx) {
-                                                            return rangeHighlighterEx.getEditorFilter().avaliableIn(editor) &&
-                                                                   HYPERLINK_LAYER == rangeHighlighterEx.getLayer() &&
+                                                            return HYPERLINK_LAYER == rangeHighlighterEx.getLayer() &&
                                                                   rangeHighlighterEx.isValid() &&
                                                                   getHyperlinkInfo(rangeHighlighterEx) != null;
                                                          }
@@ -21,6 +21,7 @@ import com.intellij.ide.DeleteProvider;
 import com.intellij.ide.PasteProvider;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.actionSystem.DataContext;
+import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.LogicalPosition;
 import com.intellij.openapi.editor.VisualPosition;
@@ -29,6 +30,8 @@ import com.intellij.openapi.editor.highlighter.EditorHighlighter;
 import com.intellij.openapi.editor.impl.TextDrawingCallback;
 import com.intellij.openapi.editor.impl.softwrap.SoftWrapAppliancePlaces;
 import com.intellij.openapi.editor.markup.TextAttributes;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -57,6 +60,21 @@ public interface EditorEx extends Editor {
  @NotNull
  MarkupModelEx getMarkupModel();

+  /**
+   * Returns the markup model for the underlying Document.
+   * <p>
+   * This model differs from the one from DocumentMarkupModel#forDocument,
+   * as it does not contain highlighters that should not be visible in this Editor.
+   * (for example, debugger breakpoints in a diff viewer editors)
+   *
+   * @return the markup model instance.
+   * @see com.intellij.openapi.editor.markup.MarkupEditorFilter
+   * @see com.intellij.openapi.editor.impl.EditorImpl#setHighlightingFilter(Condition<RangeHighlighter>)
+   * @see com.intellij.openapi.editor.impl.DocumentMarkupModel#forDocument(Document, Project, boolean)
+   */
+  @NotNull
+  MarkupModelEx getFilteredDocumentMarkupModel();
+
  @NotNull
  EditorGutterComponentEx getGutterComponentEx();

@@ -83,8 +83,6 @@ public class BorderEffect {
    markupModel.processRangeHighlightersOverlappingWith(myStartOffset, myEndOffset, new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(RangeHighlighterEx rangeHighlighter) {
-        if (!rangeHighlighter.getEditorFilter().avaliableIn(myEditor)) return true;
-
        TextAttributes textAttributes = rangeHighlighter.getTextAttributes();
        if (isBorder(textAttributes)) {
          paintBorder(rangeHighlighter, textAttributes);
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2000-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.openapi.editor.impl;
+
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.ex.DisposableIterator;
+import com.intellij.openapi.editor.ex.EditorEx;
+import com.intellij.openapi.editor.ex.MarkupModelEx;
+import com.intellij.openapi.editor.ex.RangeHighlighterEx;
+import com.intellij.openapi.editor.impl.event.MarkupModelListener;
+import com.intellij.openapi.editor.markup.HighlighterTargetArea;
+import com.intellij.openapi.editor.markup.RangeHighlighter;
+import com.intellij.openapi.editor.markup.TextAttributes;
+import com.intellij.openapi.util.Condition;
+import com.intellij.openapi.util.Key;
+import com.intellij.util.Consumer;
+import com.intellij.util.FilteringProcessor;
+import com.intellij.util.Processor;
+import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.FilteringIterator;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class EditorFilteringMarkupModelEx implements MarkupModelEx {
+  @NotNull private final EditorEx myEditor;
+  @NotNull private final MarkupModelEx myDelegate;
+
+  private final Condition<RangeHighlighter> IS_AVAILABLE = new Condition<RangeHighlighter>() {
+    @Override
+    public boolean value(RangeHighlighter highlighter) {
+      return isAvailable(highlighter);
+    }
+  };
+
+  public EditorFilteringMarkupModelEx(@NotNull EditorEx editor, @NotNull MarkupModelEx delegate) {
+    myEditor = editor;
+    myDelegate = delegate;
+  }
+
+  private boolean isAvailable(@NotNull RangeHighlighter highlighter) {
+    return highlighter.getEditorFilter().avaliableIn(myEditor);
+  }
+
+  @Override
+  public boolean containsHighlighter(@NotNull RangeHighlighter highlighter) {
+    return isAvailable(highlighter) && myDelegate.containsHighlighter(highlighter);
+  }
+
+  @Override
+  public boolean processRangeHighlightersOverlappingWith(int start, int end, @NotNull Processor<? super RangeHighlighterEx> processor) {
+    //noinspection unchecked
+    FilteringProcessor<? super RangeHighlighterEx> filteringProcessor = new FilteringProcessor(IS_AVAILABLE, processor);
+    return myDelegate.processRangeHighlightersOverlappingWith(start, end, filteringProcessor);
+  }
+
+  @Override
+  public boolean processRangeHighlightersOutside(int start, int end, @NotNull Processor<? super RangeHighlighterEx> processor) {
+    //noinspection unchecked
+    FilteringProcessor<? super RangeHighlighterEx> filteringProcessor = new FilteringProcessor(IS_AVAILABLE, processor);
+    return myDelegate.processRangeHighlightersOutside(start, end, filteringProcessor);
+  }
+
+  @Override
+  @NotNull
+  public DisposableIterator<RangeHighlighterEx> overlappingIterator(int startOffset, int endOffset) {
+    return new MyFilteringIterator(myDelegate.overlappingIterator(startOffset, endOffset));
+  }
+
+  @Override
+  @NotNull
+  public RangeHighlighter[] getAllHighlighters() {
+    List<RangeHighlighter> list = ContainerUtil.filter(myDelegate.getAllHighlighters(), IS_AVAILABLE);
+    return list.toArray(new RangeHighlighter[list.size()]);
+  }
+
+  @Override
+  public void dispose() {
+  }
+
+  private class MyFilteringIterator extends FilteringIterator<RangeHighlighterEx, RangeHighlighterEx>
+    implements DisposableIterator<RangeHighlighterEx>, IntervalTreeImpl.PeekableIterator<RangeHighlighterEx> {
+    private DisposableIterator<RangeHighlighterEx> myDelegate;
+
+    public MyFilteringIterator(@NotNull DisposableIterator<RangeHighlighterEx> delegate) {
+      super(delegate, IS_AVAILABLE);
+      myDelegate = delegate;
+    }
+
+    @Override
+    public void dispose() {
+      myDelegate.dispose();
+    }
+  }
+
+  //
+  // Delegated
+  //
+
+  @Override
+  @NotNull
+  public Document getDocument() {
+    return myDelegate.getDocument();
+  }
+
+  @Override
+  public void addMarkupModelListener(@NotNull Disposable parentDisposable, @NotNull MarkupModelListener listener) {
+    myDelegate.addMarkupModelListener(parentDisposable, listener);
+  }
+
+  @Override
+  public void fireAttributesChanged(@NotNull RangeHighlighterEx segmentHighlighter, boolean renderersChanged) {
+    myDelegate.fireAttributesChanged(segmentHighlighter, renderersChanged);
+  }
+
+  @Override
+  public void fireAfterAdded(@NotNull RangeHighlighterEx segmentHighlighter) {
+    myDelegate.fireAfterAdded(segmentHighlighter);
+  }
+
+  @Override
+  public void fireBeforeRemoved(@NotNull RangeHighlighterEx segmentHighlighter) {
+    myDelegate.fireBeforeRemoved(segmentHighlighter);
+  }
+
+  @Override
+  @Nullable
+  public RangeHighlighterEx addPersistentLineHighlighter(int lineNumber, int layer, TextAttributes textAttributes) {
+    return myDelegate.addPersistentLineHighlighter(lineNumber, layer, textAttributes);
+  }
+
+  @Override
+  public void addRangeHighlighter(@NotNull RangeHighlighterEx marker,
+                                  int start,
+                                  int end,
+                                  boolean greedyToLeft,
+                                  boolean greedyToRight,
+                                  int layer) {
+    myDelegate.addRangeHighlighter(marker, start, end, greedyToLeft, greedyToRight, layer);
+  }
+
+  @Override
+  @NotNull
+  public RangeHighlighter addRangeHighlighter(int startOffset,
+                                              int endOffset,
+                                              int layer,
+                                              @Nullable TextAttributes textAttributes,
+                                              @NotNull HighlighterTargetArea targetArea) {
+    return myDelegate.addRangeHighlighter(startOffset, endOffset, layer, textAttributes, targetArea);
+  }
+
+  @Override
+  @NotNull
+  public RangeHighlighter addLineHighlighter(int line, int layer, @Nullable TextAttributes textAttributes) {
+    return myDelegate.addLineHighlighter(line, layer, textAttributes);
+  }
+
+  @Override
+  @NotNull
+  public RangeHighlighterEx addRangeHighlighterAndChangeAttributes(int startOffset,
+                                                                   int endOffset,
+                                                                   int layer,
+                                                                   TextAttributes textAttributes,
+                                                                   @NotNull HighlighterTargetArea targetArea,
+                                                                   boolean isPersistent,
+                                                                   Consumer<RangeHighlighterEx> changeAttributesAction) {
+    return myDelegate.addRangeHighlighterAndChangeAttributes(startOffset, endOffset, layer, textAttributes, targetArea, isPersistent,
+                                                             changeAttributesAction);
+  }
+
+  @Override
+  public void setRangeHighlighterAttributes(@NotNull RangeHighlighter highlighter, @NotNull TextAttributes textAttributes) {
+    myDelegate.setRangeHighlighterAttributes(highlighter, textAttributes);
+  }
+
+  @Override
+  public void changeAttributesInBatch(@NotNull RangeHighlighterEx highlighter,
+                                      @NotNull Consumer<RangeHighlighterEx> changeAttributesAction) {
+    myDelegate.changeAttributesInBatch(highlighter, changeAttributesAction);
+  }
+
+  @Override
+  public void removeHighlighter(@NotNull RangeHighlighter rangeHighlighter) {
+    myDelegate.removeHighlighter(rangeHighlighter);
+  }
+
+  @Override
+  public void removeAllHighlighters() {
+    myDelegate.removeAllHighlighters();
+  }
+
+  @Override
+  @Nullable
+  public <T> T getUserData(@NotNull Key<T> key) {
+    return myDelegate.getUserData(key);
+  }
+
+  @Override
+  public <T> void putUserData(@NotNull Key<T> key, @Nullable T value) {
+    myDelegate.putUserData(key, value);
+  }
+}
@@ -561,9 +561,8 @@ class EditorGutterComponentImpl extends EditorGutterComponentEx implements Mouse

  private void processRangeHighlighters(int startOffset, int endOffset, @NotNull RangeHighlighterProcessor processor) {
    Document document = myEditor.getDocument();
-    final MarkupModelEx docMarkup = (MarkupModelEx)DocumentMarkupModel.forDocument(document, myEditor.getProject(), true);
    // we limit highlighters to process to between line starting at startOffset and line ending at endOffset
-    DisposableIterator<RangeHighlighterEx> docHighlighters = docMarkup.overlappingIterator(startOffset, endOffset);
+    DisposableIterator<RangeHighlighterEx> docHighlighters = myEditor.getFilteredDocumentMarkupModel().overlappingIterator(startOffset, endOffset);
    DisposableIterator<RangeHighlighterEx> editorHighlighters = myEditor.getMarkupModel().overlappingIterator(startOffset, endOffset);

    try {
@@ -614,9 +613,7 @@ class EditorGutterComponentImpl extends EditorGutterComponentEx implements Mouse
        int endLineIndex = lowerHighlighter.getDocument().getLineNumber(endOffset);
        if (!isValidLine(document, endLineIndex)) continue;

-        if (lowerHighlighter.getEditorFilter().avaliableIn(myEditor)) {
-          processor.process(lowerHighlighter);
-        }
+        processor.process(lowerHighlighter);
      }
    }
    finally {
@@ -191,6 +191,8 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
  private boolean myIsViewer;
  @NotNull private final SelectionModelImpl mySelectionModel;
  @NotNull private final EditorMarkupModelImpl myMarkupModel;
+  @NotNull private final MarkupModelEx myDocumentMarkupModel;
+
  @NotNull private final FoldingModelImpl myFoldingModel;
  @NotNull private final ScrollingModelImpl myScrollingModel;
  @NotNull private final CaretModelImpl myCaretModel;
@@ -341,8 +343,11 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
      putUserData(FORCED_SOFT_WRAPS, Boolean.TRUE);
    }

+    MarkupModelEx documentMarkup = (MarkupModelEx)DocumentMarkupModel.forDocument(myDocument, myProject, true);
+
    mySelectionModel = new SelectionModelImpl(this);
    myMarkupModel = new EditorMarkupModelImpl(this);
+    myDocumentMarkupModel = new EditorFilteringMarkupModelEx(this, documentMarkup);
    myFoldingModel = new FoldingModelImpl(this);
    myCaretModel = new CaretModelImpl(this);
    mySoftWrapModel = new SoftWrapModelImpl(this);
@@ -418,7 +423,7 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
      }
    };

-    ((MarkupModelEx)DocumentMarkupModel.forDocument(myDocument, myProject, true)).addMarkupModelListener(myCaretModel, markupModelListener);
+    getFilteredDocumentMarkupModel().addMarkupModelListener(myCaretModel, markupModelListener);
    getMarkupModel().addMarkupModelListener(myCaretModel, markupModelListener);

    myDocument.addDocumentListener(myFoldingModel, myCaretModel);
@@ -722,6 +727,12 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
    return myMarkupModel;
  }

+  @Override
+  @NotNull
+  public MarkupModelEx getFilteredDocumentMarkupModel() {
+    return myDocumentMarkupModel;
+  }
+
  @Override
  @NotNull
  public FoldingModelImpl getFoldingModel() {
@@ -2164,14 +2175,13 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi

      paintRightMargin(g, clip);
      paintCustomRenderers(g, clipStartOffset, clipEndOffset);
-      MarkupModelEx docMarkup = (MarkupModelEx)DocumentMarkupModel.forDocument(myDocument, myProject, true);
-      paintLineMarkersSeparators(g, clip, docMarkup, clipStartOffset, clipEndOffset);
+      paintLineMarkersSeparators(g, clip, myDocumentMarkupModel, clipStartOffset, clipEndOffset);
      paintLineMarkersSeparators(g, clip, myMarkupModel, clipStartOffset, clipEndOffset);
      paintText(g, clip, clipStartPosition, clipStartOffset, clipEndOffset);
-      paintSegmentHighlightersBorderAndAfterEndOfLine(g, clip, clipStartOffset, clipEndOffset, docMarkup);
+      paintSegmentHighlightersBorderAndAfterEndOfLine(g, clip, clipStartOffset, clipEndOffset, myDocumentMarkupModel);
      BorderEffect borderEffect = new BorderEffect(this, g, clipStartOffset, clipEndOffset);
      borderEffect.paintHighlighters(getHighlighter());
-      borderEffect.paintHighlighters(docMarkup);
+      borderEffect.paintHighlighters(myDocumentMarkupModel);
      borderEffect.paintHighlighters(myMarkupModel);

      paintCaretCursor(g);
@@ -2187,8 +2197,6 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
    myMarkupModel.processRangeHighlightersOverlappingWith(clipStartOffset, clipEndOffset, new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(@NotNull RangeHighlighterEx highlighter) {
-        if (!highlighter.getEditorFilter().avaliableIn(EditorImpl.this)) return true;
-
        final CustomHighlighterRenderer customRenderer = highlighter.getCustomRenderer();
        if (customRenderer != null && clipStartOffset < highlighter.getEndOffset() && highlighter.getStartOffset() < clipEndOffset) {
          customRenderer.paint(EditorImpl.this, highlighter, g);
@@ -2355,8 +2363,6 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
    Processor<RangeHighlighterEx> paintProcessor = new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(@NotNull RangeHighlighterEx highlighter) {
-        if (!highlighter.getEditorFilter().avaliableIn(EditorImpl.this)) return true;
-
        paintSegmentHighlighterAfterEndOfLine(g, highlighter, startLine, endLine);
        return true;
      }
@@ -3286,8 +3292,6 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
    markupModel.processRangeHighlightersOverlappingWith(clipStartOffset, clipEndOffset, new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(@NotNull RangeHighlighterEx lineMarker) {
-        if (!lineMarker.getEditorFilter().avaliableIn(EditorImpl.this)) return true;
-
        paintLineMarkerSeparator(lineMarker, clip, g);
        return true;
      }
@@ -196,7 +196,7 @@ public class EditorMarkupModelImpl extends MarkupModelImpl implements EditorMark
    if (IJSwingUtilities.findParentByInterface(myEditor.getComponent(), EditorWindowHolder.class) == null || isVisible || !UISettings.getInstance().SHOW_EDITOR_TOOLTIP) {
      final Set<RangeHighlighter> highlighters = new THashSet<RangeHighlighter>();
      getNearestHighlighters(this, me.getY(), highlighters);
-      getNearestHighlighters((MarkupModelEx)DocumentMarkupModel.forDocument(myEditor.getDocument(), getEditor().getProject(), true), me.getY(), highlighters);
+      getNearestHighlighters(((EditorEx)getEditor()).getFilteredDocumentMarkupModel(), me.getY(), highlighters);
      if (highlighters.isEmpty()) return false;

      int y = e.getY();
@@ -221,9 +221,7 @@ public class EditorMarkupModelImpl extends MarkupModelImpl implements EditorMark
      me = new MouseEvent(me.getComponent(), me.getID(), me.getWhen(), me.getModifiers(), me.getX(), y, me.getClickCount(), me.isPopupTrigger());
      final List<RangeHighlighterEx> highlighters = new ArrayList<RangeHighlighterEx>();
      collectRangeHighlighters(this, visualLine, highlighters);
-      collectRangeHighlighters((MarkupModelEx)DocumentMarkupModel.forDocument(myEditor.getDocument(), getEditor().getProject(), true),
-                               visualLine,
-                               highlighters);
+      collectRangeHighlighters(myEditor.getFilteredDocumentMarkupModel(), visualLine, highlighters);
      myEditorFragmentRenderer.update(visualLine, highlighters, me.isAltDown());
      myEditorFragmentRenderer.show(myEditor, me.getPoint(), true, ERROR_STRIPE_TOOLTIP_GROUP, createHint(me));
      return true;
@@ -254,8 +252,6 @@ public class EditorMarkupModelImpl extends MarkupModelImpl implements EditorMark
    markupModel.processRangeHighlightersOverlappingWith(startOffset, endOffset, new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(@NotNull RangeHighlighterEx highlighter) {
-        if (!highlighter.getEditorFilter().avaliableIn(myEditor)) return true;
-
        if (highlighter.getErrorStripeMarkColor() != null) {
          if (highlighter.getStartOffset() < endOffset && highlighter.getEndOffset() > startOffset) {
            highlighters.add(highlighter);
@@ -270,8 +266,7 @@ public class EditorMarkupModelImpl extends MarkupModelImpl implements EditorMark
  private RangeHighlighter getNearestRangeHighlighter(@NotNull final MouseEvent e) {
    List<RangeHighlighter> highlighters = new ArrayList<RangeHighlighter>();
    getNearestHighlighters(this, e.getY(), highlighters);
-    getNearestHighlighters((MarkupModelEx)DocumentMarkupModel.forDocument(myEditor.getDocument(), myEditor.getProject(), true), e.getY(),
-                           highlighters);
+    getNearestHighlighters(myEditor.getFilteredDocumentMarkupModel(), e.getY(), highlighters);
    RangeHighlighter nearestMarker = null;
    int yPos = 0;
    for (RangeHighlighter highlighter : highlighters) {
@@ -293,8 +288,6 @@ public class EditorMarkupModelImpl extends MarkupModelImpl implements EditorMark
    markupModel.processRangeHighlightersOverlappingWith(startOffset, endOffset, new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(@NotNull RangeHighlighterEx highlighter) {
-        if (!highlighter.getEditorFilter().avaliableIn(myEditor)) return true;
-
        if (highlighter.getErrorStripeMarkColor() != null) {
          ProperTextRange range = offsetsToYPositions(highlighter.getStartOffset(), highlighter.getEndOffset());
          if (scrollBarY >= range.getStartOffset() - myMinMarkHeight * 2 &&
@@ -718,7 +711,7 @@ public class EditorMarkupModelImpl extends MarkupModelImpl implements EditorMark
      g.clipRect(clip.x, clip.y, clip.width, clip.height);

      drawMarkup(g, startOffset, endOffset,
-                 (MarkupModelEx)DocumentMarkupModel.forDocument(document, myEditor.getProject(), true), EditorMarkupModelImpl.this);
+                 myEditor.getFilteredDocumentMarkupModel(), EditorMarkupModelImpl.this);

      g.setClip(oldClip);
    }
@@ -751,8 +744,6 @@ public class EditorMarkupModelImpl extends MarkupModelImpl implements EditorMark
        ContainerUtil.process(iterator, new Processor<RangeHighlighterEx>() {
          @Override
          public boolean process(@NotNull RangeHighlighterEx highlighter) {
-            if (!highlighter.getEditorFilter().avaliableIn(myEditor)) return true;
-
            Color color = highlighter.getErrorStripeMarkColor();
            if (color == null) return true;
            boolean isThin = highlighter.isThinErrorStripeMark();
@@ -180,7 +180,7 @@ public final class IterationState {
    MarkupModelEx editorMarkup = editor.getMarkupModel();
    myView = new HighlighterSweep(editorMarkup, start, myEnd, useOnlyFullLineHighlighters);

-    final MarkupModelEx docMarkup = (MarkupModelEx)DocumentMarkupModel.forDocument(editor.getDocument(), editor.getProject(), true);
+    MarkupModelEx docMarkup = editor.getFilteredDocumentMarkupModel();
    myDoc = new HighlighterSweep(docMarkup, start, myEnd, useOnlyFullLineHighlighters);

    myEndOffset = myStartOffset;
@@ -251,7 +251,7 @@ public final class IterationState {
    if (!highlighter.isValid() || highlighter.isAfterEndOfLine() || highlighter.getTextAttributes() == null) return true;
    final FoldRegion region = myFoldingModel.getCollapsedRegionAtOffset(highlighter.getAffectedAreaStartOffset());
    if (region != null && region == myFoldingModel.getCollapsedRegionAtOffset(highlighter.getAffectedAreaEndOffset())) return true;
-    return !highlighter.getEditorFilter().avaliableIn(myEditor);
+    return false;
  }

  public void advance() {
@@ -90,7 +90,7 @@ class EditorPainter implements TextDrawingCallback {
    paintBackground(g, clip, startLine, endLine);
    paintRightMargin(g, clip);
    paintCustomRenderers(g, startOffset, endOffset);
-    MarkupModelEx docMarkup = (MarkupModelEx)DocumentMarkupModel.forDocument(myDocument, myEditor.getProject(), true);
+    MarkupModelEx docMarkup = myEditor.getFilteredDocumentMarkupModel();
    paintLineMarkersSeparators(g, clip, docMarkup, startOffset, endOffset);
    paintLineMarkersSeparators(g, clip, myEditor.getMarkupModel(), startOffset, endOffset);
    paintTextWithEffects(g, clip, startLine, endLine);
@@ -282,11 +282,9 @@ class EditorPainter implements TextDrawingCallback {
    myEditor.getMarkupModel().processRangeHighlightersOverlappingWith(startOffset, endOffset, new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(RangeHighlighterEx highlighter) {
-        if (highlighter.getEditorFilter().avaliableIn(myEditor)) {
-          CustomHighlighterRenderer customRenderer = highlighter.getCustomRenderer();
-          if (customRenderer != null && startOffset < highlighter.getEndOffset() && highlighter.getStartOffset() < endOffset) {
-            customRenderer.paint(myEditor, highlighter, g);
-          }
+        CustomHighlighterRenderer customRenderer = highlighter.getCustomRenderer();
+        if (customRenderer != null && startOffset < highlighter.getEndOffset() && highlighter.getStartOffset() < endOffset) {
+          customRenderer.paint(myEditor, highlighter, g);
        }
        return true;
      }
@@ -301,9 +299,7 @@ class EditorPainter implements TextDrawingCallback {
    markupModel.processRangeHighlightersOverlappingWith(startOffset, endOffset, new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(RangeHighlighterEx highlighter) {
-        if (highlighter.getEditorFilter().avaliableIn(myEditor)) {
-          paintLineMarkerSeparator(highlighter, clip, g);
-        }
+        paintLineMarkerSeparator(highlighter, clip, g);
        return true;
      }
    });
@@ -535,7 +531,7 @@ class EditorPainter implements TextDrawingCallback {
    markupModel.processRangeHighlightersOverlappingWith(startOffset, endOffset, new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(RangeHighlighterEx highlighter) {
-        if (highlighter.getEditorFilter().avaliableIn(myEditor) && highlighter.getStartOffset() >= startOffset) {
+        if (highlighter.getStartOffset() >= startOffset) {
          paintHighlighterAfterEndOfLine(g, highlighter);
        }
        return true;
@@ -584,12 +580,10 @@ class EditorPainter implements TextDrawingCallback {
    markupModel.processRangeHighlightersOverlappingWith(clipStartOffset, clipEndOffset, new Processor<RangeHighlighterEx>() {
      @Override
      public boolean process(RangeHighlighterEx rangeHighlighter) {
-        if (rangeHighlighter.getEditorFilter().avaliableIn(myEditor)) {
-          TextAttributes attributes = rangeHighlighter.getTextAttributes();
-          if (isBorder(attributes)) {
-            paintBorderEffect(g, clipDetector, rangeHighlighter.getAffectedAreaStartOffset(), rangeHighlighter.getAffectedAreaEndOffset(), 
-                              attributes);
-          }
+        TextAttributes attributes = rangeHighlighter.getTextAttributes();
+        if (isBorder(attributes)) {
+          paintBorderEffect(g, clipDetector, rangeHighlighter.getAffectedAreaStartOffset(), rangeHighlighter.getAffectedAreaEndOffset(),
+                            attributes);
        }
        return true;
      }
@@ -21,7 +21,6 @@ import com.intellij.openapi.editor.*;
 import com.intellij.openapi.editor.colors.EditorColors;
 import com.intellij.openapi.editor.ex.*;
 import com.intellij.openapi.editor.highlighter.HighlighterIterator;
-import com.intellij.openapi.editor.impl.DocumentMarkupModel;
 import com.intellij.openapi.editor.markup.EffectType;
 import com.intellij.openapi.editor.markup.HighlighterLayer;
 import com.intellij.openapi.editor.markup.HighlighterTargetArea;
@@ -187,7 +186,7 @@ public class IterationState {
    MarkupModelEx editorMarkup = editor.getMarkupModel();
    myView = new HighlighterSweep(editorMarkup, start, myEnd, useOnlyFullLineHighlighters);

-    final MarkupModelEx docMarkup = (MarkupModelEx)DocumentMarkupModel.forDocument(editor.getDocument(), editor.getProject(), true);
+    MarkupModelEx docMarkup = editor.getFilteredDocumentMarkupModel();
    myDoc = new HighlighterSweep(docMarkup, start, myEnd, useOnlyFullLineHighlighters);

    myEndOffset = myStartOffset;
@@ -265,7 +264,7 @@ public class IterationState {
    final FoldRegion region = myFoldingModel == null ? null :
                              myFoldingModel.getCollapsedRegionAtOffset(highlighter.getAffectedAreaStartOffset());
    if (region != null && region == myFoldingModel.getCollapsedRegionAtOffset(highlighter.getAffectedAreaEndOffset())) return true;
-    return !highlighter.getEditorFilter().avaliableIn(myEditor);
+    return false;
  }

  public void advance() {
@@ -98,6 +98,11 @@ public class FilteringIterator<Dom, E extends Dom> implements Iterator<E> {
    myDelegate.remove();
  }

+  public E peek() {
+    if (!hasNext()) throw new NoSuchElementException();
+    return (E)myCurrent;
+  }
+
  public static <T> Iterator<T> skipNulls(Iterator<T> iterator) {
    return create(iterator, NOT_NULL);
  }