redcar-javamateview 0.2

data/src/com/redcareditor/mate/document/MateDocument.java

@@ -0,0 +1,15 @@
+package com.redcareditor.mate.document;
+
+
+public interface MateDocument extends MateTextFactory{
+	
+	public int getLineCount();
+	
+	public int getLineLength(int line);
+	
+	public boolean addTextLocation(MateTextLocation location);
+	
+	public boolean addTextLocation(String category, MateTextLocation location);
+	
+	public void reparseAll();
+}

data/src/com/redcareditor/mate/document/MateTextFactory.java

@@ -0,0 +1,9 @@
+package com.redcareditor.mate.document;
+
+public interface MateTextFactory {
+	public MateTextLocation getTextLocation(int line, int offset);
+	
+	public MateTextRange getTextRange();
+	
+	public MateTextRange getTextRange(MateTextLocation start, MateTextLocation end);
+}

data/src/com/redcareditor/mate/document/MateTextLocation.java

@@ -0,0 +1,8 @@
+package com.redcareditor.mate.document;
+
+public interface MateTextLocation extends Comparable<MateTextLocation> {
+	public int getOffset();
+	public int getLine();
+	public int getLineOffset();
+	public void setDocument(MateDocument document);
+}

data/src/com/redcareditor/mate/document/MateTextLocationComparator.java

@@ -0,0 +1,17 @@
+package com.redcareditor.mate.document;
+
+import java.util.Comparator;
+
+public class MateTextLocationComparator implements Comparator<MateTextLocation> {
+
+	public int compare(MateTextLocation arg0, MateTextLocation arg1) {
+		int lineCompare = arg0.getLine() - arg1.getLine();
+
+		if (lineCompare == 0) {
+			return arg0.getLineOffset() - arg1.getLineOffset();
+		}
+
+		return lineCompare;
+	}
+
+}

data/src/com/redcareditor/mate/document/MateTextRange.java

@@ -0,0 +1,18 @@
+package com.redcareditor.mate.document;
+
+public interface MateTextRange {
+
+	public MateTextLocation getStart();
+
+	public void setDocument(MateDocument document);
+	public void setStart(MateTextLocation location);
+
+	public MateTextLocation getEnd();
+
+	public void setEnd(MateTextLocation location);
+	public void clearEnd();
+	
+	public int getLength();
+	public boolean conatains(MateTextLocation location);
+	public boolean overlaps(MateTextRange range);
+}

data/src/com/redcareditor/mate/document/swt/SwtMateDocument.java

