/// <summary>
/// Retrieves and includes the meanings of the given kanji in the entity.
/// </summary>
internal static void IncludeKanjiMeanings(DaoConnection connection, KanjiEntity kanji)
{
IEnumerable <NameValueCollection> nvcMeanings = connection.Query(
string.Format("SELECT * FROM {0} km WHERE km.{1}=@kanjiId AND km.{2} IS NULL;",
SqlHelper.Table_KanjiMeaning,
SqlHelper.Field_KanjiMeaning_KanjiId,
SqlHelper.Field_KanjiMeaning_Language),
new DaoParameter("@kanjiId", kanji.ID));
KanjiMeaningBuilder meaningBuilder = new KanjiMeaningBuilder();
foreach (NameValueCollection nvcMeaning in nvcMeanings)
{
// For each meaning result : build a meaning and set the associations.
KanjiMeaning meaning = meaningBuilder.BuildEntity(nvcMeaning, null);
meaning.Kanji = kanji;
kanji.Meanings.Add(meaning);
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value == null)
{
return(null);
}
if (value is KanjiEntity && parameter is KanjiToStringConversionType)
{
KanjiEntity kanji = ((KanjiEntity)value);
KanjiToStringConversionType conversionType = (KanjiToStringConversionType)parameter;
KanjiMeaning[] meanings = kanji.Meanings.ToArray();
if (meanings.Any())
{
if (conversionType == KanjiToStringConversionType.Short)
{
// Short conversion
// Take the first meaning
KanjiMeaning meaning = meanings.First();
if (!string.IsNullOrEmpty(meaning.Meaning))
{
// Capitalize the first letter
string capitalizedFirstLetter = meaning.Meaning.Substring(0, 1).ToUpper();
string meaningString = capitalizedFirstLetter + meaning.Meaning.Substring(1);
// Shorten the result if too long
if (meaningString.Length > MaxStringLength)
{
meaningString = meaningString.Substring(0, MaxStringLength) + "[...]";
}
// Return the formatted first meaning
return(meaningString);
}
}
else
{
// Full conversion
// Build a string containing each meaning separated by a comma.
StringBuilder fullMeaningBuilder = new StringBuilder();
foreach (KanjiMeaning meaning in meanings)
{
fullMeaningBuilder.Append(meaning.Meaning);
if (meaning != meanings.Last())
{
fullMeaningBuilder.Append(", ");
}
}
// Return the formatted meanings string.
return(fullMeaningBuilder.ToString());
}
}
}
else
{
// Invalid arguments.
throw new ArgumentException(
"This converter needs a KanjiEntity as a value and a ConversionType as a parameter.");
}
// There are no meanings to display.
return("(No meaning)");
}
/// <summary>
/// Reads the KanjiDic2 file and outputs kanji entities parsed from the file.
/// </summary>
/// <returns>Kanji entities parsed from the file.</returns>
private IEnumerable <KanjiEntity> ReadKanjiDic2()
{
// Load the KanjiDic2 file.
XDocument xdoc = XDocument.Load(PathHelper.KanjiDic2Path);
// Browse kanji nodes.
foreach (XElement xkanji in xdoc.Root.Elements(XmlNode_Character))
{
// For each kanji node, read values.
KanjiEntity kanji = new KanjiEntity();
// Read the kanji character.
kanji.Character = xkanji.Element(XmlNode_Literal).Value;
// In the code point node...
XElement xcodePoint = xkanji.Element(XmlNode_CodePoint);
if (xcodePoint != null)
{
// Try to read the unicode character value.
XElement xunicode = xcodePoint.Elements(XmlNode_CodePointValue)
.Where(x => x.ReadAttributeString(XmlAttribute_CodePointType) == XmlAttributeValue_CodePointUnicode)
.FirstOrDefault();
if (xunicode != null)
{
string unicodeValueString = xunicode.Value;
int intValue = 0;
if (int.TryParse(unicodeValueString, System.Globalization.NumberStyles.HexNumber, ParsingHelper.DefaultCulture, out intValue))
{
kanji.UnicodeValue = intValue;
}
}
}
// In the misc node...
XElement xmisc = xkanji.Element(XmlNode_Misc);
if (xmisc != null)
{
// Try to read the grade, stroke count, frequency and JLPT level.
// Update: JLPT level is outdated in this file. Now using the JLPTKanjiList.
XElement xgrade = xmisc.Element(XmlNode_Grade);
XElement xstrokeCount = xmisc.Element(XmlNode_StrokeCount);
XElement xfrequency = xmisc.Element(XmlNode_Frequency);
//XElement xjlpt = xmisc.Element(XmlNode_JlptLevel);
if (xgrade != null)
{
kanji.Grade = ParsingHelper.ParseShort(xgrade.Value);
}
if (xstrokeCount != null)
{
kanji.StrokeCount = ParsingHelper.ParseShort(xstrokeCount.Value);
}
if (xfrequency != null)
{
kanji.NewspaperRank = ParsingHelper.ParseInt(xfrequency.Value);
}
//if (xjlpt != null) kanji.JlptLevel = ParsingHelper.ParseShort(xjlpt.Value);
}
// Find the JLPT level using the dictionary.
if (_jlptDictionary.ContainsKey(kanji.Character))
{
kanji.JlptLevel = _jlptDictionary[kanji.Character];
}
// Find the frequency rank using the dictionary.
if (_frequencyRankDictionary.ContainsKey(kanji.Character))
{
kanji.MostUsedRank = _frequencyRankDictionary[kanji.Character];
}
// Find the WaniKani level using the dictionary.
if (_waniKaniDictionary.ContainsKey(kanji.Character))
{
kanji.WaniKaniLevel = _waniKaniDictionary[kanji.Character];
}
// In the reading/meaning node...
XElement xreadingMeaning = xkanji.Element(XmlNode_ReadingMeaning);
if (xreadingMeaning != null)
{
// Read the nanori readings.
kanji.Nanori = string.Empty;
foreach (XElement xnanori in xreadingMeaning.Elements(XmlNode_Nanori))
{
kanji.Nanori += xnanori.Value + MultiValueFieldHelper.ValueSeparator;
}
kanji.Nanori = kanji.Nanori.Trim(MultiValueFieldHelper.ValueSeparator);
// Browse the reading group...
XElement xrmGroup = xreadingMeaning.Element(XmlNode_ReadingMeaningGroup);
if (xrmGroup != null)
{
// Read the on'yomi readings.
kanji.OnYomi = string.Empty;
foreach (XElement xonYomi in xrmGroup.Elements(XmlNode_Reading)
.Where(x => x.Attribute(XmlAttribute_ReadingType).Value == XmlAttributeValue_OnYomiReading))
{
kanji.OnYomi += xonYomi.Value + MultiValueFieldHelper.ValueSeparator;
}
kanji.OnYomi = KanaHelper.ToHiragana(kanji.OnYomi.Trim(MultiValueFieldHelper.ValueSeparator));
// Read the kun'yomi readings.
kanji.KunYomi = string.Empty;
foreach (XElement xkunYomi in xrmGroup.Elements(XmlNode_Reading)
.Where(x => x.Attribute(XmlAttribute_ReadingType).Value == XmlAttributeValue_KunYomiReading))
{
kanji.KunYomi += xkunYomi.Value + MultiValueFieldHelper.ValueSeparator;
}
kanji.KunYomi = kanji.KunYomi.Trim(MultiValueFieldHelper.ValueSeparator);
// Browse the meanings...
foreach (XElement xmeaning in xrmGroup.Elements(XmlNode_Meaning))
{
// Get the language and meaning.
XAttribute xlanguage = xmeaning.Attribute(XmlAttribute_MeaningLanguage);
string language = xlanguage != null?xlanguage.Value.ToLower() : null;
string meaning = xmeaning.Value;
if (xlanguage == null || language.ToLower() == "en")
{
// Build a meaning.
KanjiMeaning kanjiMeaning = new KanjiMeaning()
{
Kanji = kanji, Language = language, Meaning = meaning
};
// Add the meaning to the kanji.
kanji.Meanings.Add(kanjiMeaning);
}
}
}
}
// Return the kanji read and go to the next kanji node.
yield return(kanji);
xkanji.RemoveAll();
}
}
