private void RefreshLockIcons(IEnumerable <IPackageVersion> featureSets, VisualState visualState = null) { var showLockedIcon = featureSets?.Any() == true; if (showLockedIcon) { visualState = visualState ?? m_PageManager.GetVisualState(m_Package); if (visualState?.isLocked == true) { lockedIcon.RemoveFromClassList("unlocked"); lockedIcon.AddToClassList("locked"); lockedIcon.tooltip = L10n.Tr("This package is locked because it's part of a feature set. Click unlock button to be able to make changes"); } else { lockedIcon.AddToClassList("unlocked"); lockedIcon.RemoveFromClassList("locked"); lockedIcon.tooltip = L10n.Tr("This package is unlocked. You can now change its version."); } } UIUtils.SetElementDisplay(lockedIcon, showLockedIcon); }
public virtual bool SelectTab(T tabToSelect) { if (tabToSelect is null || !m_HeaderButtons.ContainsKey(tabToSelect.id) || tabToSelect.id == selectedTabId) { return(false); } var previousSelectedTab = GetTab(selectedTabId); if (previousSelectedTab != null) { m_HeaderButtons[previousSelectedTab.id].RemoveFromClassList("tabHeaderSelected"); UIUtils.SetElementDisplay(previousSelectedTab, false); } m_HeaderButtons[tabToSelect.id].AddClasses("tabHeaderSelected"); UIUtils.SetElementDisplay(tabToSelect, true); m_SelectedTabId = tabToSelect.id; onTabSwitched.Invoke(previousSelectedTab, tabToSelect); return(true); }
public void Refresh(IPackage package, IPackageVersion version) { m_Package = package; m_Version = version; detailTitle.SetValueWithoutNotify(m_Version.displayName); detailsLinks.Refresh(m_Package, m_Version); UIUtils.SetElementDisplay(disabledWarningBox, version.HasTag(PackageTag.Disabled)); RefreshName(); RefreshDependency(); RefreshFeatureSetElements(); RefreshAuthor(); RefreshTags(); RefreshVersionLabel(); RefreshVersionInfoIcon(); RefreshRegistry(); RefreshEntitlement(); RefreshEmbeddedFeatureSetWarningBox(); RefreshHiddenAssetInfo(); }
private void Init(EditorWindow anchorWindow, InputDropdownArgs args) { m_AnchorWindow = anchorWindow; m_WindowSize = args.windowSize ?? k_DefaultWindowSize; inputTextField.value = args.defaultValue ?? string.Empty; inputTextField.RegisterCallback <ChangeEvent <string> >(OnTextFieldChange); inputTextField.RegisterCallback <KeyDownEvent>(OnKeyDownShortcut); m_InputPlaceholder = new TextFieldPlaceholder(inputTextField); m_InputPlaceholder.text = args.placeholderText ?? string.Empty; mainTitle.text = args.title ?? string.Empty; UIUtils.SetElementDisplay(mainTitle, !string.IsNullOrEmpty(mainTitle.text)); var showIcon = false; if (!string.IsNullOrEmpty(args.iconUssClass)) { showIcon = true; icon.AddToClassList(args.iconUssClass); } else if (args.icon != null) { showIcon = true; icon.style.backgroundImage = new StyleBackground((Background)args.icon); } UIUtils.SetElementDisplay(icon, showIcon); submitButton.clickable.clicked += SubmitClicked; submitButton.SetEnabled(!string.IsNullOrWhiteSpace(inputTextField.value)); submitButton.text = !string.IsNullOrEmpty(args.submitButtonText) ? args.submitButtonText : k_DefaultSubmitButtonText; if (args.onInputSubmitted != null) { submitClicked = args.onInputSubmitted; } }
private void Refresh(IPage page = null) { if (page == null) { page = m_PageManager.GetCurrentPage(); } var showOnFilterTab = page.subPages.Skip(1).Any(); UIUtils.SetElementDisplay(this, showOnFilterTab); if (!showOnFilterTab) { return; } Clear(); var currentSubPage = page.currentSubPage; foreach (var subPage in page.subPages) { var button = new Button(); button.text = subPage.displayName; button.clickable.clicked += () => { if (page.currentSubPage == subPage) { return; } page.currentSubPage = subPage; PackageManagerWindowAnalytics.SendEvent("changeSubPage"); }; Add(button); if (subPage == currentSubPage) { button.AddToClassList("active"); } } }
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 PackageDependencySampleItemLowWidth(ResourceLoader resourceLoader, string name, string version, Label installStatus) { var root = resourceLoader.GetTemplate("PackageDependencySampleItemLowWidth.uxml"); Add(root); cache = new VisualElementCache(root); itemName.text = name; itemName.tooltip = name; itemSizeOrVersion.value = version; itemSizeOrVersion.tooltip = version; if (version == "---") { UIUtils.SetElementDisplay(itemSizeOrVersion, false); } if (installStatus != null && !string.IsNullOrEmpty(installStatus.text)) { item.Add(installStatus); } }
private void RefreshRegistry() { var registry = m_Version.registry; var showRegistry = registry != null; UIUtils.SetElementDisplay(detailRegistryContainer, showRegistry); if (showRegistry) { scopedRegistryInfoBox.text = k_InfoBoxReadMoreText[(int)InfoBoxState.ScopedRegistry]; UIUtils.SetElementDisplay(scopedRegistryInfoBox, !registry.isDefault); if (!m_Version.packageInfo.versions.all.Any()) { detailRegistryName.text = L10n.Tr("Unknown"); detailRegistryName.tooltip = string.Empty; } else { detailRegistryName.text = registry.isDefault ? "Unity" : registry.name; detailRegistryName.tooltip = registry.url; } } if (m_Version.HasTag(PackageTag.Experimental)) { scopedRegistryInfoBox.text = k_InfoBoxReadMoreText[(int)InfoBoxState.Experimental]; UIUtils.SetElementDisplay(scopedRegistryInfoBox, true); } else if (m_Version.HasTag(PackageTag.PreRelease)) { scopedRegistryInfoBox.text = k_InfoBoxReadMoreText[(int)InfoBoxState.PreRelease]; UIUtils.SetElementDisplay(scopedRegistryInfoBox, true); } else if (m_Version.HasTag(PackageTag.ReleaseCandidate)) { scopedRegistryInfoBox.text = k_InfoBoxReadMoreText[(int)InfoBoxState.ReleaseCandidate]; UIUtils.SetElementDisplay(scopedRegistryInfoBox, true); } }
private void UpdateOrdering(IPage page) { orderingMenu.menu.MenuItems().Clear(); var shouldDisplayOrdering = page?.capability.orderingValues?.Any() ?? false; if (!shouldDisplayOrdering) { UIUtils.SetElementDisplay(orderingMenu, false); return; } UIUtils.SetElementDisplay(orderingMenu, true); var matchCurrentFilter = false; if (shouldDisplayOrdering) { foreach (var ordering in page.capability.orderingValues) { matchCurrentFilter |= AddOrdering(page, ordering); } } if (!matchCurrentFilter) { var filters = page.filters?.Clone(); var firstOrdering = page.capability?.orderingValues?.FirstOrDefault(); if (filters != null && firstOrdering != null) { orderingMenu.text = $"Sort: {L10n.Tr(firstOrdering.displayName)}"; filters.orderBy = firstOrdering.orderBy; filters.isReverseOrder = firstOrdering.order == PageCapability.Order.Descending; page.UpdateFilters(filters); } } }
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 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 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); }
private bool RefreshSizeInfo() { var showSizes = m_Version.sizes.Any(); UIUtils.SetElementDisplay(detailSizesContainer, showSizes); detailSizes.Clear(); var sizeInfo = m_Version.sizes.FirstOrDefault(info => info.supportedUnityVersion == m_Version.supportedVersion); if (sizeInfo == null) { sizeInfo = m_Version.sizes.LastOrDefault(); } if (sizeInfo != null) { var label = new SelectableLabel(); label.style.whiteSpace = WhiteSpace.Normal; label.SetValueWithoutNotify(string.Format(L10n.Tr("Size: {0} (Number of files: {1})"), UIUtils.ConvertToHumanReadableSize(sizeInfo.downloadSize), sizeInfo.assetCount)); detailSizes.Add(label); } return(showSizes); }
private void ImagesGeometryChangeEvent(GeometryChangedEvent evt) { // hide or show the last image depending on whether it fits on the screen var images = m_ImagesContainer.Children(); var visibleImages = images.Where(elem => UIUtils.IsElementVisible(elem)); var firstInvisibleImage = images.FirstOrDefault(elem => !UIUtils.IsElementVisible(elem)); var visibleImagesWidth = visibleImages.Sum(elem => elem.rect.width); var lastVisibleImage = visibleImages.LastOrDefault(); var widthWhenLastImageRemoved = m_WidthsWhenImagesRemoved.Any() ? m_WidthsWhenImagesRemoved.Peek() : float.MaxValue; // if the container approximately doubles in height, that indicates the last image was wrapped around to another row if (lastVisibleImage != null && (evt.newRect.height >= 2 * lastVisibleImage.rect.height || visibleImagesWidth >= evt.newRect.width)) { UIUtils.SetElementDisplay(lastVisibleImage, false); m_WidthsWhenImagesRemoved.Push(evt.newRect.width); } else if (firstInvisibleImage != null && evt.newRect.width > widthWhenLastImageRemoved) { UIUtils.SetElementDisplay(firstInvisibleImage, true); m_WidthsWhenImagesRemoved.Pop(); } }
private void SetupOrdering() { orderingMenu.menu.MenuItems().Clear(); orderingMenu.ShowTextTooltipOnSizeChange(-16); UIUtils.SetElementDisplay(orderingMenu, false); }
private void RefreshEmbeddedFeatureSetWarningBox() { UIUtils.SetElementDisplay(embeddedFeatureSetWarningBox, m_Package.Is(PackageType.Feature) && m_Version.HasTag(PackageTag.Custom)); }
internal void UpdateLockedUI(bool showLock) { UIUtils.SetElementDisplay(m_LockedIcon, showLock); }
private void RefreshVersionInfoIcon() { var installed = m_Package?.versions?.installed; if (installed == null || m_Version == null) { UIUtils.SetElementDisplay(versionInfoIcon, false); return; } var installedVersionString = installed.versionString; if (installed.IsDifferentVersionThanRequested) { UIUtils.SetElementDisplay(versionInfoIcon, true); if (m_Version.IsRequestedButOverriddenVersion) { versionInfoIcon.tooltip = string.Format(L10n.Tr("Unity installed version {0} because another package depends on it (version {0} overrides version {1})."), installedVersionString, m_Version.versionString); } else if (m_Version.isInstalled) { versionInfoIcon.tooltip = L10n.Tr("At least one other package depends on this version of the package."); } else { versionInfoIcon.tooltip = string.Format(L10n.Tr("At least one other package depends on version {0} of this package."), installedVersionString); } return; } // In Lifecycle V2, if a Unity package doesn't have a lifecycle version (listed in the editor manifest), // then that package is not considered part of the Unity Editor "product" and we need to let users know. var unityVersionString = m_Application.unityVersion; if (!m_Package.versions.hasLifecycleVersion && m_Package.Is(PackageType.Unity)) { UIUtils.SetElementDisplay(versionInfoIcon, true); versionInfoIcon.tooltip = string.Format(L10n.Tr("This package is not officially supported for Unity {0}."), unityVersionString); return; } // We want to let users know when they are using a version different than the recommended. // The recommended version is the resolvedLifecycleVersion or the resolvedLifecycleNextVersion. // However, we don't want to show the info icon if the version currently installed // is a higher patch version of the one in the editor manifest (still considered verified). var recommended = m_Package.versions.recommended; if (m_Version.isInstalled && m_Package.state != PackageState.InstalledAsDependency && m_Package.Is(PackageType.Unity) && recommended != null && installed.version?.IsEqualOrPatchOf(recommended.version) != true) { UIUtils.SetElementDisplay(versionInfoIcon, true); versionInfoIcon.tooltip = string.Format(L10n.Tr("This version is not verified for Unity {0}. We recommended using {1}."), unityVersionString, recommended.versionString); return; } UIUtils.SetElementDisplay(versionInfoIcon, false); }
private void RefreshHiddenAssetInfo() { bool showHiddenInfoBox = m_Package is AssetStorePackage && (m_Package as AssetStorePackage).isHidden; UIUtils.SetElementDisplay(hiddenAssetInfoBoxContainer, showHiddenInfoBox); }
public PackageManagerProjectSettingsProvider(string path, SettingsScope scopes, IEnumerable <string> keywords = null) : base(path, scopes, keywords) { activateHandler = (s, element) => { ResolveDependencies(); // Create a child to make sure all the style sheets are not added to the root. rootVisualElement = new ScrollView(); rootVisualElement.StretchToParentSize(); rootVisualElement.AddStyleSheetPath(StylesheetPath.scopedRegistriesSettings); rootVisualElement.AddStyleSheetPath(StylesheetPath.projectSettings); rootVisualElement.AddStyleSheetPath(EditorGUIUtility.isProSkin ? StylesheetPath.stylesheetDark : StylesheetPath.stylesheetLight); rootVisualElement.AddStyleSheetPath(StylesheetPath.stylesheetCommon); rootVisualElement.styleSheets.Add(m_ResourceLoader.packageManagerCommonStyleSheet); element.Add(rootVisualElement); m_GeneralTemplate = EditorGUIUtility.Load(k_GeneralServicesTemplatePath) as VisualTreeAsset; VisualElement newVisualElement = new VisualElement(); m_GeneralTemplate.CloneTree(newVisualElement); rootVisualElement.Add(newVisualElement); cache = new VisualElementCache(rootVisualElement); advancedSettingsFoldout.SetValueWithoutNotify(m_SettingsProxy.advancedSettingsExpanded); m_SettingsProxy.onAdvancedSettingsFoldoutChanged += OnAdvancedSettingsFoldoutChanged; advancedSettingsFoldout.RegisterValueChangedCallback(changeEvent => { if (changeEvent.target == advancedSettingsFoldout) { m_SettingsProxy.advancedSettingsExpanded = changeEvent.newValue; } }); scopedRegistriesSettingsFoldout.SetValueWithoutNotify(m_SettingsProxy.scopedRegistriesSettingsExpanded); m_SettingsProxy.onScopedRegistriesSettingsFoldoutChanged += OnScopedRegistriesSettingsFoldoutChanged; scopedRegistriesSettingsFoldout.RegisterValueChangedCallback(changeEvent => { if (changeEvent.target == scopedRegistriesSettingsFoldout) { m_SettingsProxy.scopedRegistriesSettingsExpanded = changeEvent.newValue; } }); preReleaseInfoBox.Q <Button>().clickable.clicked += () => { m_ApplicationProxy.OpenURL($"https://docs.unity3d.com/{m_ApplicationProxy.shortUnityVersion}/Documentation/Manual/pack-preview.html"); }; enablePreReleasePackages.SetValueWithoutNotify(m_SettingsProxy.enablePreReleasePackages); enablePreReleasePackages.RegisterValueChangedCallback(changeEvent => { var newValue = changeEvent.newValue; if (newValue != m_SettingsProxy.enablePreReleasePackages) { var saveIt = true; if (newValue && !m_SettingsProxy.oneTimeWarningShown) { if (m_ApplicationProxy.DisplayDialog("showPreReleasePackages", L10n.Tr("Show pre-release packages"), k_Message, L10n.Tr("I understand"), L10n.Tr("Cancel"))) { m_SettingsProxy.oneTimeWarningShown = true; } else { saveIt = false; } } if (saveIt) { m_SettingsProxy.enablePreReleasePackages = newValue; m_SettingsProxy.Save(); PackageManagerWindowAnalytics.SendEvent("togglePreReleasePackages"); } } enablePreReleasePackages.SetValueWithoutNotify(m_SettingsProxy.enablePreReleasePackages); }); UIUtils.SetElementDisplay(seeAllPackageVersions, Unsupported.IsDeveloperBuild()); seeAllPackageVersions.SetValueWithoutNotify(m_SettingsProxy.seeAllPackageVersions); seeAllPackageVersions.RegisterValueChangedCallback(changeEvent => { seeAllPackageVersions.SetValueWithoutNotify(changeEvent.newValue); var newValue = changeEvent.newValue; if (newValue != m_SettingsProxy.seeAllPackageVersions) { m_SettingsProxy.seeAllPackageVersions = newValue; m_SettingsProxy.Save(); } }); }; }
private void StopSpinner() { m_Spinner?.Stop(); UIUtils.SetElementDisplay(m_StateIcon, true); }
private void RefreshErrorBox() { scopedRegistryErrorBox.text = draft.errorMessage; UIUtils.SetElementDisplay(scopedRegistryErrorBox, !string.IsNullOrEmpty(scopedRegistryErrorBox.text)); }
public void ClearError() { UIUtils.SetElementDisplay(this, false); alertMessage.text = string.Empty; HideReadMoreLink(); }
private void BuildMainItem(bool isFeature) { m_IsFeatureLayout = isFeature; m_MainItem = new VisualElement { name = "mainItem" }; Add(m_MainItem); m_LeftContainer = new VisualElement { name = "leftContainer", classList = { "left" } }; m_MainItem.Add(m_LeftContainer); m_DependencyIcon = new Label { name = "dependencyIcon" }; m_DependencyIcon.tooltip = "Installed as dependency"; m_LeftContainer.Add(m_DependencyIcon); m_LockedIcon = new Label { name = "lockedIcon" }; m_LeftContainer.Add(m_LockedIcon); m_ExpanderHidden = new Label { name = "expanderHidden", classList = { "expanderHidden" } }; m_LeftContainer.Add(m_ExpanderHidden); m_NameLabel = new Label { name = "packageName", classList = { "name" } }; if (isFeature) { m_MainItem.AddToClassList("feature"); m_NumPackagesInFeature = new Label() { name = "numPackages" }; var leftMiddleContainer = new VisualElement() { name = "leftMiddleContainer" }; leftMiddleContainer.Add(m_NameLabel); leftMiddleContainer.Add(m_NumPackagesInFeature); m_LeftContainer.Add(leftMiddleContainer); } else { m_LeftContainer.Add(m_NameLabel); } m_EntitlementLabel = new Label { name = "entitlementLabel" }; UIUtils.SetElementDisplay(m_EntitlementLabel, false); m_LeftContainer.Add(m_EntitlementLabel); m_VersionLabel = new Label { name = "versionLabel", classList = { "version", "middle" } }; m_MainItem.Add(m_VersionLabel); m_RightContainer = new VisualElement { name = "rightContainer", classList = { "right" } }; m_MainItem.Add(m_RightContainer); m_TagContainer = new VisualElement { name = "tagContainer" }; m_RightContainer.Add(m_TagContainer); m_Spinner = null; m_StateContainer = new VisualElement { name = "statesContainer" }; m_MainItem.Add(m_StateContainer); m_StateIcon = new VisualElement { name = "stateIcon", classList = { "status" } }; m_StateContainer.Add(m_StateIcon); if (isFeature) { m_InfoStateIcon = new VisualElement { name = "versionState" }; m_StateContainer.Add(m_InfoStateIcon); } }
private void DisplayPackagesCacheErrorBox(HelpBoxMessageType type, string message) { packagesCacheErrorBox.messageType = type; packagesCacheErrorBox.text = message; UIUtils.SetElementDisplay(packagesCacheErrorBox, true); }
private void DisplayAssetsCacheErrorBox(HelpBoxMessageType type, string message) { assetsCacheErrorBox.messageType = type; assetsCacheErrorBox.text = message; UIUtils.SetElementDisplay(assetsCacheErrorBox, true); }
private void HideReadMoreLink() { UIUtils.SetElementDisplay(alertReadMoreLink, false); m_ReadMoreLinkAction = null; }
private void ClearError() { UIUtils.SetElementDisplay(this, false); tooltip = string.Empty; ClearClassList(); }
private void ClearError() { UIUtils.SetElementDisplay(this, false); m_ErrorMessage.text = string.Empty; m_ErrorStatus.ClearClassList(); }
private void RefreshDependency() { UIUtils.SetElementDisplay(dependencyContainer, m_Version.isInstalled && !m_Version.isDirectDependency && !m_Version.HasTag(PackageTag.Feature)); }