@@ -0,0 +1,143 @@
+package com.redcareditor.mate.document.swt;
+
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.BadPositionCategoryException;
+import org.eclipse.jface.text.DefaultPositionUpdater;
+import org.eclipse.jface.text.Document;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.DocumentEvent;
+import org.eclipse.jface.text.IDocumentListener;
+import org.eclipse.jface.text.IPositionUpdater;
+import org.eclipse.jface.text.Position;
+import org.eclipse.swt.custom.StyledText;
+
+import com.redcareditor.mate.MateText;
+import com.redcareditor.mate.document.MateDocument;
+import com.redcareditor.mate.document.MateTextFactory;
+import com.redcareditor.mate.document.MateTextLocation;
+import com.redcareditor.mate.document.MateTextRange;
+
+public class SwtMateDocument implements MateDocument, MateTextFactory {
+	public MateText mateText;
+	private IPositionUpdater positionUpdater;
+	public Document document;
+
+	public SwtMateDocument(MateText mateText) {
+		this.mateText = mateText;
+		this.document = (Document) mateText.getDocument();
+		for (IPositionUpdater u : document.getPositionUpdaters()) {
+			document.removePositionUpdater(u);
+		}
+		document.addPositionCategory("scopes");
+		document.addPositionUpdater(new SwtScopePositionUpdater("scopes", SwtScopePositionUpdater.LEFT_GRAVITY));
+		document.addPositionCategory("lefts");
+		document.addPositionUpdater(new SwtScopePositionUpdater("lefts", SwtScopePositionUpdater.LEFT_GRAVITY));
+		document.addPositionCategory("rights");
+		document.addPositionUpdater(new SwtScopePositionUpdater("rights", SwtScopePositionUpdater.RIGHT_GRAVITY));
+	}
+
+	public void set(String text) {
+		this.mateText.getDocument().set(text);
+		//reparseAll();
+	}
+	
+	public IDocument getJFaceDocument() {
+		return this.mateText.getDocument();
+	}
+	
+	public String get() {
+		return this.mateText.getDocument().get();
+	}
+	
+	public int length() {
+		return this.mateText.getDocument().getLength();
+	}
+	
+	public int getNumberOfLines() {
+		return this.mateText.getDocument().getNumberOfLines();
+	}
+
+	public void reparseAll() {
+		SwtMateTextLocation startLocation = new SwtMateTextLocation(0, this);
+		SwtMateTextLocation endLocation = new SwtMateTextLocation(0 + document.getLength(), this);
+		if (this.mateText.parser.parserScheduler.enabled) {
+			this.mateText.parser.parserScheduler.changes.add(startLocation.getLine(), endLocation.getLine());
+			this.mateText.parser.parserScheduler.processChanges();
+		}
+	}
+
+	public void replace(int start, int length, String text) {
+		try {
+			this.mateText.getDocument().replace(start, length, text);
+			SwtMateTextLocation startLocation = new SwtMateTextLocation(start, this);
+			SwtMateTextLocation endLocation = new SwtMateTextLocation(start + length, this);
+			this.mateText.parser.parserScheduler.changes.add(startLocation.getLine(), endLocation.getLine());
+			this.mateText.parser.parserScheduler.processChanges();
+		} catch (BadLocationException e) {
+			// TODO: SwtMateDocument should throw it's own Exception here
+		}
+	}
+
+	public boolean addTextLocation(MateTextLocation location) {
+		return addTextLocation("default", location);
+	}
+
+	public boolean addTextLocation(String category, MateTextLocation location) {
+		try {
+			mateText.getDocument().addPosition(category, (SwtMateTextLocation) location);
+			return true;
+		} catch (BadLocationException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (BadPositionCategoryException e) {
+			e.printStackTrace();
+		}
+
+		return false;
+	}
+	
+	public boolean removeTextLocation(String category, MateTextLocation location) {
+		try {
+			mateText.getDocument().removePosition(category, (SwtMateTextLocation) location);
+			return true;
+		} catch (BadPositionCategoryException e) {
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+	public int getLineCount() {
+		return document.getNumberOfLines();
+	}
+
+	public int getLineLength(int line) {
+		try {
+			int startOffset = document.getLineOffset(line);
+			int endOffset;
+  
+			if (line + 1 < getLineCount()) {
+				endOffset = document.getLineOffset(line + 1);
+			} else {
+				endOffset = document.getLength();
+			}
+  
+			return endOffset - startOffset;
+		} catch (BadLocationException e) {
+			System.out.printf("*** Warning BadLocationException");
+			e.printStackTrace();
+			return -1;
+		}
+	}
+
+	public MateTextLocation getTextLocation(int line, int offset) {
+		return new SwtMateTextLocation(line, offset, this);
+	}
+
+	public MateTextRange getTextRange(MateTextLocation start, MateTextLocation end) {
+		return new SwtMateTextRange(start, end, this);
+	}
+
+	public MateTextRange getTextRange() {
+		return new SwtMateTextRange(this);
+	}
+}

data/src/com/redcareditor/mate/document/swt/SwtMateTextLocation.java

@@ -0,0 +1,88 @@
+package com.redcareditor.mate.document.swt;
+
+import org.eclipse.jface.text.Position;
+import org.eclipse.jface.text.Document;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.jface.text.BadLocationException;
+
+import com.redcareditor.mate.document.MateDocument;
+import com.redcareditor.mate.document.MateTextLocation;
+import com.redcareditor.mate.document.MateTextLocationComparator;
+
+public class SwtMateTextLocation extends Position implements MateTextLocation {
+
+	private static final MateTextLocationComparator comperator = new MateTextLocationComparator();
+	private Document document;
+
+	public SwtMateTextLocation(int offset, SwtMateDocument document) {
+		super(offset);
+		this.document = (Document) document.getJFaceDocument();
+	}
+
+	public SwtMateTextLocation(int line, int lineOffset, SwtMateDocument document) {
+		super(computeOffset(line, lineOffset, (Document) document.getJFaceDocument()));
+		this.document = (Document) document.getJFaceDocument();
+	}
+
+	public SwtMateTextLocation(MateTextLocation location, SwtMateDocument document) {
+		super(computeOffset(location.getLine(), location.getLineOffset(), (Document) document.getJFaceDocument()));
+		this.document = (Document) document.getJFaceDocument();
+	}
+
+	public void setDocument(MateDocument document) {
+		this.document = (Document) ((SwtMateDocument) document).getJFaceDocument();
+	}
+
+	public int getLine() {
+		try {
+			return document.getLineOfOffset(getOffset());
+		} catch (BadLocationException e) {
+			System.out.printf("*** Warning BadLocationException");
+			e.printStackTrace();
+			return -1;
+		}
+	}
+
+	public int getLineOffset() {
+		try {
+			return getOffset() - document.getLineOffset(getLine());
+		} catch (BadLocationException e) {
+			System.out.printf("*** Warning BadLocationException");
+			e.printStackTrace();
+			return -1;
+		}
+	}
+
+	public int compareTo(MateTextLocation other) {
+		return this.offset - ((SwtMateTextLocation)other).offset;
+	}
+	
+	//@Override
+	//public int getOffset() {
+	//	return this.offset < document.getLength() ? this.offset : document.getLength();
+	//}
+	
+	private static int computeOffset(int line, int offset, Document document){
+		try {
+			line = line < 0 ? 0 : line;
+			
+			int result = document.getLineOffset(line) + offset;
+			
+			result = result < 0 ? 0 : result;
+			result = result > document.getLength() ? document.getLength() : result; 
+			return result;
+		} catch (BadLocationException e) {
+			System.out.printf("*** Warning BadLocationException");
+			e.printStackTrace();
+			return -1;
+		}
+	}
+	
+	@Override
+	public boolean equals(Object other) {
+		if(other instanceof MateTextLocation){
+			return compareTo((MateTextLocation) other) == 0;
+		}
+		return false;
+	}
+}

data/src/com/redcareditor/mate/document/swt/SwtMateTextRange.java

@@ -0,0 +1,92 @@
+package com.redcareditor.mate.document.swt;
+
+import org.eclipse.jface.text.Document;
+import org.eclipse.jface.text.BadLocationException;
+
+import com.redcareditor.mate.document.MateDocument;
+import com.redcareditor.mate.document.MateTextLocation;
+import com.redcareditor.mate.document.MateTextRange;
+
+public class SwtMateTextRange implements MateTextRange {
+	private SwtMateTextLocation start;
+	private SwtMateTextLocation end;
+	private SwtMateDocument document;
+
+	public SwtMateTextRange(SwtMateDocument document) {
+		this.document = document;
+	}
+
+	public SwtMateTextRange(MateTextLocation start, MateTextLocation end, SwtMateDocument document) {
+		super();
+		this.start = sanatize(start);
+		this.end = sanatize(end);
+		this.document = document;
+	}
+
+	public void setDocument(MateDocument document) {
+		this.document = (SwtMateDocument) document;
+		if (start != null)
+			start.setDocument(document);
+		if (end != null)
+			end.setDocument(document);
+	}
+
+	public int getLength() {
+		return end.getOffset() - start.getOffset();
+	}
+
+	public MateTextLocation getStart() {
+		if (start != null) {
+			return start;
+		} else {
+			return document.getTextLocation(0, 0);
+		}
+	}
+
+	public void setStart(MateTextLocation location) {
+		start = sanatize(location);
+	}
+
+	public MateTextLocation getEnd() {
+		if (end != null) {
+			return end;
+		} else {// Return end of Document if not set
+			try {
+				int lastLine = document.document.getNumberOfLines() - 1;
+				int lastLineOffset = document.document.getLength() - document.document.getLineOffset(lastLine);
+				return document.getTextLocation(lastLine, lastLineOffset);
+			} catch (BadLocationException e) {
+				System.out.printf("*** Warning BadLocationException");
+				e.printStackTrace();
+				return null;
+			}
+		}
+	}
+
+	public void setEnd(MateTextLocation location) {
+		end = sanatize(location);
+	}
+	
+	public void clearEnd() {
+		end = null;
+	}
+
+	private SwtMateTextLocation sanatize(MateTextLocation location) {
+		if (location instanceof SwtMateTextLocation) {
+			return (SwtMateTextLocation) location;
+		}
+		return (SwtMateTextLocation) document.getTextLocation(location.getLine(), location.getLineOffset());
+	}
+
+	public boolean conatains(MateTextLocation location) {
+		return getStart().compareTo(location) <= 0 && getEnd().compareTo(location) > 0;
+	}
+
+	public boolean overlaps(MateTextRange range) {
+		if(getStart().compareTo(range.getStart()) >= 0){
+			return getStart().compareTo(range.getEnd()) <= 0;
+		}else{
+			return getEnd().compareTo(range.getStart()) >= 0;
+		}
+	}
+}

data/src/com/redcareditor/mate/document/swt/SwtScopePositionUpdater.java

@@ -0,0 +1,90 @@
+package com.redcareditor.mate.document.swt;
+
+import org.eclipse.jface.text.BadPositionCategoryException;
+import org.eclipse.jface.text.DocumentEvent;
+import org.eclipse.jface.text.IPositionUpdater;
+import org.eclipse.jface.text.Position;
+
+/**
+ * ScopePositionUpdater 
+ * 
+ * A position updater that never deletes a position. If the region containing
+ * the position is deleted, the position is moved to the beginning/end (falling
+ * together) of the change. If the region containing the position is replaced,
+ * the position is placed at the same location inside the replacement text, but
+ * always inside the replacement text.
+ *
+ * @since 3.1
+ */
+public class SwtScopePositionUpdater implements IPositionUpdater {
+	static final int LEFT_GRAVITY  = 0;
+	static final int RIGHT_GRAVITY = 1;
+	
+	/** The position category. */
+	private final String fCategory;
+	private final int fGravity;
+
+	/**
+	 * Creates a new updater for the given <code>category</code>.
+	 *
+	 * @param category the new category.
+	 */
+	public SwtScopePositionUpdater(String category, int gravity) {
+		fCategory = category;
+		fGravity  = gravity;
+	}
+
+	/*
+	 * @see org.eclipse.jface.text.IPositionUpdater#update(org.eclipse.jface.text.DocumentEvent)
+	 */
+	public void update(DocumentEvent event) {
+		int eventOffset       = event.getOffset();
+		int eventOldEndOffset = eventOffset + event.getLength();
+		int eventNewLength    = event.getText() == null ? 0 : event.getText().length();
+		int eventNewEndOffset = eventOffset + eventNewLength;
+		int deltaLength       = eventNewLength - event.getLength();
+		//System.out.printf("SwtScopePositionUpdater cat:%s grav:%d delta:%d\n", fCategory, fGravity, deltaLength);
+
+		try {
+			Position[] positions= event.getDocument().getPositions(fCategory);
+			for (int i= 0; i != positions.length; i++) {
+
+				Position position= positions[i];
+
+				if (position.isDeleted())
+					continue;
+
+				int posOffset = position.getOffset();
+				int posLength = position.getLength();  // always zero
+				int posEnd    = posOffset + posLength;
+				//System.out.printf("  position %s offset:%d\n", position.toString(), posOffset);
+				
+				if (posOffset > eventOldEndOffset) {
+					// position comes way after change - shift
+					position.setOffset(posOffset + deltaLength);
+				} else if (posOffset < eventOffset) {
+					// position comes way before change - leave alone
+				} else {
+					// position is within replaced text - 
+					if (fGravity == RIGHT_GRAVITY)
+						position.setOffset(eventNewEndOffset);
+					else
+						position.setOffset(eventOffset);
+				}
+				//System.out.printf("  position %s offset:%d\n", position.toString(), position.getOffset());
+			}
+		} catch (BadPositionCategoryException e) {
+			// ignore and return
+		}
+	}
+
+	/**
+	 * Returns the position category.
+	 *
+	 * @return the position category
+	 */
+	public String getCategory() {
+		return fCategory;
+	}
+	
+}