redcar-javamateview 0.1-java

data/src/com/redcareditor/mate/ScopeMatcher.java

@@ -0,0 +1,162 @@
+package com.redcareditor.mate;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.redcareditor.onig.Match;
+import com.redcareditor.onig.Range;
+import com.redcareditor.onig.Rx;
+
+public class ScopeMatcher {
+	public Rx pos_rx;
+	public List<Rx> neg_rxs;
+
+	public static List<Integer> occurrences(String target, String find) {
+		List<Integer> positions = new ArrayList<Integer>();
+		int fromIndex = 0;
+		int newIndex = -1;
+		while ((newIndex = target.indexOf(find, fromIndex)) != -1) {
+			positions.add(newIndex);
+			fromIndex = newIndex + 1;
+		}
+		return positions;
+	}
+
+	// returns 1 if m1 is better than m2, -1 if m1 is worse than m2, 0 if
+	// equally good
+	public static int compareMatch(String scopeString, Match m1, Match m2) {
+		List<Integer> spaceIxs = occurrences(scopeString, " ");
+		int max_cap1 = m1.numCaptures();
+		int max_cap2 = m2.numCaptures();
+		int cap1_ix, cap1_el_ix, len1;
+		int cap2_ix, cap2_el_ix, len2;
+		for (int i = 0; i < Math.min(max_cap1, max_cap2); i++) {
+			// first try element depth:
+			Range capture1 = m1.getCapture(max_cap1 - 1 - i);
+			Range capture2 = m2.getCapture(max_cap2 - 1 - i);
+			
+			cap1_ix = capture1.start;
+			cap2_ix = capture2.start;
+			cap1_el_ix = ScopeMatcher.sorted_ix(spaceIxs, cap1_ix);
+			cap2_el_ix = ScopeMatcher.sorted_ix(spaceIxs, cap2_ix);
+			if (cap1_el_ix > cap2_el_ix) {
+				return 1;
+			} else if (cap1_el_ix < cap2_el_ix) {
+				return -1;
+			}
+
+			// next try length of match
+			len1 = capture1.end - cap1_ix;
+			len2 = capture2.end - cap2_ix;
+			if (len1 > len2) {
+				return 1;
+			} else if (len1 < len2) {
+				return -1;
+			}
+		}
+		return 0;
+	}
+
+	private static int sorted_ix(List<Integer> ixs, int val) {
+		if (ixs.size() == 0)
+			return 0;
+		if (val < ixs.get(0))
+			return 0;
+		if (ixs.size() == 1) {
+			if (val > ixs.get(0))
+				return 1;
+			else
+				return 0;
+		} else {
+			for (int i = 0; i < ixs.size() - 1; i++) {
+				if (val > ixs.get(i) && val < ixs.get(i + 1))
+					return i + 1;
+			}
+			return ixs.size();
+		}
+	}
+
+	// this method is mainly for testing in the Ruby specs
+	public static String testRank(String selector_a, String selector_b, String scope_string) {
+		Match m1 = match(selector_a, scope_string);
+		Match m2 = match(selector_b, scope_string);
+		int r = compareMatch(scope_string, m1, m2);
+		if (r > 0) {
+			return selector_a;
+		} else if (r == 0) {
+			return selector_a + " == " + selector_b;
+		} else {
+			return selector_b;
+		}
+	}
+
+	public static boolean testMatch(String selectorString, String scopeString) {
+		Match m = getMatch(selectorString, scopeString);
+		return (m != null);
+	}
+
+	public static Match getMatch(String selectorString, String scopeString) {
+		Match m = match(selectorString, scopeString);
+		if (m != null) {
+//			System.out.printf("%d\n", m.numCaptures());
+			Range firstCapture = m.getCapture(0);
+//			System.out.printf("test_match('%s', '%s') == %d\n", selectorString, scopeString, firstCapture.start);
+		} else {
+//			System.out.printf("test_match('%s', '%s') == null\n", selectorString, scopeString);
+		}
+		return m;
+	}
+
+	public static Match match(String selectorString, String scopeString) {
+		List<ScopeMatcher> matchers = ScopeMatcher.compile(selectorString);
+		for (ScopeMatcher matcher : matchers) {
+			Match m;
+			if ((m = testMatchRe(matcher.pos_rx, matcher.neg_rxs, scopeString)) != null)
+				return m;
+		}
+		return null;
+	}
+
+	public static List<ScopeMatcher> compile(String selectorString) {
+		List<ScopeMatcher> ms = new ArrayList<ScopeMatcher>();
+		// FIXME should validate and throw UTF8 error if bad.
+		String[] scopeOrs1 = selectorString.split(",");
+//		System.out.printf("match: selector: '%s'\n", selectorString);
+		for (String selectorString1 : scopeOrs1) {
+			ScopeMatcher m = new ScopeMatcher();
+			m.neg_rxs = new ArrayList<Rx>();
+			String[] positivesAndNegatives = selectorString1.split(" -");
+			for (String subSelectorString : positivesAndNegatives) {
+				if (m.pos_rx == null) {
+					String s1 = subSelectorString.trim().replaceAll("\\.", "\\\\.");
+					String s2 = s1.replaceAll(" ", ").* .*(");
+//					System.out.printf("positive '%s'\n", "(" + s2 + ")");
+					m.pos_rx = Rx.createRx("^(?:.*[^A-Za-z])?(" + s2 + ")(?:[^A-Za-z].*)?$");
+				} else {
+					String s1 = subSelectorString.trim().replaceAll("\\.", "\\\\.");
+					String s2 = s1.trim().replaceAll(" ", ".* .*");
+//					System.out.printf("negative '%s'\n", s2);
+					m.neg_rxs.add(Rx.createRx(s2));
+				}
+			}
+			ms.add(m);
+		}
+		return ms;
+	}
+
+	public static Match testMatchRe(Rx positiveSelectorRegex, List<Rx> negativeSelectorRegexes, String scopeString) {
+		Match m = positiveSelectorRegex.search(scopeString, 0, scopeString.length());
+		if (m != null) {
+			for (Rx negRx : negativeSelectorRegexes) {
+				Match m1 = negRx.search(scopeString, 0, scopeString.length());
+				if (m1 != null) {
+					return null;
+				}
+			}
+			return m;
+		} else {
+			return null;
+		}
+	}
+
+}

