GWT: big refactoring of the translator and fridge apps.

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/CompletionOracle.java

@@ -10,14 +10,10 @@ public class CompletionOracle extends SuggestOracle {
 
 	private static final int LIMIT_SCALE_FACTOR = 4;
 
-	private PGF pgf;
-
-	private String pgfName;
+	private PGFWrapper pgf;
 
 	private ErrorHandler errorHandler;
 
-	private String inputLang = null;
-
 	private JSONRequest jsonRequest = null;
 
 	private String oldQuery = null;
@@ -25,27 +21,21 @@ public class CompletionOracle extends SuggestOracle {
 	private List<CompletionSuggestion> oldSuggestions = Collections.emptyList();
 
 
-	public CompletionOracle (PGF pgf) {
+	public CompletionOracle (PGFWrapper pgf) {
 		this(pgf, null);
 	}
 
-	public CompletionOracle (PGF pgf, ErrorHandler errorHandler) {
+	public CompletionOracle (PGFWrapper pgf, ErrorHandler errorHandler) {
 		this.pgf = pgf;
 		this.errorHandler = errorHandler;
-	}
-
-	public String getGrammarName() {
-		return pgfName;
-	}
-
-	public void setGrammarName(String pgfName) {
-		this.pgfName = pgfName;
-		clearState();
-	}
-
-	public void setInputLanguage(String inputLang) {
-		this.inputLang = inputLang;
-		clearState();
+		pgf.addSettingsListener(new PGFWrapper.SettingsListener() {
+			public void onAvailableGrammarsChanged() { clearState(); }
+			public void onAvailableLanguagesChanged() { clearState(); }
+			public void onInputLanguageChanged() { clearState(); }
+			public void onOutputLanguageChanged() { clearState(); }
+			public void onCatChanged() { clearState(); }
+			public void onSettingsError(String msg, Throwable e) { clearState(); }
+		});
 	}
 
 	private void clearState () {
@@ -57,10 +47,6 @@ public class CompletionOracle extends SuggestOracle {
 		}
 	}
 
-	public String getInputLanguage() {
-		return inputLang;
-	}
-
 	public void setErrorHandler(ErrorHandler errorHandler) {
 		this.errorHandler = errorHandler;
 	}
@@ -130,7 +116,7 @@ public class CompletionOracle extends SuggestOracle {
 		// hack: first report no completions, to hide suggestions until we get the new completions
 		callback.onSuggestionsReady(request, new SuggestOracle.Response(Collections.<CompletionSuggestion>emptyList()));
 
-		jsonRequest = pgf.complete(getGrammarName(), request.getQuery(), getInputLanguage(), null, LIMIT_SCALE_FACTOR * request.getLimit(), 
+		jsonRequest = pgf.complete(request.getQuery(), LIMIT_SCALE_FACTOR * request.getLimit(), 
 				new PGF.CompleteCallback() {
 			public void onResult(PGF.Completions completions) {
 				jsonRequest = null;

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/FridgeApp.java

@@ -1,85 +1,68 @@
 package se.chalmers.cs.gf.gwt.client;
 
-import com.google.gwt.core.client.EntryPoint;
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.History;
-import com.google.gwt.user.client.HistoryListener;
 import com.google.gwt.user.client.ui.Button;
 import com.google.gwt.user.client.ui.ClickListener;
 import com.google.gwt.user.client.ui.FlowPanel;
+import com.google.gwt.user.client.ui.HasText;
 import com.google.gwt.user.client.ui.HorizontalPanel;
 import com.google.gwt.user.client.ui.Hyperlink;
 import com.google.gwt.user.client.ui.Label;
 import com.google.gwt.user.client.ui.Panel;
-import com.google.gwt.user.client.ui.RootPanel;
 import com.google.gwt.user.client.ui.VerticalPanel;
 import com.google.gwt.user.client.ui.Widget;
 
 
-public class FridgeApp implements EntryPoint {
+public class FridgeApp extends TranslateApp {
 
-	private static final String pgfBaseURL = "/pgf";
-
-	private PGF pgf;
-
-	private FlowPanel textPanel;	
 	private FlowPanel bagPanel;
-	private SettingsPanel settingsPanel;
-	private VerticalPanel outputPanel;
-	private StatusPopup statusPopup;
+
+	//
+	// Text
+	//
+
+	protected void update () {
+		updateBag();
+		translate();
+	}
 
 	//
 	// Translation
 	//
 
-	private void translate() {
-		outputPanel.clear();
-		setStatus("Translating...");
-		pgf.translate(settingsPanel.getGrammarName(), 
-				getText(), 
-				settingsPanel.getInputLanguage(), null, 
-				settingsPanel.getOutputLanguage(), 
-				new PGF.TranslateCallback() {
-			public void onResult (PGF.Translations translations) {
-				for (final PGF.Translation t : translations.iterable()) {
-					Hyperlink l = new Hyperlink(t.getText(), t.getTo() + "/" + t.getText());
-					l.addStyleName("my-translation");
-					PGF.Language lang = settingsPanel.getGrammar().getLanguage(t.getTo());
-					if (lang != null) {
-						l.getElement().setLang(lang.getLanguageCode());
-					}
-					outputPanel.add(l);
-				}
-				clearStatus();
-			}
-			public void onError (Throwable e) {
-				showError("Translation failed", e);
-			}
-		});
+	protected Widget createTranslation(String language, String text) {
+		Hyperlink l = new Hyperlink(text, makeToken(language, text));
+		l.addStyleName("my-translation");
+		String lang = pgf.getLanguageCode(language);
+		if (lang != null) {
+			l.getElement().setLang(lang);
+		}
+		return l;
 	}
 
 	//
 	// Available words
 	//
 
+	private String makeToken (String language, String text) {
+		return pgf.getPGFName() + "/" + language + "/" + text;
+	}
+
 	private void updateBag () {
 		updateBag("");
 	}
 
 	private void updateBag (String prefix) {
-		bagPanel.clear();
 		int limit = 100;
-		pgf.complete(settingsPanel.getGrammarName(), 
-				getText() + " " + prefix, 
-				settingsPanel.getInputLanguage(), null, 
+		pgf.complete(getText() + " " + prefix, 
 				limit, new PGF.CompleteCallback() {
 			public void onResult(PGF.Completions completions) {
+				bagPanel.clear();
 				for (PGF.Completion completion : completions.iterable()) {
 					String text = completion.getText();
 					if (!completion.getText().equals(getText() + " ")) {
 						String[] words = text.split("\\s+");
 						String word = (words.length > 0) ? words[words.length - 1] : "";
-						String token = /* settingsPanel.getGrammarName() + "/" + */ completion.getFrom() + "/" + text;
+						String token = makeToken(completion.getFrom(), text);
 						Hyperlink magnet = new Hyperlink(word, token);
 						magnet.addStyleName("my-Magnet");
 						bagPanel.add(magnet);
@@ -99,150 +82,87 @@ public class FridgeApp implements EntryPoint {
 	// Current text
 	//
 
-	private String getText () {
-		StringBuilder sb = new StringBuilder();
-		for (Widget w : textPanel) {
-			String word = ((UsedMagnet)w).getText();	
-			if (sb.length() > 0) {
-				sb.append(' ');
+	private class TextPanel extends FlowPanel implements HasText {
+
+		public TextPanel () { }
+
+		public String getText () {
+			StringBuilder sb = new StringBuilder();
+			for (Widget w : this) {
+				String word = ((UsedMagnet)w).getText();	
+				if (sb.length() > 0) {
+					sb.append(' ');
+				}
+				sb.append(word);			
 			}
-			sb.append(word);			
+			return sb.toString();
 		}
-		return sb.toString();
+
+		public void setText (String text) {
+			String inputLanguage = pgf.getInputLanguage();
+			clear();
+			for (String word : text.split("\\s+")) {
+				add(new UsedMagnet(inputLanguage, word));
+			}
+		}
+
 	}
 
 	private void clear() {
-		String token = settingsPanel.getInputLanguage() + "/" + "";
-		if (History.getToken().equals(token)) {
-			History.fireCurrentHistoryState();
-		} else {
-			History.newItem(token);
-		}
-	}
-
-	private HistoryListener historyListener = new HistoryListener() {
-		public void onHistoryChanged(String historyToken) {
-			GWT.log("History changed:" + historyToken, null);
-			String[] parts = historyToken.split("/");
-			GWT.log(parts.length + " parts", null);
-			if (parts.length == 0) {
-				setState("", "");				
-			} else if (parts.length == 1) {
-				setState(parts[0], "");
-			} else if (parts.length == 2) {
-				setState(parts[0], parts[1]);
-			}
-		}
-	};
-	
-	/*
-	
-	private static class State {
-		public String grammarName = "";
-		public String inputLanguage = "";
-		public String text = "";
-				
-		public State (String token) {
-			String[] parts = token.split("/");
-			if (parts.length >= 1) {
-				this.grammarName = parts[0];
-				if (parts.length >= 2) {
-					this.inputLanguage = parts[1];	
-					if (parts.length >= 3) {
-						this.text = parts[2];
-					}
-				}
-			} 
-		}
-	}
-	
-	private void setState(State state) {
-		settingsPanel.setInputLanguage(state.inputLanguage);
-		textPanel.clear();
-		for (String word : state.text.split("\\s+")) {
-			textPanel.add(new UsedMagnet(state.inputLanguage, word));
-		}
-		updateBag();
-		translate();
-	}
-	
-	*/
-
-	private void setState(String inputLang, String text) {
-		GWT.log("New text: \"" + text + "\"", null);
-		settingsPanel.setInputLanguage(inputLang);
-		textPanel.clear();
-		for (String word : text.split("\\s+")) {
-			textPanel.add(new UsedMagnet(inputLang, word));
-		}
-		updateBag();
-		translate();
+		setText("");
 	}
 
 	//
-	// Status stuff
+	// History stuff
 	//
 
-	private void setStatus(String msg) {
-		statusPopup.setStatus(msg);
-	}
-
-	private void showError(String msg, Throwable e) {
-		statusPopup.showError(msg, e);
-	}
-
-	private void clearStatus() {
-		statusPopup.clearStatus();
+	protected void updateSettingsFromHistoryToken(String[] tokenParts) {
+		super.updateSettingsFromHistoryToken(tokenParts);
+		if (tokenParts.length >= 3 && tokenParts[2].length() > 0) {
+			textSource.setText(tokenParts[2]);
+			update();
+		}
 	}
 
 	//
 	// GUI
 	//
 
-	private void createTranslationUI() {
+	protected Widget createTranslationUI() {
+		VerticalPanel vPanel = new VerticalPanel();
+		vPanel.setWidth("100%");
+		vPanel.setHorizontalAlignment(VerticalPanel.ALIGN_CENTER);
+		vPanel.add(createTextPanel());
+		vPanel.add(createButtonPanel());
+		vPanel.add(createBagPanel());
+		vPanel.add(createSettingsPanel());
+		vPanel.add(createTranslationsPanel());
+		return vPanel;
+	}
 
-		statusPopup = new StatusPopup();
-		setStatus("Loading...");
+	protected Widget createTextPanel () {
+		TextPanel textPanel = new TextPanel();		
+		textPanel.setStylePrimaryName("my-TextPanel");
 
-		settingsPanel = new SettingsPanel(pgf);
-		settingsPanel.addSettingsListener(new SettingsPanel.SettingsListener() {
-			public void grammarChanged(String pgfName) {
-			}
-			public void languagesChanged(String inputLang, String outputLang) {
-				clear();
-			}
-			public void settingsError(String msg, Throwable e) {
-				showError(msg,e);
-			}
-		});
+		textSource = textPanel;
 
+		return textPanel;
+	}
+
+	protected Widget createButtonPanel () {
 		Panel buttons = new HorizontalPanel();
 		buttons.add(new Button("Clear", new ClickListener () {
 			public void onClick(Widget sender) {
 				clear();
 			}
 		}));
+		return buttons;
+	}
 
-		outputPanel = new VerticalPanel();
-		outputPanel.addStyleName("my-translations");
-
-		textPanel = new FlowPanel();
-		textPanel.setStylePrimaryName("my-TextPanel");
-
+	protected Widget createBagPanel () {
 		bagPanel = new FlowPanel();
 		bagPanel.setStylePrimaryName("my-BagPanel");
-
-		VerticalPanel mainPanel = new VerticalPanel();
-		mainPanel.setHorizontalAlignment(VerticalPanel.ALIGN_CENTER);
-		mainPanel.setWidth("100%");
-		mainPanel.add(textPanel);
-		mainPanel.add(buttons);
-		mainPanel.add(bagPanel);
-		mainPanel.add(outputPanel);
-		mainPanel.add(settingsPanel);
-
-		RootPanel.get().add(mainPanel);
-
+		return bagPanel;
 	}
 
 	//
@@ -250,10 +170,7 @@ public class FridgeApp implements EntryPoint {
 	//
 
 	public void onModuleLoad() {
-		pgf = new PGF(pgfBaseURL);
-		createTranslationUI();
-		History.addHistoryListener(historyListener);
-		settingsPanel.updateAvailableGrammars();
+		super.onModuleLoad();
 	}
 
 }

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/GrammarBox.java

@@ -1,26 +0,0 @@
-package se.chalmers.cs.gf.gwt.client;
-
-import com.google.gwt.user.client.ui.ListBox;
-
-public class GrammarBox extends ListBox {
-    
-	public GrammarBox() {
-		setEnabled(false);
-	}
-	
-	public void setGrammarNames(PGF.GrammarNames grammarNames) {
-		for (PGF.GrammarName grammarName : grammarNames.iterable()) {
-			addItem(grammarName.getName());
-		}
-		if (!grammarNames.isEmpty()) {
-			setSelectedIndex(0);
-			setEnabled(true);
-		}
-	}
-
-	public String getSelectedGrammar() {
-		int i = getSelectedIndex();
-		return i == -1 ? null : getValue(i);
-	}
-
-}

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/InputLanguageBox.java

@@ -1,39 +0,0 @@
-package se.chalmers.cs.gf.gwt.client;
-
-import com.google.gwt.user.client.ui.ListBox;
-
-public class InputLanguageBox extends ListBox {
-
-	public InputLanguageBox() {
-		setEnabled(false);
-	}
-
-	public String getLanguage() {
-		return getValue(getSelectedIndex());
-	}
-	
-	public void setLanguage(String lang) {
-		int c = getItemCount();
-		for (int i = 0; i < c; i++) {
-			if (getValue(i).equals(lang)) {
-				setSelectedIndex(i);
-			}
-		}
-	}
-	
-	public void setGrammar(PGF.Grammar grammar) {
-		clear();
-		addItem("Any language", "");
-		for (PGF.Language l : grammar.getLanguages().iterable()) {
-			String name = l.getName();
-			if (l.canParse()) {
-				addItem(name);
-				if (name.equals(grammar.getUserLanguage())) {
-					setSelectedIndex(getItemCount()-1);
-				}
-			}
-		}
-		setEnabled(true);
-	}
-
-}

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/MultiListBox.java

@@ -1,34 +0,0 @@
-package se.chalmers.cs.gf.gwt.client;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import com.google.gwt.user.client.ui.ListBox;
-
-public class MultiListBox extends ListBox {
-
-	public MultiListBox() {
-	}
-
-	public List<String> getSelectedValues() {
-		int c = getItemCount();
-		List<String> l = new ArrayList<String>();
-		for (int i = 0; i < c; i++) {
-			if (isItemSelected(i)) {
-				l.add(getValue(i));
-			}
-		}
-		return l;
-	}
-	
-	public void setSelectedValues(List<String> values) {
-		Set<String> vs = new HashSet<String>(values);
-		int c = getItemCount();
-		for (int i = 0; i < c; i++) {
-			setItemSelected(i, vs.contains(getValue(i)));
-		}
-	}
-
-}

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/MyListBox.java

@@ -0,0 +1,40 @@
+package se.chalmers.cs.gf.gwt.client;
+
+import java.util.Collection;
+
+import com.google.gwt.user.client.ui.ListBox;
+
+public class MyListBox extends ListBox {
+
+	public MyListBox () { }
+	
+	public void clearSelection () {
+		setSelectedIndex(-1);
+	}
+	
+	public String getSelectedValue() {
+		int i = getSelectedIndex();
+		return i == -1 ? null : getValue(i);
+	}
+	
+	public void setSelectedValue(String value) {
+		if (value == null) {
+			clearSelection();
+		} else {
+			int c = getItemCount();
+			for (int i = 0; i < c; i++) {
+				if (getValue(i).equals(value)) {
+					setSelectedIndex(i);
+					return;
+				}
+			}
+		}
+	}
+	
+	public void addItems(Collection<String> items) {
+		for (String item : items) {
+			addItem(item);
+		}
+	}
+	
+}

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/OutputLanguageBox.java

@@ -1,33 +0,0 @@
-package se.chalmers.cs.gf.gwt.client;
-
-import com.google.gwt.user.client.ui.ListBox;
-
-public class OutputLanguageBox extends ListBox {
-
-	public OutputLanguageBox() {
-		setEnabled(false);
-	}
-
-	public String getLanguage() {
-		return getValue(getSelectedIndex());
-	}
-	
-	public void setLanguage(String lang) {
-		int c = getItemCount();
-		for (int i = 0; i < c; i++) {
-			if (getValue(i).equals(lang)) {
-				setSelectedIndex(i);
-			}
-		}
-	}
-	
-	public void setGrammar(PGF.Grammar grammar) {
-		clear();
-		addItem("All languages", "");
-		for (PGF.Language l : grammar.getLanguages().iterable()) {
-			addItem(l.getName());
-		}
-		setEnabled(true);
-	}
-
-}

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/PGF.java

@@ -49,16 +49,6 @@ public class PGF {
 		public final native String getUserLanguage() /*-{ return this.userLanguage; }-*/;
 
 		public final native IterableJsArray<Language> getLanguages() /*-{ return this.languages; }-*/;
-
-		public final Language getLanguage(String name) {
-			int c = getLanguages().length();
-			for (int i = 0; i < c; i++) {
-				Language l = getLanguages().get(i);
-				if (l.getName().equals(name))
-					return l;
-			}
-			return null;
-		}
 	}
 
 	public static class Language extends JavaScriptObject {

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/PGFWrapper.java

@@ -0,0 +1,239 @@
+package se.chalmers.cs.gf.gwt.client;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+
+public class PGFWrapper {
+
+	private PGF pgf;
+
+	private String pgfName = null;
+
+	private String inputLanguage = null;
+
+	private String outputLanguage = null;
+
+	private String cat = null;
+
+	// Cached info about the available grammars 
+
+	private List<String> grammars;
+
+	// Cached info about the currently selected grammar
+	
+	private String userLanguage;
+	
+	private LinkedHashMap<String,PGF.Language> languages;
+
+	private List<String> parseableLanguages;
+	
+	// Event listeners
+	
+	private List<SettingsListener> listeners = new LinkedList<SettingsListener>();
+	
+
+	public PGFWrapper(PGF pgf, SettingsListener listener) {
+		this.pgf = pgf;
+		addSettingsListener(listener);
+		updateAvailableGrammars();
+	}
+
+	protected void updateAvailableGrammars() {
+		pgf.listGrammars(new PGF.GrammarNamesCallback() {
+			public void onResult(PGF.GrammarNames grammarNames) {
+				grammars = new ArrayList<String>();
+				for (PGF.GrammarName grammarName : grammarNames.iterable()) {
+					grammars.add(grammarName.getName());
+				}
+				fireAvailableGrammarsChanged();
+			}
+			public void onError (Throwable e) {
+				fireSettingsError("Error getting grammar list", e);
+			}
+		});
+	}
+	
+	protected void updateSelectedGrammar () {
+		clearCachedInfo();
+		pgf.grammar(pgfName, new PGF.GrammarCallback() {
+			public void onResult(PGF.Grammar grammar) {
+				userLanguage = grammar.getUserLanguage();
+				languages = new LinkedHashMap<String,PGF.Language>();
+				parseableLanguages = new ArrayList<String>();
+				for (PGF.Language l : grammar.getLanguages().iterable()) {
+					String name = l.getName();
+					languages.put(name, l);
+					if (l.canParse()) {
+						parseableLanguages.add(name);
+					}
+				}
+				fireAvailableLanguagesChanged();
+			}
+
+			public void onError (Throwable e) {
+				fireSettingsError("Error getting language information", e);
+			}
+		});
+	}
+
+	//
+	// PGF functionality
+	//
+	
+	public JSONRequest translate (String input, final PGF.TranslateCallback callback) {
+		return pgf.translate(pgfName, input, inputLanguage, cat, outputLanguage, callback);
+	}
+
+	public JSONRequest complete (String input, int limit, final PGF.CompleteCallback callback) {
+		return pgf.complete(pgfName, input, inputLanguage, cat, limit, callback);
+	}
+
+	public JSONRequest parse (String input, final PGF.ParseCallback callback) {
+		return pgf.parse(pgfName, input, inputLanguage, cat, callback);
+	}
+
+	//
+	// Settings
+	//
+	
+	public String getPGFName() {
+		return pgfName;
+	}
+
+	public void setPGFName(String pgfName) {
+		this.pgfName = pgfName;
+		this.inputLanguage = null;
+		this.outputLanguage = null;
+		this.cat = null;
+		updateSelectedGrammar();
+	}
+
+	public String getInputLanguage() {
+		return inputLanguage;
+	}
+
+	public void setInputLanguage(String inputLanguage) {
+		this.inputLanguage = inputLanguage;
+		fireInputLanguageChanged();
+	}
+
+	public String getOutputLanguage() {
+		return outputLanguage;
+	}
+
+	public void setOutputLanguage(String outputLanguage) {
+		this.outputLanguage = outputLanguage;
+		fireOutputLanguageChanged();
+	}
+
+	public String getCat() {
+		return cat;
+	}
+
+	public void setCat(String cat) {
+		this.cat = cat;
+		fireCatChanged();
+	}
+	
+	
+	//
+	// Information about the available grammars
+	//
+	
+	public List<String> getGrammars() {
+		return grammars;
+	}
+	
+	//
+	// Information about the selected grammar
+	//
+	
+	private void clearCachedInfo () {
+		languages = null;
+		parseableLanguages = null;
+	}
+	
+	public String getUserLanguage () {
+		return userLanguage;
+	}
+	
+	public String getLanguageCode (String language) {
+		PGF.Language l = languages.get(language);
+		return l == null ? null : l.getLanguageCode();
+	}
+
+	public Collection<String> getParseableLanguages() {
+		return parseableLanguages;
+	}
+	
+	public Collection<String> getAllLanguages() {
+		return languages.keySet();
+	}
+	
+	//
+	// Listeners
+	//
+	
+	public interface SettingsListener {
+		public void onAvailableGrammarsChanged();
+		public void onAvailableLanguagesChanged();
+		public void onInputLanguageChanged();
+		public void onOutputLanguageChanged();
+		public void onCatChanged();
+		public void onSettingsError(String msg, Throwable e);
+	}
+	
+	public static class SettingsAdapter implements SettingsListener {
+		public void onAvailableGrammarsChanged() {}
+		public void onAvailableLanguagesChanged() {}
+		public void onInputLanguageChanged() {}
+		public void onOutputLanguageChanged() {}
+		public void onCatChanged() {}
+		public void onSettingsError(String msg, Throwable e) {}
+	}
+
+	public void addSettingsListener(SettingsListener listener) {
+		listeners.add(listener);
+	}
+
+	protected void fireAvailableGrammarsChanged() {
+		for (SettingsListener listener : listeners) {
+			listener.onAvailableGrammarsChanged();
+		}
+	}
+
+	protected void fireAvailableLanguagesChanged() {
+		for (SettingsListener listener : listeners) {
+			listener.onAvailableLanguagesChanged();
+		}
+	}
+
+	protected void fireInputLanguageChanged() {
+		for (SettingsListener listener : listeners) {
+			listener.onInputLanguageChanged();
+		}
+	}
+	
+	protected void fireOutputLanguageChanged() {
+		for (SettingsListener listener : listeners) {
+			listener.onOutputLanguageChanged();
+		}
+	}
+	
+	protected void fireCatChanged() {
+		for (SettingsListener listener : listeners) {
+			listener.onCatChanged();
+		}
+	}
+	
+	protected void fireSettingsError(String msg, Throwable e) {
+		for (SettingsListener listener : listeners) {
+			listener.onSettingsError(msg, e);
+		}
+	}
+	
+}

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/SettingsPanel.java

@@ -1,8 +1,5 @@
 package se.chalmers.cs.gf.gwt.client;
 
-import java.util.LinkedList;
-import java.util.List;
-
 import com.google.gwt.user.client.ui.ChangeListener;
 import com.google.gwt.user.client.ui.Composite;
 import com.google.gwt.user.client.ui.HorizontalPanel;
@@ -11,143 +8,101 @@ import com.google.gwt.user.client.ui.Widget;
 
 public class SettingsPanel extends Composite {
 
-	private PGF pgf;
-	private PGF.Grammar grammar;
+	private PGFWrapper pgf;
 
-	private GrammarBox grammarBox;
-	private InputLanguageBox fromLangBox;
-	private OutputLanguageBox toLangBox;
+	private MyListBox grammarBox;
+	private MyListBox fromLangBox;
+	private MyListBox toLangBox;
 
-	private List<SettingsListener> listeners = new LinkedList<SettingsListener>();
+	public SettingsPanel (PGFWrapper pgf) {
+		this(pgf, true, true);
+	}
 
-	public SettingsPanel (PGF pgf) {
+	public SettingsPanel (PGFWrapper pgf, boolean showPGFName, boolean showOutputLanguage) {
 		this.pgf = pgf;
-
-		grammarBox = new GrammarBox();
-		grammarBox.addChangeListener(new ChangeListener() {
-			public void onChange(Widget sender) {
-				updateSelectedGrammar();
-			}
-		});
-
-		ChangeListener languageChangeListener = new ChangeListener() {
-			public void onChange(Widget sender) {
-				updateSelectedLanguages();
-			}
-		};
-
-		fromLangBox = new InputLanguageBox();
-		fromLangBox.addChangeListener(languageChangeListener);
-
-		toLangBox = new OutputLanguageBox();
-		toLangBox.addChangeListener(languageChangeListener);
-
+		
 		HorizontalPanel settingsPanel = new HorizontalPanel();
 		settingsPanel.setVerticalAlignment(HorizontalPanel.ALIGN_MIDDLE);
-		settingsPanel.add(new Label("Grammar:"));
-		settingsPanel.add(grammarBox);
+
+		if (showPGFName) {
+			grammarBox = new MyListBox();
+			grammarBox.addChangeListener(new ChangeListener() {
+				public void onChange(Widget sender) {
+					SettingsPanel.this.pgf.setPGFName(grammarBox.getSelectedValue());
+				}
+			});
+			settingsPanel.add(new Label("Grammar:"));
+			settingsPanel.add(grammarBox);
+		}
+
+		fromLangBox = new MyListBox();
+		fromLangBox.addChangeListener(new ChangeListener() {
+			public void onChange(Widget sender) {
+				SettingsPanel.this.pgf.setInputLanguage(fromLangBox.getSelectedValue());
+			}
+		});
 		settingsPanel.add(new Label("From:"));
 		settingsPanel.add(fromLangBox);
-		settingsPanel.add(new Label("To:"));
-		settingsPanel.add(toLangBox);
+
+		if (showOutputLanguage) {
+			toLangBox = new MyListBox();
+			toLangBox.addChangeListener(new ChangeListener() {
+				public void onChange(Widget sender) {
+					SettingsPanel.this.pgf.setOutputLanguage(toLangBox.getSelectedValue());
+				}
+			});
+			settingsPanel.add(new Label("To:"));
+			settingsPanel.add(toLangBox);
+		}
 
 		initWidget(settingsPanel);
 		setStylePrimaryName("my-SettingsPanel");
+
+		pgf.addSettingsListener(new MySettingsListener());
 	}
 
-	public interface SettingsListener {
-		public void grammarChanged(String pgfName);
-		public void languagesChanged(String inputLang, String outputLang);
-		public void settingsError(String msg, Throwable e);
-	}
-
-	public void addSettingsListener(SettingsListener listener) {
-		listeners.add(listener);
-	}
-
-	void fireGrammarChanged() {
-		for (SettingsListener listener : listeners) {
-			listener.grammarChanged(getGrammarName());
+	private class MySettingsListener implements PGFWrapper.SettingsListener {
+		public void onAvailableGrammarsChanged() {
+			if (grammarBox != null) {
+				grammarBox.clear();
+				grammarBox.addItems(pgf.getGrammars());
+			}
 		}
-	}
-
-	void fireLanguagesChanged() {
-		for (SettingsListener listener : listeners) {
-			listener.languagesChanged(getInputLanguage(), getOutputLanguage());
+		public void onAvailableLanguagesChanged() {
+			if (grammarBox != null) {
+				grammarBox.setSelectedValue(pgf.getPGFName());
+			}
+			if (fromLangBox != null) {
+				fromLangBox.clear();
+				fromLangBox.addItem("Any language", "");
+				fromLangBox.addItems(pgf.getParseableLanguages());
+				String inputLanguage = pgf.getInputLanguage();
+				if (inputLanguage != null) {
+					fromLangBox.setSelectedValue(inputLanguage);
+				}
+			}
+			if (toLangBox != null) {
+				toLangBox.clear();
+				toLangBox.addItem("All languages", "");		
+				toLangBox.addItems(pgf.getAllLanguages());
+				String outputLanguage = pgf.getOutputLanguage();
+				if (outputLanguage != null) {
+					fromLangBox.setSelectedValue(outputLanguage);
+				}
+			}
 		}
-	}
-
-	void fireSettingsError(String msg, Throwable e) {
-		for (SettingsListener listener : listeners) {
-			listener.settingsError(msg, e);
+		public void onInputLanguageChanged() {
+			if (fromLangBox != null) {
+				fromLangBox.setSelectedValue(pgf.getInputLanguage());
+			}
 		}
-	}
-
-	//
-	// Grammars
-	//
-
-	public void updateAvailableGrammars() {
-		pgf.listGrammars(new PGF.GrammarNamesCallback() {
-			public void onResult(PGF.GrammarNames grammarNames) {
-				grammarBox.setGrammarNames(grammarNames);
-				// setGrammarNames() picks the first grammar automatically
-				updateSelectedGrammar();
+		public void onOutputLanguageChanged() {
+			if (toLangBox != null) {
+				toLangBox.setSelectedValue(pgf.getOutputLanguage());
 			}
-
-			public void onError (Throwable e) {
-				fireSettingsError("Error getting grammar list", e);
-			}
-		});
-	}
-
-	private void updateSelectedGrammar() {
-		fireGrammarChanged();
-		updateAvailableLanguages();
-	}
-
-	public PGF.Grammar getGrammar() {
-		return grammar;
-	}
-
-	public String getGrammarName() {
-		return grammarBox.getSelectedGrammar();
-	}
-
-
-	//
-	// Languages
-	//
-
-	public String getInputLanguage() {
-		return fromLangBox.getLanguage();
-	}	
-	
-	public String getOutputLanguage() {
-		return toLangBox.getLanguage();
-	}
-
-	public void setInputLanguage(String lang) {
-		fromLangBox.setLanguage(lang);
-	}
-	
-	private void updateAvailableLanguages() {
-		pgf.grammar(getGrammarName(), new PGF.GrammarCallback() {
-			public void onResult(PGF.Grammar grammar) {
-				SettingsPanel.this.grammar = grammar;
-				fromLangBox.setGrammar(grammar);
-				toLangBox.setGrammar(grammar);
-				updateSelectedLanguages();
-			}
-
-			public void onError (Throwable e) {
-				fireSettingsError("Error getting language information", e);
-			}
-		});	
-	}
-
-	private void updateSelectedLanguages() {
-		fireLanguagesChanged();
+		}
+		public void onCatChanged() { }
+		public void onSettingsError(String msg, Throwable e) { }
 	}
 
 }

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/SuggestPanel.java

@@ -8,22 +8,22 @@ import com.google.gwt.user.client.ui.Button;
 import com.google.gwt.user.client.ui.ClickListener;
 import com.google.gwt.user.client.ui.Composite;
 import com.google.gwt.user.client.ui.DockPanel;
+import com.google.gwt.user.client.ui.HasText;
 import com.google.gwt.user.client.ui.HasVerticalAlignment;
 import com.google.gwt.user.client.ui.KeyboardListenerAdapter;
 import com.google.gwt.user.client.ui.SuggestBox;
 import com.google.gwt.user.client.ui.Widget;
 
-public class SuggestPanel extends Composite {
+public class SuggestPanel extends Composite implements HasText {
 
-	private CompletionOracle oracle;
 	private SuggestBox suggest;
 	private Button submitButton;
 
 	private List<SubmitListener> listeners = new LinkedList<SubmitListener>();
 
-	public SuggestPanel (PGF pgf) {
+	public SuggestPanel (PGFWrapper pgf) {
 
-		oracle = new CompletionOracle(pgf, new CompletionOracle.ErrorHandler() {
+		CompletionOracle oracle = new CompletionOracle(pgf, new CompletionOracle.ErrorHandler() {
 			public void onError(Throwable e) {
 				GWT.log("Completion failed", e);
 			}
@@ -40,7 +40,6 @@ public class SuggestPanel extends Composite {
 		});
 
 		submitButton = new Button("Submit");
-		submitButton.setEnabled(false);
 		submitButton.addClickListener(new ClickListener() {
 			public void onClick(Widget sender) {
 				submit();
@@ -81,14 +80,6 @@ public class SuggestPanel extends Composite {
 		submitButton.setEnabled(enabled);
 	}
 
-	public void setGrammarName(String pgfName) {
-		oracle.setGrammarName(pgfName);
-	}
-
-	public void setInputLanguage(String inputLang) {
-		oracle.setInputLanguage(inputLang);
-	}
-
 	public void setLimit(int limit) {
 		suggest.setLimit(limit);
 	}

src/server/gwt/src/se/chalmers/cs/gf/gwt/client/TranslateApp.java

@@ -1,45 +1,61 @@
 package se.chalmers.cs.gf.gwt.client;
 
+import java.util.List;
+
 import com.google.gwt.core.client.EntryPoint;
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.History;
+import com.google.gwt.user.client.HistoryListener;
+import com.google.gwt.user.client.ui.HasText;
 import com.google.gwt.user.client.ui.Label;
 import com.google.gwt.user.client.ui.RootPanel;
 import com.google.gwt.user.client.ui.VerticalPanel;
+import com.google.gwt.user.client.ui.Widget;
 
 
 public class TranslateApp implements EntryPoint {
 
 	private static final String pgfBaseURL = "/pgf";
 
-	private PGF pgf;
+	protected PGFWrapper pgf;
 
-	private SuggestPanel suggestPanel;
-	private SettingsPanel settingsPanel;
-	private VerticalPanel outputPanel;
-	private StatusPopup statusPopup;
+	protected Widget translationUI;
 
+	protected HasText textSource;
+	protected VerticalPanel outputPanel;
+	protected StatusPopup statusPopup;
+
+	//
+	// Text
+	//
+	
+	public String getText () {
+		return textSource.getText();
+	}
+	
+	public void setText(String text) {
+		textSource.setText(text);
+		update();
+	}
+	
+	protected void update () {
+		translate();
+	}
+	
 	//
 	// Translation
 	//
-
-	private void translate() {
+	
+	protected void translate() {
 		outputPanel.clear();
-		setStatus("Translating...");
-		pgf.translate(settingsPanel.getGrammarName(), 
-					  suggestPanel.getText(), 
-					  settingsPanel.getInputLanguage(), null, 
-				      settingsPanel.getOutputLanguage(), 
-				      new PGF.TranslateCallback() {
+		outputPanel.addStyleDependentName("working");
+		pgf.translate(textSource.getText(), 
+				new PGF.TranslateCallback() {
 			public void onResult (PGF.Translations translations) {
+				outputPanel.removeStyleDependentName("working");
 				for (PGF.Translation t : translations.iterable()) {
-					Label l = new Label(t.getText());
-					l.addStyleName("my-translation");
-					PGF.Language lang = settingsPanel.getGrammar().getLanguage(t.getTo());
-					if (lang != null) {
-						l.getElement().setLang(lang.getLanguageCode());
-					}
-					outputPanel.add(l);
+					outputPanel.add(createTranslation(t.getTo(), t.getText()));
 				}
-				clearStatus();
 			}
 			public void onError (Throwable e) {
 				showError("Translation failed", e);
@@ -47,89 +63,161 @@ public class TranslateApp implements EntryPoint {
 		});
 	}
 
+	protected Widget createTranslation(String language, String text) {
+		Label l = new Label(text);
+		l.addStyleName("my-translation");
+		String lang = pgf.getLanguageCode(language);
+		if (lang != null) {
+			l.getElement().setLang(lang);
+		}
+		return l;
+	}
+
 	//
 	// Status stuff
 	//
 
-	private void setStatus(String msg) {
+	protected void setStatus(String msg) {
 		statusPopup.setStatus(msg);
 	}
 
-	private void showError(String msg, Throwable e) {
+	protected void showError(String msg, Throwable e) {
 		statusPopup.showError(msg, e);
 	}
 
-	private void clearStatus() {
+	protected void clearStatus() {
 		statusPopup.clearStatus();
 	}
-	
-	//
-	// Grammars and languages
-	//
-
-	private void updateSelectedGrammar() {
-		suggestPanel.setGrammarName(settingsPanel.getGrammarName());
-	}
-
-	private void updateSelectedLanguages() {
-		suggestPanel.setInputLanguage(settingsPanel.getInputLanguage());
-		suggestPanel.setEnabled(true);
-		clearStatus();
-		translate();
-	}
 
 	//
 	// GUI
 	//
 
-	private void createTranslationUI() {
+	protected Widget createTranslationUI() {
+		VerticalPanel vPanel = new VerticalPanel();
+		vPanel.setWidth("100%");
+		vPanel.setHorizontalAlignment(VerticalPanel.ALIGN_CENTER);
+		vPanel.add(createSuggestPanel());
+		vPanel.add(createSettingsPanel());
+		vPanel.add(createTranslationsPanel());
+		return vPanel;
+	}
 
-		statusPopup = new StatusPopup();
-		setStatus("Loading...");
-
-		suggestPanel = new SuggestPanel(pgf);
+	protected Widget createSuggestPanel () {
+		SuggestPanel suggestPanel = new SuggestPanel(pgf);
 		suggestPanel.setButtonText("Translate");
 		suggestPanel.addSubmitListener(new SuggestPanel.SubmitListener() {
 			public void onSubmit(String text) {
 				translate();
 			}
 		});
+		
+		textSource = suggestPanel;
+		
+		return suggestPanel;
+	}
 
-		settingsPanel = new SettingsPanel(pgf);
-		settingsPanel.addSettingsListener(new SettingsPanel.SettingsListener() {
-			public void grammarChanged(String pgfName) {
-				updateSelectedGrammar();
-			}
-			public void languagesChanged(String inputLang, String outputLang) {
-				updateSelectedLanguages();
-			}
-			public void settingsError(String msg, Throwable e) {
-				showError(msg,e);
-			}
-		});
+	protected Widget createSettingsPanel () {
+		return new SettingsPanel(pgf);
+	}
 
+	protected Widget createTranslationsPanel () {
 		outputPanel = new VerticalPanel();
 		outputPanel.addStyleName("my-translations");
+		return outputPanel;
+	}
 
-		VerticalPanel vPanel = new VerticalPanel();
-		vPanel.setWidth("100%");
-		vPanel.setHorizontalAlignment(VerticalPanel.ALIGN_CENTER);
-		vPanel.add(suggestPanel);
-		vPanel.add(settingsPanel);
-		vPanel.add(outputPanel);
+	protected Widget createLoadingWidget () {
+		VerticalPanel loadingPanel = new VerticalPanel();
+		loadingPanel.setHorizontalAlignment(VerticalPanel.ALIGN_CENTER);
+		loadingPanel.add(new Label("Loading..."));
+		return loadingPanel;
+	}
+	
+	//
+	// History stuff
+	//
+	
+	private HistoryListener historyListener = new HistoryListener() {
+		public void onHistoryChanged(String historyToken) {
+			updateSettingsFromHistoryToken();
+		}
+	};
 
-		RootPanel.get().add(vPanel);
+	protected void updateSettingsFromHistoryToken() {
+		updateSettingsFromHistoryToken(History.getToken().split("/"));
+	}
+	
+	protected void updateSettingsFromHistoryToken(String[] tokenParts) {
+		if (tokenParts.length >= 1 && tokenParts[0].length() > 0) {
+			setPGFName(tokenParts[0]);
+		}
+		if (tokenParts.length >= 2 && tokenParts[1].length() > 0) {
+			setInputLanguage(tokenParts[1]);
+		}
+	}
 
+	protected void setPGFName (String pgfName) {
+		if (pgfName != null && !pgfName.equals(pgf.getPGFName())) {
+			pgf.setPGFName(pgfName);
+		}
+	}
+
+	protected void setInputLanguage (String inputLanguage) {
+		if (inputLanguage != null && !inputLanguage.equals(pgf.getInputLanguage())) {
+			pgf.setInputLanguage(inputLanguage);	
+		}
 	}
 
 	//
 	// Initialization
 	//
 
+	protected class MySettingsListener implements PGFWrapper.SettingsListener {
+		// Will only happen on load
+		public void onAvailableGrammarsChanged() {
+			if (pgf.getPGFName() == null) {
+				List<String> grammars = pgf.getGrammars();
+				if (!grammars.isEmpty()) {
+					pgf.setPGFName(grammars.get(0));
+				}
+			}			
+			RootPanel.get().clear();
+			RootPanel.get().add(translationUI);
+		}
+		public void onAvailableLanguagesChanged() {
+			if (pgf.getInputLanguage() == null) {
+				GWT.log("Setting input language to user language: " + pgf.getUserLanguage(), null);
+				pgf.setInputLanguage(pgf.getUserLanguage());
+			}
+			update();
+		}
+		public void onInputLanguageChanged() {
+			update();
+		}
+		public void onOutputLanguageChanged() {
+			update();
+		}
+		public void onCatChanged() {
+			update();
+		}
+		public void onSettingsError(String msg, Throwable e) {
+			showError(msg,e);
+		}
+	}
+
 	public void onModuleLoad() {
-		pgf = new PGF(pgfBaseURL);
-		createTranslationUI();
-		settingsPanel.updateAvailableGrammars();
+		statusPopup = new StatusPopup();
+
+		RootPanel.get().add(createLoadingWidget());
+
+		pgf = new PGFWrapper(new PGF(pgfBaseURL), new MySettingsListener());
+
+		translationUI = createTranslationUI();
+
+		History.addHistoryListener(historyListener);
+
+		updateSettingsFromHistoryToken();
 	}
 
 }