Exemple #1
0
        public IconMappingPresets Load(Stream streamWithIconNameMappingFile)
        {
            if (streamWithIconNameMappingFile == null)
            {
                throw new ArgumentNullException(nameof(streamWithIconNameMappingFile));
            }

            IconMappingPresets result = null;

            try
            {
                result = SerializationHelper.LoadFromStream <IconMappingPresets>(streamWithIconNameMappingFile);
                //no mappings = old version of file without version info
                if (result?.IconNameMappings == null)
                {
                    if (streamWithIconNameMappingFile.CanSeek)
                    {
                        streamWithIconNameMappingFile.Position = 0;
                    }

                    var oldIconMapping = SerializationHelper.LoadFromStream <List <IconNameMap> >(streamWithIconNameMappingFile);
                    result.IconNameMappings = oldIconMapping;

                    result.Version = string.Empty;
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine($"Error loading the icon name mapping file.{Environment.NewLine}{ex}");
                throw;
            }

            return(result);
        }
        public void WriteIconNameMapping(IconFileNameHelper iconFileNameHelper, bool isTest, IEnumerable <XmlNode> iconNodes, Dictionary <string, SerializableDictionary <string> > localizations, string annoVersion, string BUILDING_PRESETS_VERSION)
        {
            var iconNameMappings = new IconMappingPresets()
            {
                Version = BUILDING_PRESETS_VERSION
            };

            foreach (var iconNode in iconNodes)
            {
                var guid         = iconNode["GUID"].InnerText;
                var iconFilename = iconFileNameHelper.GetIconFilename(iconNode["Icons"].FirstChild, annoVersion);
                if (!localizations.ContainsKey(guid) || iconNameMappings.IconNameMappings.Exists(_ => _.IconFilename == iconFilename))
                {
                    continue;
                }

                iconNameMappings.IconNameMappings.Add(new IconNameMap
                {
                    IconFilename  = iconFilename,
                    Localizations = localizations[guid]
                });
            }

            if (!isTest)
            {
                var fileName = "icons-Anno" + annoVersion + "-v" + BUILDING_PRESETS_VERSION + ".json";
                SerializationHelper.SaveToFile(iconNameMappings, fileName);
                Console.WriteLine($"saved icon name mapping file: {fileName}");
            }
            else
            {
                Console.WriteLine("THIS IS A TEST: No icons.json file is writen");
            }
        }
        public IconMappingPresets Load(string jsonString)
        {
            if (string.IsNullOrWhiteSpace(jsonString))
            {
                throw new ArgumentNullException(nameof(jsonString));
            }
            var result = new IconMappingPresets();

            try
            {
                result = SerializationHelper.LoadFromJsonString <IconMappingPresets>(jsonString);
            }
            catch (Newtonsoft.Json.JsonSerializationException)
            {
                //failed deserialization = old version of file without version info
                var oldIconMapping = SerializationHelper.LoadFromJsonString <List <IconNameMap> >(jsonString);
                result.IconNameMappings = oldIconMapping;
                result.Version          = string.Empty;
            }
            catch (Exception ex)
            {
                logger.Error(ex, "Error loading the icon name mapping file.");
                throw;
            }

            return(result);
        }
Exemple #4
0
        public Dictionary <string, IconImage> Load(IconMappingPresets iconNameMapping)
        {
            Dictionary <string, IconImage> result = null;

            try
            {
                result = new Dictionary <string, IconImage>();

                var pathToIconFolder = Path.Combine(App.ApplicationPath, Constants.IconFolder);

                foreach (var path in Directory.EnumerateFiles(pathToIconFolder, Constants.IconFolderFilter))
                {
                    var filenameWithoutExt = Path.GetFileNameWithoutExtension(path);
                    if (string.IsNullOrWhiteSpace(filenameWithoutExt))
                    {
                        continue;
                    }

                    var filenameWithExt = Path.GetFileName(path);

                    // try mapping to the icon translations
                    Dictionary <string, string> localizations = null;
                    if (iconNameMapping?.IconNameMappings != null)
                    {
                        var map = iconNameMapping.IconNameMappings.Find(x => string.Equals(x.IconFilename, filenameWithExt, StringComparison.OrdinalIgnoreCase));
                        if (map != null)
                        {
                            localizations = map.Localizations.Dict;
                        }
                    }

                    // add the current icon
                    result.Add(filenameWithoutExt, new IconImage(filenameWithoutExt, localizations, path));
                }

                // sort icons by their DisplayName
                result = result.OrderBy(x => x.Value.DisplayName).ToDictionary(x => x.Key, x => x.Value);
            }
            catch (Exception ex)
            {
                Trace.WriteLine($"Error loading the icons.{Environment.NewLine}{ex}");
                throw;
            }

            return(result);
        }
        public Dictionary<string, IconImage> Load(string pathToIconFolder, IconMappingPresets iconNameMapping)
        {
            Dictionary<string, IconImage> result = null;

            try
            {
                result = new Dictionary<string, IconImage>();

                foreach (var path in Directory.EnumerateFiles(pathToIconFolder, CoreConstants.IconFolderFilter))
                {
                    var filenameWithoutExt = Path.GetFileNameWithoutExtension(path);
                    if (string.IsNullOrWhiteSpace(filenameWithoutExt))
                    {
                        continue;
                    }

                    var filenameWithExt = Path.GetFileName(path);

                    // try mapping to the icon translations
                    Dictionary<string, string> localizations = null;
                    if (iconNameMapping?.IconNameMappings != null)
                    {
                        var map = iconNameMapping.IconNameMappings.Find(x => string.Equals(x.IconFilename, filenameWithExt, StringComparison.OrdinalIgnoreCase));
                        if (map != null)
                        {
                            localizations = map.Localizations.Dict;
                        }
                    }

                    // add the current icon
                    result.Add(filenameWithoutExt, new IconImage(filenameWithoutExt, localizations, path));
                }

                // sort icons by their DisplayName
                result = result.OrderBy(x => x.Value.DisplayName).ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase);//make sure ContainsKey is caseInSensitive
            }
            catch (Exception ex)
            {
                logger.Error(ex, "Error loading the icons.");
                throw;
            }

            return result;
        }
        public IconMappingPresets Load()
        {
            IconMappingPresets result = null;

            try
            {
                result = DataIO.LoadFromFile <IconMappingPresets>(Path.Combine(App.ApplicationPath, Constants.IconNameFile));
                //no mappings = old version of file without version info
                if (result?.IconNameMappings == null)
                {
                    var oldIconMapping = DataIO.LoadFromFile <List <IconNameMap> >(Path.Combine(App.ApplicationPath, Constants.IconNameFile));
                    result.IconNameMappings = oldIconMapping;

                    result.Version = string.Empty;
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine($"Error loading the icon name mapping file.{Environment.NewLine}{ex}");
                throw;
            }

            return(result);
        }