protected abstract bool TryFindDataTemplate(
     ResourceDictionary resources, 
     FrameworkElement resourcesOwner,
     DependencyObject itemContainer,
     object item, 
     Type itemType,
     out DataTemplate dataTemplate);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="existing"></param>
        /// <param name="newResource"></param>
        /// <param name="validTypes"></param>
        /// <returns></returns>
        public static bool VerifyResources(this ResourceDictionary existing, ResourceDictionary newResource, params Type[] validTypes)
        {
            if (existing == null)
                throw new ArgumentNullException("existing");

            if (newResource == null)
                return false;

            if (validTypes != null && validTypes.Length > 0)
            {
                foreach (var resource in newResource.Values)
                {
                    if (!(resource.GetType().IsAssignableToAny(validTypes)))
                    {
                        MessageBox.Show(FindText("InvalidLanguageResourceType"), FindText("ApplicationTitle"), MessageBoxButton.OK, MessageBoxImage.Error);
                        return false;
                    }
                }
            }

            var newKeys = newResource.Keys.Cast<object>();

            foreach (var existingKey in existing.Keys)
            {
                if (!newKeys.Contains(existingKey))
                {
                    var message = FindText("MissingLanguageResourceKey", existingKey);
                    MessageBox.Show(message, FindText("ApplicationTitle"), MessageBoxButton.OK, MessageBoxImage.Error);
                    return false;
                }
            }

            return true;
        }

        private static ResourceDictionary LoadDictionary()
        {
            if (cacheDictionary != null)
                return cacheDictionary;

            ResourceDictionary dictionary = null;
            try
            {
                dictionary =
                    (ResourceDictionary)Application.LoadComponent(
                        new Uri(@"Lang\" + CurrentCultureInfo.Name + ".xaml", UriKind.Relative));
            }
            catch
            {
            }

            //If dictionary is still null, use default language.
            if (dictionary == null)
                if (Application.Current.Resources.MergedDictionaries.Count > 0)
                    dictionary = Application.Current.Resources.MergedDictionaries[0];
                else
                    throw new Exception("No language file.");

            cacheDictionary = dictionary;

            return cacheDictionary;
        }

 static LogFormatter()
 {
     _imageDict = new ResourceDictionary()
     {
         Source = new Uri("pack://application:,,,/Resources;component/Images/SystemImages.xaml")
     };
 }

        public virtual void SetLightDark(bool isDark)
        {
            var existingResourceDictionary = Application.Current.Resources.MergedDictionaries
                .Where(rd => rd.Source != null)
                .SingleOrDefault(rd => Regex.Match(rd.Source.AbsolutePath, @"(\/MaterialDesignThemes.Wpf;component\/Themes\/MaterialDesignTheme\.)((Light)|(Dark))").Success);
            if (existingResourceDictionary == null)
                throw new ApplicationException("Unable to find Light/Dark base theme in Application resources.");

            var source = "pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme." + (isDark ? "Dark" : "Light") + ".xaml";

            //$"pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.{(isDark ? "Dark" : "Light")}.xaml";
            var newResourceDictionary = new ResourceDictionary() { Source = new Uri(source) };

            Application.Current.Resources.MergedDictionaries.Remove(existingResourceDictionary);
            Application.Current.Resources.MergedDictionaries.Add(newResourceDictionary);

            var existingMahAppsResourceDictionary = Application.Current.Resources.MergedDictionaries
                .Where(rd => rd.Source != null)
                .SingleOrDefault(rd => Regex.Match(rd.Source.AbsolutePath, @"(\/MahApps.Metro;component\/Styles\/Accents\/)((BaseLight)|(BaseDark))").Success);
            if (existingMahAppsResourceDictionary == null) return;

            source =
                         "pack://application:,,,/MahApps.Metro;component/Styles/Accents/" + (isDark ? "BaseDark" : "BaseLight") + ".xaml";
          //  $"pack://application:,,,/MahApps.Metro;component/Styles/Accents/{(isDark ? "BaseDark" : "BaseLight")}.xaml";
            var newMahAppsResourceDictionary = new ResourceDictionary { Source = new Uri(source) };

            Application.Current.Resources.MergedDictionaries.Remove(existingMahAppsResourceDictionary);
            Application.Current.Resources.MergedDictionaries.Add(newMahAppsResourceDictionary);
        }

        public ChgReserveWindow()
        {
            InitializeComponent();

            if (Settings.Instance.NoStyle == 0)
            {
                ResourceDictionary rd = new ResourceDictionary();
                rd.MergedDictionaries.Add(
                    Application.LoadComponent(new Uri("/PresentationFramework.Aero, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35;component/themes/aero.normalcolor.xaml", UriKind.Relative)) as ResourceDictionary
                    //Application.LoadComponent(new Uri("/PresentationFramework.Classic, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, ProcessorArchitecture=MSIL;component/themes/Classic.xaml", UriKind.Relative)) as ResourceDictionary
                    );
                this.Resources = rd;
            }
            else
            {
                button_chg_reserve.Style = null;
                button_del_reserve.Style = null;
                button_cancel.Style = null;
            }

            comboBox_service.ItemsSource = ChSet5.Instance.ChList.Values;
            comboBox_sh.ItemsSource = CommonManager.Instance.HourDictionary.Values;
            comboBox_eh.ItemsSource = CommonManager.Instance.HourDictionary.Values;
            comboBox_sm.ItemsSource = CommonManager.Instance.MinDictionary.Values;
            comboBox_em.ItemsSource = CommonManager.Instance.MinDictionary.Values;
            comboBox_ss.ItemsSource = CommonManager.Instance.MinDictionary.Values;
            comboBox_es.ItemsSource = CommonManager.Instance.MinDictionary.Values;
        }

        protected PackagesProviderBase(
            IPackageRepository localRepository, 
            ResourceDictionary resources, 
            ProviderServices providerServices, 
            IProgressProvider progressProvider, 
            ISolutionManager solutionManager)
        {
            if (resources == null)
            {
                throw new ArgumentNullException("resources");
            }

            if (providerServices == null)
            {
                throw new ArgumentNullException("providerServices");
            }

            if (solutionManager == null)
            {
                throw new ArgumentNullException("solutionManager");
            }

            _localRepository = localRepository;
            _providerServices = providerServices;
            _progressProvider = progressProvider;
            _solutionManager = solutionManager;
            _resources = resources;
            _outputConsole = new Lazy<IConsole>(() => providerServices.OutputConsoleProvider.CreateOutputConsole(requirePowerShellHost: false));
        }

 public SharedThemeService(ResourceDictionary resourceDictionary)
 {
     _resourceDictionary = resourceDictionary;
     _themes = new BehaviorSubject<IEnumerable<ITheme>>(Enumerable.Empty<ITheme>());
     _activeTheme = new BehaviorSubject<ITheme>(null);
     _themesMap = new Dictionary<string, ITheme>();
 }

        //private static readonly Logger _logger = LogManager.GetCurrentClassLogger();
        public static ResourceDictionary GetDictionary(string relativePath = @"Resources\Dictionaries")
        {
            var mergedDictionary = new ResourceDictionary();
            string path = Path.Combine(HttpRuntime.AppDomainAppPath, relativePath);

            if (Directory.Exists(path))
                foreach (string fileName in Directory.GetFiles(path).Where(f => f.EndsWith(".xaml")))
                    using (var fs = new FileStream(fileName, FileMode.Open))
                    {
                        try
                        {
                            var xr = new XamlReader();

                            var tmp = (ResourceDictionary)XamlReader.Load(fs);
                            foreach (string key in tmp.Keys)
                                if (tmp[key] is Canvas)
                                {
                                    mergedDictionary.Add(key, tmp[key]);
                                }

                        }
                        catch (Exception)
                        {
                            //_logger.Error(ex.Message);
                        }
                    }
            else
                Directory.CreateDirectory(path);

            return mergedDictionary;
        }

 public void LoadStyle()
 {
     Uri resourceLocater = HbRelogManager.Settings.UseDarkStyle ? new Uri("/styles/ExpressionDark.xaml", UriKind.Relative) : new Uri("/styles/BureauBlue.xaml", UriKind.Relative);
     var rDict = new ResourceDictionary { Source = resourceLocater };
     Resources.MergedDictionaries.Clear();
     Resources.MergedDictionaries.Add(rDict);
 }

 public ThemeManager()
 {
     this.themeResources = new ResourceDictionary
                               {
                                   Source = new Uri("pack://application:,,,/Caliburn.Metro.Demo;component/Resources/Theme1.xaml")
                               };
 }

        internal static void ChangeTheme(string theme)
        {
            var app = System.Windows.Application.Current;
            if (string.IsNullOrEmpty(theme))
            {
                if (currentUri != null)
                {
                    var oldtheme = app.Resources.MergedDictionaries[app.Resources.MergedDictionaries.Count - 1];
                    //FindName(currentUri.OriginalString) as ResourceDictionary;
                    app.Resources.MergedDictionaries.Remove(oldtheme);
                }
                CurrentSkin = null;
                currentUri = null;
                return;
            }

            Uri resourceLocator = new Uri("BackBock;Component/Themes/" + theme + "/Theme.xaml", UriKind.Relative);
            //Application.Current.Resources =  Application.LoadComponent(resourceLocator) as ResourceDictionary;
            //var dictionary = System.Windows.Application.LoadComponent(resourceLocator) as ResourceDictionary;
            var dictionary = new ResourceDictionary();
            dictionary.Source = resourceLocator;
            if (currentUri != null)
            {
                var oldtheme = app.Resources.MergedDictionaries[app.Resources.MergedDictionaries.Count - 1];
                //FindName(currentUri.OriginalString) as ResourceDictionary;
                app.Resources.MergedDictionaries.Remove(oldtheme);
            }

            app.Resources.MergedDictionaries.Add(dictionary);
            //app.Resources = dictionary;
            CurrentSkin = theme;
            currentUri = resourceLocator;
        }

        private static void RegisterResources(string moduleName = null)
        {
            var dictionary = new ResourceDictionary();
            
            

            if (string.IsNullOrEmpty(moduleName))
            {
                StackTrace stackTrace = new StackTrace();
                Assembly assembly = stackTrace.GetFrame(2).GetMethod().Module.Assembly;
                string assemblyName = assembly.FullName;
                string[] nameParts = assemblyName.Split(',');
                moduleName = nameParts[0];
            }
#if SILVERLIGHT

            StreamResourceInfo resourceInfo = Application.GetResourceStream(new Uri(moduleName + ";component/Resources/ModuleResources.xaml", UriKind.Relative));
            if (resourceInfo == null) return;
            var resourceReader = new StreamReader(resourceInfo.Stream);
            string xaml = resourceReader.ReadToEnd();
            var resourceTheme = XamlReader.Load(xaml) as ResourceDictionary;
            Application.Current.Resources.MergedDictionaries.Add(resourceTheme);
#else
        dictionary.Source = new Uri(
            "pack://application:,,,/" + moduleName + ";component/Resources/ModuleResources.xaml");
        Application.Current.Resources.MergedDictionaries.Add(dictionary);
#endif
        }

        public void ApplyConvention(Assembly assembly, DictionaryEntry entry)
        {
            string assemblyName = assembly.GetName().Name;
            string key = entry.Key as string;
            key = key.Replace(".baml", ".xaml");

            string uriString = String.Format("pack://application:,,,/{0};Component/{1}", assemblyName, key);

            try
            {
                if (!uriString.ToUpper().Contains("VIEW.XAML")
                    && !uriString.ToUpper().Contains("APP.XAML"))
                {
                    var dictionary = new ResourceDictionary
                                         {
                                             Source = new Uri(uriString)
                                         };

                    Application.Current.Resources.MergedDictionaries.Add(dictionary);
                }
            }
            catch
            {
                // do nothing. This allows for user controls to 'not' be loaded into the
                // Resource Dictionary
            }
        }

        // Given a ResourceDictionary and a set of keys, try to find the best
        //  match in the resource dictionary.
        private static object FindBestMatchInResourceDictionary(
            ResourceDictionary table, ArrayList keys, int exactMatch, ref int bestMatch)
        {
            object resource = null;
            int k;

            // Search target element's ResourceDictionary for the resource
            if (table != null)
            {
                for (k = 0; k < bestMatch; ++k)
                {
                    object candidate = table[keys[k]];
                    if (candidate != null)
                    {
                        resource = candidate;
                        bestMatch = k;

                        // if we found an exact match, no need to continue
                        if (bestMatch < exactMatch)
                            return resource;
                    }
                }
            }

            return resource;
        }

        private static ResourceDictionary LoadDictionary()
        {
            if (cacheDictionary != null)
                return cacheDictionary;

            ResourceDictionary dictionary = null;
            try
            {
                Application.Current.Resources.MergedDictionaries
                           .Insert(0,
                                   XamlReader.Load(
                                                   new FileStream(
                                                       Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
                                                       + @"\Lang\" + CurrentCultureInfo.Name + ".xaml",
                                                       FileMode.Open)) as ResourceDictionary);
            }
            catch
            {
            }

            //If dictionary is still null, use default language.
            if (dictionary == null)
                if (Application.Current.Resources.MergedDictionaries.Count > 0)
                    dictionary = Application.Current.Resources.MergedDictionaries[0];
                else
                    throw new Exception("No language file.");

            cacheDictionary = dictionary;

            return cacheDictionary;
        }

        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;
        }

        private void SugarButton_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            // check if the theme is supposed to be the owner
            if (this.Theme == Theme.Owner)
            {
                this.Theme = CommonMethods.GetTheme(this);
            }

            // The resource dictionaire that contain desired style
            ResourceDictionary resource = new ResourceDictionary();


            // Apply the theme
            switch (this.Theme)
            {
                case Theme.Sugar:
                    resource.Source = new Uri("/SugarControls;component/Themes/Sugar/SugarImageButtonStyle.xaml", UriKind.RelativeOrAbsolute);
                    this.Style = (Style)resource["SugarImageButtonStyle"];
                    break;
                case Theme.VS:
                    resource.Source = new Uri("/SugarControls;component/Themes/VS/VSImageButtonStyle.xaml", UriKind.RelativeOrAbsolute);
                    this.Style = (Style)resource["VSImageButtonStyle"];
                    break;
                default:
                    break;
            }


        }

        /// <summary>
        /// return object 
        /// </summary>
        /// <returns></returns>
        public static ResourceDictionary Objectlang()
        {
            var s = String.Empty;

            switch (Elang)
            {
                case Lang.Portuguese:
                    s = "..\\Lang\\LANG_BR.xaml";
                    break;
                case Lang.English:
                    s = "..\\Lang\\LANG_EN.xaml";
                    break;
                //case Lang.Chinese:
                //    s = "..\\Lang\\LANG_CH.xaml";
                //    break;
                case Lang.Korean:
                    s = "..\\Lang\\LANG_KO.xaml";
                    break;
            }
            if (s != string.Empty)
            {
                ResourceDictionary d = new ResourceDictionary()
                {
                    Source =  new Uri(s ,UriKind.Relative)
                };
                return d;
            }
            return null;
        }

 void SugarIconPresenter_Loaded(object sender, RoutedEventArgs e)
 {
     // Get the resource containing the Window Style and assign it to the window
     ResourceDictionary _resources = new ResourceDictionary();
     _resources.Source = new Uri("/SugarControls;component/Styles/IconPresenter.xaml", UriKind.RelativeOrAbsolute);
     this.Style = (Style)_resources["IconPresenter"];
 }