'x' coordinate to use
+ * @param y target 'y' coordinate to use
+ * @param lineHeight line height used at editor
+ * @return painted drawing width
+ */
+ int paint(@NotNull Graphics g, @NotNull SoftWrapDrawingType drawingType, int x, int y, int lineHeight);
}
diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/ArrowPainter.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/ArrowPainter.java
new file mode 100644
index 000000000000..a211348e6d3d
--- /dev/null
+++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/ArrowPainter.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2000-2010 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.util.Computable;
+import com.intellij.util.ui.UIUtil;
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.*;
+
+/**
+ * Encapsulates logic of drawing arrows at graphics buffer (primary usage is to draw tabulation symbols representation arrows).
+ *
+ * @author Denis Zhdanov
+ * @since Jul 2, 2010 11:35:23 AM
+ */
+public class ArrowPainter {
+
+ private final ColorHolder myColorHolder;
+ private final Computable'x' position to use during drawing
+ * @param stop ending 'x' position to use during drawing
+ */
+ public void paint(Graphics g, int y, int start, int stop) {
+ stop -= g.getFontMetrics().charWidth(' ') / 2;
+ Color oldColor = g.getColor();
+ g.setColor(myColorHolder.getColor());
+ final int height = myHeightProvider.compute();
+ final int halfHeight = height / 2;
+ int mid = y - halfHeight;
+ int top = y - height;
+ UIUtil.drawLine(g, start, mid, stop, mid);
+ UIUtil.drawLine(g, stop, y, stop, top);
+ g.fillPolygon(new int[]{stop - halfHeight, stop - halfHeight, stop}, new int[]{y, y - height, y - halfHeight}, 3);
+ g.setColor(oldColor);
+ }
+}
diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/CaretModelImpl.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/CaretModelImpl.java
index 3310c6c80f17..b62353d3467d 100644
--- a/platform/platform-impl/src/com/intellij/openapi/editor/impl/CaretModelImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/CaretModelImpl.java
@@ -308,17 +308,13 @@ public class CaretModelImpl implements CaretModel, PrioritizedDocumentListener {
myOffset = myEditor.logicalPositionToOffset(myLogicalCaret);
LOG.assertTrue(myOffset >= 0 && myOffset <= myEditor.getDocument().getTextLength());
- int caretOffset = myEditor.logicalPositionToOffset(myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line, 0)));
- int caretLine = doc.getLineNumber(caretOffset);
- myVisualLineStart = doc.getLineStartOffset(caretLine);
- myVisualLineEnd = doc.getLineEndOffset(caretLine) + 1;
+ myVisualLineStart = myEditor.logicalPositionToOffset(myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line, 0)));
+ myVisualLineEnd = myEditor.logicalPositionToOffset(myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line + 1, 0)));
myEditor.updateCaretCursor();
requestRepaint(oldInfo);
- if (oldCaretPosition.column + oldCaretPosition.softWrapColumnDiff != myLogicalCaret.column + myLogicalCaret.softWrapColumnDiff
- || oldCaretPosition.line + oldCaretPosition.softWrapLinesBeforeCurrentLogicalLine != myLogicalCaret.line + myLogicalCaret.softWrapLinesBeforeCurrentLogicalLine)
- {
+ if (!oldCaretPosition.toVisualPosition().equals(myLogicalCaret.toVisualPosition())) {
CaretEvent event = new CaretEvent(myEditor, oldCaretPosition, myLogicalCaret);
for (CaretListener listener : myCaretListeners) {
listener.caretPositionChanged(event);
@@ -366,18 +362,6 @@ public class CaretModelImpl implements CaretModel, PrioritizedDocumentListener {
return myOffset;
}
- /**
- * There is a possible case that single logical line is spread to more than one visual lines because of soft wraps. This method
- * allows to receive information about vertical range occupied by the active logical line, i.e. it identifies
- * 'y' coordinate of the first visual line that corresponds to the logical line and total height
- * of all visual lines that correspond to the active logical line.
- *
- * @return object that encapsulates information about visual vertical range occupied by the current logical line on a screen
- */
- public VerticalInfo getVisualCaretInfo() {
- return myCaretInfo;
- }
-
public int getVisualLineStart() {
return myVisualLineStart;
}
diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/ColorHolder.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/ColorHolder.java
new file mode 100644
index 000000000000..c2bda05bf4c9
--- /dev/null
+++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/ColorHolder.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2000-2010 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.editor.Editor;
+import com.intellij.openapi.editor.colors.ColorKey;
+import com.intellij.openapi.editor.colors.EditorColorsScheme;
+
+import java.awt.*;
+
+/**
+ * Defines common contract for target {@link Color} retrieving.
+ *
+ * @author Denis Zhdanov
+ * @since Jul 2, 2010 11:12:07 AM
+ */
+public abstract class ColorHolder {
+
+ /**
+ * @return target {@link Color} object managed by the current holder
+ */
+ public abstract Color getColor();
+
+ /**
+ * Factory method for creating color holder that always returns given {@link Color} object.
+ *
+ * @param color target color to use
+ * @return color holder that uses given color all the time
+ */
+ public static ColorHolder byColor(Color color) {
+ return new StaticColorHolder(color);
+ }
+
+ /**
+ * Shortcut for calling {@link #byColorsScheme(EditorColorsScheme, ColorKey)} with colors scheme retrieved from the given editor.
+ *
+ * @param editor target colors scheme holder
+ * @param key target color identifier within the colors scheme
+ * @return color holder that delegate target color retrieval to the colors scheme associated
+ * with the given editor using given color key
+ */
+ public static ColorHolder byColorsScheme(Editor editor, ColorKey key) {
+ return new ColorSchemeBasedHolder(editor.getColorsScheme(), key);
+ }
+
+ /**
+ * Factory method for creating color holder that delegate target color retrieval to the given colors scheme using given color key.
+ *
+ * @param scheme target colors scheme to use
+ * @param key target color identifier
+ * @return color holder that delegate target color retrieval to the given colors scheme using given color key
+ */
+ public static ColorHolder byColorsScheme(EditorColorsScheme scheme, ColorKey key) {
+ return new ColorSchemeBasedHolder(scheme, key);
+ }
+
+ private static class StaticColorHolder extends ColorHolder {
+
+ private final Color myColor;
+
+ StaticColorHolder(Color color) {
+ myColor = color;
+ }
+
+ @Override
+ public Color getColor() {
+ return myColor;
+ }
+ }
+
+ private static class ColorSchemeBasedHolder extends ColorHolder {
+
+ private final EditorColorsScheme myScheme;
+ private final ColorKey myKey;
+
+ ColorSchemeBasedHolder(EditorColorsScheme scheme, ColorKey key) {
+ myScheme = scheme;
+ myKey = key;
+ }
+
+ @Override
+ public Color getColor() {
+ return myScheme.getColor(myKey);
+ }
+ }
+}
diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/EditorGutterComponentImpl.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/EditorGutterComponentImpl.java
index b540e898fe13..578bd2b92b99 100644
--- a/platform/platform-impl/src/com/intellij/openapi/editor/impl/EditorGutterComponentImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/EditorGutterComponentImpl.java
@@ -258,11 +258,12 @@ class EditorGutterComponentImpl extends EditorGutterComponentEx implements Mouse
}
private void paintCaretRowBackground(final Graphics g, final int x, final int width) {
- CaretModelImpl.VerticalInfo caretInfo = myEditor.getCaretModel().getVisualCaretInfo();
+ final VisualPosition visCaret = myEditor.getCaretModel().getVisualPosition();
Color caretRowColor = myEditor.getColorsScheme().getColor(EditorColors.CARET_ROW_COLOR);
if (caretRowColor != null) {
g.setColor(caretRowColor);
- g.fillRect(x, caretInfo.y, width, caretInfo.height);
+ final Point caretPoint = myEditor.visualPositionToXY(visCaret);
+ g.fillRect(x, caretPoint.y, width, myEditor.getLineHeight());
}
}
diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/EditorImpl.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/EditorImpl.java
index 1a58ca8e889b..182cd653dd90 100644
--- a/platform/platform-impl/src/com/intellij/openapi/editor/impl/EditorImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/EditorImpl.java
@@ -49,6 +49,7 @@ import com.intellij.openapi.editor.highlighter.EditorHighlighter;
import com.intellij.openapi.editor.highlighter.HighlighterClient;
import com.intellij.openapi.editor.impl.event.MarkupModelEvent;
import com.intellij.openapi.editor.impl.event.MarkupModelListener;
+import com.intellij.openapi.editor.impl.softwrap.SoftWrapDrawingType;
import com.intellij.openapi.editor.markup.*;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.progress.ProgressManager;
@@ -154,6 +155,7 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
private MyEditable myEditable;
private EditorColorsScheme myScheme;
+ private ArrowPainter myTabPainter;
private final boolean myIsViewer;
private final SelectionModelImpl mySelectionModel;
private final EditorMarkupModelImpl myMarkupModel;
@@ -178,6 +180,7 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
private boolean myUnderRepainting;
private EditorHighlighter myHighlighter;
+ private final TextDrawingCallback myTextDrawingCallback = new MyTextDrawingCallback();
private int myScrollBarOrientation;
private boolean myMousePressedInsideSelection;
@@ -237,11 +240,11 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
ourCaretBlinkingCommand.start();
}
-
public EditorImpl(Document document, boolean viewer, Project project) {
myProject = project;
myDocument = (DocumentImpl)document;
myScheme = new MyColorSchemeDelegate();
+ initTabPainter();
myIsViewer = viewer;
mySettings = new SettingsImpl(this);
@@ -474,6 +477,7 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
myEditorComponent.repaint();
+ initTabPainter();
updateCaretCursor();
if (myInitialMouseEvent != null) {
@@ -481,6 +485,18 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
}
}
+ private void initTabPainter() {
+ myTabPainter = new ArrowPainter(
+ ColorHolder.byColorsScheme(myScheme, EditorColors.WHITESPACES_COLOR),
+ new Computable[start; end) interval should be soft wrapped,
* i.e. represented on a next line.
*
- * @param chars symbols holder
- * @param start target symbols sub-sequence start within the given char array (inclusive)
- * @param end target symbols sub-sequence end within the given char array (exclusive)
- * @param position current drawing position
- * @return true if target symbols sub-sequence should be soft-wrapped; false otherwise
+ * @param g graphics buffer being used
+ * @param chars symbols holder
+ * @param start target symbols sub-sequence start within the given char array (inclusive)
+ * @param end target symbols sub-sequence end within the given char array (exclusive)
+ * @param x 'x' coordinate of the current drawing position
+ * @param onSoftWrapIntroducedVisualLine defines if current visual position belongs to soft wrap-introduced visual line
+ * @return true if target symbols sub-sequence should be soft-wrapped;
+ * false otherwise
*/
- public boolean shouldWrap(char[] chars, int start, int end, Point position) {
+ public boolean shouldWrap(@NotNull Graphics g, @NotNull char[] chars, int start, int end, int x, boolean onSoftWrapIntroducedVisualLine) {
if (!isSoftWrappingEnabled()) {
return false;
}
@@ -178,7 +183,11 @@ public class SoftWrapModelImpl implements SoftWrapModelEx {
}
//TODO den implement
- return position.x + (end - start) * 7 > myRightEdgeLocation;
+ int xAfterCharsDrawing = x + myPainter.getMinDrawingWidth(SoftWrapDrawingType.BEFORE_SOFT_WRAP_LINE_FEED) + (end - start) * 7;
+ if (onSoftWrapIntroducedVisualLine) {
+ xAfterCharsDrawing += myPainter.getMinDrawingWidth(SoftWrapDrawingType.AFTER_SOFT_WRAP_LINE_FEED);
+ }
+ return xAfterCharsDrawing > myRightEdgeLocation;
}
private static boolean containsOnlyWhiteSpaces(char[] chars, int start, int end) {
@@ -243,6 +252,11 @@ public class SoftWrapModelImpl implements SoftWrapModelEx {
myDirtyLines.clear();
}
+ @Override
+ public int paint(@NotNull Graphics g, @NotNull SoftWrapDrawingType drawingType, int x, int y, int lineHeight) {
+ return myPainter.paint(g, drawingType, x, y, lineHeight);
+ }
+
@NotNull
public LogicalPosition adjustLogicalPosition(@NotNull LogicalPosition defaultLogical, @NotNull VisualPosition visual) {
if (myActive > 0 || !isSoftWrappingEnabled() || myStorage.isEmpty() || myEditor.getDocument().getTextLength() <= 0) {
@@ -706,7 +720,7 @@ public class SoftWrapModelImpl implements SoftWrapModelEx {
Document document = myEditor.getDocument();
- if (softWrapIndex >= softWraps.size() || document.getTextLength() <= 0) {
+ if (softWrapIndex >= softWraps.size() || document.getTextLength() <= 0 || change.getStart() >= document.getTextLength()) {
return;
}
int firstChangedLine = document.getLineNumber(change.getStart());
@@ -723,7 +737,7 @@ public class SoftWrapModelImpl implements SoftWrapModelEx {
// Add modified soft wraps.
for (TextChange softWrap : toModify) {
- softWraps.add(softWrap.advance(change.getDiff()));
+ myStorage.storeSoftWrap(softWrap.advance(change.getDiff()));
}
}
diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/TextDrawingCallback.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/TextDrawingCallback.java
new file mode 100644
index 000000000000..45a7f3631636
--- /dev/null
+++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/TextDrawingCallback.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2000-2010 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 java.awt.*;
+
+/**
+ * IDEA editors use highly-optimized drawing algorithm that is tuned for painting large amounts of text data.
+ *
+ * However, there is a possible case that particular editor extension or third-party component may want to draw text at
+ * IDEA editor on it own. It's not supposed to do that directly, contrary, it's expected to delegate the processing
+ * to the code that knows how to do that.
+ *
+ * Current interface defines a contract for such a text drawing delegation task.
+ *
+ * @author Denis Zhdanov
+ * @since Jul 1, 2010 8:01:30 PM
+ */
+public interface TextDrawingCallback {
+
+ /**
+ * Asks to draw symbols from [start; end) range of given char array at given graphics buffer using given
+ * font info and color.
+ *
+ * @param g graphics buffer to use
+ * @param data target symbols holder
+ * @param start start offset within the symbols holder to use (inclusive)
+ * @param end end offset within the symbols holder to use (inclusive)
+ * @param x 'x' coordinate to use as a start position at the given graphics buffer
+ * @param y 'y' coordinate to use as a start position at the given graphics buffer
+ * @param fontInfo font info to use during drawing target text at the given graphics buffer
+ * @param color color to use during drawing target text at the given graphics buffer
+ */
+ void drawChars(Graphics g, char[] data, int start, int end, int x, int y, Color color, FontInfo fontInfo);
+}
diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/softwrap/ArrowSoftWrapPainter.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/softwrap/ArrowSoftWrapPainter.java
new file mode 100644
index 000000000000..eed5d982730d
--- /dev/null
+++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/softwrap/ArrowSoftWrapPainter.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2000-2010 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.softwrap;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.ex.util.EditorUtil;
+import com.intellij.openapi.editor.impl.ArrowPainter;
+import com.intellij.openapi.editor.impl.ColorHolder;
+import com.intellij.openapi.util.Computable;
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.*;
+
+/**
+ * {@link SoftWrapPainter} implementation that draws arrows in soft wrap location.
+ *
+ * Primary idea is to use dedicated unicode symbols as soft wrap drawings and this class is introduced only as a part
+ * of defensive programming - there is unlikely case that local client environment doesn't have a font that is able to
+ * represent target unicode symbol. We draw an arrow manually then (platform-independent approach).
+ *
+ * @author Denis Zhdanov
+ * @since Jul 2, 2010 11:31:36 AM
+ */
+public class ArrowSoftWrapPainter implements SoftWrapPainter {
+
+ private final HeightProvider myHeightProvider = new HeightProvider();
+ private final Editor myEditor;
+ private final ArrowPainter myArrowPainter;
+ private int myMinWidth = -1;
+
+ public ArrowSoftWrapPainter(Editor editor) {
+ myEditor = editor;
+ myArrowPainter = new ArrowPainter(ColorHolder.byColor(myEditor.getColorsScheme().getDefaultForeground()), myHeightProvider);
+ }
+
+ @Override
+ public int paint(@NotNull Graphics g, @NotNull SoftWrapDrawingType drawingType, int x, int y, int lineHeight) {
+ myHeightProvider.myHeight = lineHeight / 2;
+
+ int start;
+ int end;
+ int result;
+ switch (drawingType) {
+ case BEFORE_SOFT_WRAP_LINE_FEED:
+ start = x;
+ end = myEditor.getScrollingModel().getVisibleArea().width;
+ result = end - start;
+ break;
+ case AFTER_SOFT_WRAP_LINE_FEED:
+ start = 0;
+ end = x;
+ result = 0;
+ break;
+ default: throw new IllegalStateException("Soft wrap arrow painting is not set up for drawing type " + drawingType);
+ }
+ myArrowPainter.paint(g, y + lineHeight - g.getFontMetrics().getDescent(), start, end);
+ return result;
+ }
+
+ @Override
+ public int getDrawingHorizontalOffset(@NotNull Graphics g, @NotNull SoftWrapDrawingType drawingType, int x, int y, int lineHeight) {
+ switch (drawingType) {
+ case BEFORE_SOFT_WRAP_LINE_FEED: return myEditor.getScrollingModel().getVisibleArea().width - x;
+ case AFTER_SOFT_WRAP_LINE_FEED: return 0;
+ default: throw new IllegalStateException("Soft wrap arrow painting is not set up for drawing type " + drawingType);
+ }
+ }
+
+ @Override
+ public int getMinDrawingWidth(@NotNull SoftWrapDrawingType drawingType) {
+ if (myMinWidth < 0) {
+ // We need to reserve a minimal space required for representing arrow before soft wrap-introduced line feed.
+ myMinWidth = EditorUtil.charWidth('a', Font.PLAIN, myEditor);
+ }
+ return myMinWidth;
+ }
+
+ @Override
+ public boolean canUse() {
+ return true;
+ }
+
+ private static class HeightProvider implements Computable+ * This is a long text + * that is soft-wrapped + *+ * + * Implementations of this interface are not obliged to be thread-safe. + * + * @author Denis Zhdanov + * @since Jul 1, 2010 5:02:37 PM + */ +public interface SoftWrapPainter { + + /** + * Asks to paint drawing of target type at the given graphics buffer at the given position. + * + * @param g target graphics buffer to draw in + * @param drawingType target drawing type + * @param x target
'x' coordinate to use
+ * @param y target 'y' coordinate to use
+ * @param lineHeight line height used at editor
+ * @return horizontal offset introduced to the given 'x' coordinate after target drawing painting
+ */
+ int paint(@NotNull Graphics g, @NotNull SoftWrapDrawingType drawingType, int x, int y, int lineHeight);
+
+ /**
+ * Allows to ask about horizontal offset to be applied to the given 'x' coordinate if drawing of the given
+ * type is performed at the given graphics buffer.
+ *
+ * Generally, this method is useful when we don't want to perform actual drawing for now but want to reserve
+ * a space necessary to do that in future. I.e. the aim is to avoid horizontal movement of already drawn content
+ * when the drawing is actually performed.
+ *
+ * @param g target graphics buffer to draw in
+ * @param drawingType target drawing type
+ * @param x target 'x' coordinate to use
+ * @param y target 'y' coordinate to use
+ * @param lineHeight line height used at editor
+ * @return horizontal offset that would be introduced if the drawing is performed
+ */
+ int getDrawingHorizontalOffset(@NotNull Graphics g, @NotNull SoftWrapDrawingType drawingType, int x, int y, int lineHeight);
+
+ /**
+ * Allows to ask for the minimal width in pixels required for painting of the given type.
+ *
+ * @param drawingType target drawing type
+ * @return width in pixels required for the painting of the given type
+ */
+ int getMinDrawingWidth(@NotNull SoftWrapDrawingType drawingType);
+
+ /**
+ * Allows to answer if it's possible to use current painter implementation at local environment (e.g. there is a possible
+ * case that particular painter that exploits unicode symbols for drawing can't be used because there is no font
+ * at local environment that knows how to draw target symbols).
+ *
+ * @return true if current painter can be used at local environment; false otherwise
+ */
+ boolean canUse();
+}
diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/softwrap/TextBasedSoftWrapPainter.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/softwrap/TextBasedSoftWrapPainter.java
new file mode 100644
index 000000000000..fd68ccc36163
--- /dev/null
+++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/softwrap/TextBasedSoftWrapPainter.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2000-2010 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.softwrap;
+
+import com.intellij.openapi.editor.impl.ColorHolder;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.ex.util.EditorUtil;
+import com.intellij.openapi.editor.impl.FontInfo;
+import com.intellij.openapi.editor.impl.TextDrawingCallback;
+import org.jetbrains.annotations.NotNull;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.EnumMap;
+import java.util.Map;
+
+/**
+ * {@link SoftWrapPainter} implementation that uses target unicode symbols as soft wrap drawings.
+ *
+ * Not thread-safe.
+ *
+ * @author Denis Zhdanov
+ * @since Jul 1, 2010 5:30:43 PM
+ */
+public class TextBasedSoftWrapPainter implements SoftWrapPainter {
+
+ private final Maptrue if target font that is capable to display all unicode symbols used by the current painter is found;
+ * false otherwise
+ */
+ private boolean init(Map