Added Kanji JIS spec to FC18 maisdoc

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocWriter.java

@@ -23,7 +23,9 @@
 package love.distributedrebirth.nx01.mushroom.mais.fc18;
 
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
@@ -42,6 +44,15 @@ import org.x4o.maisdoc.model.MaisDocConcept;
 import org.x4o.maisdoc.model.MaisDocNode;
 import org.xml.sax.SAXException;
 
+import love.distributedrebirth.nx01.mushroom.mais.fc18.kanji.KanjiDict;
+import love.distributedrebirth.nx01.mushroom.mais.fc18.kanji.KanjiDictLiteral;
+import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocPageWriterBaklava;
+import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocPageWriterMuffin;
+import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocSegmentWriterCake;
+import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocSegmentWriterCakeSlice;
+import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocSegmentWriterCakeWord;
+import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocSegmentWriterKanjiDictLiteral;
+
 /**
  * Cake doc writer.
  * 
@@ -54,14 +65,18 @@ public class FCDocWriter {
 	private static final String[] C_FC_TOWER		= {"fc-tower","Tower","All cake slices.","The cake slices of the four corner cake tower."};
 	private static final String[] C_FC_SLICE		= {"fc-slice","Cake","The cake slice information.","The four corner cake slice provides the layout of boundries."};
 	private static final String[] C_FC_WORD			= {"fc-word","Word","An FC18 word.","The word of an number."};
+	private static final String[] C_FC_KD			= {"fc-kd","Kanji","An kanji spec.","The format spec of kanji."};
+	private static final String[] C_FC_KDL			= {"fc-kdl","Kanji Literal","An kanji literal.","The kanji defined literal."};
 	
 	private MaisDocGenerator writer = null;
 	private MaisDoc doc = null;
+	private KanjiDict kanjiDict = null;
 	
 	static public void main(String[] args) {
 		Iterator<String> arguments = Arrays.asList(args).iterator();
 		String outputFolder = null;
 		Integer stopCakePoint = null;
+		KanjiDict kanjiDictArgu = null;
 		while (arguments.hasNext()) {
 			String arg = arguments.next();
 			if ("-output".equals(arg)) {
@@ -81,6 +96,21 @@ public class FCDocWriter {
 				String stopNum = arguments.next();
 				stopCakePoint = Integer.parseInt(stopNum);
 			}
+			if ("-kanji".equals(arg)) {
+				if (!arguments.hasNext()) {
+					System.err.println("No kanji file argument given.");
+					System.exit(1);
+					return;
+				}
+				kanjiDictArgu = new KanjiDict();
+				try (InputStream in = new FileInputStream(new File(arguments.next()))) {
+					kanjiDictArgu.parseXML(in);
+					System.out.println("Parsed kanji, mapKuTen208=" + kanjiDictArgu.mapKuTen208().size());
+				} catch (Exception e) {
+					e.printStackTrace();
+					System.exit(1);
+				}
+			}
 		}
 		if (outputFolder == null) {
 			System.err.println("Missing output argument");
@@ -91,7 +121,7 @@ public class FCDocWriter {
 		if (stopCakePoint != null) {
 			System.out.println("Writing fcdoc, stop requested at: " +  stopCakePoint);
 		}
-		FCDocWriter run = new FCDocWriter(stopCakePoint);
+		FCDocWriter run = new FCDocWriter(stopCakePoint, kanjiDictArgu);
 		try {
 			File out = new File(outputFolder);
 			//out.mkdir();
@@ -102,7 +132,8 @@ public class FCDocWriter {
 		System.out.println("Writing fcdoc, DONE");
 	}
 	
-	public FCDocWriter(Integer stopCakePoint) {
+	public FCDocWriter(Integer stopCakePoint, KanjiDict kanjiDict) {
+		this.kanjiDict = kanjiDict;
 		this.doc = buildApiDoc(new TDocCake(), stopCakePoint);
 		this.writer = new MaisDocGenerator();
 	}
@@ -132,22 +163,27 @@ public class FCDocWriter {
 		doc.setGroupTypeName("overview", "Overview",2);
 		
 		doc.addTreeNodeClassExclude(TDocCakeWord.class);
+		doc.addTreeNodeClassExclude(KanjiDictLiteral.class);
 		doc.setFrameNavConceptClass(TDocCakeSlice.class);
 		
 		doc.addTreeNodePageModeClass(TDocCake.class);
 		doc.addTreeNodePageModeClass(TDocCakeTower.class);
+		doc.addTreeNodePageModeClass(KanjiDict.class);
 		
 		doc.addAnnotatedClasses(FCDocSegmentWriterCake.class);
 		doc.addAnnotatedClasses(FCDocSegmentWriterCakeWord.class);
 		doc.addAnnotatedClasses(FCDocSegmentWriterCakeSlice.class);
+		doc.addAnnotatedClasses(FCDocSegmentWriterKanjiDictLiteral.class);
 		
 		MaisDocConcept adc1 = doc.addConcept(new MaisDocConcept(null,C_FC_ROOT,TDocCake.class));
 		MaisDocConcept adc2 = doc.addConcept(new MaisDocConcept(adc1,C_FC_TOWER,TDocCakeTower.class));
 		MaisDocConcept adc3 = doc.addConcept(new MaisDocConcept(adc2,C_FC_SLICE,TDocCakeSlice.class));
 		/*ApiDocConcept adc4 = */doc.addConcept(new MaisDocConcept(adc3,C_FC_WORD,TDocCakeWord.class));
 		
