Add i18n support [WIP]

Wox.Core/Theme/FontHelper.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Linq;
+using System.Windows;
+using System.Windows.Media;
+
+namespace Wox.Core.Theme
+{
+    public static class FontHelper
+    {
+        static FontWeightConverter fontWeightConverter = new FontWeightConverter();
+        public static FontWeight GetFontWeightFromInvariantStringOrNormal(string value)
+        {
+            if (value == null) return FontWeights.Normal;
+
+            try
+            {
+                return (FontWeight) fontWeightConverter.ConvertFromInvariantString(value);
+            }
+            catch {
+                return FontWeights.Normal;
+            }
+        }
+
+        static FontStyleConverter fontStyleConverter = new FontStyleConverter();
+        public static FontStyle GetFontStyleFromInvariantStringOrNormal(string value)
+        {
+            if (value == null) return FontStyles.Normal;
+
+            try
+            {
+                return (FontStyle)fontStyleConverter.ConvertFromInvariantString(value);
+            }
+            catch
+            {
+                return FontStyles.Normal;
+            }
+        }
+
+        static FontStretchConverter fontStretchConverter = new FontStretchConverter();
+        public static FontStretch GetFontStretchFromInvariantStringOrNormal(string value)
+        {
+            if (value == null) return FontStretches.Normal;
+            try
+            {
+                return (FontStretch)fontStretchConverter.ConvertFromInvariantString(value);
+            }
+            catch
+            {
+                return FontStretches.Normal;
+            }
+        }
+
+        public static FamilyTypeface ChooseRegularFamilyTypeface(this FontFamily family)
+        {
+            return family.FamilyTypefaces.OrderBy(o =>
+            {
+                return Math.Abs(o.Stretch.ToOpenTypeStretch() - FontStretches.Normal.ToOpenTypeStretch()) * 100 +
+                    Math.Abs(o.Weight.ToOpenTypeWeight() - FontWeights.Normal.ToOpenTypeWeight()) +
+                    (o.Style == FontStyles.Normal ? 0 : o.Style == FontStyles.Oblique ? 1 : 2) * 1000;
+            }).FirstOrDefault() ?? family.FamilyTypefaces.FirstOrDefault();
+        }
+
+        public static FamilyTypeface ConvertFromInvariantStringsOrNormal(this FontFamily family, string style, string weight, string stretch)
+        {
+            var styleObj = GetFontStyleFromInvariantStringOrNormal(style);
+            var weightObj = GetFontWeightFromInvariantStringOrNormal(weight);
+            var stretchObj = GetFontStretchFromInvariantStringOrNormal(stretch);
+            return family.FamilyTypefaces.FirstOrDefault(o => o.Style == styleObj && o.Weight == weightObj && o.Stretch == stretchObj)
+                ?? family.ChooseRegularFamilyTypeface();
+        }
+
+    }
+}

