redcar-javamateview 0.1-java

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+
+require File.join(File.dirname(__FILE__), *%w(.. src ruby java-mateview))
+
+JavaMateView::Bundle.load_bundles("input/")
+JavaMateView::ThemeManager.load_themes("input/")
+
+class JavaMateView::MateText
+  
+  def type(line, line_offset, char)
+    line_start = get_text_widget.get_offset_at_line(line)
+    getMateDocument.replace(line_start + line_offset, 0, char)
+  end
+      
+  def backspace(line, line_offset)
+    line_start = get_text_widget.get_offset_at_line(line)
+    getMateDocument.replace(line_start + line_offset - 1, 1, "")
+  end
+      
+  def clean_reparse
+    shell = Swt::Widgets::Shell.new($display)
+    mt = JavaMateView::MateText.new(shell, false)
+    mt.set_grammar_by_name(self.parser.grammar.name)
+    st = mt.get_text_widget
+    st.text = get_text_widget.getText
+    mt.parser.root.pretty(0)
+  end
+  
+  def pretty
+    parser.root.pretty(0)
+  end
+end
+
+JavaMateView::ParserScheduler.synchronousParsing = true

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

@@ -0,0 +1,81 @@
+package com.redcareditor.mate;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Bundle {
+	private String name;
+	private List<Grammar> grammars;
+	private static List<Bundle> bundles;
+
+	public Bundle(String name) {
+		this.name = name;
+		grammars = new ArrayList<Grammar>();
+	}
+
+	public static Bundle getBundleByName(String findName) {
+		for (Bundle b : getBundles()) {
+			if (b.getName().equals(findName))
+				return b;
+		}
+		return null;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public List<Grammar> getGrammars() {
+		return grammars;
+	}
+
+	public static List<Bundle> getBundles() {
+		return bundles;
+	}
+
+	/**
+	 * Return a list of bundle names like "Ruby.tmbundle"
+	 */
+	public static List<String> bundleDirs(String textmateDir) {
+		List<String> names = new ArrayList<String>();
+		File dir = new File(textmateDir + "/Bundles");
+		if (dir.exists()) {
+			for (String name : dir.list()) {
+				if (name.endsWith(".tmbundle")) {
+					names.add(name);
+				}
+			}
+		}
+		return names;
+	}
+
+	public static void loadBundles(String textmateDir) {
+		if (getBundles() == null) {
+  		bundles = new ArrayList<Bundle>();
+		}
+		for (String bundleDir : bundleDirs(textmateDir)) {
+//			System.out.printf("loading %s\n", bundleDir);
+			Bundle bundle = new Bundle(bundleDir.split("\\.")[0]);
+			getBundles().add(bundle);
+			File grammarDirectory = new File(textmateDir + "/Bundles/" + bundleDir + "/Syntaxes");
+			if (grammarDirectory.exists()) {
+				loadGrammar(bundle, grammarDirectory);
+			}
+		}
+	}
+
+	private static void loadGrammar(Bundle bundle, File syntaxDir) {
+		for (String grammarFileName : syntaxDir.list()) {
+			if (isTmBundlefile(grammarFileName)) {
+				String grammarFilePath = syntaxDir.getPath() + "/" + grammarFileName;
+				Grammar grammar = new Grammar(grammarFilePath);
+				bundle.getGrammars().add(grammar);
+			}
+		}
+	}
+
+	private static boolean isTmBundlefile(String syntaxFileName) {
+		return (syntaxFileName.endsWith(".tmLanguage") || syntaxFileName.endsWith(".plist"));
+	}
+}

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

@@ -0,0 +1,89 @@
+package com.redcareditor.mate;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.joni.exception.ValueException;
+
+import com.redcareditor.onig.Rx;
+import com.redcareditor.plist.Dict;
+import com.redcareditor.plist.PlistNode;
+
+public class DoublePattern extends Pattern {
+	public String contentName;
+	public Rx begin;
+	public Rx end;
+	public String endString;
+	public String beginString;
+	public Map<Integer, String> beginCaptures;
+	public Map<Integer, String> endCaptures;
+	public Map<Integer, String> bothCaptures;
+	public List<Pattern> patterns;
+	public boolean hasReplacedGrammarIncludes = false;
+	
+	public DoublePattern() {}
+	
+	public DoublePattern(List<Pattern> grammarPatterns, Dict dict) {
+		name = dict.getString("name");
+//		System.out.printf("new DoublePattern name: %s\n", name);
+		try {
+			setDisabled(dict);
+			endString = dict.getString("end");
+			contentName = dict.getString("contentName");
+			begin = Rx.createRx(dict.getString("begin"));
+
+			loadCaptures(dict);
+			loadPatterns(grammarPatterns, dict);
+			grammarPatterns.add(this);
+		}
+		catch(ValueException e) {
+			System.out.printf("joni.exception.ValueException: %s in %s\n", e.getMessage(), dict.getString("begin"));
+		}
+	}
+
+	private void loadPatterns(List<Pattern> grammarPatterns, Dict dict) {
+		patterns = new ArrayList<Pattern>();
+		if (dict.containsElement("patterns")) {
+			for (PlistNode<?> plistPattern : dict.getArray("patterns")) {
+				Pattern subPattern = Pattern.createPattern(grammarPatterns, (Dict) plistPattern);
+				if (subPattern != null) {
+					patterns.add(subPattern);
+				}
+			}
+		}
+	}
+
+	private void loadCaptures(Dict dict) {
+		if (dict.containsElement("beginCaptures")) {
+			beginCaptures = Pattern.makeCapturesFromPlist(dict.getDictionary("beginCaptures"));
+		}
+		if (dict.containsElement("captures")) {
+			bothCaptures = Pattern.makeCapturesFromPlist(dict.getDictionary("captures"));
+		}
+		if (dict.containsElement("endCaptures")) {
+			endCaptures = Pattern.makeCapturesFromPlist(dict.getDictionary("endCaptures"));
+		}
+	}
+	
+	public void replaceGrammarIncludes() {
+		if (hasReplacedGrammarIncludes)
+			return;
+		Grammar ng;
+		int i = 0;
+		while (i < patterns.size()) {
+			Pattern p = patterns.get(i);
+			if (p instanceof IncludePattern) {
+				if ((ng = Grammar.findByScopeName(p.name)) != null) {
+					ng.initForUse();
+					patterns.remove(i);
+					patterns.addAll(i, ng.patterns);
+					i--;
+				}
+			}
+			i++;
+		}
+		hasReplacedGrammarIncludes = true;
+	}
+
+}

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

@@ -0,0 +1,129 @@
+package com.redcareditor.mate;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.redcareditor.onig.Rx;
+import com.redcareditor.plist.Dict;
+import com.redcareditor.plist.PlistNode;
+import com.redcareditor.plist.PlistPropertyLoader;
+
+public class Grammar {
+	public String name;
+	public String fileName;
+	public Dict plist;
+	private PlistPropertyLoader propertyLoader;
+	public String[] fileTypes;
+	public String keyEquivalent;
+	public String scopeName;
+	public String comment;
+
+	public List<Pattern> allPatterns;
+	public List<Pattern> patterns;
+	public List<Pattern> singlePatterns;
+	public Map<String, List<Pattern>> repository;
+	public Rx firstLineMatch;
+	public Rx foldingStartMarker;
+	public Rx foldingStopMarker;
+
+	/* these are here for lookup speed purposes */
+	private static Map<String, Grammar> grammarsByScopeNames = new HashMap<String, Grammar>();
+	
+	public Grammar(String plistFile){
+		this.plist = Dict.parseFile(plistFile);
+		propertyLoader = new PlistPropertyLoader(plist, this);
+		initForReference();
+	}
+
+	private void initForReference() {
+		String[] properties = new String[] { "name", "keyEquivalent", "scopeName", "comment" };
+		for (String property : properties) {
+			propertyLoader.loadStringProperty(property);
+		}
+		grammarsByScopeNames.put(scopeName, this);
+		if (scopeName == null)
+			System.out.printf("** WARNING: syntax %s has no top level scope name.\n", name);
+		propertyLoader.loadRegexProperty("firstLineMatch");
+		if (plist.containsElement("fileTypes"))
+			fileTypes = plist.getStrings("fileTypes");
+	}
+
+	public void initForUse() {
+		if (loaded())
+			return;
+		
+		initForReference();
+		propertyLoader.loadRegexProperty("foldingStartMarker");
+		propertyLoader.loadRegexProperty("foldingStopMarker");
+		
+		this.allPatterns = new ArrayList<Pattern>();
+		loadPatterns();
+		loadRepository();
+		replaceIncludePatterns();
+	}
+
+	private void loadPatterns() {
+		this.patterns = new ArrayList<Pattern>();
+		Dict[] dictPatterns = plist.getDictionaries("patterns");
+		for (Dict p : dictPatterns) {
+			Pattern pattern = Pattern.createPattern(allPatterns, p);
+			if (pattern != null) {
+				pattern.grammar = this;
+				this.patterns.add(pattern);
+			}
+		}
+	}
+
+	private void loadRepository() {
+		repository = new HashMap<String, List<Pattern>>();
+		Dict plistRepo = plist.getDictionary("repository");
+		if (plistRepo == null)
+			return;
+		Dict plistRepoEntry;
+		for (String key : plistRepo.keys()) {
+//			System.out.printf("loading repository entry: %s\n", key);
+			List<Pattern> repoArray = new ArrayList<Pattern>();
+			plistRepoEntry = plistRepo.getDictionary(key);
+			if (plistRepoEntry.containsElement("begin") || plistRepoEntry.containsElement("match")) {
+//				System.out.printf("    contains begin or match\n");
+				Pattern pattern = Pattern.createPattern(this.allPatterns, plistRepoEntry);
+				if (pattern != null) {
+					pattern.grammar = this;
+					repoArray.add(pattern);
+				}
+			}
+			else if (plistRepoEntry.containsElement("patterns")) {
+//				System.out.printf("    contains patterns\n");
+				for (PlistNode<?> plistPattern : plistRepoEntry.getArray("patterns")) {
+					Pattern pattern = Pattern.createPattern(this.allPatterns, (Dict) plistPattern);
+					if (pattern != null) {
+						pattern.grammar = this;
+						repoArray.add(pattern);
+					}
+				}
+			}
+			repository.put(key, repoArray);
+		}
+	}
+
+	private void replaceIncludePatterns() {
+		Pattern.replaceIncludePatterns(patterns, this);
+		for (Pattern p : allPatterns) {
+//			System.out.printf("%s replaceIncludePattern for %s\n", this.name, p.name);
+			if (p instanceof DoublePattern) {
+				Pattern.replaceIncludePatterns(((DoublePattern) p).patterns, this);
+			}
+//			System.out.printf("%s replaceIncludePattern for %s [done]\n", this.name, p.name);
+		}
+	}
+
+	public static Grammar findByScopeName(String scope) {
+		return grammarsByScopeNames.get(scope);
+	}
+
+	private boolean loaded() {
+		return allPatterns != null && repository != null;
+	}
+}

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

@@ -0,0 +1,7 @@
+
+package com.redcareditor.mate;
+
+public interface IAnnotationAreaListener {
+    public void mouseClick(int line);
+    public void mouseDoubleClick(int line);
+}

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

@@ -0,0 +1,5 @@
+package com.redcareditor.mate;
+
+public interface IGrammarListener {
+  public void grammarChanged(String new_name);
+}

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

@@ -0,0 +1,10 @@
+package com.redcareditor.mate;
+
+import com.redcareditor.plist.Dict;
+
+public class IncludePattern extends Pattern {
+	public IncludePattern(Dict dict) {
+		name = dict.getString("include");
+//		System.out.printf("ip: %s\n", name);
+	}
+}

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

@@ -0,0 +1,922 @@
+/*******************************************************************************
+ * 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
+ *     Nikolay Botev <bono8106@hotmail.com> - [rulers] Shift clicking in line number column doesn't select range - https://bugs.eclipse.org/bugs/show_bug.cgi?id=32166
+ *     Nikolay Botev <bono8106@hotmail.com> - [rulers] Clicking in line number ruler should not trigger annotation ruler - https://bugs.eclipse.org/bugs/show_bug.cgi?id=40889
+ *******************************************************************************/
+package com.redcareditor.mate;
+
+import java.util.Arrays;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.events.DisposeEvent;
+import org.eclipse.swt.events.DisposeListener;
+import org.eclipse.swt.events.MouseEvent;
+import org.eclipse.swt.events.MouseListener;
+import org.eclipse.swt.events.MouseMoveListener;
+import org.eclipse.swt.events.PaintEvent;
+import org.eclipse.swt.events.PaintListener;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.FontMetrics;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.widgets.Canvas;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.TypedListener;
+
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.ITextListener;
+import org.eclipse.jface.text.ITextViewer;
+import org.eclipse.jface.text.ITextViewerExtension;
+import org.eclipse.jface.text.ITextViewerExtension5;
+import org.eclipse.jface.text.IViewportListener;
+import org.eclipse.jface.text.JFaceTextUtil;
+import org.eclipse.jface.text.TextEvent;
+
+import org.eclipse.jface.text.source.IVerticalRulerColumn;
+import org.eclipse.jface.text.source.CompositeRuler;
+import org.eclipse.jface.text.source.ILineRange;
+import org.eclipse.jface.text.source.IAnnotationModel;
+
+
+/**
+ * A vertical ruler column displaying line numbers.
+ * Clients usually instantiate and configure object of this class.
+ *
+ * @since 2.0
+ */
+public class LineNumberRulerColumn implements IVerticalRulerColumn {
+
+	/**
+	 * Internal listener class.
+	 */
+	class InternalListener implements IViewportListener, ITextListener {
+
+		/**
+		 * @since 3.1
+		 */
+		private boolean fCachedRedrawState= true;
+
+		/*
+		 * @see IViewportListener#viewportChanged(int)
+		 */
+		public void viewportChanged(int verticalPosition) {
+			if (fCachedRedrawState && verticalPosition != fScrollPos)
+				redraw();
+		}
+
+		/*
+		 * @see ITextListener#textChanged(TextEvent)
+		 */
+		public void textChanged(TextEvent event) {
+
+			fCachedRedrawState= event.getViewerRedrawState();
+			if (!fCachedRedrawState)
+				return;
+
+			if (updateNumberOfDigits()) {
+				computeIndentations();
+				layout(event.getViewerRedrawState());
+				return;
+			}
+
+			boolean viewerCompletelyShown= isViewerCompletelyShown();
+			if (viewerCompletelyShown || fSensitiveToTextChanges || event.getDocumentEvent() == null)
+				postRedraw();
+			fSensitiveToTextChanges= viewerCompletelyShown;
+		}
+	}
+
+	/**
+	 * Handles all the mouse interaction in this line number ruler column.
+	 */
+	class MouseHandler implements MouseListener, MouseMoveListener {
+
+		/** The cached view port size. */
+		private int fCachedViewportSize;
+		/** The area of the line at which line selection started. */
+		private int fStartLineOffset;
+		/** The number of the line at which line selection started. */
+		private int fStartLineNumber;
+		/** The auto scroll direction. */
+		private int fAutoScrollDirection;
+		/* @since 3.2 */
+		private boolean fIsListeningForMove= false;
+
+		/*
+		 * @see org.eclipse.swt.events.MouseListener#mouseUp(org.eclipse.swt.events.MouseEvent)
+		 */
+		public void mouseUp(MouseEvent event) {
+			// see bug 45700
+			if (event.button == 1) {
+				stopSelecting();
+				stopAutoScroll();
+			}
+		}
+
+		/*
+		 * @see org.eclipse.swt.events.MouseListener#mouseDown(org.eclipse.swt.events.MouseEvent)
+		 */
+		public void mouseDown(MouseEvent event) {
+			fParentRuler.setLocationOfLastMouseButtonActivity(event.x, event.y);
+			// see bug 45700
+			if (event.button == 1) {
+				startSelecting((event.stateMask & SWT.SHIFT) != 0);
+			}
+		}
+
+		/*
+		 * @see org.eclipse.swt.events.MouseListener#mouseDoubleClick(org.eclipse.swt.events.MouseEvent)
+		 */
+		public void mouseDoubleClick(MouseEvent event) {
+			fParentRuler.setLocationOfLastMouseButtonActivity(event.x, event.y);
+			stopSelecting();
+			stopAutoScroll();
+		}
+
+		/*
+		 * @see org.eclipse.swt.events.MouseMoveListener#mouseMove(org.eclipse.swt.events.MouseEvent)
+		 */
+		public void mouseMove(MouseEvent event) {
+			if (fIsListeningForMove && !autoScroll(event)) {
+				int newLine= fParentRuler.toDocumentLineNumber(event.y);
+				expandSelection(newLine);
+			}
+			fParentRuler.setLocationOfLastMouseButtonActivity(event.x, event.y);
+		}
+
+		/**
+		 * Called when line drag selection started. Adds mouse move and track
+		 * listeners to this column's control.
+		 *
+		 * @param expandExistingSelection if <code>true</code> the existing selection will be expanded,
+		 * 			otherwise a new selection is started
+		 */
+		private void startSelecting(boolean expandExistingSelection) {
+			try {
+
+				// select line
+				IDocument document= fCachedTextViewer.getDocument();
+				int lineNumber= fParentRuler.getLineOfLastMouseButtonActivity();
+				if (expandExistingSelection && fCachedTextViewer instanceof ITextViewerExtension5
+						&& fCachedTextViewer.getTextWidget() != null) {
+					ITextViewerExtension5 extension5= ((ITextViewerExtension5)fCachedTextViewer);
+					// Find model curosr position
+					int widgetCaret= fCachedTextViewer.getTextWidget().getCaretOffset();
+					int modelCaret= extension5.widgetOffset2ModelOffset(widgetCaret);
+					// Find model selection range
+					Point selection= fCachedTextViewer.getSelectedRange();
+					// Start from tail of selection range (opposite of cursor position)
+					int startOffset= modelCaret == selection.x ? selection.x + selection.y : selection.x;
+
+					fStartLineNumber= document.getLineOfOffset(startOffset);
+					fStartLineOffset= startOffset;
+
+					expandSelection(lineNumber);
+				} else {
+					fStartLineNumber= lineNumber;
+					fStartLineOffset= document.getLineInformation(fStartLineNumber).getOffset();
+					fCachedTextViewer.setSelectedRange(fStartLineOffset, 0);
+				}
+				fCachedViewportSize= getVisibleLinesInViewport();
+
+				// prepare for drag selection
+				fIsListeningForMove= true;
+
+			} catch (BadLocationException x) {
+			}
+		}
+
+		/**
+		 * Called when line drag selection stopped. Removes all previously
+		 * installed listeners from this column's control.
+		 */
+		private void stopSelecting() {
+			// drag selection stopped
+			fIsListeningForMove= false;
+		}
+
+		/**
+		 * Expands the line selection from the remembered start line to the
+		 * given line.
+		 *
+		 * @param lineNumber the line to which to expand the selection
+		 */
+		private void expandSelection(int lineNumber) {
+			try {
+
+				IDocument document= fCachedTextViewer.getDocument();
+				IRegion lineInfo= document.getLineInformation(lineNumber);
+
+				Display display= fCachedTextWidget.getDisplay();
+				Point absolutePosition= display.getCursorLocation();
+				Point relativePosition= fCachedTextWidget.toControl(absolutePosition);
+
+				int offset;
+
+				if (relativePosition.x < 0)
+					offset= lineInfo.getOffset();
+				else {
+					try {
+						int widgetOffset= fCachedTextWidget.getOffsetAtLocation(relativePosition);
+						Point p= fCachedTextWidget.getLocationAtOffset(widgetOffset);
+						if (p.x > relativePosition.x)
+							widgetOffset--;
+
+						// Convert to model offset
+						if (fCachedTextViewer instanceof ITextViewerExtension5) {
+							ITextViewerExtension5 extension= (ITextViewerExtension5)fCachedTextViewer;
+							offset= extension.widgetOffset2ModelOffset(widgetOffset);
+						} else
+							offset= widgetOffset + fCachedTextViewer.getVisibleRegion().getOffset();
+
+					} catch (IllegalArgumentException ex) {
+						int lineEndOffset= lineInfo.getOffset() + lineInfo.getLength();
+
+						// Convert to widget offset
+						int lineEndWidgetOffset;
+						if (fCachedTextViewer instanceof ITextViewerExtension5) {
+							ITextViewerExtension5 extension= (ITextViewerExtension5)fCachedTextViewer;
+							lineEndWidgetOffset= extension.modelOffset2WidgetOffset(lineEndOffset);
+						} else
+							lineEndWidgetOffset= lineEndOffset - fCachedTextViewer.getVisibleRegion().getOffset();
+
+						Point p= fCachedTextWidget.getLocationAtOffset(lineEndWidgetOffset);
+						if (p.x < relativePosition.x)
+							offset= lineEndOffset;
+						else
+							offset= lineInfo.getOffset();
+					}
+				}
+
+				int start= Math.min(fStartLineOffset, offset);
+				int end= Math.max(fStartLineOffset, offset);
+
+				if (lineNumber < fStartLineNumber)
+					fCachedTextViewer.setSelectedRange(end, start - end);
+				else
+					fCachedTextViewer.setSelectedRange(start, end - start);
+
+			} catch (BadLocationException x) {
+			}
+		}
+
+		/**
+		 * Called when auto scrolling stopped. Clears the auto scroll direction.
+		 */
+		private void stopAutoScroll() {
+			fAutoScrollDirection= SWT.NULL;
+		}
+
+		/**
+		 * Called on drag selection.
+		 *
+		 * @param event the mouse event caught by the mouse move listener
+		 * @return <code>true</code> if scrolling happened, <code>false</code> otherwise
+		 */
+		private boolean autoScroll(MouseEvent event) {
+			Rectangle area= fCanvas.getClientArea();
+
+			if (event.y > area.height) {
+				autoScroll(SWT.DOWN);
+				return true;
+			}
+
+			if (event.y < 0) {
+				autoScroll(SWT.UP);
+				return true;
+			}
+
+			stopAutoScroll();
+			return false;
+		}
+
+		/**
+		 * Scrolls the viewer into the given direction.
+		 *
+		 * @param direction the scroll direction
+		 */
+		private void autoScroll(int direction) {
+
+			if (fAutoScrollDirection == direction)
+				return;
+
+			final int TIMER_INTERVAL= 5;
+			final Display display= fCanvas.getDisplay();
+			Runnable timer= null;
+			switch (direction) {
+				case SWT.UP:
+					timer= new Runnable() {
+						public void run() {
+							if (fAutoScrollDirection == SWT.UP) {
+								int top= getInclusiveTopIndex();
+								if (top > 0) {
+									fCachedTextViewer.setTopIndex(top -1);
+									expandSelection(top -1);
+									display.timerExec(TIMER_INTERVAL, this);
+								}
+							}
+						}
+					};
+					break;
+				case  SWT.DOWN:
+					timer= new Runnable() {
+						public void run() {
+							if (fAutoScrollDirection == SWT.DOWN) {
+								int top= getInclusiveTopIndex();
+								fCachedTextViewer.setTopIndex(top +1);
+								expandSelection(top +1 + fCachedViewportSize);
+								display.timerExec(TIMER_INTERVAL, this);
+							}
+						}
+					};
+					break;
+			}
+
+			if (timer != null) {
+				fAutoScrollDirection= direction;
+				display.timerExec(TIMER_INTERVAL, timer);
+			}
+		}
+
+		/**
+		 * Returns the viewer's first visible line, even if only partially visible.
+		 *
+		 * @return the viewer's first visible line
+		 */
+		private int getInclusiveTopIndex() {
+			if (fCachedTextWidget != null && !fCachedTextWidget.isDisposed()) {
+				return JFaceTextUtil.getPartialTopIndex(fCachedTextViewer);
+			}
+			return -1;
+		}
+	}
+
+	/** This column's parent ruler */
+	private CompositeRuler fParentRuler;
+	/** Cached text viewer */
+	private ITextViewer fCachedTextViewer;
+	/** Cached text widget */
+	private StyledText fCachedTextWidget;
+	/** The columns canvas */
+	private Canvas fCanvas;
+	/** Cache for the actual scroll position in pixels */
+	private int fScrollPos;
+	/** The drawable for double buffering */
+	private Image fBuffer;
+	/** The internal listener */
+	private InternalListener fInternalListener= new InternalListener();
+	/** The font of this column */
+	private Font fFont;
+	/** The indentation cache */
+	private int[] fIndentation;
+	/** Indicates whether this column reacts on text change events */
+	private boolean fSensitiveToTextChanges= false;
+	/** The foreground color */
+	private Color fForeground;
+	/** The background color */
+	private Color fBackground;
+	/** Cached number of displayed digits */
+	private int fCachedNumberOfDigits= -1;
+	/** Flag indicating whether a relayout is required */
+	private boolean fRelayoutRequired= false;
+	/**
+	 * Redraw runnable lock
+	 * @since 3.0
+	 */
+	private Object fRunnableLock= new Object();
+	/**
+	 * Redraw runnable state
+	 * @since 3.0
+	 */
+	private boolean fIsRunnablePosted= false;
+	/**
+	 * Redraw runnable
+	 * @since 3.0
+	 */
+	private Runnable fRunnable= new Runnable() {
+		public void run() {
+			synchronized (fRunnableLock) {
+				fIsRunnablePosted= false;
+			}
+			redraw();
+		}
+	};
+	/* @since 3.2 */
+	private MouseHandler fMouseHandler;
+
+
+	/**
+	 * Constructs a new vertical ruler column.
+	 */
+	public LineNumberRulerColumn() {
+    }
+
+	/**
+	 * Sets the foreground color of this column.
+	 *
+	 * @param foreground the foreground color
+	 */
+	public void setForeground(Color foreground) {
+		fForeground= foreground;
+	}
+
+	/**
+	 * Returns the foreground color being used to print the line numbers.
+	 *
+	 * @return the configured foreground color
+	 * @since 3.0
+	 */
+	protected Color getForeground() {
+		return fForeground;
+	}
+
+	/**
+	 * Sets the background color of this column.
+	 *
+	 * @param background the background color
+	 */
+	public void setBackground(Color background) {
+		fBackground= background;
+		if (fCanvas != null && !fCanvas.isDisposed())
+			fCanvas.setBackground(getBackground(fCanvas.getDisplay()));
+	}
+
+	/**
+	 * Returns the System background color for list widgets.
+	 *
+	 * @param display the display
+	 * @return the System background color for list widgets
+	 */
+	protected Color getBackground(Display display) {
+		if (fBackground == null)
+			return display.getSystemColor(SWT.COLOR_LIST_BACKGROUND);
+		return fBackground;
+	}
+
+	/*
+	 * @see IVerticalRulerColumn#getControl()
+	 */
+	public Control getControl() {
+		return fCanvas;
+	}
+
+	/*
+	 * @see IVerticalRuleColumnr#getWidth
+	 */
+	public int getWidth() {
+		return fIndentation[0];
+	}
+
+	/**
+	 * Computes the number of digits to be displayed. Returns
+	 * <code>true</code> if the number of digits changed compared
+	 * to the previous call of this method. If the method is called
+	 * for the first time, the return value is also <code>true</code>.
+	 *
+	 * @return whether the number of digits has been changed
+	 * @since 3.0
+	 */
+	protected boolean updateNumberOfDigits() {
+		if (fCachedTextViewer == null)
+			return false;
+
+		int digits= computeNumberOfDigits();
+
+		if (fCachedNumberOfDigits != digits) {
+			fCachedNumberOfDigits= digits;
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Does the real computation of the number of digits. Subclasses may override this method if
+	 * they need extra space on the line number ruler.
+	 *
+	 * @return the number of digits to be displayed on the line number ruler.
+	 */
+	protected int computeNumberOfDigits() {
+		IDocument document= fCachedTextViewer.getDocument();
+		int lines= document == null ? 0 : document.getNumberOfLines();
+
+		int digits= 2;
+		while (lines > Math.pow(10, digits) -1) {
+			++digits;
+		}
+		return Math.max(digits, 3);
+	}
+
+	/**
+	 * Layouts the enclosing viewer to adapt the layout to changes of the
+	 * size of the individual components.
+	 *
+	 * @param redraw <code>true</code> if this column can be redrawn
+	 */
+	protected void layout(boolean redraw) {
+		if (!redraw) {
+			fRelayoutRequired= true;
+			return;
+		}
+
+		fRelayoutRequired= false;
+		if (fCachedTextViewer instanceof ITextViewerExtension) {
+			ITextViewerExtension extension= (ITextViewerExtension) fCachedTextViewer;
+			Control control= extension.getControl();
+			if (control instanceof Composite && !control.isDisposed()) {
+				Composite composite= (Composite) control;
+				composite.layout(true);
+			}
+		}
+	}
+
+	/**
+	 * Computes the indentations for the given font and stores them in
+	 * <code>fIndentation</code>.
+	 */
+	protected void computeIndentations() {
+		if (fCanvas == null || fCanvas.isDisposed())
+			return;
+
+		GC gc= new GC(fCanvas);
+		try {
+
+			gc.setFont(fCanvas.getFont());
+
+			fIndentation= new int[fCachedNumberOfDigits + 1];
+
+			char[] nines= new char[fCachedNumberOfDigits];
+			Arrays.fill(nines, '9');
+			String nineString= new String(nines);
+			Point p= gc.stringExtent(nineString);
+			fIndentation[0]= p.x;
+
+			for (int i= 1; i <= fCachedNumberOfDigits; i++) {
+				p= gc.stringExtent(nineString.substring(0, i));
+				fIndentation[i]= fIndentation[0] - p.x;
+			}
+
+		} finally {
+			gc.dispose();
+		}
+	}
+
+	/*
+	 * @see IVerticalRulerColumn#createControl(CompositeRuler, Composite)
+	 */
+	public Control createControl(CompositeRuler parentRuler, Composite parentControl) {
+
+		fParentRuler= parentRuler;
+		fCachedTextViewer= parentRuler.getTextViewer();
+		fCachedTextWidget= fCachedTextViewer.getTextWidget();
+
+		fCanvas= new Canvas(parentControl, SWT.NO_FOCUS ) {
+ 			/*
+ 			 * @see org.eclipse.swt.widgets.Control#addMouseListener(org.eclipse.swt.events.MouseListener)
+ 			 * @since 3.4
+ 			 */
+ 			public void addMouseListener(MouseListener listener) {
+				// see bug 40889, bug 230073 and AnnotationRulerColumn#isPropagatingMouseListener()
+				if (listener == fMouseHandler)
+					super.addMouseListener(listener);
+				else {
+					TypedListener typedListener= null;
+					if (listener != null)
+						typedListener= new TypedListener(listener);
+					addListener(SWT.MouseDoubleClick, typedListener);
+				}
+			}
+		};
+		fCanvas.setBackground(getBackground(fCanvas.getDisplay()));
+		fCanvas.setForeground(fForeground);
+
+		fCanvas.addPaintListener(new PaintListener() {
+			public void paintControl(PaintEvent event) {
+				if (fCachedTextViewer != null)
+					doubleBufferPaint(event.gc);
+			}
+		});
+
+		fCanvas.addDisposeListener(new DisposeListener() {
+			public void widgetDisposed(DisposeEvent e) {
+				handleDispose();
+				fCachedTextViewer= null;
+				fCachedTextWidget= null;
+			}
+		});
+
+		fMouseHandler= new MouseHandler();
+		fCanvas.addMouseListener(fMouseHandler);
+		fCanvas.addMouseMoveListener(fMouseHandler);
+
+		if (fCachedTextViewer != null) {
+
+			fCachedTextViewer.addViewportListener(fInternalListener);
+			fCachedTextViewer.addTextListener(fInternalListener);
+
+			if (fFont == null) {
+				if (fCachedTextWidget != null && !fCachedTextWidget.isDisposed())
+					fFont= fCachedTextWidget.getFont();
+			}
+		}
+
+		if (fFont != null)
+			fCanvas.setFont(fFont);
+
+		updateNumberOfDigits();
+		computeIndentations();
+		return fCanvas;
+	}
+
+	/**
+	 * Disposes the column's resources.
+	 */
+	protected void handleDispose() {
+
+		if (fCachedTextViewer != null) {
+			fCachedTextViewer.removeViewportListener(fInternalListener);
+			fCachedTextViewer.removeTextListener(fInternalListener);
+		}
+
+		if (fBuffer != null) {
+			fBuffer.dispose();
+			fBuffer= null;
+		}
+	}
+
+	/**
+	 * Double buffer drawing.
+	 *
+	 * @param dest the GC to draw into
+	 */
+	private void doubleBufferPaint(GC dest) {
+
+		Point size= fCanvas.getSize();
+
+		if (size.x <= 0 || size.y <= 0)
+			return;
+
+		if (fBuffer != null) {
+			Rectangle r= fBuffer.getBounds();
+			if (r.width != size.x || r.height != size.y) {
+				fBuffer.dispose();
+				fBuffer= null;
+			}
+		}
+		if (fBuffer == null)
+			fBuffer= new Image(fCanvas.getDisplay(), size.x, size.y);
+
+		GC gc= new GC(fBuffer);
+		gc.setFont(fCanvas.getFont());
+		if (fForeground != null)
+			gc.setForeground(fForeground);
+
+		try {
+			gc.setBackground(getBackground(fCanvas.getDisplay()));
+			gc.fillRectangle(0, 0, size.x, size.y);
+
+			ILineRange visibleLines= JFaceTextUtil.getVisibleModelLines(fCachedTextViewer);
+			if (visibleLines == null)
+				return;
+			fScrollPos= fCachedTextWidget.getTopPixel();
+			doPaint(gc, visibleLines);
+		} finally {
+			gc.dispose();
+		}
+
+		dest.drawImage(fBuffer, 0, 0);
+	}
+
+	/**
+	 * Returns the view port height in lines.
+	 *
+	 * @return the view port height in lines
+	 * @deprecated as of 3.2 the number of lines in the viewport cannot be computed because
+	 *             StyledText supports variable line heights
+	 */
+	protected int getVisibleLinesInViewport() {
+		return getVisibleLinesInViewport(fCachedTextWidget);
+	}
+
+
+	/**
+	 * Returns <code>true</code> if the viewport displays the entire viewer contents, i.e. the
+	 * viewer is not vertically scrollable.
+	 *
+	 * @return <code>true</code> if the viewport displays the entire contents, <code>false</code> otherwise
+	 * @since 3.2
+	 */
+	protected final boolean isViewerCompletelyShown() {
+		return JFaceTextUtil.isShowingEntireContents(fCachedTextWidget);
+	}
+
+	/**
+	 * Draws the ruler column.
+	 *
+	 * @param gc the GC to draw into
+	 * @param visibleLines the visible model lines
+	 * @since 3.2
+	 */
+	void doPaint(GC gc, ILineRange visibleLines) {
+		Display display= fCachedTextWidget.getDisplay();
+
+		// draw diff info
+		int y= -JFaceTextUtil.getHiddenTopLinePixels(fCachedTextWidget);
+
+		int lastLine= end(visibleLines);
+        int prevLine= -1;
+        int actualModelLine= -1;
+		for (int line= visibleLines.getStartLine(); line < lastLine; ) {
+			int widgetLine= JFaceTextUtil.modelLineToWidgetLine(fCachedTextViewer, line);
+			if (widgetLine == -1)
+				continue;
+
+			int lineHeight= fCachedTextWidget.getLineHeight(fCachedTextWidget.getOffsetAtLine(widgetLine));
+            if (fCachedTextWidget.getWordWrap()) {
+                Point pt = new Point(5, y);
+                actualModelLine = fCachedTextWidget.getLineAtOffset(fCachedTextWidget.getOffsetAtLocation(pt));
+                if (actualModelLine != prevLine) {
+        			paintLine(line, y, lineHeight, gc, display);
+                    line++;
+                }
+                else {
+                }
+                prevLine = actualModelLine;
+            }
+            else {
+    			paintLine(line, y, lineHeight, gc, display);
+                line++;
+            }
+            y += lineHeight;
+		}
+	}
+
+	/* @since 3.2 */
+	private static int end(ILineRange range) {
+		return range.getStartLine() + range.getNumberOfLines();
+	}
+
+	/**
+	 * Computes the string to be printed for <code>line</code>. The default implementation returns
+	 * <code>Integer.toString(line + 1)</code>.
+	 *
+	 * @param line the line number for which the line number string is generated
+	 * @return the string to be printed on the line number bar for <code>line</code>
+	 * @since 3.0
+	 */
+	protected String createDisplayString(int line) {
+		return Integer.toString(line + 1);
+	}
+
+	/**
+	 * Returns the difference between the baseline of the widget and the
+	 * baseline as specified by the font for <code>gc</code>. When drawing
+	 * line numbers, the returned bias should be added to obtain text lined up
+	 * on the correct base line of the text widget.
+	 *
+	 * @param gc the <code>GC</code> to get the font metrics from
+	 * @param widgetLine the widget line
+	 * @return the baseline bias to use when drawing text that is lined up with
+	 *         <code>fCachedTextWidget</code>
+	 * @since 3.2
+	 */
+	private int getBaselineBias(GC gc, int widgetLine) {
+		/*
+		 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=62951
+		 * widget line height may be more than the font height used for the
+		 * line numbers, since font styles (bold, italics...) can have larger
+		 * font metrics than the simple font used for the numbers.
+		 */
+		int offset= fCachedTextWidget.getOffsetAtLine(widgetLine);
+		int widgetBaseline= fCachedTextWidget.getBaseline(offset);
+
+		FontMetrics fm= gc.getFontMetrics();
+		int fontBaseline= fm.getAscent() + fm.getLeading();
+		int baselineBias= widgetBaseline - fontBaseline;
+		return Math.max(0, baselineBias);
+	}
+
+	/**
+	 * Paints the line. After this method is called the line numbers are painted on top
+	 * of the result of this method.
+	 *
+	 * @param line the line of the document which the ruler is painted for
+	 * @param y the y-coordinate of the box being painted for <code>line</code>, relative to <code>gc</code>
+	 * @param lineheight the height of one line (and therefore of the box being painted)
+	 * @param gc the drawing context the client may choose to draw on.
+	 * @param display the display the drawing occurs on
+	 * @since 3.0
+	 */
+	protected void paintLine(int line, int y, int lineheight, GC gc, Display display) {
+		int widgetLine= JFaceTextUtil.modelLineToWidgetLine(fCachedTextViewer, line);
+
+		String s= createDisplayString(line);
+		int indentation= fIndentation[s.length()];
+		int baselineBias= getBaselineBias(gc, widgetLine);
+		gc.drawString(s, indentation, y + baselineBias, true);
+	}
+
+	/**
+	 * Triggers a redraw in the display thread.
+	 *
+	 * @since 3.0
+	 */
+	protected final void postRedraw() {
+		if (fCanvas != null && !fCanvas.isDisposed()) {
+			Display d= fCanvas.getDisplay();
+			if (d != null) {
+				synchronized (fRunnableLock) {
+					if (fIsRunnablePosted)
+						return;
+					fIsRunnablePosted= true;
+				}
+				d.asyncExec(fRunnable);
+			}
+		}
+	}
+
+	/*
+	 * @see IVerticalRulerColumn#redraw()
+	 */
+	public void redraw() {
+
+		if (fRelayoutRequired) {
+			layout(true);
+			return;
+		}
+
+		if (fCachedTextViewer != null && fCanvas != null && !fCanvas.isDisposed()) {
+			GC gc= new GC(fCanvas);
+			doubleBufferPaint(gc);
+			gc.dispose();
+		}
+	}
+
+	/*
+	 * @see IVerticalRulerColumn#setModel(IAnnotationModel)
+	 */
+	public void setModel(IAnnotationModel model) {
+	}
+
+	/*
+	 * @see IVerticalRulerColumn#setFont(Font)
+	 */
+	public void setFont(Font font) {
+		fFont= font;
+		if (fCanvas != null && !fCanvas.isDisposed()) {
+			fCanvas.setFont(fFont);
+			updateNumberOfDigits();
+			computeIndentations();
+		}
+	}
+
+	/**
+	 * Returns the parent (composite) ruler of this ruler column.
+	 *
+	 * @return the parent ruler
+	 * @since 3.0
+	 */
+	protected CompositeRuler getParentRuler() {
+		return fParentRuler;
+	}
+
+
+	/**
+	 * Returns the number of lines in the view port.
+	 *
+	 * @param textWidget the styled text widget
+	 * @return the number of lines visible in the view port <code>-1</code> if there's no client
+	 *         area
+	 * @deprecated this method should not be used - it relies on the widget using a uniform line
+	 *             height
+	 */
+	static int getVisibleLinesInViewport(StyledText textWidget) {
+		if (textWidget != null) {
+			Rectangle clArea= textWidget.getClientArea();
+			if (!clArea.isEmpty()) {
+				int firstPixel= 0;
+				int lastPixel= clArea.height - 1; // XXX: what about margins? don't take trims as they include scrollbars
+				int first= JFaceTextUtil.getLineIndex(textWidget, firstPixel);
+				int last= JFaceTextUtil.getLineIndex(textWidget, lastPixel);
+				return last - first;
+			}
+		}
+		return -1;
+	}
+
+}