redcar-javamateview 0.1-java

data/src/com/redcareditor/theme/ScopeSelector.java

@@ -0,0 +1,39 @@
+package com.redcareditor.theme;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.redcareditor.onig.Rx;
+
+public class ScopeSelector {
+	public Rx positiveRegex;
+	public List<Rx> negativeRegexes;
+
+	public static List<ScopeSelector> compile(String scopeSelector) {
+		List<ScopeSelector> result = new ArrayList<ScopeSelector>();
+		for (String selector : scopeSelector.split(",")) {
+			result.add(new ScopeSelector(selector));
+		}
+		return result;
+	}
+
+	private ScopeSelector(String selector) {
+		negativeRegexes = new ArrayList<Rx>();
+		String[] positivesAndNegatives = selector.split(" -");
+		for (String subSelector : positivesAndNegatives) {
+			if (positiveRegex == null) {
+				String s1 = backSlashDots(subSelector);
+				String s2 = s1.replace(" ", ").* .*(");
+				positiveRegex = Rx.createRx("(" + s2 + ")");
+			} else {
+				String s1 = backSlashDots(subSelector);
+				String s2 = s1.replace(" ", ".* .*");
+				negativeRegexes.add(Rx.createRx(s2));
+			}
+		}
+	}
+
+	private String backSlashDots(String subSelector) {
+		return subSelector.trim().replace(".", "\\.");
+	}
+}

data/src/com/redcareditor/theme/Theme.java

@@ -0,0 +1,122 @@
+package com.redcareditor.theme;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Collections;
+import java.util.Comparator;
+
+import com.redcareditor.mate.Scope;
+import com.redcareditor.mate.ScopeMatcher;
+import com.redcareditor.onig.Match;
+import com.redcareditor.plist.Dict;
+import com.redcareditor.plist.PlistNode;
+import com.redcareditor.plist.PlistPropertyLoader;
+
+public class Theme {
+	public String author;
+	public String name;
+	public Map<String, String> globalSettings = new HashMap<String, String>();
+	public List<ThemeSetting> settings = new ArrayList<ThemeSetting>();
+	public Map<String, ThemeSetting> cachedSettingsForScopes = new HashMap<String, ThemeSetting>();
+
+	private PlistPropertyLoader propertyLoader;
+	private boolean isInitialized = false;
+
+	public Theme(Dict dict) {
+		propertyLoader = new PlistPropertyLoader(dict, this);
+		propertyLoader.loadStringProperty("name");
+		propertyLoader.loadStringProperty("author");
+		loadSettings(dict);
+	}
+
+	private void loadSettings(Dict dict) {
+		List<PlistNode<?>> dictSettings = dict.getArray("settings");
+		for (PlistNode<?> node : dictSettings) {
+			Dict nodeDict = (Dict) node;
+			if (!nodeDict.containsElement("scope")) {
+				loadGlobalSetting(nodeDict);
+			} else {
+				settings.add(new ThemeSetting(nodeDict));
+			}
+		}
+	}
+
+	private void loadGlobalSetting(Dict nodeDict) {
+		Dict settingsDict = nodeDict.getDictionary("settings");
+		for (String key : settingsDict.value.keySet()) {
+			globalSettings.put(key, settingsDict.getString(key));
+		}
+	}
+
+	public void initForUse() {
+		if (isInitialized)
+			return;
+		isInitialized = true;
+		// System.out.printf("initializing theme for use: %s\n", name);
+		this.cachedSettingsForScopes = new HashMap<String, ThemeSetting>();
+		for (ThemeSetting setting : settings) {
+			setting.compileScopeMatchers();
+		}
+	}
+
+	public ThemeSetting settingsForScope(Scope scope, boolean inner, ThemeSetting excludeSetting) {
+		String hierarchyNames = scope.hierarchyNames(inner);
+		if (isSettingAlreadyCached(hierarchyNames)) {
+			return cachedSettingsForScopes.get(hierarchyNames);
+		} else {
+			ThemeSetting setting = findSetting(hierarchyNames, inner, excludeSetting);
+			cachedSettingsForScopes.put(hierarchyNames, setting);
+			return setting;
+		}
+	}
+
+	private boolean isSettingAlreadyCached(String scope) {
+		return cachedSettingsForScopes.containsKey(scope);
+	}
+
+	public class ThemeSettingComparator implements Comparator {
+		String scopeName;
+		
+		public ThemeSettingComparator(String scopeName) {
+			this.scopeName = scopeName;
+		}
+		
+		public int compare(Object o1, Object o2) {
+			return ScopeMatcher.compareMatch(scopeName, ((ThemeSetting) o1).thisMatch, ((ThemeSetting) o2).thisMatch);
+		}
+	}
+	
+	public ThemeSetting findSetting(String hierarchyNames, boolean inner, ThemeSetting excludeSetting) {
+		// collect matching ThemeSettings
+		Match m;
+		ArrayList<ThemeSetting> matchingThemeSettings = new ArrayList<ThemeSetting>();
+		for (ThemeSetting setting : settings) {
+			if (setting == excludeSetting && excludeSetting != null) {
+			}
+			else {
+				if ((m = setting.match(hierarchyNames)) != null) {
+					setting.thisMatch = m;
+					matchingThemeSettings.add(setting);
+				}
+			}
+		}
+		
+		Collections.sort(matchingThemeSettings, new ThemeSettingComparator(hierarchyNames));
+		
+		// merge them together into a single ThemeSetting
+		ThemeSetting result = new ThemeSetting();
+		for (ThemeSetting ts : matchingThemeSettings) {
+			ts.thisMatch = null;
+			result.merge(ts);
+		}
+			
+		return result;
+	}
+}
+
+
+
+
+

