DreamineLocalizationManager.cs

이 파일의 문서화 페이지로 가기

using System.ComponentModel;
using System.IO;
using System.Windows;
 
namespace Dreamine.UI.Wpf.Localization;

public enum Language
{
    English,
    Korean,
    Chinese,
    Vietnamese
}

public enum TextcaseType
{
    Default,
    SentenceCase,
    TitleCase,
    UpperCase,
    LowerCase,
    EmphasisCase
}

public static class DreamineLocalizationManager
{
    private static readonly HashSet<Language> _valid = Enum.GetValues<Language>().ToHashSet();

    private static readonly Dictionary<Language, Dictionary<string, Dictionary<string, string>>> _langDict = new();

    private static Language _currentLanguage = Language.Korean;
    private static Language _oldLanguage     = Language.Korean;

    public static Language OldLanguage => _oldLanguage;

    public static Language CurrentLanguage
    {
        get => _currentLanguage;
        set
        {
            if (_valid.Contains(value) && _currentLanguage != value)
            {
                _oldLanguage     = _currentLanguage;
                _currentLanguage = value;
                LanguageChanged?.Invoke(null, EventArgs.Empty);
            }
        }
    }

    public static event EventHandler? LanguageChanged;

    public static IReadOnlyDictionary<Language, IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>>> Languages
        => _langDict.ToDictionary(
            l => l.Key,
            l => (IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>>)
                 l.Value.ToDictionary(s => s.Key, s => (IReadOnlyDictionary<string, string>)s.Value));

    public static void SetLanguageData(
        Language language,
        Dictionary<Language, Dictionary<string, Dictionary<string, string>>> data)
    {
        _langDict.Clear();
        foreach (var kv in data)
            _langDict[kv.Key] = kv.Value;
        CurrentLanguage = language;
    }

    public static void Load(
        Func<string, Dictionary<string, Dictionary<string, string>>> loadFn,
        Language language = Language.English,
        string? basePath = null)
    {
        CurrentLanguage = language;
        string dir = basePath ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Languages");
 
        foreach (Language lang in Enum.GetValues<Language>())
        {
            string langName = lang.ToString();
            string filePath = Path.Combine(dir, $"Ui{langName}.INI");
            if (!File.Exists(filePath))
                filePath = Path.Combine(dir, $"UI_{langName}.INI");
            if (!File.Exists(filePath))
                continue;
 
            _langDict[lang] = loadFn(filePath);
        }
    }

    public static string Get(string section, string key)
        => Get(CurrentLanguage, section, key);

    public static string Get(Language lang, string section, string key)
    {
        if (_langDict.TryGetValue(lang, out var sectionDict) &&
            sectionDict.TryGetValue(section, out var keyDict) &&
            keyDict.TryGetValue(key, out var value))
            return value;
 
        return null!;
    }

    public static string? GetKeyFromValue(Language lang, string section, string value)
    {
        if (_langDict.TryGetValue(lang, out var sectionDict) &&
            sectionDict.TryGetValue(section, out var keyDict))
        {
            foreach (var pair in keyDict)
                if (pair.Value == value) return pair.Key;
        }
        return null;
    }

    public static string GetLocalizedEquivalent(string section, string value)
    {
        if (string.IsNullOrEmpty(value)) return value;
        var key     = GetKeyFromValue(_oldLanguage, section, value);
        if (string.IsNullOrEmpty(key)) return value;
        var newLang = Get(CurrentLanguage, section, key);
        return string.IsNullOrEmpty(newLang) ? value : newLang;
    }
}

public class StaticLocalizationProxy : DependencyObject, INotifyPropertyChanged
{
    public static StaticLocalizationProxy Instance { get; set; } = new();

    public StaticLocalizationProxy()
    {
        DreamineLocalizationManager.LanguageChanged += (_, _) => OnPropertyChanged(nameof(CurrentLanguage));
    }

    public Language CurrentLanguage
    {
        get => DreamineLocalizationManager.CurrentLanguage;
        set => DreamineLocalizationManager.CurrentLanguage = value;
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    protected void OnPropertyChanged(string name)
        => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}