protected override bool IsVisible(IPackageVersion version)
{
if (version?.HasTag(PackageTag.Downloadable) != true)
{
return(false);
}
var localInfo = m_AssetStoreCache.GetLocalInfo(version.packageUniqueId);
if (localInfo?.canDowngrade != true)
{
return(false);
}
var operation = m_AssetStoreDownloadManager.GetDownloadOperation(version.packageUniqueId);
return(operation == null || operation.state == DownloadState.DownloadRequested || !operation.isProgressVisible);
}
private void AnalyzePackage(IPackageVersion packageVersion)
{
foreach (var referencingProject in packageVersion.ReferencingProjects)
{
AnalyzeProject(referencingProject);
}
foreach (var referencingPackage in packageVersion.ReferencingPackages)
{
AnalyzePackage(referencingPackage);
}
if (!_items.Contains(packageVersion))
{
_items.Add(packageVersion);
List.Insert(0, packageVersion);
}
}
private static void ViewOfflineUrl(IPackageVersion version, Func <IPackageVersion, bool, string> getUrl, string messageOnNotFound)
{
if (!version.isAvailableOnDisk)
{
EditorUtility.DisplayDialog("Unity Package Manager", "This package is not available offline.", "Ok");
return;
}
var offlineUrl = getUrl(version, true);
if (!string.IsNullOrEmpty(offlineUrl))
{
ApplicationUtil.instance.OpenURL(offlineUrl);
}
else
{
EditorUtility.DisplayDialog("Unity Package Manager", messageOnNotFound, "Ok");
}
}
public void Test(IPackageVersion packageVersion, TestMode testMode)
{
Reset();
if (packageVersion is MockPackageVersion)
{
mockPackageVersion = packageVersion as MockPackageVersion;
}
else
{
upmPackageVersion = packageVersion as UpmPackageVersion;
}
TestMode = testMode;
ShowTestRunnerWindow();
Run();
}
public void Refresh(IPackage package, IPackageVersion version)
{
m_Package = package;
m_Version = version;
detailTitle.SetValueWithoutNotify(m_Version.displayName);
detailsLinks.Refresh(m_Package, m_Version);
RefreshName();
RefreshFeatureSetElements();
RefreshAuthor();
RefreshTags();
RefreshVersionLabel();
RefreshVersionInfoIcon();
RefreshRegistry();
RefreshEntitlement();
RefreshEmbeddedFeatureSetWarningBox();
RefreshHiddenAssetInfo();
}
public static PackageTagLabel CreateTagLabel(IPackageVersion version, bool isVersionItem = false)
{
if (version != null)
{
if (version.HasTag(PackageTag.InDevelopment))
{
return(new PackageTagLabel(L10n.Tr("In Development"), PackageTag.InDevelopment));
}
if (version.HasTag(PackageTag.Preview))
{
return(new PackageTagLabel(L10n.Tr("Preview"), PackageTag.Preview));
}
if (isVersionItem && version.HasTag(PackageTag.Verified))
{
return(new PackageTagLabel(L10n.Tr("Verified"), PackageTag.Verified));
}
}
return(null);
}
public void Refresh(IPackage package, IPackageVersion version)
{
m_Package = package;
m_Version = version;
detailsImages.Refresh(m_Package);
sampleList.SetPackageVersion(m_Version);
UIUtils.SetElementDisplay(disabledInfoBox, m_Version.HasTag(PackageTag.Disabled));
SetEnabled(m_Package?.hasEntitlementsError != true);
RefreshDependencies();
RefreshLabels();
RefreshDescription();
RefreshReleaseDetails();
RefreshSizeAndSupportedUnityVersions();
RefreshPurchasedDate();
RefreshSourcePath();
RefreshPlatformList();
}
public void SetPackageVersion(IPackageVersion version)
{
var samples = version.isInstalled || version.HasTag(PackageTag.Feature) ? m_PackageDatabase.GetSamples(version) : Enumerable.Empty <Sample>();
if (samples?.Any() != true)
{
UIUtils.SetElementDisplay(this, false);
return;
}
UIUtils.SetElementDisplay(this, true);
var packageChanged = version.packageUniqueId != m_Version?.packageUniqueId;
var width = rect.width;
m_Version = version;
m_Samples = samples;
UIUtils.SetElementDisplay(samplesErrorInfoBox, m_Version.HasTag(PackageTag.InDevelopment) && m_Samples.Any(sample => string.IsNullOrEmpty(sample.displayName)));
ToggleLowWidthSampleView(width, packageChanged);
}
private void ProcessNuspecXml(Stream xmlStream, IPackageVersion packageVersion)
{
var reader = new StreamReader(xmlStream);
var nuspec = reader.ReadToEnd();
var doc = XDocument.Parse(nuspec);
var ns = doc.Root?.Name.Namespace;
var metaDataElement = doc.Root?.Element(ns + "metadata");
var packageName = metaDataElement?.Element(ns + "id")?.Value;
var versionString = metaDataElement?.Element(ns + "version")?.Value ?? string.Empty;
var repositoryElement = metaDataElement?.Element(ns + "repository");
packageVersion.Description = metaDataElement?.Element(ns + "description")?.Value ?? string.Empty;
packageVersion.NuSpec = nuspec;
packageVersion.RepositoryUrl = repositoryElement?.Attribute("url")?.Value;
if (GetVersion(versionString, out var version, out var isPrerelease, out var preRelease, out _))
{
packageVersion.Version = version;
packageVersion.IsPrerelease = isPrerelease;
packageVersion.PreReleaseSuffix = preRelease;
if (!_packageCache.PackagesDictionary.TryGetValue(packageName, out var package))
{
package = _packageFactoryFunc(packageName);
_packageCache.PackagesDictionary[packageName] = package;
}
packageVersion.Package = package;
package.VersionDictionary[version] = packageVersion;
var dependenciesElement = metaDataElement?.Element(ns + "dependencies");
if (dependenciesElement != null)
{
HandleNuspecDependencies(packageVersion, ns, dependenciesElement, string.Empty);
}
var referencesElement = metaDataElement?.Element(ns + "references");
if (referencesElement != null)
{
HandleNuspecReferences(packageVersion, ns, referencesElement, string.Empty);
}
}
public static string GetChangelogUrl(IOProxy IOProxy, IPackageVersion version, bool offline = false)
{
var upmVersion = version as UpmPackageVersion;
if (upmVersion == null)
{
return(string.Empty);
}
if (offline)
{
return(GetOfflineChangelogUrl(IOProxy, upmVersion));
}
if (!string.IsNullOrEmpty(upmVersion.changelogUrl))
{
return(upmVersion.changelogUrl);
}
return($"http://docs.unity3d.com/Packages/{upmVersion.shortVersionId}/changelog/CHANGELOG.html");
}
private void GetSelectedPackageAndVersionInternal(out IPackage package, out IPackageVersion version, bool applyDifference = false)
{
var selected = GetVisualState(m_SelectedUniqueIds.FirstOrDefault());
PackageDatabase.instance.GetPackageAndVersion(selected?.packageUniqueId, selected?.selectedVersionId, out package, out version);
if (selected?.visible != true || package == null)
{
var firstVisible = items.FirstOrDefault(id => GetVisualState(id)?.visible == true);
package = firstVisible == null ? null : PackageDatabase.instance.GetPackage(firstVisible);
version = package?.versions.primary;
}
else if (version == null)
{
version = package?.versions.primary;
}
if (applyDifference)
{
SetSelected(package?.uniqueId, version?.uniqueId);
}
}
public void SetPackageVersion(IPackageVersion version)
{
if (!m_SettingsProxy.enablePackageDependencies || version?.HasTag(PackageTag.Feature) == true)
{
UIUtils.SetElementDisplay(this, false);
return;
}
var dependencies = version?.dependencies;
var reverseDependencies = m_PackageDatabase.GetReverseDependencies(version);
var showDependency = dependencies != null || reverseDependencies != null;
UIUtils.SetElementDisplay(this, showDependency);
if (!showDependency)
{
return;
}
UpdateDependencies(dependencies);
UpdateReverseDependencies(reverseDependencies);
}
private void RefreshSupportedUnityVersions(IPackageVersion version)
{
var supportedVersion = version.supportedVersions?.Any() == true?version.supportedVersions.First() : version.supportedVersion;
var hasSupportedVersions = supportedVersion != null;
if (hasSupportedVersions)
{
detailUnityVersions.SetValueWithoutNotify(string.Format(L10n.Tr("{0} or higher"), supportedVersion));
var tooltip = supportedVersion.ToString();
if (version.supportedVersions?.Any() == true)
{
var versions = version.supportedVersions.Select(version => version.ToString()).ToArray();
tooltip = versions.Length == 1 ? versions[0] :
string.Format(L10n.Tr("{0} and {1} to improve compatibility with the range of these versions of Unity"), string.Join(", ", versions, 0, versions.Length - 1), versions[versions.Length - 1]);
}
detailUnityVersions.tooltip = string.Format(L10n.Tr("Package has been submitted using Unity {0}"), tooltip);
}
UIUtils.SetElementDisplay(detailUnityVersionsContainer, hasSupportedVersions);
}
public void OnPackageSelectionChange(IPackageVersion packageVersion, VisualElement toolbar)
{
if (packageVersion == null || toolbar == null)
{
return;
}
PackageVersion = packageVersion;
Toolbar = toolbar;
if (PrepareTools == null)
{
PrepareTools = new PrepareTools(packageVersion, PackageTestRunner);
PrepareTools.OnValidate += OnValidate;
}
if (PublishTools == null)
{
PublishTools = new PublishTools();
}
if (DevelopTools == null)
{
DevelopTools = new DevelopTools();
}
// Put the publish button right before the edit package manifest button, or at the end if it does not exists
var rightItems = toolbar.Q <VisualElement>(RightItemsName);
var editPackageManifest = rightItems.Q <VisualElement>("editPackageManifest");
var publishPosition = editPackageManifest != null?rightItems.IndexOf(editPackageManifest) : rightItems.childCount;
AddIfNotExists(toolbar.Q <VisualElement>(LeftItemsName), PrepareTools);
AddIfNotExists(toolbar.Q <VisualElement>(LeftItemsName), DevelopTools);
AddIfNotExists(rightItems, PublishTools, publishPosition);
DevelopTools.SetPackage(packageVersion);
PrepareTools.SetPackage(packageVersion);
PublishTools.SetPackage(packageVersion);
var publishTarget = PackageManagerState.Instance.ForPackage(PackageVersion)?.PublishTarget;
var extension = PackageManagerDevelopExtensions.GetPublishExtension(publishTarget);
}
public PackageDetailsVersionHistoryItem(ResourceLoader resourceLoader,
PackageDatabase packageDatabase,
UpmCache upmCache,
ApplicationProxy applicationProxy,
IOProxy ioProxy,
IPackageVersion version,
bool multipleVersionsVisible,
bool isLatestVersion,
bool expanded,
PackageToolBarRegularButton button)
{
m_Version = version;
m_PackageDatabase = packageDatabase;
m_UpmCache = upmCache;
m_ApplicationProxy = applicationProxy;
m_IOProxy = ioProxy;
var root = resourceLoader.GetTemplate("PackageDetailsVersionHistoryItem.uxml");
Add(root);
m_Cache = new VisualElementCache(root);
SetExpanded(expanded);
versionHistoryItemToggle.RegisterValueChangedCallback(evt =>
{
SetExpanded(evt.newValue);
onToggleChanged?.Invoke(evt.newValue);
});
m_Button = button;
if (m_Button != null)
{
versionHistoryItemToggleRightContainer.Add(m_Button.element);
}
versionHistoryItemChangeLogLink.clickable.clicked += () => UpmPackageDocs.ViewUrl(UpmPackageDocs.GetChangelogUrl(m_Version), UpmPackageDocs.GetOfflineChangelog(m_IOProxy, m_Version), L10n.Tr("changelog"), "viewChangelog", m_Version, m_Version.package, m_ApplicationProxy);
Refresh(multipleVersionsVisible, isLatestVersion);
}
public FeatureDependencyItem(IPackageVersion featureVersion, IPackageVersion featureDependencyVersion, FeatureState state = FeatureState.None)
{
packageVersion = featureDependencyVersion;
packageName = featureDependencyVersion.packageUniqueId;
m_Name = new Label {
name = "name"
};
m_Name.text = featureDependencyVersion?.displayName ?? string.Empty;
Add(m_Name);
m_State = new VisualElement {
name = "versionState"
};
if (state == FeatureState.Customized && featureVersion.isInstalled)
{
m_State.AddToClassList(state.ToString().ToLower());
m_State.tooltip = L10n.Tr("This package has been manually customized");
}
Add(m_State);
}
public void Refresh(IPackageVersion version)
{
UIUtils.SetElementDisplay(this, false);
if (version?.packageInfo == null)
{
return;
}
var upmReserved = m_UpmCache.ParseUpmReserved(version?.packageInfo);
var platformNames = upmReserved?.GetList <string>("supportedPlatforms") ?? Enumerable.Empty <string>();
if (!platformNames.Any())
{
return;
}
UIUtils.SetElementDisplay(this, true);
var listLabel = platformNames.Count() > 1 ? L10n.Tr("Supported Platforms:") : L10n.Tr("Supported Platform:");
m_TagLabelList.Refresh(listLabel, platformNames);
}
public static string[] GetDocumentationUrl(IPackageVersion version)
{
var upmVersion = version as UpmPackageVersion;
if (upmVersion == null)
{
return new string[] { }
}
;
if (!string.IsNullOrEmpty(upmVersion.documentationUrl))
{
return new string[] { upmVersion.documentationUrl }
}
;
if (upmVersion.HasTag(PackageTag.BuiltIn) && !string.IsNullOrEmpty(upmVersion.description))
{
return(FetchUrlsFromDescription(upmVersion));
}
return(new string[] { $"https://docs.unity3d.com/Packages/{upmVersion.shortVersionId}/index.html" });
}
public void SetPackage(IPackageVersion package)
{
importStatusContainer.Clear();
nameLabelContainer.Clear();
sizeLabelContainer.Clear();
importButtonContainer.Clear();
if (package == null || package.samples == null || !package.samples.Any())
{
UIUtils.SetElementDisplay(this, false);
return;
}
UIUtils.SetElementDisplay(this, true);
foreach (var sample in package.samples)
{
var sampleItem = new PackageSampleItem(sample);
importStatusContainer.Add(sampleItem.importStatus);
nameLabelContainer.Add(sampleItem.nameLabel);
sizeLabelContainer.Add(sampleItem.sizeLabel);
importButtonContainer.Add(sampleItem.importButton);
sampleItem.importButton.SetEnabled(package.isInstalled);
}
}
public static string GetStatusText(DependencyInfo dependency, IPackageVersion installedVersion)
{
if (installedVersion == null)
{
return(string.Empty);
}
if (installedVersion.HasTag(PackageTag.Custom))
{
return(L10n.Tr("(custom)"));
}
if (installedVersion.HasTag(PackageTag.Local))
{
return(L10n.Tr("(local)"));
}
var statusText = installedVersion.HasTag(PackageTag.BuiltIn)
? L10n.Tr("enabled") : L10n.Tr("installed");
return(installedVersion.version?.ToString() == dependency.version
? string.Format("({0})", statusText) : string.Format("({0} {1})", installedVersion.version, statusText));
}
public PackageDependencySampleItemLowWidth(IPackageVersion version, Sample sample)
{
ResolveDependencies();
var root = m_ResourceLoader.GetTemplate("PackageDependencySampleItemLowWidth.uxml");
Add(root);
cache = new VisualElementCache(root);
var sampleItem = new PackageSampleItem(version, sample);
sampleItem.importButton.SetEnabled(version.isInstalled);
var name = sampleItem.nameLabel.text;
var size = sampleItem.sizeLabel.text;
var description = sampleItem.descriptionLabel.text;
itemName.text = name;
itemName.tooltip = name;
sampleStatus.Add(sampleItem.importStatus);
itemSizeOrVersion.value = size;
itemSizeOrVersion.tooltip = size;
importButtonContainer.Add(sampleItem.importButton);
if (!string.IsNullOrEmpty(description))
{
UIUtils.SetElementDisplay(sampleDescription, true);
sampleDescription.SetValueWithoutNotify(description);
}
else
{
UIUtils.SetElementDisplay(sampleDescription, false);
}
}
public static string GetVersionText(IPackageVersion version, bool simplified = false)
{
if (version?.version == null)
return version?.versionString;
var label = version.version?.StripTag();
if (!simplified)
{
if (version.HasTag(PackageTag.Local))
label = string.Format(ApplicationUtil.instance.GetTranslationForText("local - {0}"), label);
if (version.HasTag(PackageTag.Git))
label = string.Format(ApplicationUtil.instance.GetTranslationForText("git - {0}"), label);
if (version.HasTag(PackageTag.Verified))
label = string.Format(ApplicationUtil.instance.GetTranslationForText("verified - {0}"), label);
if (version.isInstalled)
label = string.Format(ApplicationUtil.instance.GetTranslationForText("current - {0}"), label);
}
if (version.HasTag(PackageTag.Preview))
{
var previewLabel = string.IsNullOrEmpty(version.version?.Prerelease) ? ApplicationUtil.instance.GetTranslationForText("preview") : version.version?.Prerelease;
label = $"{previewLabel} - {label}";
}
return label;
}
private static void ViewUrl(IPackageVersion version, Func <IPackageVersion, bool, string> getUrl, string messageOnNotFound)
{
if (ApplicationUtil.instance.isInternetReachable)
{
var onlineUrl = getUrl(version, false);
var request = UnityWebRequest.Head(onlineUrl);
var operation = request.SendWebRequest();
operation.completed += (op) =>
{
if (request.responseCode != 404)
{
ApplicationUtil.instance.OpenURL(onlineUrl);
}
else
{
ViewOfflineUrl(version, getUrl, messageOnNotFound);
}
};
}
else
{
ViewOfflineUrl(version, getUrl, messageOnNotFound);
}
}
public void SetError(UIError error, IPackageVersion packageVersion = null)
{
var message = string.Empty;
if (!string.IsNullOrEmpty(error.message))
{
message = error.message;
}
if (error.HasAttribute(UIError.Attribute.IsDetailInConsole))
{
message = string.Format(L10n.Tr("{0} See console for more details."), message);
}
if (error.HasAttribute(UIError.Attribute.IsWarning))
{
alertContainer.RemoveFromClassList("error");
alertContainer.AddClasses("warning");
}
else
{
alertContainer.RemoveFromClassList("warning");
alertContainer.AddClasses("error");
}
if (!string.IsNullOrEmpty(error.readMoreURL))
{
ShowReadMoreLink(error, packageVersion);
}
else
{
HideReadMoreLink();
}
alertMessage.text = message;
UIUtils.SetElementDisplay(this, true);
}
public static string GetDocumentationUrl(IPackageVersion version, bool offline = false)
{
var upmVersion = version as UpmPackageVersion;
if (upmVersion == null)
{
return(string.Empty);
}
if (offline)
{
return(GetOfflineDocumentationUrl(upmVersion));
}
if (upmVersion.HasTag(PackageTag.BuiltIn) && !string.IsNullOrEmpty(upmVersion.description))
{
var split = SplitBuiltinDescription(upmVersion);
if (split.Length > 1)
{
return(split[1]);
}
}
return($"http://docs.unity3d.com/Packages/{upmVersion.shortVersionId}/index.html");
}
public PackageDependencySampleItemLowWidth(ResourceLoader resourceLoader, IPackageVersion version, Sample sample, SelectionProxy selection, AssetDatabaseProxy assetDatabase, ApplicationProxy application, IOProxy iOProxy)
{
var root = resourceLoader.GetTemplate("PackageDependencySampleItemLowWidth.uxml");
Add(root);
cache = new VisualElementCache(root);
var sampleItem = new PackageDetailsSampleItem(version, sample, selection, assetDatabase, application, iOProxy);
sampleItem.importButton.SetEnabled(version.isInstalled);
var name = sampleItem.nameLabel.text;
var size = sampleItem.sizeLabel.text;
var description = sampleItem.descriptionLabel.text;
itemName.text = name;
itemName.tooltip = name;
sampleStatus.Add(sampleItem.importStatus);
itemSizeOrVersion.value = size;
itemSizeOrVersion.tooltip = size;
importButtonContainer.Add(sampleItem.importButton);
if (!string.IsNullOrEmpty(description))
{
UIUtils.SetElementDisplay(sampleDescription, true);
sampleDescription.SetValueWithoutNotify(description);
}
else
{
UIUtils.SetElementDisplay(sampleDescription, false);
}
}
public PackageDetailsImagesTab(AssetStoreCache assetStoreCache)
{
m_Id = k_Id;
m_DisplayName = L10n.Tr("Images");
m_AssetStoreCache = assetStoreCache;
m_ImageTextures = new List <Texture2D>();
m_MainImage = new Image()
{
name = "mainImage", classList = { "image" }
};
m_MainImage.scaleMode = ScaleMode.ScaleToFit;
// Wrap main image in two layers of containers to lock the aspect ratio
var mainImageOuterContainer = new VisualElement()
{
name = "mainImageOuterContainer"
};
m_MainImageInnerContainer = new VisualElement()
{
name = "mainImageInnerContainer"
};
m_MainImageInnerContainer.Add(m_MainImage);
mainImageOuterContainer.Add(m_MainImageInnerContainer);
Add(mainImageOuterContainer);
m_ThumbnailsContainer = new VisualElement()
{
name = "thumbnailsContainer"
};
Add(m_ThumbnailsContainer);
m_Version = null;
}
protected override bool IsInProgress(IPackageVersion version) => false;
protected override string GetText(IPackageVersion version, bool isInProgress)
{
return(L10n.Tr("Reset"));
}
protected override string GetTooltip(IPackageVersion version, bool isInProgress)
{
return(string.Format(L10n.Tr("Click to reset this {0} dependencies to their default versions."), version.package.GetDescriptor()));
}