data/src/com/redcareditor/theme/ThemeManager.java

@@ -0,0 +1,41 @@
+package com.redcareditor.theme;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.redcareditor.plist.Dict;
+
+public class ThemeManager {
+	public static List<Theme> themes;
+
+	public static List<String> themeNames(String textmateDir) {
+		List<String> names = new ArrayList<String>();
+		File dir = new File(textmateDir + "/Themes");
+		if (dir.exists()) {
+			for (String name : dir.list()) {
+				if (name.endsWith(".tmTheme")) {
+					names.add(name);
+				}
+			}
+		}
+		return names;
+	}
+	
+	public static void loadThemes(String textmateDir) {
+		if (themes == null) {
+    		themes = new ArrayList<Theme>();
+		}
+        for (String themeName : themeNames(textmateDir)) {
+			Dict dict = Dict.parseFile(textmateDir + "/Themes/" + themeName);
+			if (dict != null) {
+				Theme theme = new Theme(dict);
+				themes.add(theme);
+			}
+		}
+	}
+
+	private static boolean initialized() {
+		return themes != null;
+	}
+}

data/src/com/redcareditor/theme/ThemeSetting.java

@@ -0,0 +1,78 @@
+package com.redcareditor.theme;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.redcareditor.mate.ScopeMatcher;
+import com.redcareditor.onig.Match;
+import com.redcareditor.plist.Dict;
+import com.redcareditor.plist.PlistNode;
+import com.redcareditor.plist.PlistPropertyLoader;
+
+public class ThemeSetting {
+	public String name;
+	public String scopeSelector;
+	public String background;
+	public String foreground;
+	public String fontStyle;
+    public String marginBackground;
+    public String marginForeground;
+	
+	public List<ScopeMatcher> matchers;
+	
+	public Match thisMatch;
+	
+	public ThemeSetting() {}
+	
+	public ThemeSetting(Dict dict){
+		name          = dict.getString("name");
+		scopeSelector = dict.getString("scope");
+		
+		loadSettings(dict);
+		compileScopeMatchers();
+	}
+
+	private void loadSettings(Dict dict) {
+		Dict settingsDict = dict.getDictionary("settings");
+		
+		background = getSetting(settingsDict, "background");
+		foreground = getSetting(settingsDict, "foreground");
+		fontStyle  = getSetting(settingsDict, "fontStyle");
+	}
+
+	private String getSetting(Dict settingsDict, String settingName) {
+		PlistNode node = settingsDict.value.get(settingName);
+		return node == null ? null : (String) node.value;
+	}
+
+	public void compileScopeMatchers() {
+		this.matchers = ScopeMatcher.compile(scopeSelector);
+	}
+
+	public Match match(String scope) {
+		Match m;
+		if (this.matchers == null)
+			compileScopeMatchers();
+		
+		for (ScopeMatcher matcher : this.matchers) {
+			if ((m = ScopeMatcher.testMatchRe(matcher.pos_rx, matcher.neg_rxs, scope)) != null)
+				return m;
+		}
+		return null;
+	}
+	
+	// Merge this ThemeSetting with another, higher priority setting.
+	public void merge(ThemeSetting other) {
+		//System.out.printf("merging %s %s %s with %s %s %s\n",
+		//	name, background, foreground,
+		//	other.name, other.background, other.foreground);
+		if (other.background != null)
+			background = other.background;
+		if (other.foreground != null)
+			foreground = other.foreground;
+		if (other.fontStyle != null)
+			fontStyle = other.fontStyle;
+	}
+}
+

