public void Show(FontFamily font, char glyph, string code) { lblGlyph.FontFamily = font; lblGlyph.Content = glyph.ToString(); this.Title = $"Details - U+{code}"; var info = UnicodeInfo.GetCharInfo(glyph); lblName.Content = info.Name.Replace("WITH", "\nWITH"); lblName.ToolTip = info.Name; tbxCode.Text = $"U+{code} (&#x{code};) [Alt+{Convert.ToInt32(code, 16),0:D4}]"; if (!string.IsNullOrEmpty(info.OldName)) { PrintCharInfo("Old Name", info.OldName); } PrintCharInfo("Category", info.Category.ToString()); PrintCharInfo("Block", info.Block); PrintCharInfo("Canoncial Combining Class", info.CanonicalCombiningClass.ToString()); PrintCharInfo("Bidirectional Class", info.BidirectionalClass.ToString()); PrintCharInfo("Contributory Properties", info.ContributoryProperties.ToString()); PrintCharInfo("Core Properties", info.CoreProperties.ToString()); this.Show(); }
private string GetResult(int value) { var sb = new StringBuilder(); char ch = (char)value; bool isSurrogate = char.IsSurrogate(ch); string text = null; if (!isSurrogate) { text = char.ConvertFromUtf32(value); sb.AppendLine(DivClass(Escape(text), "charSample")); } if (descriptions.TryGetValue(value, out string description)) { sb.AppendLine(Div(description)); } var info = UnicodeInfo.GetCharInfo(value); sb.AppendLine(TableStart("smallTable")); sb.AppendLine(Tr(Td(Gray("Code point:")), Td($"{value} (U+{value.ToHex()})"))); sb.AppendLine(Tr(Td(Gray("Category:")), Td(CharUnicodeInfo.GetUnicodeCategory(ch).ToString()))); sb.AppendLine(Tr(Td(Gray("Block:")), Td(info.Block))); sb.AppendLine(Tr(Td(Gray("Escape:")), Td(DivClass(GetEscapeString(value), "fixed")))); if (text != null) { sb.AppendLine(Tr(Td(Gray("UTF-8:")), Td(GetUtf8(text)))); } sb.AppendLine("</table>"); return(sb.ToString()); }
public static Models.CodePoint GetCodePoint(UnicodeCharInfo charInfo) { var category = UnicodeCategoryInfo.Get(charInfo.Category); return(new Models.CodePoint ( charInfo.CodePoint, UnicodeInfo.GetDisplayText(charInfo), charInfo.Name, charInfo.OldName, charInfo.NameAliases.Select(na => new Models.NameAlias((Models.UnicodeNameAliasKind)(int) na.Kind, na.Name)).ToArray(), new Models.UnicodeCategory(category.ShortName, category.LongName), charInfo.Block, (Models.UnicodeNumericType)(int) charInfo.NumericType, (Models.UnihanNumericType)(int) charInfo.UnihanNumericType, charInfo.NumericValue != null ? new Models.RationalNumber(charInfo.NumericValue.GetValueOrDefault().Numerator, charInfo.NumericValue.GetValueOrDefault().Denominator) : null, charInfo.Definition, charInfo.MandarinReading, charInfo.CantoneseReading, charInfo.JapaneseKunReading, charInfo.JapaneseOnReading, charInfo.KoreanReading, charInfo.HangulReading, charInfo.VietnameseReading, charInfo.SimplifiedVariant, charInfo.TraditionalVariant )); }
public void MethodGetDisplayTextShouldNeverFail() { for (int i = 0; i <= 0x10FFFF; i++) { UnicodeInfo.GetDisplayText(i); } }
private static List <IndexEntry> BuildUnicodeIndex() { var sw = Stopwatch.StartNew(); var result = new List <IndexEntry>(); var blocks = UnicodeInfo.GetBlocks(); foreach (var block in blocks) { foreach (var codepoint in block.CodePointRange) { if (char.IsSurrogate((char)codepoint)) { continue; } var charInfo = UnicodeInfo.GetCharInfo(codepoint); var displayText = charInfo.Name; if (displayText != null) { result.Add(new(charInfo, displayText, displayText.ToUpperInvariant())); } } } Console.WriteLine("Index built in " + sw.Elapsed); return(result); }
public void MethodGetCategoryShouldNeverFail() { for (int i = 0; i <= 0x10FFFF; i++) { UnicodeInfo.GetCategory(i); } }
public void MethodGetCharInfoShouldNeverFail() { for (int i = 0; i <= 0x10FFFF; i++) { UnicodeInfo.GetCharInfo(i); } }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { int codePoint; if (value is int) { codePoint = (int)value; } else if (value is char) { codePoint = (char)value; } else if (value is string) { codePoint = ((string)value)[0]; } else { //throw new ArgumentException("Unsupported value type."); return(null); } var info = UnicodeInfo.GetChar(codePoint); return("U+" + codePoint.ToString("X4") + " " + info.Name); }
public static Models.CodePoint[] GetCodePoints(int offset, int limit) { if (offset < 0 || offset > 0x10FFFF) { throw new ArgumentOutOfRangeException(nameof(offset)); } if (limit < 1) { throw new ArgumentOutOfRangeException(nameof(limit)); } var codePoints = new List <Models.CodePoint>(); int max = Math.Min(offset + limit - 1, 0x10FFFF); for (int i = offset; i <= max; i++) { var charInfo = UnicodeInfo.GetCharInfo(i); if (charInfo.Category != UnicodeCategory.OtherNotAssigned) { codePoints.Add(GetCodePoint(charInfo)); } } return(codePoints.ToArray()); }
public void ControlCharactersShouldHaveSpecificDisplayText() { for (int i = 0; i <= 0x20; ++i) { Assert.Equal(char.ConvertFromUtf32(0x2400 + i), UnicodeInfo.GetDisplayText(i)); Assert.Equal(char.ConvertFromUtf32(0x2400 + i), UnicodeInfo.GetDisplayText(UnicodeInfo.GetCharInfo(i))); } }
private static void PrintCodePointInfo(int codePoint) { var charInfo = UnicodeInfo.GetCharInfo(codePoint); Console.WriteLine(UnicodeInfo.GetDisplayText(charInfo)); Console.WriteLine("U+" + codePoint.ToString("X4")); Console.WriteLine(charInfo.Name ?? charInfo.OldName); Console.WriteLine(charInfo.Category); }
public override string ToDescriptionString() { var info = UnicodeInfo.GetCharInfo(codePoint); return(base.ToLongString() + "\n" + "Kun: " + info.JapaneseKunReading + "\n" + "On: " + info.JapaneseOnReading + "\n" + info.Definition + "\n"); }
public void RadicalUnicodeCategories() { foreach (var radical in lookup.AllRadicals) { Console.Write(radical.ToString()); Console.Write(": "); var info = UnicodeInfo.GetCharInfo(radical.Utf32); Console.WriteLine(info.Name); } }
public void MethodGetCharInfoShouldHaveCoherentResults() { for (int i = 0; i <= 0x10FFFF; i++) { var charInfo = UnicodeInfo.GetCharInfo(i); Assert.Equal(charInfo.Name, UnicodeInfo.GetName(i)); Assert.Equal(charInfo.Category, UnicodeInfo.GetCategory(i)); Assert.Equal(UnicodeInfo.GetDisplayText(charInfo), UnicodeInfo.GetDisplayText(i)); } }
private void UpdateDisplayText() { string oldValue = displayText; displayText = character != null?UnicodeInfo.GetDisplayText(characterInfo) : null; if (displayText != oldValue) { NotifyPropertyChanged(nameof(DisplayText)); } }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value == null) { return(null); } var radicalStrokeCount = (UnicodeRadicalStrokeCount)value; var radical = UnicodeInfo.GetCjkRadicalInfo(radicalStrokeCount.Radical); return(radicalStrokeCount.IsSimplified ? radical.TraditionalRadicalCodePoint : radical.SimplifiedRadicalCodePoint); }
public void Show(MainWindow owner) { this.Owner = owner; cbxBlocks.ItemsSource = UnicodeInfo.GetBlocks().Select(b => $"{b.Name} [{b.CodePointRange.ToString().Replace("..", "-")}]"); cbxCategories.ItemsSource = Enum.GetNames(typeof(UnicodeCategory)); cbxBlocks.SelectedIndex = cbxCategories.SelectedIndex = 0; chxBlockApplies.IsChecked = chxCategoryApplies.IsChecked = false; Show(); }
private static Dictionary <string, string> CreateUnicodeHashSet() { Dictionary <string, string> unicodeTable = new Dictionary <string, string>(); for (int i = 0x13000; i < 0x1342E; i++) { string unicodeString = char.ConvertFromUtf32(i); string unicodeName = UnicodeInfo.GetName(i).Split(' ').ToList().Last(); unicodeName = FixUnicodeName(unicodeName); unicodeTable.Add(unicodeName, unicodeString); } return(unicodeTable); }
private void UpdateFontView(object sender, System.Windows.Input.MouseEventArgs e) { if (sender is System.Windows.Controls.Image) { string preview = ""; WriteableBitmap wbm = (WriteableBitmap)((System.Windows.Controls.Image)sender).Source; int[] Pixels = new int[TheFontW * TheFontH]; wbm.CopyPixels(Pixels, wbm.BackBufferStride, 0); // lets use the average algorithm to get gray scale (4 bytes to 1) for (int x = 0; x < Pixels.Length; x++) { // get the greyscale pixel int average = GSPixel(Pixels[x]); // Large Preview 1Bit per pixel if (average > Threshold.Value) { preview += "@"; } else if (average > Threshold.Value / 2) { preview += "&"; } else { preview += "."; } if (x % wbm.PixelWidth == wbm.PixelWidth - 1) { preview += " "; } } preview += Environment.NewLine + Environment.NewLine; string c = ((System.Windows.Controls.Image)sender).ToolTip.ToString(); string charname = UnicodeInfo.GetName((char)int.Parse(c)); if (!string.IsNullOrEmpty(charname)) { preview += charname; } Preview.Text = preview; } }
private static BlockInformation[] GetBlocksInternal() { var blocks = UnicodeInfo.GetBlocks(); var blockViewModel = new BlockInformation[blocks.Length]; for (int i = 0; i < blocks.Length; i++) { var block = blocks[i]; blockViewModel[i] = new BlockInformation(block.Name, BlockMetadata.GetDescription(block.Name), new CodePointRange(block.CodePointRange.FirstCodePoint, block.CodePointRange.LastCodePoint)); } return(blockViewModel); }
public void RadicalStrokeCountShouldHaveExpectedResults() { var char5E7A = UnicodeInfo.GetCharInfo(0x5E7A); Assert.NotEmpty(char5E7A.UnicodeRadicalStrokeCounts); Assert.False(char5E7A.UnicodeRadicalStrokeCounts[0].IsSimplified); Assert.Equal(52, char5E7A.UnicodeRadicalStrokeCounts[0].Radical); Assert.Equal(0, char5E7A.UnicodeRadicalStrokeCounts[0].StrokeCount); var char2A6D6 = UnicodeInfo.GetCharInfo(0x2A6D6); Assert.NotEmpty(char2A6D6.UnicodeRadicalStrokeCounts); Assert.False(char2A6D6.UnicodeRadicalStrokeCounts[0].IsSimplified); Assert.Equal(214, char2A6D6.UnicodeRadicalStrokeCounts[0].Radical); Assert.Equal(20, char2A6D6.UnicodeRadicalStrokeCounts[0].StrokeCount); }
public void CodePointEncodingTest() { using (var stream = new MemoryStream(4)) using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { for (int i = 0; i <= 0x10FFFF; ++i) { writer.WriteCodePoint(i); writer.Flush(); stream.Position = 0; Assert.Equal(i, UnicodeInfo.ReadCodePoint(reader)); stream.Position = 0; } } }
public static CodePoint FromInt(int codePoint) { var info = UnicodeInfo.GetCharInfo(codePoint); switch (info.Block) { case "Hiragana": return(new Hiragana(codePoint)); case "Katakana": return(new Katakana(codePoint)); case "CJK Unified Ideographs": return(new Kanji(codePoint)); default: return(new CodePoint(codePoint)); } }
public void CharacterInfoShouldHaveExpectedResults(int codePoint, UnicodeCategory expectedCategory, UnicodeNumericType expectedNumericType, string expectedNumericValue, string expectedName, string expectedBlock) { var info = UnicodeInfo.GetCharInfo(codePoint); Assert.Equal(codePoint, info.CodePoint); Assert.Equal(expectedCategory, info.Category); Assert.Equal(expectedNumericType, info.NumericType); if (expectedNumericValue != null) { Assert.Equal(UnicodeRationalNumber.Parse(expectedNumericValue), info.NumericValue); } else { Assert.Null(info.NumericValue); } Assert.Equal(expectedName, info.Name); Assert.Equal(expectedBlock, UnicodeInfo.GetBlockName(codePoint)); Assert.Equal(expectedBlock, info.Block); }
/* * // Format: * // U,V,Width,Height */ private void WriteTextCoords(int textureIndex) { int rpt; int cpt; int spt; int offset; if (textureIndex == 0) { rpt = this.FontInfo.UVInfo.PrimaryRowsPerTexture; cpt = this.FontInfo.UVInfo.PrimaryColumnsPerTexture; spt = this.FontInfo.UVInfo.PrimarySpritesPerTexture; offset = 0; } else { rpt = this.FontInfo.UVInfo.AuxRowsPerTexture; cpt = this.FontInfo.UVInfo.AuxColumnsPerTexture; spt = this.FontInfo.UVInfo.AuxSpritesPerTexture; offset = this.FontInfo.UVInfo.PrimarySpritesPerTexture - this.FontInfo.UVInfo.AuxSpritesPerTexture; } File.AppendLine($"static constexpr unsigned int {this.TextSizeName.ToLowerInvariant()}_font_{textureIndex}_texcoords[] = {{"); for (int i = 0; i < rpt; i++) { for (int j = 0; j < cpt; j++) { int characterIndex = (i * cpt) + j + (spt * textureIndex) + offset; if (characterIndex >= this.Charset.Count) { break; } var charEntry = this.FontInfo.CharMap.First(c => c.Character == this.Charset[characterIndex]); File.AppendLine($" {j * this.FontInfo.UVInfo.TileWidth}, " + $"{i * this.FontInfo.UVInfo.TileHeight}, {charEntry.Width}, " + $"TEXT_{this.TextSizeName.Substring(0, 1)}Y, // {UnicodeInfo.GetName(charEntry.Character)}"); } } File.AppendLine(); File.AppendLine("};"); }
private void Initialize() { var builder = new IndexBuilder(); for (int i = 0; i <= 0x10FFFF; i++) { var charInfo = UnicodeInfo.GetCharInfo(i); string name = charInfo.Name; if (!string.IsNullOrEmpty(name)) { foreach (string word in name.Split(i == 0x1180 ? SimplifiedWordSeparators : WordSeparators)) { builder.AddWord(word, i); } } if (!string.IsNullOrEmpty(charInfo.OldName)) { foreach (string word in RemoveForbiddenCharacters(charInfo.OldName).Split(WordSeparators)) { builder.AddWord(word, i); } } if (charInfo.NameAliases.Count > 0) { foreach (var nameAlias in charInfo.NameAliases) { foreach (string word in nameAlias.Name.Split(WordSeparators)) { builder.AddWord(word, i); } } } } _wordIndex = builder.Build(); GC.Collect(); }
private void BuildUnicodeList() { var blocks = UnicodeInfo.GetBlocks(); foreach (var block in blocks) { foreach (var codepoint in block.CodePointRange) { if (char.IsSurrogate((char)codepoint)) { continue; } var charInfo = UnicodeInfo.GetCharInfo(codepoint); var displayText = charInfo.Name; if (displayText != null) { descriptions[codepoint] = displayText; } } } }
private string GetCharEncoded(int[] bits, char c) { StringBuilder result = new StringBuilder(); BitArray ba = new BitArray(TheFontH * TheFontW); // lets use the average algorithm to get gray scale (4 bytes to 1) for (int x = 0; x < bits.Length; x++) { // get the greyscale pixel int average = GSPixel(bits[x]); // encode to 1Bit per pixel if (average > Threshold.Value) { ba[x] = true; } else { ba[x] = false; } } byte[] fontbyte = new byte[TheFontH * TheFontW / 8]; ba.CopyTo(fontbyte, 0); // encode the font bits into code result.Append(" new byte[] { "); foreach (var b in fontbyte) { result.Append($"0x{b:X2}, "); } result.Remove(result.Length - 2, 2); result.Append($"}}, //{(int)c:X4}({c}) {UnicodeInfo.GetName(c)?.ToLowerInvariant()}"); return(result.ToString()); }
static void Main(string[] args) { string fontPath = @"C:\Users\zhdon\Desktop\lsu.ttf"; Uri fontUri = new Uri(fontPath); GlyphTypeface gt = new GlyphTypeface(fontUri); WriteLine("FONT_METRICS.glyphCount = {0}", gt.GlyphCount); WriteLine("FONT_METRICS.baseline = {0}", gt.Baseline); WriteLine("FONT_METRICS.capsHeight = {0}", gt.CapsHeight); WriteLine("FONT_METRICS.xHeight = {0}", gt.XHeight); WriteLine("FONT_METRICS.height = {0}", gt.Height); WriteLine("FONT_METRICS.glyphs = {0}", "GLYPHS"); foreach (var kvp in gt.CharacterToGlyphMap) { var code = kvp.Key; var c = char.ConvertFromUtf32(code); var i = kvp.Value; const double em = 18; var g = gt.GetGlyphOutline(i, em, em); var width = (g.Bounds.Right - g.Bounds.Left) / em; var ascent = (0 - g.Bounds.Top) / em; var descent = g.Bounds.Bottom / em; if (double.IsInfinity(ascent) || double.IsInfinity(descent)) { continue; } WriteLine("GLYPHS[{0}] = Glyph('{1}', '{2}', {3}, {4}, {5}, {6}, {7})", code, c != "'" && c != "\\" ? c : "\\" + c, UnicodeInfo.GetName(code).ToLower(), gt.AdvanceWidths[i], descent, ascent, gt.LeftSideBearings[i], gt.RightSideBearings[i]); } Pause(); }
public void RadicalInfoShouldHaveExpectedResults() { var radical1 = UnicodeInfo.GetCjkRadicalInfo(1); Assert.False(radical1.HasSimplifiedForm); Assert.Equal(1, radical1.RadicalIndex); Assert.Equal('\u2F00', radical1.TraditionalRadicalCodePoint); Assert.Equal('\u4E00', radical1.TraditionalCharacterCodePoint); Assert.Equal('\u2F00', radical1.SimplifiedRadicalCodePoint); Assert.Equal('\u4E00', radical1.SimplifiedCharacterCodePoint); var radical214 = UnicodeInfo.GetCjkRadicalInfo(214); Assert.False(radical214.HasSimplifiedForm); Assert.Equal(214, radical214.RadicalIndex); Assert.Equal('\u2FD5', radical214.TraditionalRadicalCodePoint); Assert.Equal('\u9FA0', radical214.TraditionalCharacterCodePoint); Assert.Equal('\u2FD5', radical214.SimplifiedRadicalCodePoint); Assert.Equal('\u9FA0', radical214.SimplifiedCharacterCodePoint); Assert.Throws <IndexOutOfRangeException>(() => UnicodeInfo.GetCjkRadicalInfo(0)); Assert.Throws <IndexOutOfRangeException>(() => UnicodeInfo.GetCjkRadicalInfo(215)); }