From 294309f2e07aef352523cb89c87dd2b3ac3b7a70 Mon Sep 17 00:00:00 2001 From: bjorn Date: Wed, 5 Nov 2008 16:36:52 +0000 Subject: [PATCH] GWT: big refactoring of the translator and fridge apps. --- .../cs/gf/gwt/client/CompletionOracle.java | 38 +-- .../chalmers/cs/gf/gwt/client/FridgeApp.java | 243 ++++++------------ .../chalmers/cs/gf/gwt/client/GrammarBox.java | 26 -- .../cs/gf/gwt/client/InputLanguageBox.java | 39 --- .../cs/gf/gwt/client/MultiListBox.java | 34 --- .../chalmers/cs/gf/gwt/client/MyListBox.java | 40 +++ .../cs/gf/gwt/client/OutputLanguageBox.java | 33 --- .../src/se/chalmers/cs/gf/gwt/client/PGF.java | 10 - .../chalmers/cs/gf/gwt/client/PGFWrapper.java | 239 +++++++++++++++++ .../cs/gf/gwt/client/SettingsPanel.java | 201 ++++++--------- .../cs/gf/gwt/client/SuggestPanel.java | 17 +- .../cs/gf/gwt/client/TranslateApp.java | 220 +++++++++++----- 12 files changed, 607 insertions(+), 533 deletions(-) delete mode 100644 src/server/gwt/src/se/chalmers/cs/gf/gwt/client/GrammarBox.java delete mode 100644 src/server/gwt/src/se/chalmers/cs/gf/gwt/client/InputLanguageBox.java delete mode 100644 src/server/gwt/src/se/chalmers/cs/gf/gwt/client/MultiListBox.java create mode 100644 src/server/gwt/src/se/chalmers/cs/gf/gwt/client/MyListBox.java delete mode 100644 src/server/gwt/src/se/chalmers/cs/gf/gwt/client/OutputLanguageBox.java create mode 100644 src/server/gwt/src/se/chalmers/cs/gf/gwt/client/PGFWrapper.java diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/CompletionOracle.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/CompletionOracle.java index 259a3fe88..52d0e387a 100644 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/CompletionOracle.java +++ b/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 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.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; diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/FridgeApp.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/FridgeApp.java index fde06f978..c03fd4544 100644 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/FridgeApp.java +++ b/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(); } } diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/GrammarBox.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/GrammarBox.java deleted file mode 100644 index 50b375b55..000000000 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/GrammarBox.java +++ /dev/null @@ -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); - } - -} diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/InputLanguageBox.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/InputLanguageBox.java deleted file mode 100644 index e2526196d..000000000 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/InputLanguageBox.java +++ /dev/null @@ -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); - } - -} \ No newline at end of file diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/MultiListBox.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/MultiListBox.java deleted file mode 100644 index fafdf2646..000000000 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/MultiListBox.java +++ /dev/null @@ -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 getSelectedValues() { - int c = getItemCount(); - List l = new ArrayList(); - for (int i = 0; i < c; i++) { - if (isItemSelected(i)) { - l.add(getValue(i)); - } - } - return l; - } - - public void setSelectedValues(List values) { - Set vs = new HashSet(values); - int c = getItemCount(); - for (int i = 0; i < c; i++) { - setItemSelected(i, vs.contains(getValue(i))); - } - } - -} \ No newline at end of file diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/MyListBox.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/MyListBox.java new file mode 100644 index 000000000..95d834ae0 --- /dev/null +++ b/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 items) { + for (String item : items) { + addItem(item); + } + } + +} diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/OutputLanguageBox.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/OutputLanguageBox.java deleted file mode 100644 index a02990ea1..000000000 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/OutputLanguageBox.java +++ /dev/null @@ -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); - } - -} \ No newline at end of file diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/PGF.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/PGF.java index 50898552e..3e1be9a7c 100644 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/PGF.java +++ b/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 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 { diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/PGFWrapper.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/PGFWrapper.java new file mode 100644 index 000000000..4ba8f69f8 --- /dev/null +++ b/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 grammars; + + // Cached info about the currently selected grammar + + private String userLanguage; + + private LinkedHashMap languages; + + private List parseableLanguages; + + // Event listeners + + private List listeners = new LinkedList(); + + + 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(); + 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(); + parseableLanguages = new ArrayList(); + 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 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 getParseableLanguages() { + return parseableLanguages; + } + + public Collection 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); + } + } + +} \ No newline at end of file diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/SettingsPanel.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/SettingsPanel.java index 4b0553e16..40233b004 100644 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/SettingsPanel.java +++ b/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 listeners = new LinkedList(); + 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) { } } } diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/SuggestPanel.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/SuggestPanel.java index ed3b8d42d..fea44c820 100644 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/SuggestPanel.java +++ b/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 listeners = new LinkedList(); - 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); } diff --git a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/TranslateApp.java b/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/TranslateApp.java index f26e18466..6d3be2f43 100644 --- a/src/server/gwt/src/se/chalmers/cs/gf/gwt/client/TranslateApp.java +++ b/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 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(); } }