/// <summary>
/// Updates the local package of this version.
/// </summary>
/// <param name="package">The local package corresponding to this version.</param>
internal void UpdateLocalPackage(NugetLocalPackage package, IEnumerable <NugetLocalPackage> alternateVersions)
{
OnPropertyChanging(nameof(FullName), nameof(Version));
LocalPackage = package;
OnPropertyChanged(nameof(FullName), nameof(Version));
Dispatcher.Invoke(UpdateStatus);
if (alternateVersions != null)
{
Dispatcher.Invoke(() =>
{
UpdateAlternateVersions(alternateVersions, (alternateVersionViewModel, alternateVersion) =>
{
if (alternateVersion == null && alternateVersionViewModel.ServerPackage == null)
{
AlternateVersions.Remove(alternateVersionViewModel);
}
else
{
alternateVersionViewModel.UpdateLocalPackage(alternateVersion);
}
});
});
}
Dispatcher.Invoke(() => UpdateFrameworks());
}
/// <summary>
/// Updates the local package of this version.
/// </summary>
/// <param name="package">The local package corresponding to this version.</param>
internal void UpdateLocalPackage(NugetLocalPackage package)
{
OnPropertyChanging(nameof(FullName), nameof(Version));
LocalPackage = package;
OnPropertyChanged(nameof(FullName), nameof(Version));
Dispatcher.Invoke(UpdateStatus);
}
/// <summary>
/// Gets the xenko SDK dir.
/// </summary>
/// <returns></returns>
internal static async Task <PackageInfo> FindXenkoSdkDir(string solution, string packageName = "Xenko.VisualStudio.Commands")
{
// Resolve the sdk version to load from the solution's package
var packageInfo = new PackageInfo {
ExpectedVersion = await PackageSessionHelper.GetPackageVersion(solution), SdkPaths = new List <string>()
};
// Check if we are in a root directory with store/packages facilities
var store = new NugetStore(null);
NugetLocalPackage xenkoPackage = null;
// Try to find the package with the expected version
if (packageInfo.ExpectedVersion != null && packageInfo.ExpectedVersion >= MinimumVersion)
{
// Xenko up to 3.0
if (packageInfo.ExpectedVersion < new PackageVersion(3, 1, 0, 0))
{
xenkoPackage = store.GetPackagesInstalled(new[] { "Xenko" }).FirstOrDefault(package => package.Version == packageInfo.ExpectedVersion);
if (xenkoPackage != null)
{
var xenkoSdkDir = store.GetRealPath(xenkoPackage);
packageInfo.LoadedVersion = xenkoPackage.Version;
foreach (var path in new[]
{
// Xenko 2.x and 3.0
@"Bin\Windows\Direct3D11",
@"Bin\Windows",
// Xenko 1.x
@"Bin\Windows-Direct3D11"
})
{
var fullPath = Path.Combine(xenkoSdkDir, path);
if (Directory.Exists(fullPath))
{
packageInfo.SdkPaths.AddRange(Directory.EnumerateFiles(fullPath, "*.dll", SearchOption.TopDirectoryOnly));
packageInfo.SdkPaths.AddRange(Directory.EnumerateFiles(fullPath, "*.exe", SearchOption.TopDirectoryOnly));
}
}
}
}
// Xenko 3.1+
else
{
var logger = new Logger();
var(request, result) = await RestoreHelper.Restore(logger, packageName, new VersionRange(packageInfo.ExpectedVersion.ToNuGetVersion()));
if (result.Success)
{
packageInfo.SdkPaths.AddRange(RestoreHelper.ListAssemblies(request, result));
packageInfo.LoadedVersion = packageInfo.ExpectedVersion;
}
}
}
return(packageInfo);
}
internal XenkoDevVersionViewModel(LauncherViewModel launcher, NugetStore store, [CanBeNull] NugetLocalPackage localPackage, UDirectory path, bool isDevRedirect)
: base(launcher, store, localPackage, int.MaxValue, devMinorCounter--)
{
this.path = path;
this.localPackage = localPackage;
this.isDevRedirect = isDevRedirect;
DownloadCommand.IsEnabled = false;
// Update initial status (IsVisible will be set to true)
UpdateStatus();
}
/// <summary>
/// Gets the xenko SDK dir.
/// </summary>
/// <returns></returns>
private static PackageInfo FindXenkoSdkDir()
{
// Resolve the sdk version to load from the solution's package
var packageInfo = new PackageInfo {
ExpectedVersion = PackageSessionHelper.GetPackageVersion(solution)
};
// TODO: Maybe move it in some common class somewhere? (in this case it would be included with "Add as link" in VSPackage)
var xenkoSdkDir = Environment.GetEnvironmentVariable("XenkoDir");
// Failed to locate xenko
if (xenkoSdkDir == null)
{
return(packageInfo);
}
// If we are in a dev directory, assume we have the right version
if (File.Exists(Path.Combine(xenkoSdkDir, "build\\Xenko.sln")))
{
packageInfo.StorePath = xenkoSdkDir;
packageInfo.SdkPath = xenkoSdkDir;
packageInfo.LoadedVersion = packageInfo.ExpectedVersion;
return(packageInfo);
}
// Check if we are in a root directory with store/packages facilities
var store = new NugetStore(xenkoSdkDir);
NugetLocalPackage xenkoPackage = null;
// Try to find the package with the expected version
if (packageInfo.ExpectedVersion != null && packageInfo.ExpectedVersion >= MinimumVersion)
{
xenkoPackage = store.GetPackagesInstalled(store.MainPackageIds).FirstOrDefault(package => GetVersion(package) == packageInfo.ExpectedVersion);
}
// If the expected version is not found, get the latest package
if (xenkoPackage == null)
{
xenkoPackage = store.GetLatestPackageInstalled(store.MainPackageIds);
}
// If no package was found, return no sdk path
if (xenkoPackage == null)
{
return(packageInfo);
}
// Return the loaded version and the sdk path
packageInfo.LoadedVersion = GetVersion(xenkoPackage);
packageInfo.StorePath = xenkoSdkDir;
packageInfo.SdkPath = store.GetRealPath(xenkoPackage);
return(packageInfo);
}
internal XenkoVersionViewModel(LauncherViewModel launcher, NugetStore store, NugetLocalPackage localPackage, int major, int minor)
: base(launcher, store, localPackage)
{
Major = major;
Minor = minor;
SetAsActiveCommand = new AnonymousCommand(ServiceProvider, () => launcher.ActiveVersion = this);
// Update status if the user changes whether to display beta versions.
launcher.PropertyChanged += (s, e) => { if (e.PropertyName == nameof(LauncherViewModel.ShowBetaVersions))
{
UpdateStatus();
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="PackageVersionViewModel"/> class.
/// </summary>
/// <param name="launcher">The parent <see cref="LauncherViewModel"/> instance.</param>
/// <param name="store">The related <see cref="NugetStore"/> instance.</param>
/// <param name="localPackage">The local package of this version, if a local package exists.</param>
internal PackageVersionViewModel(LauncherViewModel launcher, NugetStore store, NugetLocalPackage localPackage)
: base(launcher.SafeArgument("launcher").ServiceProvider)
{
if (launcher == null)
{
throw new ArgumentNullException(nameof(launcher));
}
if (store == null)
{
throw new ArgumentNullException(nameof(store));
}
Launcher = launcher;
Store = store;
LocalPackage = localPackage;
DownloadCommand = new AnonymousCommand(ServiceProvider, () => Download(true));
DeleteCommand = new AnonymousTaskCommand(ServiceProvider, () => Delete(true, true))
{
IsEnabled = CanDelete
};
UpdateStatusInternal();
}
/// <summary>
/// Initializes a new instance of the <see cref="StrideStoreVersionViewModel"/>
/// </summary>
/// <param name="launcher"></param>
/// <param name="store"></param>
/// <param name="localPackage"></param>
/// <param name="major"></param>
/// <param name="minor"></param>
internal StrideStoreVersionViewModel(LauncherViewModel launcher, NugetStore store, NugetLocalPackage localPackage, string packageId, int major, int minor)
: base(launcher, store, localPackage, packageId, major, minor)
{
FetchReleaseNotes();
FetchDocumentation();
}
internal StrideVersionViewModel(LauncherViewModel launcher, NugetStore store, NugetLocalPackage localPackage, string packageId, int major, int minor)
: base(launcher, store, localPackage)
{
PackageSimpleName = packageId.Replace(".GameStudio", string.Empty);
Major = major;
Minor = minor;
SetAsActiveCommand = new AnonymousCommand(ServiceProvider, () => launcher.ActiveVersion = this);
// Update status if the user changes whether to display beta versions.
launcher.PropertyChanged += (s, e) => { if (e.PropertyName == nameof(LauncherViewModel.ShowBetaVersions))
{
UpdateStatus();
}
};
if (LocalPackage != null && InstallPath != null)
{
var libDirectory = Path.Combine(InstallPath, "lib");
var frameworks = Directory.EnumerateDirectories(libDirectory);
foreach (var frameworkPath in frameworks)
{
var frameworkFolder = new DirectoryInfo(frameworkPath).Name;
if (File.Exists(Path.Combine(frameworkPath, "Stride.GameStudio.exe")) ||
File.Exists(Path.Combine(frameworkPath, "Xenko.GameStudio.exe")))
{
Frameworks.Add(frameworkFolder);
}
}
if (Frameworks.Count > 0)
{
try
{
// If preferred framework exists in our list, select it
var preferredFramework = LauncherSettings.PreferredFramework;
if (Frameworks.Contains(preferredFramework))
{
SelectedFramework = preferredFramework;
}
else
{
// Otherwise, try to find a framework of the same kind (.NET Core or .NET Framework)
var nugetFramework = NuGetFramework.ParseFolder(preferredFramework);
SelectedFramework =
Frameworks.FirstOrDefault(x => NuGetFramework.ParseFolder(preferredFramework).Framework == nugetFramework.Framework)
?? Frameworks.First(); // otherwise fallback to first choice
}
}
catch
{
SelectedFramework = Frameworks.First();
}
}
}
}
/// <summary>
/// Gets the stride SDK dir.
/// </summary>
/// <returns></returns>
internal static async Task <PackageInfo> FindStrideSdkDir(string solution, string packageName = "Stride.VisualStudio.Commands")
{
// Resolve the sdk version to load from the solution's package
var packageInfo = new PackageInfo {
ExpectedVersion = await PackageSessionHelper.GetPackageVersion(solution), SdkPaths = new List <string>()
};
// Check if we are in a root directory with store/packages facilities
var store = new NugetStore(null);
NugetLocalPackage stridePackage = null;
// Try to find the package with the expected version
if (packageInfo.ExpectedVersion != null && packageInfo.ExpectedVersion >= MinimumVersion)
{
// Stride up to 3.0
if (packageInfo.ExpectedVersion < new PackageVersion(3, 1, 0, 0))
{
stridePackage = store.GetPackagesInstalled(new[] { "Stride" }).FirstOrDefault(package => package.Version == packageInfo.ExpectedVersion);
if (stridePackage != null)
{
var strideSdkDir = store.GetRealPath(stridePackage);
packageInfo.LoadedVersion = stridePackage.Version;
foreach (var path in new[]
{
// Stride 2.x and 3.0
@"Bin\Windows\Direct3D11",
@"Bin\Windows",
// Stride 1.x
@"Bin\Windows-Direct3D11"
})
{
var fullPath = Path.Combine(strideSdkDir, path);
if (Directory.Exists(fullPath))
{
packageInfo.SdkPaths.AddRange(Directory.EnumerateFiles(fullPath, "*.dll", SearchOption.TopDirectoryOnly));
packageInfo.SdkPaths.AddRange(Directory.EnumerateFiles(fullPath, "*.exe", SearchOption.TopDirectoryOnly));
}
}
}
}
// Stride 3.1+
else
{
var logger = new Logger();
var(request, result) = await RestoreHelper.Restore(logger, NuGetFramework.ParseFrameworkName(".NETFramework,Version=v4.7.2", DefaultFrameworkNameProvider.Instance), "win", packageName, new VersionRange(packageInfo.ExpectedVersion.ToNuGetVersion()));
if (result.Success)
{
packageInfo.SdkPaths.AddRange(RestoreHelper.ListAssemblies(request, result));
packageInfo.LoadedVersion = packageInfo.ExpectedVersion;
}
else
{
MessageBox.Show($"Could not restore {packageName} {packageInfo.ExpectedVersion}, this visual studio extension may fail to work properly without it."
+ $"To fix this you can either build {packageName} or pull the right version from nugget manually");
throw new InvalidOperationException($"Could not restore {packageName} {packageInfo.ExpectedVersion}.");
}
}
}
return(packageInfo);
}
internal void UpdateLocalPackage(NugetLocalPackage package)
{
OnPropertyChanging(nameof(FullName), nameof(Version));
LocalPackage = package;
OnPropertyChanged(nameof(FullName), nameof(Version));
}