-		//ApiDocConcept adc4 = doc.addConcept(new ApiDocConcept(adc3,C_TABLE,Table.class));
+		MaisDocConcept kanjiDoc = new MaisDocConcept(adc1,C_FC_KD,KanjiDict.class);
-		//adc4.addChildConcepts(new ApiDocConcept(adc4, CC_RS, Relationship.class));
+		MaisDocConcept kanjiDocLit = new MaisDocConcept(adc1,C_FC_KDL,KanjiDictLiteral.class);
+		adc1.addChildConcept(kanjiDoc);
+		adc1.addChildConcept(kanjiDocLit);
 		
 		doc.addDocPage(FCDocPageWriterMuffin.createDocPage());
 		doc.addDocPage(FCDocPageWriterBaklava.createDocPage());
@@ -172,9 +208,39 @@ public class FCDocWriter {
 				// TODO: print full 21 bit unicode range too
 			}
 		}
+		if (kanjiDict != null) {
+			MaisDocNode kanjiDictNode208 = rootNode.addNode(createNodeKanjiDict("208"));
+			for (KanjiDictLiteral literal : kanjiDict.mapKuTen208Sorted()) {
+				kanjiDictNode208.addNode(createNodeKanjiDictLiteral(literal, true));
+			}
+			MaisDocNode kanjiDictNode213 = rootNode.addNode(createNodeKanjiDict("213"));
+			for (KanjiDictLiteral literal : kanjiDict.mapKuTen213Sorted()) {
+				kanjiDictNode213.addNode(createNodeKanjiDictLiteral(literal, false));
+			}
+		}
 		return doc;
 	}
 	
+	private MaisDocNode createNodeKanjiDict(String version) {
+		return new MaisDocNode(kanjiDict, "jis_x_0" +  version, "JIS X 0" + version, "Kanji JIS X 0" + version);
+	}
+	
+	private MaisDocNode createNodeKanjiDictLiteral(KanjiDictLiteral literal, boolean is208) {
+		//String hexPoint = Integer.toHexString(literal.getCodePoint()).toUpperCase();
+		String utfPoint = new StringBuilder().appendCodePoint(literal.getCodePoint()).toString();
+		String kuTen = is208?literal.getKuTen208():literal.getKuTen213();
+		String kuTenPath = kuTen.replaceAll("-", "_");
+		String firstMean = "";
+		if (literal.getMeaningDefault() != null) {
+			firstMean = literal.getMeaningDefault().stream().findFirst().orElse("");
+		}
+		String desc = utfPoint;
+		if (!firstMean.isEmpty()) {
+			desc = desc + " (" + firstMean + ")";
+		}
+		return new MaisDocNode(literal, kuTenPath, kuTen, desc);
+	}
+	
 	private MaisDocNode createNodeCakeTower(FourCornerDotCakeTower tower) {
 		return new MaisDocNode(new TDocCakeTower(tower), tower.name(), tower.nameNice(), tower.description());
 	}

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDict.java

