Add oxford

Signed-off-by: Hiroshi Miura <miurahr@linux.com>

build.gradle.kts

@@ -100,10 +100,13 @@ dependencies {
     implementation("io.github.eb4j:mdict4j:0.2.0")
     implementation("org.jsoup:jsoup:1.14.3")
 
+    // for oxford-api
+    implementation("tokyo.northside:java-oxford-dictionaries:0.3.1")
+
     // for video replay
     implementation("uk.co.caprica:vlcj:4.7.1")
 
-    implementation("com.formdev:flatlaf:1.6.4")
+    implementation("com.formdev:flatlaf:1.6.5")
 
     // for projector support
     implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))

src/main/java/io/github/eb4j/ebview/dictionary/DictionariesManager.java

@@ -20,6 +20,7 @@
 
 import io.github.eb4j.ebview.data.DictionaryEntry;
 import io.github.eb4j.ebview.data.IDictionary;
+import io.github.eb4j.ebview.dictionary.oxford.OxfordDriver;
 import io.github.eb4j.ebview.utils.Stemmer;
 import io.github.eb4j.ebview.utils.FileUtils;
 import org.slf4j.Logger;
@@ -55,6 +56,7 @@ public DictionariesManager() {
         factories.add(new StarDict());
         factories.add(new PDic());
         factories.add(new MDict());
+        dictionaries.add(new OxfordDriver());
         stemmer = new Stemmer();
     }
 

src/main/java/io/github/eb4j/ebview/dictionary/oxford/HTMLFormatter.java

@@ -0,0 +1,84 @@
+package io.github.eb4j.ebview.dictionary.oxford;
+
+import io.github.eb4j.ebview.data.DictionaryEntry;
+import tokyo.northside.oxfordapi.dtd.Entry;
+import tokyo.northside.oxfordapi.dtd.Example;
+import tokyo.northside.oxfordapi.dtd.LexicalEntry;
+import tokyo.northside.oxfordapi.dtd.Pronunciation;
+import tokyo.northside.oxfordapi.dtd.Sense;
+import tokyo.northside.oxfordapi.dtd.Translation;
+
+import java.util.List;
+
+public final class HTMLFormatter {
+
+    private HTMLFormatter() {
+    }
+
+    public static DictionaryEntry formatTranslations(final LexicalEntry lexicalEntry) {
+        String title = lexicalEntry.getText();
+        StringBuilder sb = new StringBuilder("<ol>");
+        for (Entry entry : lexicalEntry.getEntries()) {
+            for (Sense sense : entry.getSenses()) {
+                if (sense.getTranslations() == null) {
+                    continue;
+                }
+                for (Translation translation : sense.getTranslations()) {
+                    sb.append("<li>").append(translation.getText()).append("</li>");
+                }
+            }
+        }
+        sb.append("</ol>");
+        return new DictionaryEntry(title, sb.toString(), "oxford");
+    }
+
+    public static DictionaryEntry formatDefinitions(final LexicalEntry lexicalEntry) {
+        String title = lexicalEntry.getText();
+        String category = lexicalEntry.getLexicalCategory().getText();
+        StringBuilder sb = new StringBuilder("[").append(category).append("]&nbsp;");
+        for (Entry entry : lexicalEntry.getEntries()) {
+            List<Pronunciation> pronunciations = entry.getPronunciations();
+            if (pronunciations != null) {
+                sb.append("<span>");
+                for (Pronunciation pron: pronunciations) {
+                    if (pron.getAudioFile() != null) {
+                        sb.append("<a href=\"").append(pron.getAudioFile()).append("\">");
+                    }
+                    sb.append("[").append(pron.getPhoneticSpelling()).append("]");
+                    if (pron.getAudioFile() != null) {
+                        sb.append("</a>");
+                    }
+                }
+                sb.append("</span>&nbsp;");
+            }
+            List<String> etymologies = entry.getEtymologies();
+            if (etymologies != null) {
+                sb.append("<span>");
+                for (String etymology : etymologies) {
+                    sb.append(etymology);
+                }
+                sb.append("</span>");
+            }
+            sb.append("<ol>");
+            for (Sense sense : entry.getSenses()) {
+                if (sense.getDefinitions() == null) {
+                    continue;
+                }
+                for (String text : sense.getDefinitions()) {
+                    sb.append("<li>").append(text).append("</li>");
+                }
+
+                List<Example> examples = sense.getExamples();
+                if (examples != null) {
+                    sb.append("<ul>");
+                    for (Example ex : examples) {
+                        sb.append("<li>").append(ex.getText()).append("</li>");
+                    }
+                    sb.append("</ul>");
+                }
+            }
+            sb.append("</ol>");
+        }
+        return new DictionaryEntry(title, sb.toString(), "oxford");
+    }
+}

src/main/java/io/github/eb4j/ebview/dictionary/oxford/OxfordDriver.java

@@ -0,0 +1,79 @@
+package io.github.eb4j.ebview.dictionary.oxford;
+
+import io.github.eb4j.ebview.data.DictionaryEntry;
+import io.github.eb4j.ebview.data.IDictionary;
+import tokyo.northside.oxfordapi.OxfordClient;
+import tokyo.northside.oxfordapi.OxfordClientException;
+import tokyo.northside.oxfordapi.dtd.LexicalEntry;
+import tokyo.northside.oxfordapi.dtd.Result;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class OxfordDriver implements IDictionary {
+
+    private final OxfordClient client;
+    private final String source;
+    private static final String APPID = "";  // FIXME
+    private static final String APPKEY = "";  // FIXME: add GUI to set and store encrypted
+    private final Map<String, List<DictionaryEntry>> cache = new HashMap<>();
+
+    public OxfordDriver() {
+        source = "en-gb";
+        client = new OxfordClient(APPID, APPKEY);
+    }
+
+    @Override
+    public String getDictionaryName() {
+        return "Oxford Dictionaries";
+    }
+
+    /**
+     * Read article's text.
+     *
+     * @param word The word to look up in the dictionary
+     * @return List of entries. May be empty, but cannot be null.
+     */
+    @Override
+    public List<DictionaryEntry> readArticles(final String word) {
+        return queryArticle(word, true);
+    }
+
+    /**
+     * Read article's text. Matching is predictive, so e.g. supplying "term"
+     * will return articles for "term", "terminology", "termite", etc.
+     *
+     * @param word The word to look up in the dictionary
+     * @return List of entries. May be empty, but cannot be null.
+     */
+    @Override
+    public List<DictionaryEntry> readArticlesPredictive(final String word) {
+        return queryArticle(word, false);
+    }
+
+    private List<DictionaryEntry> queryArticle(final String word, final boolean strict) {
+        if (!cache.containsKey(word)) {
+            List<DictionaryEntry> dictionaryEntries = new ArrayList<>();
+            try {
+                for (Result result: client.queryEntry(word, source, strict)) {
+                    for (LexicalEntry lexicalEntry : result.getLexicalEntries()) {
+                        dictionaryEntries.add(HTMLFormatter.formatDefinitions(lexicalEntry));
+                    }
+                }
+            } catch (OxfordClientException oce) {
+                // when got connection/query error, return without any content.
+                return Collections.emptyList();
+            }
+            cache.put(word, dictionaryEntries);
+        }
+        return cache.get(word);
+    }
+
+
+    @Override
+    public void close() {
+    }
+}