/// <summary>
/// Returns a simple array of all incompatible modules for
/// the specified version of KSP (installed version by default)
/// </summary>
public List <CkanModule> Incompatible(KSPVersion ksp_version = null)
{
// Default to the user's current KSP install for version.
if (ksp_version == null)
{
ksp_version = KSPManager.CurrentInstance.Version();
}
var candidates = new List <string>(available_modules.Keys);
var incompatible = new List <CkanModule>();
// It's nice to see things in alphabetical order, so sort our keys first.
candidates.Sort();
// Now find what we can give our user.
foreach (string candidate in candidates)
{
CkanModule available = LatestAvailable(candidate, ksp_version);
if (available == null)
{
incompatible.Add(LatestAvailable(candidate, null));
}
}
return(incompatible);
}
private void DeSerialisationFixes(StreamingContext like_i_could_care)
{
// Make sure our version fields are populated.
// TODO: There's got to be a better way of doing this, right?
if (ksp_version_min == null)
{
ksp_version_min = new KSPVersion(null);
}
else
{
ksp_version_min.ToLongMin();
}
if (ksp_version_max == null)
{
ksp_version_max = new KSPVersion(null);
}
else
{
ksp_version_max.ToLongMax();
}
if (ksp_version == null)
{
ksp_version = new KSPVersion(null);
}
// Now see if we've got version with version min/max.
if (ksp_version.IsNotAny() && (ksp_version_max.IsNotAny() || ksp_version_min.IsNotAny()))
{
// KSP version mixed with min/max.
throw new InvalidModuleAttributesException("ksp_version mixed wtih ksp_version_(min|max)", this);
}
}
public GUIMod(CkanModule mod, Registry registry, KSPVersion ksp_version)
{
//Currently anything which could alter these causes a full reload of the modlist
// If this is ever changed these could be moved into the properties
Mod = mod;
IsInstalled = registry.IsInstalled(mod.identifier);
IsInstallChecked = IsInstalled;
HasUpdate = registry.HasUpdate(mod.identifier);
IsIncompatible = !mod.IsCompatibleKSP(ksp_version);
IsAutodetected = registry.IsAutodetected(mod.identifier);
Authors = mod.author == null ? "N/A" : String.Join(",", mod.author);
var installedVersion = registry.InstalledVersion(mod.identifier);
var latestVersion = mod.version;
var kspVersion = mod.ksp_version;
InstalledVersion = installedVersion != null?installedVersion.ToString() : "-";
LatestVersion = latestVersion != null?latestVersion.ToString() : "-";
KSPversion = kspVersion != null?kspVersion.ToString() : "-";
Abstract = mod.@abstract;
Homepage = mod.resources != null && mod.resources.homepage != null
? (object)mod.resources.homepage
: "N/A";
Identifier = mod.identifier;
}
/// <summary>
/// Tries to parse an identifier in the format Modname=version
/// If the module cannot be found in the registry, throws a ModuleNotFoundKraken.
/// </summary>
public static CkanModule FromIDandVersion(Registry registry, string mod, KSPVersion ksp_version)
{
CkanModule module;
Match match = Regex.Match(mod, @"^(?<mod>[^=]*)=(?<version>.*)$");
if (match.Success)
{
string ident = match.Groups["mod"].Value;
string version = match.Groups["version"].Value;
module = registry.GetModuleByVersion(ident, version);
if (module == null)
{
throw new ModuleNotFoundKraken(ident, version, string.Format("Cannot install {0}, version {1} not available", ident, version));
}
}
else
{
module = registry.LatestAvailable(mod, ksp_version);
}
if (module == null)
{
throw new ModuleNotFoundKraken(mod, null, string.Format("Cannot install {0}, module not available", mod));
}
else
{
return(module);
}
}
/// <summary>
/// Creates a new resolver that will find a way to install all the modules specified.
/// </summary>
public RelationshipResolver(ICollection <CkanModule> modules, RelationshipResolverOptions options, Registry registry,
KSPVersion kspversion)
{
this.registry = registry;
this.kspversion = kspversion;
// Start by figuring out what versions we're installing, and then
// adding them to the list. This *must* be pre-populated with all
// user-specified modules, as they may be supplying things that provide
// virtual packages.
var user_requested_mods = new List <CkanModule>();
log.DebugFormat("Processing relationships for {0} modules", modules.Count);
foreach (CkanModule module in modules)
{
log.DebugFormat("Preparing to resolve relationships for {0} {1}", module.identifier, module.version);
var module1 = module; //Silence a warning re. closures over foreach var.
foreach (CkanModule listed_mod in modlist.Values.Where(listed_mod => listed_mod.ConflictsWith(module1)))
{
if (options.procede_with_inconsistencies)
{
conflicts.Add(new KeyValuePair <Module, Module>(listed_mod, module));
conflicts.Add(new KeyValuePair <Module, Module>(module, listed_mod));
}
else
{
throw new InconsistentKraken(string.Format("{0} conflicts with {1}, can't install both.", module,
listed_mod));
}
}
user_requested_mods.Add(module);
Add(module, new Relationship.UserRequested());
}
// Now that we've already pre-populated modlist, we can resolve
// the rest of our dependencies.
foreach (CkanModule module in user_requested_mods)
{
log.InfoFormat("Resolving relationships for {0}", module.identifier);
Resolve(module, options);
}
var final_modules = new List <Module>(modlist.Values);
final_modules.AddRange(registry.InstalledModules.Select(x => x.Module));
if (!options.without_enforce_consistency)
{
// Finally, let's do a sanity check that our solution is actually sane.
SanityChecker.EnforceConsistency(
final_modules,
registry.InstalledDlls
);
}
}
public bool Compatible(KSPVersion gameVersion, CkanModule module)
{
KSPVersion ksp_version = module.ksp_version;
KSPVersion ksp_version_min = module.ksp_version_min;
KSPVersion ksp_version_max = module.ksp_version_max;
// Check the min and max versions.
if (ksp_version_min.IsNotAny() && gameVersion < ksp_version_min)
{
return(false);
}
if (ksp_version_max.IsNotAny() && gameVersion > ksp_version_max)
{
return(false);
}
// We didn't hit the min/max guards. They may not have existed.
// Note that since ksp_version is "any" if not specified, this
// will work fine if there's no target, or if there were min/max
// fields and we passed them successfully.
return(ksp_version.Targets(gameVersion));
}
public bool Compatible(KSPVersion gameVersion, CkanModule module)
{
// If it's strictly compatible, then it's compatible.
if (strict.Compatible(gameVersion, module))
{
return(true);
}
// If we're in strict mode, and it's not strictly compatible, then it's
// not compatible.
if (module.ksp_version_strict)
{
return(false);
}
// Otherwise, check if it's "generally recognise as safe".
// If we're running KSP 1.0.4, then allow the mod to run if we would have
// considered it compatible under 1.0.3 (as 1.0.4 was "just a hotfix").
if (gameVersion.Equals("1.0.4"))
{
return(strict.Compatible(v103, module));
}
return(false);
}
/// <summary>
/// Returns the latest available version of a module that
/// satisifes the specified version. Takes into account module 'provides',
/// which may result in a list of alternatives being provided.
/// Returns an empty list if nothing is available for our system, which includes if no such module exists.
/// If no KSP version is provided, the latest module for *any* KSP version is given.
/// </summary>
public List <CkanModule> LatestAvailableWithProvides(string module, KSPVersion ksp_version)
{
// This public interface calcultes a cache of modules which
// are compatible with the current version of KSP, and then
// calls the private version below for heavy lifting.
return(LatestAvailableWithProvides(module, ksp_version,
available_modules.Values.Where(pair => pair.Latest(ksp_version) != null)));
}
public static int Update(RegistryManager registry_manager, KSPVersion ksp_version, string repo = null)
{
if (repo == null)
{
return(Update(registry_manager, ksp_version, (Uri)null));
}
return(Update(registry_manager, ksp_version, new Uri(repo)));
}
/// <summary>
/// <see cref = "IRegistryQuerier.LatestAvailableWithProvides" />
/// </summary>
public List <CkanModule> LatestAvailableWithProvides(string module, KSPVersion ksp_version, RelationshipDescriptor relationship_descriptor = null)
{
// This public interface calculates a cache of modules which
// are compatible with the current version of KSP, and then
// calls the private version below for heavy lifting.
return(LatestAvailableWithProvides(module, ksp_version,
available_modules.Values.Select(pair => pair.Latest(ksp_version)).Where(mod => mod != null).ToArray(),
relationship_descriptor));
}
public KSPVersion Version()
{
if (version != null)
{
return(version);
}
return(version = DetectVersion(GameDir()));
}
/// <summary>
/// Attempts to convert the module_names to ckan modules via CkanModule.FromIDandVersion and then calls RelationshipResolver.ctor(IEnumerable{CkanModule}, Registry, KSPVersion)"/>
/// </summary>
/// <param name="module_names"></param>
/// <param name="options"></param>
/// <param name="registry"></param>
/// <param name="kspversion"></param>
public RelationshipResolver(IEnumerable <string> module_names, RelationshipResolverOptions options, IRegistryQuerier registry,
KSPVersion kspversion) :
this(module_names.Select(name => CkanModule.FromIDandVersion(registry, name, kspversion)).ToList(),
options,
registry,
kspversion)
{
// Does nothing, just calls the other overloaded constructor
}
/// <summary>
/// Return the most recent release of a module with a optional ksp version to target and a RelationshipDescriptor to satisfy.
/// </summary>
/// <param name="ksp_version">If not null only consider mods which match this ksp version.</param>
/// <param name="relationship">If not null only consider mods which satisfy the RelationshipDescriptor.</param>
/// <returns></returns>
public CkanModule Latest(KSPVersion ksp_version = null, RelationshipDescriptor relationship = null)
{
var available_versions = new List <Version>(module_version.Keys);
CkanModule module;
log.DebugFormat("Our dictionary has {0} keys", module_version.Keys.Count);
log.DebugFormat("Choosing between {0} available versions", available_versions.Count);
// Uh oh, nothing available. Maybe this existed once, but not any longer.
if (available_versions.Count == 0)
{
return(null);
}
// No restrictions? Great, we can just pick the first one!
if (ksp_version == null && relationship == null)
{
module = module_version[available_versions.First()];
log.DebugFormat("No KSP version restriction, {0} is most recent", module);
return(module);
}
// If there's no relationship to satisfy, we can just pick the first that is
// compatible with our version of KSP.
if (relationship == null)
{
// Time to check if there's anything that we can satisfy.
var version =
available_versions.FirstOrDefault(v => module_version[v].IsCompatibleKSP(ksp_version));
if (version != null)
{
return(module_version[version]);
}
log.DebugFormat("No version of {0} is compatible with KSP {1}",
module_version[available_versions[0]].identifier, ksp_version);
return(null);
}
// If we're here, then we have a relationship to satisfy, so things get more complex.
if (ksp_version == null)
{
var version = available_versions.FirstOrDefault(relationship.version_within_bounds);
return(version == null ? null : module_version[version]);
}
else
{
var version = available_versions.FirstOrDefault(v =>
relationship.version_within_bounds(v) &&
module_version[v].IsCompatibleKSP(ksp_version));
return(version == null ? null : module_version[version]);
}
}
/// <summary>
/// <see cref="IRegistryQuerier.Available"/>
/// </summary>
public List <CkanModule> Available(KSPVersion ksp_version)
{
var candidates = new List <string>(available_modules.Keys);
var compatible = new List <CkanModule>();
// It's nice to see things in alphabetical order, so sort our keys first.
candidates.Sort();
//Cache
CkanModule[] modules_for_current_version = available_modules.Values.Select(pair => pair.Latest(ksp_version)).Where(mod => mod != null).ToArray();
// Now find what we can give our user.
foreach (string candidate in candidates)
{
CkanModule available = LatestAvailable(candidate, ksp_version);
if (available != null)
{
// we need to check that we can get everything we depend on
bool failedDepedency = false;
if (available.depends != null)
{
foreach (RelationshipDescriptor dependency in available.depends)
{
try
{
if (!LatestAvailableWithProvides(dependency.name, ksp_version, modules_for_current_version).Any())
{
failedDepedency = true;
break;
}
}
catch (KeyNotFoundException e)
{
log.ErrorFormat("Cannot find available version with provides for {0} in registry", dependency.name);
throw e;
}
catch (ModuleNotFoundKraken)
{
failedDepedency = true;
break;
}
}
}
if (!failedDepedency)
{
compatible.Add(available);
}
}
}
return(compatible);
}
/// <summary>
/// Returns a simple array of all available modules for
/// the specified version of KSP (installed version by default)
/// </summary>
public List <CkanModule> Available(KSPVersion ksp_version = null)
{
// Default to the user's current KSP install for version.
if (ksp_version == null)
{
ksp_version = KSPManager.CurrentInstance.Version();
}
var candidates = new List <string>(available_modules.Keys);
var compatible = new List <CkanModule>();
// It's nice to see things in alphabetical order, so sort our keys first.
candidates.Sort();
// Now find what we can give our user.
foreach (string candidate in candidates)
{
CkanModule available = LatestAvailable(candidate, ksp_version);
if (available != null)
{
// we need to check that we can get everything we depend on
bool failedDepedency = false;
if (available.depends != null)
{
foreach (RelationshipDescriptor dependency in available.depends)
{
try
{
if (LatestAvailableWithProvides(dependency.name, ksp_version).Count == 0)
{
failedDepedency = true;
break;
}
}
catch (ModuleNotFoundKraken)
{
failedDepedency = true;
break;
}
}
}
if (!failedDepedency)
{
compatible.Add(available);
}
}
}
return(compatible);
}
/// <summary>
/// This function returns a changeset based on the selections of the user.
/// Currently returns null if a conflict is detected.
/// </summary>
/// <param name="registry"></param>
/// <param name="current_instance"></param>
public static IEnumerable <KeyValuePair <CkanModule, GUIModChangeType> > ComputeChangeSetFromModList(
Registry registry, HashSet <KeyValuePair <CkanModule, GUIModChangeType> > changeSet, ModuleInstaller installer,
KSPVersion version)
{
var modules_to_install = new HashSet <string>();
var modules_to_remove = new HashSet <string>();
var options = new RelationshipResolverOptions()
{
without_toomanyprovides_kraken = true,
with_recommends = false
};
foreach (var change in changeSet)
{
switch (change.Value)
{
case GUIModChangeType.None:
break;
case GUIModChangeType.Install:
modules_to_install.Add(change.Key.identifier);
break;
case GUIModChangeType.Remove:
modules_to_remove.Add(change.Key.identifier);
break;
case GUIModChangeType.Update:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
//May throw InconsistentKraken
var resolver = new RelationshipResolver(modules_to_install.ToList(), options, registry, version);
changeSet.UnionWith(
resolver.ModList()
.Select(mod => new KeyValuePair <CkanModule, GUIModChangeType>(mod, GUIModChangeType.Install)));
foreach (var reverse_dependencies in modules_to_remove.Select(installer.FindReverseDependencies))
{
//TODO This would be a good place to have a event that alters the row's graphics to show it will be removed
//TODO This currently gets the latest version. This may cause the displayed version to wrong in the changset.
var modules = reverse_dependencies.Select(rDep => registry.LatestAvailable(rDep, null));
changeSet.UnionWith(
modules.Select(mod => new KeyValuePair <CkanModule, GUIModChangeType>(mod, GUIModChangeType.Remove)));
}
return(changeSet);
}
/// <summary>
/// Creates a new Relationship resolver.
/// </summary>
/// <param name="options"><see cref="RelationshipResolverOptions"/></param>
/// <param name="registry">The registry to use</param>
/// <param name="kspversion">The version of the install that the registry corresponds to</param>
public RelationshipResolver(RelationshipResolverOptions options, IRegistryQuerier registry, KSPVersion kspversion)
{
this.registry = registry;
this.kspversion = kspversion;
this.options = options;
installed_modules = new HashSet <Module>(registry.InstalledModules.Select(i_module => i_module.Module));
var installed_relationship = new SelectionReason.Installed();
foreach (var module in installed_modules)
{
reasons.Add(module, installed_relationship);
}
}
/// <summary>
/// Returns the latest available version of a module that
/// satisifes the specified version.
/// Throws a ModuleNotFoundException if asked for a non-existant module.
/// Returns null if there's simply no compatible version for this system.
/// If no ksp_version is provided, the latest module for *any* KSP is returned.
/// </summary>
// TODO: Consider making this internal, because practically everything should
// be calling LatestAvailableWithProvides()
public CkanModule LatestAvailable(string module, KSPVersion ksp_version)
{
log.DebugFormat("Finding latest available for {0}", module);
// TODO: Check user's stability tolerance (stable, unstable, testing, etc)
try
{
return(available_modules[module].Latest(ksp_version));
}
catch (KeyNotFoundException)
{
throw new ModuleNotFoundKraken(module);
}
}
/// <summary>
/// Download and update the local CKAN meta-info.
/// Optionally takes a URL to the zipfile repo to download.
/// Returns the number of unique modules updated.
/// </summary>
public static int Update(RegistryManager registry_manager, KSPVersion ksp_version, Uri repo = null)
{
// Use our default repo, unless we've been told otherwise.
if (repo == null)
{
repo = default_ckan_repo;
}
UpdateRegistry(repo, registry_manager.registry);
// Save our changes!
registry_manager.Save();
// Return how many we got!
return(registry_manager.registry.Available(ksp_version).Count);
}
/// <summary>
/// Returns the latest available version of a module that
/// satisifes the specified version. Takes into account module 'provides',
/// which may result in a list of alternatives being provided.
/// Returns an empty list if nothing is available for our system, which includes if no such module exists.
/// </summary>
public List <CkanModule> LatestAvailableWithProvides(string module, KSPVersion ksp_version = null)
{
log.DebugFormat("Finding latest available with provides for {0}", module);
// TODO: Check user's stability tolerance (stable, unstable, testing, etc)
var modules = new List <CkanModule>();
try
{
// If we can find the module requested for our KSP, use that.
CkanModule mod = LatestAvailable(module, ksp_version);
if (mod != null)
{
modules.Add(mod);
}
}
catch (ModuleNotFoundKraken)
{
// It's cool if we can't find it, though.
}
// Walk through all our available modules, and see if anything
// provides what we need.
foreach (var pair in available_modules)
{
// Skip this module if not available for our system.
if (pair.Value.Latest(ksp_version) == null)
{
continue;
}
List <string> provides = pair.Value.Latest(ksp_version).provides;
if (provides != null)
{
foreach (string provided in provides)
{
if (provided == module)
{
modules.Add(pair.Value.Latest(ksp_version));
}
}
}
}
return(modules);
}
/// <summary>
/// Returns the latest version of a module that can be installed for
/// the given KSP version. This is a *private* method that assumes
/// the `available_for_current_version` list has been correctly
/// calculated. Not for direct public consumption. ;)
/// </summary>
private List <CkanModule> LatestAvailableWithProvides(string module, KSPVersion ksp_version,
IEnumerable <AvailableModule> available_for_current_version)
{
log.DebugFormat("Finding latest available with provides for {0}", module);
// TODO: Check user's stability tolerance (stable, unstable, testing, etc)
var modules = new List <CkanModule>();
try
{
// If we can find the module requested for our KSP, use that.
CkanModule mod = LatestAvailable(module, ksp_version);
if (mod != null)
{
modules.Add(mod);
}
}
catch (ModuleNotFoundKraken)
{
// It's cool if we can't find it, though.
}
// Walk through all our available modules, and see if anything
// provides what we need.
foreach (AvailableModule available_module in available_for_current_version)
{
// Get our candidate module. We can assume this is non-null, as
// if it *is* null then available_for_current_version is corrupted,
// and something is terribly wrong.
CkanModule candidate = available_module.Latest(ksp_version);
// Find everything this module provides (for our version of KSP)
List <string> provides = candidate.provides;
// If the module has provides, and any of them are what we're looking
// for, the add it to our list.
if (provides != null && provides.Any(provided => provided == module))
{
modules.Add(candidate);
}
}
return(modules);
}
public bool HasUpdate(string identifier, KSPVersion version)
{
CkanModule newestVersion;
try
{
newestVersion = LatestAvailable(identifier, version);
}
catch (ModuleNotFoundKraken)
{
return(false);
}
if (newestVersion == null)
{
return(false);
}
return(IsInstalled(identifier) && newestVersion.version.IsGreaterThan(InstalledVersion(identifier)));
}
/// <summary>
/// Return the most recent release of a module.
/// Optionally takes a KSP version number to target.
/// If no KSP version is supplied, we return the latest release of that module for any KSP.
/// Returns null if there are no compatible versions.
/// </summary>
public CkanModule Latest(KSPVersion ksp_version = null)
{
var available_versions = new List <Version>(module_version.Keys);
log.DebugFormat("Our dictionary has {0} keys", module_version.Keys.Count);
log.DebugFormat("Choosing between {0} available versions", available_versions.Count);
// Uh oh, nothing available. Maybe this existed once, but not any longer.
if (available_versions.Count == 0)
{
return(null);
}
// Sort most recent versions first.
available_versions.Sort();
available_versions.Reverse();
if (ksp_version == null)
{
CkanModule module = module_version[available_versions.First()];
log.DebugFormat("No KSP version restriction, {0} is most recent", module);
return(module);
}
// Time to check if there's anything that we can satisfy.
foreach (Version v in available_versions)
{
if (module_version[v].IsCompatibleKSP(ksp_version))
{
return(module_version[v]);
}
}
log.DebugFormat("No version of {0} is compatible with KSP {1}",
module_version[available_versions[0]].identifier, ksp_version);
// Oh noes! Nothing available!
return(null);
}
/// <summary>
/// <see cref="IRegistryQuerier.Incompatible"/>
/// </summary>
public List <CkanModule> Incompatible(KSPVersion ksp_version)
{
var candidates = new List <string>(available_modules.Keys);
var incompatible = new List <CkanModule>();
// It's nice to see things in alphabetical order, so sort our keys first.
candidates.Sort();
// Now find what we can give our user.
foreach (string candidate in candidates)
{
CkanModule available = LatestAvailable(candidate, ksp_version);
if (available == null)
{
incompatible.Add(LatestAvailable(candidate, null));
}
}
return(incompatible);
}
public bool IsCompatibleKSP(KSPVersion version)
{
log.DebugFormat("Testing if {0} is compatible with KSP {1}", this, version);
// Check the min and max versions.
if (ksp_version_min.IsNotAny() && version < ksp_version_min)
{
return(false);
}
if (ksp_version_max.IsNotAny() && version > ksp_version_max)
{
return(false);
}
// We didn't hit the min/max guards. They may not have existed.
// Note that since ksp_version is "any" if not specified, this
// will work fine if there's no target, or if there were min/max
// fields and we passed them successfully.
return(ksp_version.Targets(version));
}
public GUIMod(Module mod, IRegistryQuerier registry, KSPVersion current_ksp_version)
{
IsCKAN = mod is CkanModule;
//Currently anything which could alter these causes a full reload of the modlist
// If this is ever changed these could be moved into the properties
Mod = mod;
IsInstalled = registry.IsInstalled(mod.identifier, false);
IsInstallChecked = IsInstalled;
HasUpdate = registry.HasUpdate(mod.identifier, current_ksp_version);
IsIncompatible = !mod.IsCompatibleKSP(current_ksp_version);
IsAutodetected = registry.IsAutodetected(mod.identifier);
Authors = mod.author == null ? "N/A" : String.Join(",", mod.author);
var installed_version = registry.InstalledVersion(mod.identifier);
Version latest_version = null;
var ksp_version = mod.ksp_version;
try
{
var latest_available = registry.LatestAvailable(mod.identifier, current_ksp_version);
if (latest_available != null)
{
latest_version = latest_available.version;
}
}
catch (ModuleNotFoundKraken)
{
latest_version = installed_version;
}
InstalledVersion = installed_version != null?installed_version.ToString() : "-";
// Let's try to find the compatibility for this mod. If it's not in the registry at
// all (because it's a DarkKAN mod) then this might fail.
CkanModule latest_available_for_any_ksp = null;
try
{
latest_available_for_any_ksp = registry.LatestAvailable(mod.identifier, null);
}
catch
{
// If we can't find the mod in the CKAN, but we've a CkanModule installed, then
// use that.
if (IsCKAN)
{
latest_available_for_any_ksp = (CkanModule)mod;
}
}
// If there's known information for this mod in any form, calculate the highest compatible
// KSP.
if (latest_available_for_any_ksp != null)
{
KSPCompatibility = KSPCompatibilityLong = latest_available_for_any_ksp.HighestCompatibleKSP();
// If the mod we have installed is *not* the mod we have installed, or we don't know
// what we have installed, indicate that an upgrade would be needed.
if (installed_version == null || !latest_available_for_any_ksp.version.IsEqualTo(installed_version))
{
KSPCompatibilityLong = string.Format("{0} (using mod version {1})",
KSPCompatibility, latest_available_for_any_ksp.version);
}
}
else
{
// No idea what this mod is, sorry!
KSPCompatibility = KSPCompatibilityLong = "unknown";
}
if (latest_version != null)
{
LatestVersion = latest_version.ToString();
}
else if (latest_available_for_any_ksp != null)
{
LatestVersion = latest_available_for_any_ksp.version.ToString();
}
else
{
LatestVersion = "-";
}
KSPversion = ksp_version != null?ksp_version.ToString() : "-";
Abstract = mod.@abstract;
// If we have homepage provided use that, otherwise use the kerbalstuff page or the github repo so that users have somewhere to get more info than just the abstract.
Homepage = "N/A";
if (mod.resources != null)
{
if (mod.resources.homepage != null)
{
Homepage = mod.resources.homepage.ToString();
}
else if (mod.resources.kerbalstuff != null)
{
Homepage = mod.resources.kerbalstuff.ToString();
}
else if (mod.resources.repository != null)
{
Homepage = mod.resources.repository.ToString();
}
}
Identifier = mod.identifier;
if (mod.download_size == 0)
{
DownloadSize = "N/A";
}
else if (mod.download_size / 1024.0 < 1)
{
DownloadSize = "1<KB";
}
else
{
DownloadSize = mod.download_size / 1024 + "";
}
}
public GUIMod(CkanModule mod, IRegistryQuerier registry, KSPVersion current_ksp_version)
: this((Module)mod, registry, current_ksp_version)
{
}
/// <summary>
/// Is the mod installed and does it have a newer version compatible with version
/// We can't update AD mods
/// </summary>
public static bool HasUpdate(this IRegistryQuerier querier, string identifier, KSPVersion version)
{
CkanModule newest_version;
try
{
newest_version = querier.LatestAvailable(identifier, version);
}
catch (ModuleNotFoundKraken)
{
return(false);
}
if (newest_version == null)
{
return(false);
}
return(!new List <string>(querier.InstalledDlls).Contains(identifier) && querier.IsInstalled(identifier, false) &&
newest_version.version.IsGreaterThan(querier.InstalledVersion(identifier)));
}
private void _UpdateModsList(bool markUpdates)
{
Registry registry = RegistryManager.Instance(KSPManager.CurrentInstance).registry;
ModList.Rows.Clear();
List <CkanModule> modules = GetModsByFilter(m_ModFilter);
// filter by left menu selection
switch (m_ModFilter)
{
case GUIModFilter.All:
break;
case GUIModFilter.Installed:
modules.RemoveAll(m => !registry.IsInstalled(m.identifier));
break;
case GUIModFilter.InstalledUpdateAvailable:
modules.RemoveAll
(
m => !(registry.IsInstalled(m.identifier) &&
m.version.IsGreaterThan(
registry.InstalledVersion(m.identifier)))
);
break;
case GUIModFilter.NewInRepository:
break;
case GUIModFilter.NotInstalled:
modules.RemoveAll(m => registry.IsInstalled(m.identifier));
break;
case GUIModFilter.Incompatible:
break;
}
// filter by name
modules.RemoveAll(m => !m.name.ToLowerInvariant().Contains(m_ModNameFilter.ToLowerInvariant()));
foreach (CkanModule mod in modules)
{
var item = new DataGridViewRow();
item.Tag = mod;
bool isInstalled = registry.IsInstalled(mod.identifier);
// installed
if (m_ModFilter != GUIModFilter.Incompatible)
{
var installedCell = new DataGridViewCheckBoxCell();
installedCell.Value = isInstalled;
item.Cells.Add(installedCell);
}
else
{
var installedCell = new DataGridViewTextBoxCell();
installedCell.Value = "-";
item.Cells.Add(installedCell);
}
// want update
if (!isInstalled)
{
var updateCell = new DataGridViewTextBoxCell();
item.Cells.Add(updateCell);
updateCell.ReadOnly = true;
updateCell.Value = "-";
}
else
{
bool isUpToDate =
!registry.InstalledVersion(mod.identifier).IsLessThan(mod.version);
if (!isUpToDate)
{
var updateCell = new DataGridViewCheckBoxCell();
item.Cells.Add(updateCell);
updateCell.ReadOnly = false;
}
else
{
var updateCell = new DataGridViewTextBoxCell();
item.Cells.Add(updateCell);
updateCell.ReadOnly = true;
updateCell.Value = "-";
}
}
// name
var nameCell = new DataGridViewTextBoxCell();
nameCell.Value = mod.name;
item.Cells.Add(nameCell);
// author
var authorCell = new DataGridViewTextBoxCell();
if (mod.author != null)
{
string authors = "";
for (int i = 0; i < mod.author.Count(); i++)
{
authors += mod.author[i];
if (i != mod.author.Count() - 1)
{
authors += ", ";
}
}
authorCell.Value = authors;
}
else
{
authorCell.Value = "N/A";
}
item.Cells.Add(authorCell);
// installed version
Version installedVersion = registry.InstalledVersion(mod.identifier);
var installedVersionCell = new DataGridViewTextBoxCell();
if (installedVersion != null)
{
installedVersionCell.Value = installedVersion.ToString();
}
else
{
installedVersionCell.Value = "-";
}
item.Cells.Add(installedVersionCell);
// latest version
Version latestVersion = mod.version;
var latestVersionCell = new DataGridViewTextBoxCell();
if (latestVersion != null)
{
latestVersionCell.Value = latestVersion.ToString();
}
else
{
latestVersionCell.Value = "-";
}
item.Cells.Add(latestVersionCell);
// KSP version
KSPVersion kspVersion = mod.ksp_version;
var kspVersionCell = new DataGridViewTextBoxCell();
if (kspVersion != null)
{
kspVersionCell.Value = kspVersion.ToString();
}
else
{
kspVersionCell.Value = "-";
}
item.Cells.Add(kspVersionCell);
// description
var descriptionCell = new DataGridViewTextBoxCell();
descriptionCell.Value = mod.@abstract;
item.Cells.Add(descriptionCell);
// homepage
var homepageCell = new DataGridViewLinkCell();
if (mod.resources != null && mod.resources.homepage != null)
{
homepageCell.Value = mod.resources.homepage;
}
else
{
homepageCell.Value = "N/A";
}
item.Cells.Add(homepageCell);
ModList.Rows.Add(item);
// sort by name
ModList.Sort(ModList.Columns[2], ListSortDirection.Ascending);
ModList.Refresh();
}
}
/// <summary>
/// Creates a new resolver that will find a way to install all the modules specified.
/// </summary>
public RelationshipResolver(IEnumerable <CkanModule> modules, RelationshipResolverOptions options, IRegistryQuerier registry,
KSPVersion kspversion) : this(options, registry, kspversion)
{
AddModulesToInstall(modules);
}