Wox.Core/Theme/ThemeManager.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using Wox.Core.UI;
+using Wox.Infrastructure.Logger;
+using Wox.Infrastructure.Storage.UserSettings;
+
+namespace Wox.Core.Theme
+{
+    public class ThemeManager : IUIResource
+    {
+        private static List<string> themeDirectories = new List<string>();
+        private static ThemeManager instance;
+        private static object syncObject = new object();
+
+        private ThemeManager() { }
+
+        public static ThemeManager Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    lock (syncObject)
+                    {
+                        if (instance == null)
+                        {
+                            instance = new ThemeManager();
+                        }
+                    }
+                }
+                return instance;
+            }
+        }
+
+        static ThemeManager()
+        {
+            themeDirectories.Add(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Themes"));
+
+            string userProfilePath = Environment.GetEnvironmentVariable("USERPROFILE");
+            if (userProfilePath != null)
+            {
+                themeDirectories.Add(Path.Combine(Path.Combine(userProfilePath, ".Wox"), "Themes"));
+            }
+
+            MakesureThemeDirectoriesExist();
+        }
+
+        private static void MakesureThemeDirectoriesExist()
+        {
+            foreach (string pluginDirectory in themeDirectories)
+            {
+                if (!Directory.Exists(pluginDirectory))
+                {
+                    try
+                    {
+                        Directory.CreateDirectory(pluginDirectory);
+                    }
+                    catch (System.Exception e)
+                    {
+                        Log.Error(e.Message);
+                    }
+                }
+            }
+        }
+
+        public void ChangeTheme(string themeName)
+        {
+            string themePath = GetThemePath(themeName);
+            if (string.IsNullOrEmpty(themePath))
+            {
+                themePath = GetThemePath("Dark");
+                if (string.IsNullOrEmpty(themePath))
+                {
+                    throw new System.Exception("Change theme failed");
+                }
+            }
+
+            UserSettingStorage.Instance.Theme = themeName;
+            UserSettingStorage.Instance.Save();
+
+            ResourceMerger.ApplyResources();
+        }
+
+        public ResourceDictionary GetResourceDictionary()
+        {
+            var dict = new ResourceDictionary
+            {
+                Source = new Uri(GetThemePath(UserSettingStorage.Instance.Theme), UriKind.Absolute)
+            };
+
+            Style queryBoxStyle = dict["QueryBoxStyle"] as Style;
+            if (queryBoxStyle != null)
+            {
+                queryBoxStyle.Setters.Add(new Setter(TextBox.FontFamilyProperty, new FontFamily(UserSettingStorage.Instance.QueryBoxFont)));
+                queryBoxStyle.Setters.Add(new Setter(TextBox.FontStyleProperty, FontHelper.GetFontStyleFromInvariantStringOrNormal(UserSettingStorage.Instance.QueryBoxFontStyle)));
+                queryBoxStyle.Setters.Add(new Setter(TextBox.FontWeightProperty, FontHelper.GetFontWeightFromInvariantStringOrNormal(UserSettingStorage.Instance.QueryBoxFontWeight)));
+                queryBoxStyle.Setters.Add(new Setter(TextBox.FontStretchProperty, FontHelper.GetFontStretchFromInvariantStringOrNormal(UserSettingStorage.Instance.QueryBoxFontStretch)));
+            }
+
+            Style resultItemStyle = dict["ItemTitleStyle"] as Style;
+            Style resultSubItemStyle = dict["ItemSubTitleStyle"] as Style;
+            Style resultItemSelectedStyle = dict["ItemTitleSelectedStyle"] as Style;
+            Style resultSubItemSelectedStyle = dict["ItemSubTitleSelectedStyle"] as Style;
+            if (resultItemStyle != null && resultSubItemStyle != null && resultSubItemSelectedStyle != null && resultItemSelectedStyle != null)
+            {
+                Setter fontFamily = new Setter(TextBlock.FontFamilyProperty, new FontFamily(UserSettingStorage.Instance.ResultItemFont));
+                Setter fontStyle = new Setter(TextBlock.FontStyleProperty, FontHelper.GetFontStyleFromInvariantStringOrNormal(UserSettingStorage.Instance.ResultItemFontStyle));
+                Setter fontWeight = new Setter(TextBlock.FontWeightProperty, FontHelper.GetFontWeightFromInvariantStringOrNormal(UserSettingStorage.Instance.ResultItemFontWeight));
+                Setter fontStretch = new Setter(TextBlock.FontStretchProperty, FontHelper.GetFontStretchFromInvariantStringOrNormal(UserSettingStorage.Instance.ResultItemFontStretch));
+
+                Setter[] setters = new Setter[] { fontFamily, fontStyle, fontWeight, fontStretch };
+                Array.ForEach(new Style[] { resultItemStyle, resultSubItemStyle, resultItemSelectedStyle, resultSubItemSelectedStyle }, o => Array.ForEach(setters, p => o.Setters.Add(p)));
+            }
+
+            return dict;
+        }
+
+        public List<string> LoadAvailableThemes()
+        {
+            List<string> themes = new List<string>();
+            foreach (var themeDirectory in themeDirectories)
+            {
+                themes.AddRange(
+                    Directory.GetFiles(themeDirectory)
+                        .Where(filePath => filePath.EndsWith(".xaml") && !filePath.EndsWith("Base.xaml"))
+                        .ToList());
+            }
+            return themes;
+        }
+
+        private string GetThemePath(string themeName)
+        {
+            foreach (string themeDirectory in themeDirectories)
+            {
+                string path = Path.Combine(themeDirectory, themeName + ".xaml");
+                if (File.Exists(path))
+                {
+                    return path;
+                }
+            }
+
+            return string.Empty;
+        }
+    }
+}