public bool TryShowDialog(bool includeSeen = false)
        {
            if (freshVersions.Count == 0 && !includeSeen)
            {
                return(false);
            }
            List <UpdateFeatureDef> defsToShow;

            if (includeSeen)
            {
                defsToShow = DefDatabase <UpdateFeatureDef> .AllDefs.ToList();
            }
            else
            {
                // try to pull defs newer than already featured, remember highest pulled version
                defsToShow = new List <UpdateFeatureDef>();
                foreach (var freshVersionPair in freshVersions)
                {
                    var          modId        = freshVersionPair.Key;
                    var          freshVersion = freshVersionPair.Value;
                    var          knownVersion = TryGetKnownVersion(modId) ?? new VersionShort();
                    VersionShort highestVersionWithFeature = null;
                    foreach (var def in DefDatabase <UpdateFeatureDef> .AllDefs)
                    {
                        if (def.modIdentifier != modId)
                        {
                            continue;
                        }
                        if (def.Version <= knownVersion || def.Version > freshVersion)
                        {
                            continue;
                        }
                        defsToShow.Add(def);
                        if (highestVersionWithFeature == null || def.Version > highestVersionWithFeature)
                        {
                            highestVersionWithFeature = def.Version;
                        }
                    }
                    if (highestVersionWithFeature != null)
                    {
                        knownVersions[modId] = highestVersionWithFeature;
                    }
                }
            }
            if (defsToShow.Count > 0)
            {
                // sort defs by modNameReadable, Version
                defsToShow.Sort((d1, d2) => {
                    if (d1.modNameReadable == d2.modNameReadable)
                    {
                        return(d1.Version.CompareTo(d2.Version));
                    }
                    return(String.Compare(d1.modNameReadable, d2.modNameReadable, StringComparison.Ordinal));
                });
                Find.WindowStack.Add(new Dialog_UpdateFeatures(defsToShow));
                SaveData();
                return(true);
            }
            return(false);
        }
        public void InspectActiveMod(string modId, VersionShort currentVersion)
        {
            var knownVersion = TryGetKnownVersion(modId);

            if (knownVersion == null || currentVersion > knownVersion)
            {
                freshVersions.Add(modId, currentVersion);
            }
        }
 protected override void LoadFromXml(XDocument xml)
 {
     knownVersions.Clear();
     if (xml.Root == null)
     {
         throw new Exception("missing root node");
     }
     foreach (var element in xml.Root.Elements())
     {
         knownVersions.Add(element.Name.ToString(), VersionShort.Parse(element.Value));
     }
 }
        public override void ResolveReferences()
        {
            base.ResolveReferences();
            if (defName == null)
            {
                defName = modIdentifier + assemblyVersion;
            }
            if (modIdentifier == null)
            {
                ReportError("UpdateFeatureDef.modIdentifier must be set");
            }
            if (modNameReadable == null)
            {
                ReportError("UpdateFeatureDef.modNameReadable must be set");
            }
            Exception versionFailure = null;

            try {
                if (assemblyVersion == null)
                {
                    throw new Exception("UpdateFeatureDef.assemblyVersion must be defined");
                }
                Version = VersionShort.Parse(assemblyVersion);
            } catch (Exception e) {
                Version        = new VersionShort();
                versionFailure = e;
            }
            if (versionFailure != null)
            {
                ReportError("UpdateFeatureDef.version parsing failed: " + versionFailure);
            }
            if (content == null)
            {
                ReportError("UpdateFeatureDef.content must be set");
            }
        }