data/src/com/redcareditor/util/FileUtility.java

@@ -0,0 +1,64 @@
+package com.redcareditor.util;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+
+public class FileUtility {
+	private static final int INITIAL_BUFFER_SIZE = 2048;
+
+	/**
+	 * read the file at the given path fully to a byte array.
+	 */
+	public static byte[] readFully(String filepath)
+			throws FileNotFoundException {
+		return readFully(new File(filepath));
+	}
+
+	/**
+	 * read the given file fully into a byte array.
+	 * 
+	 * @return The files contents as a byte[].
+	 * @throws FileNotFoundException
+	 */
+	public static final byte[] readFully(File file)
+			throws FileNotFoundException {
+		return readFully(new FileInputStream(file));
+	}
+
+	/**
+	 * read the given stream fully into a byte array.<br>
+	 * This means that the stream has to end at some place, otherwise this
+	 * method makes not sense.
+	 */
+	public static final byte[] readFully(InputStream stream) {
+		try {
+			int readBytes = 0;
+			byte[] buffer = new byte[INITIAL_BUFFER_SIZE];
+			int b = 0;
+			while ((b = stream.read()) != -1) {
+				if (readBytes == buffer.length) {
+					buffer = doubleArraySize(buffer);
+				}
+
+				buffer[readBytes] = (byte) b;
+				readBytes++;
+			}
+
+			byte[] result = new byte[readBytes];
+			System.arraycopy(buffer, 0, result, 0, readBytes);
+			return result;
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return new byte[0];
+	}
+
+	private static final byte[] doubleArraySize(byte[] array) {
+		byte[] temp = new byte[array.length * 2];
+		System.arraycopy(array, 0, temp, 0, array.length);
+		return temp;
+	}
+}

data/src/com/redcareditor/util/SingleLineFormatter.java

@@ -0,0 +1,11 @@
+
+package com.redcareditor.util;
+
+import java.util.logging.LogRecord;
+import java.util.logging.SimpleFormatter;
+
+public class SingleLineFormatter extends SimpleFormatter {
+	public String format(LogRecord record) {
+		return new java.util.Date().toGMTString() + " " + record.getLoggerName() + " " + record.getLevel() + " " + record.getMessage() + "\r\n";
+	}
+}

data/src/com/redcareditor/util/swt/ColourUtil.java

@@ -0,0 +1,56 @@
+package com.redcareditor.util.swt;
+
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.widgets.Display;
+
+
+public class ColourUtil {
+
+	// Here parent_colour is like '#FFFFFF' and
+	// colour is like '#000000DD'.
+	static public String mergeColour(String parentColour, String colour) {
+		int pre_r, pre_g, pre_b;
+		int post_r, post_g, post_b;
+		int opacity;
+		int new_r, new_g, new_b;
+		String new_colour = null;
+		if (parentColour == null)
+			return null;
+		if (colour.length() == 7)
+			return colour;
+		if (colour.length() == 9) {
+			pre_r = ColourUtil.hex_to_int(parentColour.charAt(1), parentColour.charAt(2));
+			pre_g = ColourUtil.hex_to_int(parentColour.charAt(3), parentColour.charAt(4));
+			pre_b = ColourUtil.hex_to_int(parentColour.charAt(5), parentColour.charAt(6));
+	
+			post_r = ColourUtil.hex_to_int(colour.charAt(1), colour.charAt(2));
+			post_g = ColourUtil.hex_to_int(colour.charAt(3), colour.charAt(4));
+			post_b = ColourUtil.hex_to_int(colour.charAt(5), colour.charAt(6));
+			opacity = ColourUtil.hex_to_int(colour.charAt(7), colour.charAt(8));
+	
+			new_r = (pre_r*(255-opacity) + post_r*opacity)/255;
+			new_g = (pre_g*(255-opacity) + post_g*opacity)/255;
+			new_b = (pre_b*(255-opacity) + post_b*opacity)/255;
+			new_colour = String.format("#%02x%02x%02x", new_r, new_g, new_b);
+			// stdout.printf("%s/%s/%s - %d,%d,%d\n", parent_colour, colour, new_colour, new_r, new_g, new_b);
+			return new_colour;
+		}
+		return "#000000";
+	}
+
+	private static int char_to_hex(Character ch) {
+		return Character.digit(ch, 16);
+	}
+
+	private static int hex_to_int(char ch1, char ch2) {
+		return char_to_hex(ch1)*16 + char_to_hex(ch2);
+	}
+
+	public static Color getColour(String colour) {
+		return new Color(Display.getCurrent(), 
+					Integer.parseInt(colour.substring(1, 3), 16),
+					Integer.parseInt(colour.substring(3, 5), 16),
+					Integer.parseInt(colour.substring(5, 7), 16));
+	}
+
+}

data/src/ruby/java-mateview.rb

@@ -0,0 +1,68 @@
+require 'java'
+
+$CLASSPATH << File.expand_path(File.join(File.dirname(__FILE__), *%w(.. .. bin)))
+$:.push(File.expand_path(File.join(File.dirname(__FILE__), *%w(.. .. lib))))
+
+require 'jdom'
+
+require 'rbconfig'
+
+swt_lib = case Config::CONFIG["host_os"]
+  when /darwin/i
+    if Config::CONFIG["host_cpu"] == "x86_64"
+      'osx64/swt'
+    else
+      'osx/swt'
+    end
+  when /linux/i
+    if %w(amd64 x84_64).include? Config::CONFIG["host_cpu"]
+      'linux64/swt'
+    else
+      'linux/swt'
+    end
+  when /windows/i
+    'windows/swt'
+end
+
+require swt_lib
+require 'org.eclipse.core.commands'
+require 'org.eclipse.core.runtime_3.5.0.v20090525'
+require 'org.eclipse.equinox.common'
+require 'org.eclipse.jface.databinding_1.3.0.I20090525-2000'
+require 'org.eclipse.jface'
+require 'org.eclipse.jface.text_3.5.0'
+require 'org.eclipse.osgi'
+require 'org.eclipse.text_3.5.0.v20090513-2000'
+require 'org.eclipse.core.jobs_3.4.100.v20090429-1800'
+require 'org.eclipse.core.runtime_3.5.0.v20090525'
+require 'org.eclipse.core.resources'
+
+require 'swt_wrapper'
+
+unless defined?(JavaMateView)
+
+  module JavaMateView
+    import com.redcareditor.mate.MateText
+    import com.redcareditor.mate.Grammar
+    import com.redcareditor.mate.Bundle
+    import com.redcareditor.mate.Parser
+    import com.redcareditor.mate.ParserScheduler
+    import com.redcareditor.theme.Theme
+    import com.redcareditor.theme.ThemeManager
+  end
+
+  module Plist
+    import com.redcareditor.plist.Dict
+    import com.redcareditor.plist.PlistNode
+    import com.redcareditor.plist.PlistPropertyLoader
+  end
+
+  module Onig
+    import com.redcareditor.onig.Rx
+    import com.redcareditor.onig.Match
+  end
+  
+  module Util
+    import com.redcareditor.util.swt.ColourUtil
+  end
+end