data/src/com/redcareditor/mate/SharedTextColors.java

@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2008 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package com.redcareditor.mate;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.RGB;
+import org.eclipse.swt.widgets.Display;
+
+import org.eclipse.jface.text.source.ISharedTextColors;
+
+/*
+ * @see org.eclipse.jface.text.source.ISharedTextColors
+ * @since 2.1
+ */
+class SharedTextColors implements ISharedTextColors {
+
+	/** The display table. */
+	private Map fDisplayTable;
+
+	/** Creates an returns a shared color manager. */
+	public SharedTextColors() {
+		super();
+	}
+
+	/*
+	 * @see ISharedTextColors#getColor(RGB)
+	 */
+	public Color getColor(RGB rgb) {
+		if (rgb == null)
+			return null;
+
+		if (fDisplayTable == null)
+			fDisplayTable= new HashMap(2);
+
+		final Display display= Display.getCurrent();
+
+		Map colorTable= (Map) fDisplayTable.get(display);
+		if (colorTable == null) {
+			colorTable= new HashMap(10);
+			fDisplayTable.put(display, colorTable);
+			display.disposeExec(new Runnable() {
+				public void run() {
+					dispose(display);
+				}
+			});
+		}
+
+		Color color= (Color) colorTable.get(rgb);
+		if (color == null) {
+			color= new Color(display, rgb);
+			colorTable.put(rgb, color);
+		}
+
+		return color;
+	}
+
+	/*
+	 * @see ISharedTextColors#dispose()
+	 */
+	public void dispose() {
+		if (fDisplayTable == null)
+			return;
+
+		Iterator iter= fDisplayTable.values().iterator();
+		while (iter.hasNext())
+			dispose((Map)iter.next());
+		fDisplayTable= null;
+	}
+
+	/**
+	 * Disposes the colors for the given display.
+	 *
+	 * @param display the display for which to dispose the colors
+	 * @since 3.3
+	 */
+	private void dispose(Display display) {
+		if (fDisplayTable != null)
+			dispose((Map)fDisplayTable.remove(display));
+	}
+
+	/**
+	 * Disposes the given color table.
+	 *
+	 * @param colorTable the color table that maps <code>RGB</code> to <code>Color</code>
+	 * @since 3.3
+	 */
+	private void dispose(Map colorTable) {
+		if (colorTable == null)
+			return;
+
+		Iterator iter= colorTable.values().iterator();
+		while (iter.hasNext())
+			((Color) iter.next()).dispose();
+
+		colorTable.clear();
+	}
+
+}