@@ -24,7 +24,10 @@ package love.distributedrebirth.nx01.mushroom.mais.fc18.kanji;
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import javax.xml.parsers.ParserConfigurationException;
@@ -46,13 +49,43 @@ import org.xml.sax.XMLReader;
  */
 public class KanjiDict {
 	
-	Map<String, KanjiDictLiteral> mapKuTen208 = new HashMap<>();
+	private final Map<String, KanjiDictLiteral> mapKuTen208 = new HashMap<>();
-	Map<String, KanjiDictLiteral> mapKuTen213 = new HashMap<>();
+	private final Map<String, KanjiDictLiteral> mapKuTen213 = new HashMap<>();
-	Map<Integer, KanjiDictLiteral> mapFourCorner = new HashMap<>();
+	private final Map<Integer, KanjiDictLiteral> mapFourCorner = new HashMap<>();
 	
 	public KanjiDict() {
 	}
 	
+	public Map<String, KanjiDictLiteral> mapKuTen208() {
+		return mapKuTen208;
+	}
+	
+	public List<KanjiDictLiteral> mapKuTen208Sorted() {
+		return new ArrayList<>(mapKuTen208.values()).stream().sorted(new Comparator<KanjiDictLiteral>() {
+			@Override
+			public int compare(KanjiDictLiteral arg0, KanjiDictLiteral arg1) {
+				return arg0.getKuTen208().compareTo(arg1.getKuTen208());
+			}
+		}).toList();
+	}
+	
+	public Map<String, KanjiDictLiteral> mapKuTen213() {
+		return mapKuTen213;
+	}
+	
+	public List<KanjiDictLiteral> mapKuTen213Sorted() {
+		return new ArrayList<>(mapKuTen213.values()).stream().sorted(new Comparator<KanjiDictLiteral>() {
+			@Override
+			public int compare(KanjiDictLiteral arg0, KanjiDictLiteral arg1) {
+				return arg0.getKuTen213().compareTo(arg1.getKuTen213());
+			}
+		}).toList();
+	}
+	
+	public Map<Integer, KanjiDictLiteral> mapFourCorner() {
+		return mapFourCorner;
+	}
+	
 	public void parseXML(InputStream input) throws ParserConfigurationException, SAXException, IOException {
 		SAXParserFactory factory = SAXParserFactory.newInstance();
 		SAXParser parser = factory.newSAXParser();

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDictTest.java

@@ -59,8 +59,8 @@ public class KanjiDictTest {
 			dict.parseXML(in);
 		}
 		System.out.println("=======================================");
-		for (Integer key : dict.mapFourCorner.keySet()) {
+		for (Integer key : dict.mapFourCorner().keySet()) {
-			KanjiDictLiteral lit = dict.mapFourCorner.get(key);
+			KanjiDictLiteral lit = dict.mapFourCorner().get(key);
 			int meanCnt = lit.getMeaningDefault().size();
 			String meaning = lit.getMeaningDefault().stream().map(v -> v.replaceAll(" ", "\u3000")).collect(Collectors.joining(" - "));
 			System.out.print(new StringBuilder().appendCodePoint(lit.getCodePoint()).toString());
@@ -76,16 +76,16 @@ public class KanjiDictTest {
 		}
 		
 		List<Integer> kuTen2UNI2K = new ArrayList<>();
-		for (String key : dict.mapKuTen208.keySet()) {
+		for (String key : dict.mapKuTen208().keySet()) {
-			KanjiDictLiteral lit = dict.mapKuTen208.get(key);
+			KanjiDictLiteral lit = dict.mapKuTen208().get(key);
 			String valueUnicode = new StringBuilder().appendCodePoint(lit.getCodePoint()).toString();
 			kuTen2UNI2K.addAll(FourCornerUnicodeImport.strict().convertToInt18(key));
 			kuTen2UNI2K.add(FCDotCDC1604DashP6.NY09_EQUALS.cakePointDotIndex());
 			kuTen2UNI2K.addAll(FourCornerUnicodeMapper.DICTIONARY.embedUNI2K(valueUnicode));
 			kuTen2UNI2K.addAll(FCDotCMD5401Dash2D.CMD_F4TTY0001_NL.cakePointSequence());
 		}
-		for (String key : dict.mapKuTen213.keySet()) {
+		for (String key : dict.mapKuTen213().keySet()) {
-			KanjiDictLiteral lit = dict.mapKuTen213.get(key);
+			KanjiDictLiteral lit = dict.mapKuTen213().get(key);
 			String valueUnicode = new StringBuilder().appendCodePoint(lit.getCodePoint()).toString();
 			kuTen2UNI2K.addAll(FourCornerUnicodeImport.strict().convertToInt18(key));
 			kuTen2UNI2K.add(FCDotCDC1604DashP6.NY09_EQUALS.cakePointDotIndex());
@@ -119,8 +119,8 @@ public class KanjiDictTest {
 		int meanUse2 = 0;
 		int meanUse1 = 0;
 		Map<String, KanjiDictLiteral> uniqMean = new HashMap<>();
-		for (Integer key : dict.mapFourCorner.keySet()) {
+		for (Integer key : dict.mapFourCorner().keySet()) {
-			KanjiDictLiteral lit = dict.mapFourCorner.get(key);
+			KanjiDictLiteral lit = dict.mapFourCorner().get(key);
 			if (lit.getMeaningDefault().isEmpty()) {
 				meanEmpty++;
 				continue;
@@ -156,9 +156,9 @@ public class KanjiDictTest {
 		// JIS X 0213 + 0208 have total characters 11233
 		// Japanese engineers have defined 
 		System.out.println("=======================================");
-		System.out.println("mapFourCorner: " + dict.mapFourCorner.size());
+		System.out.println("mapFourCorner: " + dict.mapFourCorner().size());
-		System.out.println("mapKuTen208: " + dict.mapKuTen208.size());
+		System.out.println("mapKuTen208: " + dict.mapKuTen208().size());
-		System.out.println("mapKuTen213: " + dict.mapKuTen213.size());
+		System.out.println("mapKuTen213: " + dict.mapKuTen213().size());
 		System.out.println("=======================================");
 		System.out.println("meanUniq: " + uniqMean.size());
 		System.out.println("meanEmpty: " + meanEmpty);

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocPageWriterBaklava.java

@@ -20,7 +20,7 @@
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package love.distributedrebirth.nx01.mushroom.mais.fc18;
+package love.distributedrebirth.nx01.mushroom.mais.fc18.print;
 
 import java.io.IOException;
 import java.util.ArrayList;

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocPageWriterMuffin.java

@@ -20,7 +20,7 @@
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package love.distributedrebirth.nx01.mushroom.mais.fc18;
+package love.distributedrebirth.nx01.mushroom.mais.fc18.print;
 
 import java.io.IOException;
 import java.util.List;

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriter.java

@@ -20,9 +20,10 @@
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package love.distributedrebirth.nx01.mushroom.mais.fc18;
+package love.distributedrebirth.nx01.mushroom.mais.fc18.print;
 
 import java.io.IOException;
+import java.util.List;
 import java.util.function.Function;
 
 import org.x4o.fc18.cake2.FourCornerDotCake;
@@ -155,4 +156,18 @@ public interface FCDocSegmentWriter {
 		}
 		writer.printTagEnd(Tag.tr);
 	}
+	
+	default void writeTableRowSequenceHex(MaisDocContentWriter writer, String system, int minHex, List<Integer> sequence) throws IOException {
+		String displayFormat = "0x%0" + minHex + "X";
+		StringBuilder buf = new StringBuilder();
+		for (int i = 0; i < sequence.size(); i++) {
+			int seq = sequence.get(i);
+			String hex = String.format(displayFormat, seq);
+			buf.append(hex);
+			if (i + 1 < sequence.size()) {
+				buf.append(" - ");
+			}
+		}
+		writer.docTableRow(system, buf.toString());
+	}
 }

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCake.java

@@ -20,7 +20,7 @@
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package love.distributedrebirth.nx01.mushroom.mais.fc18;
+package love.distributedrebirth.nx01.mushroom.mais.fc18.print;
 
 import java.io.IOException;
 import java.util.HashSet;
@@ -39,6 +39,9 @@ import org.x4o.maisdoc.model.MaisDocWriteEvent;
 import org.x4o.sax3.SAX3WriterHtml.Tag;
 import org.x4o.sax3.io.ContentCloseable;
 
+import love.distributedrebirth.nx01.mushroom.mais.fc18.TDocCake;
+import love.distributedrebirth.nx01.mushroom.mais.fc18.TDocCakeSlice;
+
 /**
  * Cake doc slice writer.
  * 
@@ -159,6 +162,9 @@ public class FCDocSegmentWriterCake implements FCDocSegmentWriter {
 			Set<FourCornerDotCake> linkableSlices = new HashSet<>();
 			for (MaisDocNode towerNode : e.getEventObject().getNodes()) {
 				for (MaisDocNode sliceNode : towerNode.getNodes()) {
+					if (!(sliceNode.getUserData() instanceof TDocCakeSlice)) {
+						continue;
+					}
 					FourCornerDotCake slice = sliceNode.toUserData(TDocCakeSlice.class).getSlice();
 					linkableSlices.add(slice);
 					StringBuilder buf = new StringBuilder();

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCakeSlice.java

@@ -20,7 +20,7 @@
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package love.distributedrebirth.nx01.mushroom.mais.fc18;
+package love.distributedrebirth.nx01.mushroom.mais.fc18.print;
 
 import java.io.IOException;
 import java.util.List;
@@ -35,6 +35,8 @@ import org.x4o.maisdoc.model.MaisDocNodeBody;
 import org.x4o.maisdoc.model.MaisDocWriteEvent;
 import org.x4o.sax3.io.ContentCloseable;
 
+import love.distributedrebirth.nx01.mushroom.mais.fc18.TDocCakeSlice;
+
 /**
  * Cake doc segment slice writer.
  * 

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCakeWord.java

@@ -20,7 +20,7 @@
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package love.distributedrebirth.nx01.mushroom.mais.fc18;
+package love.distributedrebirth.nx01.mushroom.mais.fc18.print;
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
@@ -44,6 +44,8 @@ import org.x4o.maisdoc.model.MaisDocWriteEvent;
 import org.x4o.fc18.cake2.FourCornerX00PetitVide;
 import org.x4o.sax3.SAX3WriterHtml.Tag;
 
+import love.distributedrebirth.nx01.mushroom.mais.fc18.TDocCakeWord;
+
 /**
  * Cake doc word writer.
  * 
@@ -85,16 +87,16 @@ public class FCDocSegmentWriterCakeWord implements FCDocSegmentWriter {
 		writer.docTableRow(name, value);
 		
 		if (x06BaklavaSequence.isPresent()) {
-			writeSequence(writer, "Sequence-X06", 2, x06BaklavaSequence.get().baklavaPointSequence());
+			writeTableRowSequenceHex(writer, "Sequence-X06", 2, x06BaklavaSequence.get().baklavaPointSequence());
 		}
 		if (x08MuffinSequence.isPresent()) {
-			writeSequence(writer, "Sequence-X08", 2, x08MuffinSequence.get().muffinPointSequence());
+			writeTableRowSequenceHex(writer, "Sequence-X08", 2, x08MuffinSequence.get().muffinPointSequence());
 		}
 		if (x18CakeSequence.isPresent()) {
-			writeSequence(writer, "Sequence-X18", 6, x18CakeSequence.get().cakePointSequence());
+			writeTableRowSequenceHex(writer, "Sequence-X18", 6, x18CakeSequence.get().cakePointSequence());
 		}
 		if (x21CodeDisplay.isPresent()) {
-			writeSequence(writer, "Sequence-X21", 6, x21CodeDisplay.get().codePointSequence());
+			writeTableRowSequenceHex(writer, "Sequence-X21", 6, x21CodeDisplay.get().codePointSequence());
 			StringBuilder bufUTF8 = new StringBuilder();
 			x21CodeDisplay.get().codePointSequence().forEach(v -> bufUTF8.appendCodePoint(v));
 			byte[] sequenceUTF8Bytes = bufUTF8.toString().getBytes(StandardCharsets.UTF_8);
@@ -102,7 +104,7 @@ public class FCDocSegmentWriterCakeWord implements FCDocSegmentWriter {
 			for (int i = 0; i < sequenceUTF8Bytes.length; i++) {
 				sequenceUTF8.add(Byte.toUnsignedInt(sequenceUTF8Bytes[i]));
 			}
-			writeSequence(writer, "Sequence-X21-UTF8", 2, sequenceUTF8);
+			writeTableRowSequenceHex(writer, "Sequence-X21-UTF8", 2, sequenceUTF8);
 			
 			StringBuilder bufXML = new StringBuilder();
 			PrimitiveIterator.OfInt codePoints = bufUTF8.codePoints().iterator();
@@ -137,19 +139,4 @@ public class FCDocSegmentWriterCakeWord implements FCDocSegmentWriter {
 			writer.docTableEnd();
 		}
 	}
-	
-	
-	private void writeSequence(MaisDocContentWriter writer, String system, int minHex, List<Integer> sequence) throws IOException {
-		String displayFormat = "0x%0" + minHex + "X";
-		StringBuilder buf = new StringBuilder();
-		for (int i = 0; i < sequence.size(); i++) {
-			int seq = sequence.get(i);
-			String hex = String.format(displayFormat, seq);
-			buf.append(hex);
-			if (i + 1 < sequence.size()) {
-				buf.append(" - ");
-			}
-		}
-		writer.docTableRow(system, buf.toString());
-	}
 }

nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterKanjiDictLiteral.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2004-2014, Willem Cazander
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided
+ * that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this list of conditions and the
+ *   following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
+ *   the following disclaimer in the documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package love.distributedrebirth.nx01.mushroom.mais.fc18.print;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.PrimitiveIterator;
+import java.util.stream.Collectors;
+
+import org.x4o.maisdoc.flake.MaisDocContentCss;
+import org.x4o.maisdoc.flake.MaisDocContentWriter;
+import org.x4o.maisdoc.flake.MaisDocNodeWriterMethod;
+import org.x4o.maisdoc.model.MaisDocNode;
+import org.x4o.maisdoc.model.MaisDocNodeBody;
+import org.x4o.maisdoc.model.MaisDocWriteEvent;
+import org.x4o.sax3.SAX3WriterHtml.Tag;
+
+import love.distributedrebirth.nx01.mushroom.mais.fc18.kanji.KanjiDictLiteral;
+
+/**
+ * Kanji dict literal doc segment writer.
+ * 
+ * @author Willem Cazander
+ * @version 1.0 May 21, 2025
+ */
+public class FCDocSegmentWriterKanjiDictLiteral implements FCDocSegmentWriter {
+	
+	@MaisDocNodeWriterMethod(nodeBody=MaisDocNodeBody.SUMMARY,targetClasses={KanjiDictLiteral.class})
+	public void writeCakeWordSummary(MaisDocWriteEvent<MaisDocNode> event) throws IOException {
+		MaisDocContentWriter writer = event.getWriter();
+		KanjiDictLiteral literal  = event.getEventObject().toUserData(KanjiDictLiteral.class);
+		if (literal == null) {
+			writer.printTagStart(Tag.pre);
+			writer.printCharacters("No literal data for: " + event.getEventObject());
+			writer.printTagEnd(Tag.pre);
+			return;
+		}
+		writer.docTableStart("Literal Summary", "The kanji literal value information.",MaisDocContentCss.overviewSummary);
+		writer.docTableHeader("Point", "Value");
+		String name = "" + literal.getCodePoint();
+		String value = "";
+		StringBuilder buf = new StringBuilder();
+		buf.appendCodePoint(literal.getCodePoint());
+		value = buf.toString();
+		writer.docTableRow(name, value);
+		
+		if (literal.getFourCorner() != null) {
+			writer.docTableRow("Four-Corner", "" + literal.getFourCorner());
+		}
+		if (literal.getKuTen208() != null) {
+			writer.docTableRow("KuTen-208", "" + literal.getKuTen208());
+		}
+		if (literal.getKuTen213() != null) {
+			writer.docTableRow("KuTen-213", "" + literal.getKuTen213());
+		}
+		
+		writeTableRowSequenceHex(writer, "Sequence-X21", 6, List.of(literal.getCodePoint()));
+		StringBuilder bufUTF8 = new StringBuilder();
+		bufUTF8.appendCodePoint(literal.getCodePoint());
+		byte[] sequenceUTF8Bytes = bufUTF8.toString().getBytes(StandardCharsets.UTF_8);
+		List<Integer> sequenceUTF8 = new ArrayList<>();
+		for (int i = 0; i < sequenceUTF8Bytes.length; i++) {
+			sequenceUTF8.add(Byte.toUnsignedInt(sequenceUTF8Bytes[i]));
+		}
+		writeTableRowSequenceHex(writer, "Sequence-X21-UTF8", 2, sequenceUTF8);
+		
+		StringBuilder bufXML = new StringBuilder();
+		PrimitiveIterator.OfInt codePoints = bufUTF8.codePoints().iterator();
+		while (codePoints.hasNext()) {
+			int codePoint = codePoints.nextInt();
+			bufXML.append("&amp;#x"); // manual &amp to show literal escape string
+			bufXML.append(Integer.toHexString(codePoint));
+			bufXML.append(";");
+		}
+		writer.docTableRow("Sequence-X21-XML", bufXML.toString());
+		
+		writer.docTableEnd();
+		
+		writer.docTableStart("Meaning Summary", "The kanji literal meaning information.",MaisDocContentCss.overviewSummary);
+		writer.docTableHeader("Locale", "Value");
+		for (String key : literal.getMeaning().keySet()) {
+			String meanLocale = key;
+			if (key.isEmpty()) {
+				meanLocale = "en";
+			}
+			List<String> meanings = literal.getMeaning().get(key);
+			String meanLocal = meanings.stream().collect(Collectors.joining(", "));
+			writer.docTableRow(meanLocale, meanLocal);
+		}
+		writer.docTableEnd();
+	}
+}

nx01-mushroom-mais-mm/src/main/java/org/eobjects/metamodel/doc/DocModelWriter.java

@@ -111,7 +111,7 @@ public class DocModelWriter {
 		MaisDocConcept adc3 = doc.addConcept(new MaisDocConcept(adc2,C_SCHEMA,Schema.class));
 		MaisDocConcept adc4 = doc.addConcept(new MaisDocConcept(adc3,C_TABLE,Table.class));
 		
-		adc4.addChildConcepts(new MaisDocConcept(adc4, CC_RS, Relationship.class));
+		adc4.addChildConcept(new MaisDocConcept(adc4, CC_RS, Relationship.class));
 		
 		doc.addDocPage(DefaultPageWriterTree.createDocPage());
 		doc.addDocPage(DefaultPageWriterIndexAll.createDocPage());

nx01-x4o-driver/src/main/java/org/x4o/xml/eld/doc/EldDocWriter.java

@@ -52,7 +52,6 @@ import org.x4o.xml.element.ElementNamespace;
 import org.x4o.xml.lang.X4OLanguage;
 import org.x4o.xml.lang.X4OLanguageModule;
 import org.x4o.xml.lang.X4OLanguageSession;
-import org.xml.sax.SAXException;
 
 /**
  * EldDocWriter writes the x4o eld documentation.
@@ -210,13 +209,13 @@ public class EldDocWriter {
 		MaisDocConcept adcEc = doc.addConcept(new MaisDocConcept(adcNs,C_ELEMENT,ElementClass.class));
 		
 		// mm maybe redo something here
-		adcMod.addChildConcepts(new MaisDocConcept(adcMod,CC_ATTRIBUTE_H,ElementNamespaceAttribute.class));
+		adcMod.addChildConcept(new MaisDocConcept(adcMod,CC_ATTRIBUTE_H,ElementNamespaceAttribute.class));
-		adcMod.addChildConcepts(new MaisDocConcept(adcMod,CC_CONFIGURATOR_G,ElementConfiguratorGlobal.class));
+		adcMod.addChildConcept(new MaisDocConcept(adcMod,CC_CONFIGURATOR_G,ElementConfiguratorGlobal.class));
-		adcMod.addChildConcepts(new MaisDocConcept(adcMod,CC_BINDING,ElementBindingHandler.class));
+		adcMod.addChildConcept(new MaisDocConcept(adcMod,CC_BINDING,ElementBindingHandler.class));
-		adcIface.addChildConcepts(new MaisDocConcept(adcMod,CC_ATTRIBUTE,ElementClassAttribute.class));
+		adcIface.addChildConcept(new MaisDocConcept(adcMod,CC_ATTRIBUTE,ElementClassAttribute.class));
-		adcIface.addChildConcepts(new MaisDocConcept(adcMod,CC_CONFIGURATOR,ElementConfigurator.class));
+		adcIface.addChildConcept(new MaisDocConcept(adcMod,CC_CONFIGURATOR,ElementConfigurator.class));
-		adcEc.addChildConcepts(new MaisDocConcept(adcEc,CC_CONFIGURATOR,ElementConfigurator.class));
+		adcEc.addChildConcept(new MaisDocConcept(adcEc,CC_CONFIGURATOR,ElementConfigurator.class));
-		adcEc.addChildConcepts(new MaisDocConcept(adcEc,CC_ATTRIBUTE,ElementClassAttribute.class));
+		adcEc.addChildConcept(new MaisDocConcept(adcEc,CC_ATTRIBUTE,ElementClassAttribute.class));
 		
 		// Non-tree pages config
 		if (propertyConfig.getPropertyBoolean(PAGE_PRINT_XTREE)) {     doc.addDocPage(EldDocXTreePageWriter.createDocPage()); }

nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDoc.java

@@ -196,9 +196,16 @@ public class MaisDoc {
 			if (concept.getConceptClass().isAssignableFrom(objClass)) {
 				return concept;
 			}
+			// NOTE: only 2 level search for sub child concepts
 			for (MaisDocConcept c:concept.getChildConcepts()) {
 				if (c.getConceptClass().isAssignableFrom(objClass)) {
-					return concept;
+					//return concept;
+					return c;
+				}
+				for (MaisDocConcept cc:c.getChildConcepts()) {
+					if (cc.getConceptClass().isAssignableFrom(objClass)) {
+						return cc;
+					}
 				}
 			}
 		}

nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDocConcept.java

@@ -133,7 +133,7 @@ public class MaisDocConcept {
 		this.conceptClass = conceptClass;
 	}
 	
-	public void addChildConcepts(MaisDocConcept childConcept) {
+	public void addChildConcept(MaisDocConcept childConcept) {
 		childConcepts.add(childConcept);
 	}