* Add a Help screen and two topics: kanji input by component and romaji input.

* Add a button for direct help access on radical input.

* Application can now download dictionaries from Wadoku.

### Translations

import androidx.appcompat.widget.Toolbar;

import androidx.preference.PreferenceManager;

import android.view.View;

import android.view.Menu;

import android.view.MenuItem;

    private static ArrayList<Result> savedResults;

    private RadicalSelectorView radical_selector;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

            FuriganaTextView kanji_view = child_result.findViewById(R.id.kanji_view);

            LinearLayout senses_view = child_result.findViewById(R.id.sense_view);

            TextView additional_info = child_result.findViewById(R.id.additional_info_view);

            // Populate the data into the template view using the data object

            kanji_view.setFuriganaText(result.getKanjiFurigana());

            StringBuilder additional = new StringBuilder();

            boolean separator = false;

            for (String s : result.getAlternatives()) {

    private static void augment(Result r) throws IncompatibleFormatException {

        for(Dictionary d: dictionaries) {

            if(d instanceof ResultAugmenterDictionary && d.isDownloaded()) {

                ((ResultAugmenterDictionary) d).augment(r);

            }

        }

                    String expected = readSha256FromFile(sha256);

                    // If the file has the expected hash, we have it

                    return expected.compareTo(hash) == 0;

                } catch (FileNotFoundException e) {

                    e.printStackTrace();

            return new HuffmanTree(left, right);

        } else if (b == 0) {

            return new HuffmanValue("");

        } else {

            ArrayList<Byte> bs = new ArrayList<>();

        while(c == null || !c.isEmpty()) {

            if(h instanceof ResultDictionary.HuffmanValue) {

                c = ((ResultDictionary.HuffmanValue) h).character;

                b.append(c);

                h = huffman;

            } else if(h instanceof ResultDictionary.HuffmanTree) {

                if(bits.isEmpty()) {

                    byte by = file.readByte();

                    for(int i = 7; i>-1; i--) {

                        bits.add((by&(1<<i))!=0);

                    }

                }

                Boolean bo = bits.get(0);

    }

    static void logHuffman(Huffman h, ArrayList<Boolean> address) {

            ArrayList<Boolean> address_l = new ArrayList<>(address);

            address_l.add(false);

            ArrayList<Boolean> address_r = new ArrayList<>(address);

    static ArrayList<String> getHuffmanStringList(RandomAccessFile file, Huffman huffman) throws IOException {

        ArrayList<String> results = new ArrayList<>();

        int number = file.readShort();

        for(int i=0; i<number; i++) {

            results.add(getHuffmanString(file, huffman));

        }

        }

        int valuesLength = file.readShort();

        file.skipBytes(valuesLength * 4);

        int transitionLength = file.readByte();

        for(int i = 0; i < transitionLength; i++) {

            byte letter = file.readByte();

            if(letter == txt[0]) {

                byte[] ntxt = new byte[txt.length-1];

                System.arraycopy(txt, 1, ntxt, 0, txt.length-1);

                return searchTrie(file, file.readInt(), ntxt, decoder);

    private Result getValue(RandomAccessFile file, long pos) throws IOException {

        file.seek(pos);

        ArrayList<String> kanjis = getHuffmanStringList(file, kanjiHuffman);

        ArrayList<Result.Reading> readings = new ArrayList<>();

        int reading_number = file.readShort();

        for(int i=0; i<reading_number; i++) {

            ArrayList<String> reading_kanjis = getStringList(file);

            ArrayList<String> reading_infos = getStringList(file);

            ArrayList<String> reading_readings = getHuffmanStringList(file, readingHuffman);

            Result.Reading r = new Result.Reading(reading_kanjis, reading_infos, reading_readings);

            readings.add(r);

        ArrayList<Result.Sense> senses = new ArrayList<>();

        int meaning_number = file.readShort();

        for(int i=0; i<meaning_number; i++) {

            ArrayList<String> sense_references = getStringList(file);

            ArrayList<String> sense_limits = getStringList(file);

    private ArrayList<Integer> getValues(RandomAccessFile file, long triePos) throws IOException {

        file.seek(triePos);

        int valuesLength = file.readShort();

        ArrayList<Integer> results = new ArrayList<>();

        for(int i=0; i<valuesLength; i++) {

            results.add(file.readInt());

        }

        int transitionLength = file.readByte();

        int[] others = new int[transitionLength];

        for(int i=0; i<transitionLength; i++) {

            file.skipBytes(1);

            results.addAll(getValues(file, others[i]));

        }

        return results;

    }

                long meaningTriePos = file.readInt();

                Log.d(TAG, "Search in: " + getFile());

                kanjiHuffman = loadHuffman(file);

                readingHuffman = loadHuffman(file);

                }

                Arrays.sort(uniqResultsArray);

                int num = 0;

                for(int i: uniqResultsArray) {

class WadokuPitchDictionary extends ResultAugmenterDictionary {

    private static final String TAG = "PITCH";

    private long triePos;

    WadokuPitchDictionary(String name, String description, String fullDescription, File cacheDir, String url, int fileSize, int entries, String hash) {

    void augment(Result r) throws IncompatibleFormatException {

        try {

            RandomAccessFile file = new RandomAccessFile(getFile(), "r");

            List<String> kanjis = r.getAlternatives();

            for(String k: kanjis) {

                String pitch = findPitch(k, file);

                if(pitch != null) {

                    r.addPitch(k, pitch);

                }

            }

import android.util.Log;

import java.util.ArrayList;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

        return reading;

    }

    public String getKanjiFurigana() {

        String txt = getKanji();

        String reading = getReading();

        // split the text into kanji / not kanji portions

        ArrayList<String> portions = new ArrayList<>();

        }

        current.append("$");

        Pattern p = Pattern.compile(current.toString());

        Matcher m = p.matcher(reading);

        if(!m.matches()) {

            return txt;

        }

        // We have a match!

        current = new StringBuilder();

        int group = 1;

                current.append(s);

            }

        }

        return current.toString();

    }

        app:contains_ruby_tags="true"

        android:textSize="@dimen/title_size" />

    <LinearLayout

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"