data/src/com/redcareditor/mate/SinglePattern.java

@@ -0,0 +1,20 @@
+package com.redcareditor.mate;
+
+import java.util.List;
+import java.util.Map;
+
+import com.redcareditor.onig.Rx;
+import com.redcareditor.plist.Dict;
+
+public class SinglePattern extends Pattern {
+	public Rx match;
+	public Map<Integer, String> captures;
+	
+	public SinglePattern(List<Pattern> grammarPatterns, Dict dict) {
+		name = dict.getString("name");
+		match = Rx.createRx(dict.getString("match"));
+		captures = makeCapturesFromPlist(dict.getDictionary("captures"));
+		setDisabled(dict);
+		grammarPatterns.add(this);
+	}
+}

data/src/com/redcareditor/mate/WhitespaceCharacterPainter.java

@@ -0,0 +1,395 @@
+/*******************************************************************************
+ * Copyright (c) 2006, 2009 Wind River Systems, Inc., IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Anton Leherbauer (Wind River Systems) - initial API and implementation - https://bugs.eclipse.org/bugs/show_bug.cgi?id=22712
+ *     Anton Leherbauer (Wind River Systems) - [painting] Long lines take too long to display when "Show Whitespace Characters" is enabled - https://bugs.eclipse.org/bugs/show_bug.cgi?id=196116
+ *     Anton Leherbauer (Wind River Systems) - [painting] Whitespace characters not drawn when scrolling to right slowly - https://bugs.eclipse.org/bugs/show_bug.cgi?id=206633
+ *     Tom Eicher (Avaloq Evolution AG) - block selection mode
+ *******************************************************************************/
+package com.redcareditor.mate;
+
+import org.eclipse.swt.custom.StyleRange;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.custom.StyledTextContent;
+import org.eclipse.swt.events.PaintEvent;
+import org.eclipse.swt.events.PaintListener;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.FontMetrics;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IPainter;
+import org.eclipse.jface.text.ITextViewer;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.ITextViewerExtension5;
+import org.eclipse.jface.text.IPaintPositionManager;
+
+
+/**
+ * A painter for drawing visible characters for (invisible) whitespace
+ * characters.
+ *
+ * @since 3.3
+ */
+public class WhitespaceCharacterPainter implements IPainter, PaintListener {
+
+	private static final char SPACE_SIGN= '\u00b7';
+	private static final char IDEOGRAPHIC_SPACE_SIGN= '\u00b0';
+	private static final char TAB_SIGN= '\u00bb';
+	private static final char CARRIAGE_RETURN_SIGN= '\u00a4';
+	private static final char LINE_FEED_SIGN= '\u00ac';
+
+	/** Indicates whether this painter is active. */
+	private boolean fIsActive= false;
+	/** The source viewer this painter is attached to. */
+	private ITextViewer fTextViewer;
+	/** The viewer's widget. */
+	private StyledText fTextWidget;
+	/** Tells whether the advanced graphics sub system is available. */
+	private final boolean fIsAdvancedGraphicsPresent;
+
+	/**
+	 * Creates a new painter for the given text viewer.
+	 *
+	 * @param textViewer  the text viewer the painter should be attached to
+	 */
+	public WhitespaceCharacterPainter(ITextViewer textViewer) {
+		super();
+		fTextViewer= textViewer;
+		fTextWidget= textViewer.getTextWidget();
+		GC gc= new GC(fTextWidget);
+		gc.setAdvanced(true);
+		fIsAdvancedGraphicsPresent= gc.getAdvanced();
+		gc.dispose();
+	}
+
+	/*
+	 * @see org.eclipse.jface.text.IPainter#dispose()
+	 */
+	public void dispose() {
+		fTextViewer= null;
+		fTextWidget= null;
+	}
+
+	/*
+	 * @see org.eclipse.jface.text.IPainter#paint(int)
+	 */
+	public void paint(int reason) {
+		IDocument document= fTextViewer.getDocument();
+		if (document == null) {
+			deactivate(false);
+			return;
+		}
+		if (!fIsActive) {
+			fIsActive= true;
+			fTextWidget.addPaintListener(this);
+			redrawAll();
+		} else if (reason == CONFIGURATION || reason == INTERNAL) {
+			redrawAll();
+		} else if (reason == TEXT_CHANGE) {
+			// redraw current line only
+			try {
+				IRegion lineRegion =
+					document.getLineInformationOfOffset(getDocumentOffset(fTextWidget.getCaretOffset()));
+				int widgetOffset= getWidgetOffset(lineRegion.getOffset());
+				int charCount= fTextWidget.getCharCount();
+				int redrawLength= Math.min(lineRegion.getLength(), charCount - widgetOffset);
+				if (widgetOffset >= 0 && redrawLength > 0) {
+					fTextWidget.redrawRange(widgetOffset, redrawLength, true);
+				}
+			} catch (BadLocationException e) {
+				// ignore
+			}
+		}
+	}
+
+	/*
+	 * @see org.eclipse.jface.text.IPainter#deactivate(boolean)
+	 */
+	public void deactivate(boolean redraw) {
+		if (fIsActive) {
+			fIsActive= false;
+			fTextWidget.removePaintListener(this);
+			if (redraw) {
+				redrawAll();
+			}
+		}
+	}
+
+	/*
+	 * @see org.eclipse.jface.text.IPainter#setPositionManager(org.eclipse.jface.text.IPaintPositionManager)
+	 */
+	public void setPositionManager(IPaintPositionManager manager) {
+		// no need for a position manager
+	}
+
+	/*
+	 * @see org.eclipse.swt.events.PaintListener#paintControl(org.eclipse.swt.events.PaintEvent)
+	 */
+	public void paintControl(PaintEvent event) {
+		if (fTextWidget != null) {
+			handleDrawRequest(event.gc, event.x, event.y, event.width, event.height);
+		}
+	}
+
+	/*
+	 * Draw characters in view range.
+	 */
+	private void handleDrawRequest(GC gc, int x, int y, int w, int h) {
+		int startLine= fTextWidget.getLineIndex(y);
+		int endLine= fTextWidget.getLineIndex(y + h - 1);
+		if (startLine <= endLine && startLine < fTextWidget.getLineCount()) {
+			if (fIsAdvancedGraphicsPresent) {
+				int alpha= gc.getAlpha();
+				gc.setAlpha(100);
+				drawLineRange(gc, startLine, endLine, x, w);
+				gc.setAlpha(alpha);
+			} else
+				drawLineRange(gc, startLine, endLine, x, w);
+		}
+	}
+
+	/**
+	 * Draw the given line range.
+	 *
+	 * @param gc the GC
+	 * @param startLine first line number
+	 * @param endLine last line number (inclusive)
+	 * @param x the X-coordinate of the drawing range
+	 * @param w the width of the drawing range
+	 */
+	private void drawLineRange(GC gc, int startLine, int endLine, int x, int w) {
+		final int viewPortWidth= fTextWidget.getClientArea().width;
+		for (int line= startLine; line <= endLine; line++) {
+			int lineOffset= fTextWidget.getOffsetAtLine(line);
+			// line end offset including line delimiter
+			int lineEndOffset;
+			if (line < fTextWidget.getLineCount() - 1) {
+				lineEndOffset= fTextWidget.getOffsetAtLine(line + 1);
+			} else {
+				lineEndOffset= fTextWidget.getCharCount();
+			}
+			// line length excluding line delimiter
+			int lineLength= lineEndOffset - lineOffset;
+			while (lineLength > 0) {
+				char c= fTextWidget.getTextRange(lineOffset + lineLength - 1, 1).charAt(0);
+				if (c != '\r' && c != '\n') {
+					break;
+				}
+				--lineLength;
+			}
+			// compute coordinates of last character on line
+			Point endOfLine= fTextWidget.getLocationAtOffset(lineOffset + lineLength);
+			if (x - endOfLine.x > viewPortWidth) {
+				// line is not visible
+				continue;
+			}
+			// Y-coordinate of line
+			int y= fTextWidget.getLinePixel(line);
+			// compute first visible char offset
+			int startOffset;
+			try {
+				startOffset= fTextWidget.getOffsetAtLocation(new Point(x, y)) - 1;
+				if (startOffset - 2 <= lineOffset) {
+					startOffset= lineOffset;
+				}
+			} catch (IllegalArgumentException iae) {
+				startOffset= lineOffset;
+			}
+			// compute last visible char offset
+			int endOffset;
+			if (x + w >= endOfLine.x) {
+				// line end is visible
+				endOffset= lineEndOffset;
+			} else {
+				try {
+					endOffset= fTextWidget.getOffsetAtLocation(new Point(x + w - 1, y)) + 1;
+					if (endOffset + 2 >= lineEndOffset) {
+						endOffset= lineEndOffset;
+					}
+				} catch (IllegalArgumentException iae) {
+					endOffset= lineEndOffset;
+				}
+			}
+			// draw character range
+			if (endOffset > startOffset) {
+				drawCharRange(gc, startOffset, endOffset);
+			}
+		}
+	}
+
+	/**
+	 * Draw characters of content range.
+	 *
+	 * @param gc the GC
+	 * @param startOffset inclusive start index
+	 * @param endOffset exclusive end index
+	 */
+	private void drawCharRange(GC gc, int startOffset, int endOffset) {
+		StyledTextContent content= fTextWidget.getContent();
+		int length= endOffset - startOffset;
+		String text= content.getTextRange(startOffset, length);
+		StyleRange styleRange= null;
+		Color fg= null;
+		StringBuffer visibleChar= new StringBuffer(10);
+		for (int textOffset= 0; textOffset <= length; ++textOffset) {
+			int delta= 0;
+			boolean eol= false;
+			if (textOffset < length) {
+				delta= 1;
+				char c= text.charAt(textOffset);
+				switch (c) {
+				//case ' ' :
+				//	visibleChar.append(SPACE_SIGN);
+					// 'continue' would improve performance but may produce drawing errors
+					// for long runs of space if width of space and dot differ
+				//	break;
+				case '\u3000' : // ideographic whitespace
+					visibleChar.append(IDEOGRAPHIC_SPACE_SIGN);
+					// 'continue' would improve performance but may produce drawing errors
+					// for long runs of space if width of space and dot differ
+					break;
+				case '\t' :
+					visibleChar.append(TAB_SIGN);
+					break;
+				case '\r' :
+					visibleChar.append(CARRIAGE_RETURN_SIGN);
+					if (textOffset >= length - 1 || text.charAt(textOffset + 1) != '\n') {
+						eol= true;
+						break;
+					}
+					continue;
+				case '\n' :
+					visibleChar.append(LINE_FEED_SIGN);
+					eol= true;
+					break;
+				default :
+					delta= 0;
+					break;
+				}
+			}
+			if (visibleChar.length() > 0) {
+				int widgetOffset= startOffset + textOffset - visibleChar.length() + delta;
+				if (!eol || !isFoldedLine(content.getLineAtOffset(widgetOffset))) {
+					/* 
+					 * Block selection is drawn using alpha and no selection-inverting
+					 * takes place, we always draw as 'unselected' in block selection mode.
+					 */
+					if (!fTextWidget.getBlockSelection() && isOffsetSelected(fTextWidget, widgetOffset)) {
+						fg= fTextWidget.getSelectionForeground();
+					} else if (styleRange == null || styleRange.start + styleRange.length <= widgetOffset) {
+						styleRange= fTextWidget.getStyleRangeAtOffset(widgetOffset);
+						if (styleRange == null || styleRange.foreground == null) {
+							fg= fTextWidget.getForeground();
+						} else {
+							fg= styleRange.foreground;
+						}
+					}
+					draw(gc, widgetOffset, visibleChar.toString(), fg);
+				}
+				visibleChar.delete(0, visibleChar.length());
+			}
+		}
+	}
+	
+	/**
+	 * Returns <code>true</code> if <code>offset</code> is selection in <code>widget</code>,
+	 * <code>false</code> otherwise.
+	 * 
+	 * @param widget the widget
+	 * @param offset the offset
+	 * @return <code>true</code> if <code>offset</code> is selection, <code>false</code> otherwise
+	 * @since 3.5
+	 */
+	private static final boolean isOffsetSelected(StyledText widget, int offset) {
+		Point selection= widget.getSelection();
+		return offset >= selection.x && offset < selection.y;
+	}
+
+	/**
+	 * Check if the given widget line is a folded line.
+	 *
+	 * @param widgetLine  the widget line number
+	 * @return <code>true</code> if the line is folded
+	 */
+	private boolean isFoldedLine(int widgetLine) {
+		if (fTextViewer instanceof ITextViewerExtension5) {
+			ITextViewerExtension5 extension= (ITextViewerExtension5)fTextViewer;
+			int modelLine= extension.widgetLine2ModelLine(widgetLine);
+			int widgetLine2= extension.modelLine2WidgetLine(modelLine + 1);
+			return widgetLine2 == -1;
+		}
+		return false;
+	}
+
+	/**
+	 * Redraw all of the text widgets visible content.
+	 */
+	private void redrawAll() {
+		fTextWidget.redraw();
+	}
+
+	/**
+	 * Draw string at widget offset.
+	 *
+	 * @param gc the GC
+	 * @param offset the widget offset
+	 * @param s the string to be drawn
+	 * @param fg the foreground color
+	 */
+	private void draw(GC gc, int offset, String s, Color fg) {
+		// Compute baseline delta (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=165640)
+		int baseline= fTextWidget.getBaseline(offset);
+		FontMetrics fontMetrics= gc.getFontMetrics();
+		int fontBaseline= fontMetrics.getAscent() + fontMetrics.getLeading();
+		int baslineDelta= baseline - fontBaseline;
+
+		Point pos= fTextWidget.getLocationAtOffset(offset);
+		gc.setForeground(fg);
+		gc.drawString(s, pos.x, pos.y + baslineDelta, true);
+	}
+
+	/**
+	 * Convert a document offset to the corresponding widget offset.
+	 *
+	 * @param documentOffset the document offset
+	 * @return widget offset
+	 */
+	private int getWidgetOffset(int documentOffset) {
+		if (fTextViewer instanceof ITextViewerExtension5) {
+			ITextViewerExtension5 extension= (ITextViewerExtension5)fTextViewer;
+			return extension.modelOffset2WidgetOffset(documentOffset);
+		}
+		IRegion visible= fTextViewer.getVisibleRegion();
+		int widgetOffset= documentOffset - visible.getOffset();
+		if (widgetOffset > visible.getLength()) {
+			return -1;
+		}
+		return widgetOffset;
+	}
+
+	/**
+	 * Convert a widget offset to the corresponding document offset.
+	 *
+	 * @param widgetOffset the widget offset
+	 * @return document offset
+	 */
+	private int getDocumentOffset(int widgetOffset) {
+		if (fTextViewer instanceof ITextViewerExtension5) {
+			ITextViewerExtension5 extension= (ITextViewerExtension5)fTextViewer;
+			return extension.widgetOffset2ModelOffset(widgetOffset);
+		}
+		IRegion visible= fTextViewer.getVisibleRegion();
+		if (widgetOffset > visible.getLength()) {
+			return -1;
+		}
+		return widgetOffset + visible.getOffset();
+	}
+
+}