public static void HandleInvalidOrUnreachableOnlineUrl(string onlineUrl, string offlineDocPath, string docType, string analyticsEvent, IPackageVersion version, IPackage package, ApplicationProxy applicationProxy) { if (!string.IsNullOrEmpty(offlineDocPath)) { applicationProxy.RevealInFinder(offlineDocPath); PackageManagerWindowAnalytics.SendEvent($"{analyticsEvent}OnDisk", version?.uniqueId); return; } if (!string.IsNullOrEmpty(onlineUrl)) { // With the current `UpmPackageDocs.GetDocumentationUrl` implementation, // We'll get invalid url links for non-unity packages on unity3d.com // We want to avoiding opening these kinds of links to avoid confusion. if (!UpmClient.IsUnityUrl(onlineUrl) || package.Is(PackageType.Unity) || version.packageUniqueId.StartsWith("com.unity.")) { applicationProxy.OpenURL(onlineUrl); PackageManagerWindowAnalytics.SendEvent($"{analyticsEvent}UnreachableOrInvalidUrl", version?.uniqueId); return; } } PackageManagerWindowAnalytics.SendEvent($"{analyticsEvent}NotFound", version?.uniqueId); Debug.LogError(string.Format(L10n.Tr("[Package Manager Window] Unable to find valid {0} for this {1}."), docType, package.GetDescriptor())); }
public static void OpenWebUrl(string onlineUrl, IPackageVersion version, ApplicationProxy applicationProxy, string analyticsEvent, Action errorCallback) { var request = UnityWebRequest.Head(onlineUrl); try { var operation = request.SendWebRequest(); operation.completed += (op) => { if (request.responseCode >= 200 && request.responseCode < 300) { applicationProxy.OpenURL(onlineUrl); PackageManagerWindowAnalytics.SendEvent($"{analyticsEvent}ValidUrl", version?.uniqueId); } else { errorCallback?.Invoke(); } }; } catch (InvalidOperationException e) { if (e.Message != "Insecure connection not allowed") { throw e; } } }
protected override bool TriggerAction(IList <IPackageVersion> versions) { var title = string.Format(L10n.Tr("Removing {0} items"), versions.Count); var result = 0; if (!m_PackageManagerPrefs.skipMultiSelectRemoveConfirmation) { var message = L10n.Tr("Are you sure you want to remove these items?"); result = m_Application.DisplayDialogComplex(title, message, L10n.Tr("Remove"), L10n.Tr("Cancel"), L10n.Tr("Never ask")); } // Cancel if (result == 1) { return(false); } // Never ask if (result == 2) { m_PackageManagerPrefs.skipMultiSelectRemoveConfirmation = true; } m_PackageDatabase.Uninstall(versions.Select(v => v.package)); PackageManagerWindowAnalytics.SendEvent("uninstall", packageIds: versions.Select(v => v.uniqueId)); // After a bulk removal, we want to deselect them to avoid installing them back by accident. DeselectVersions(versions); return(true); }
protected override bool TriggerAction(IPackageVersion version) { var packagesToUninstall = m_PackageDatabase.GetCustomizedDependencies(version, true); if (!packagesToUninstall.Any()) { return(false); } var packageNameAndVersions = string.Join("\n\u2022 ", packagesToUninstall.Select(package => $"{package.displayName} - {package.versions.lifecycleVersion.version}").ToArray()); var message = packagesToUninstall.Length == 1 ? string.Format( L10n.Tr("Are you sure you want to reset this {0}?\nThe following included package will reset to the required version:\n\u2022 {1}"), version.package.GetDescriptor(), packageNameAndVersions) : string.Format( L10n.Tr("Are you sure you want to reset this {0}?\nThe following included packages will reset to their required versions:\n\u2022 {1}"), version.package.GetDescriptor(), packageNameAndVersions); if (!m_Application.DisplayDialog(L10n.Tr("Unity Package Manager"), message, L10n.Tr("Continue"), L10n.Tr("Cancel"))) { return(false); } m_PageManager.SetPackagesUserUnlockedState(packagesToUninstall.Select(p => p.uniqueId), false); m_PackageDatabase.ResetDependencies(version, packagesToUninstall); PackageManagerWindowAnalytics.SendEvent("reset", version?.uniqueId); return(true); }
private void OnImportButtonClicked() { var previousImports = m_Sample.previousImports; var previousImportPaths = previousImports.Aggregate <string, string>(string.Empty, (current, next) => current + next.Replace(@"\", "/").Replace(Application.dataPath, "Assets") + "\n"); var warningMessage = string.Empty; if (previousImports.Count > 1) { warningMessage = L10n.Tr("Different versions of the sample are already imported at") + "\n\n" + previousImportPaths + "\n" + L10n.Tr("They will be deleted when you update."); } else if (previousImports.Count == 1) { if (m_Sample.isImported) { warningMessage = L10n.Tr("The sample is already imported at") + "\n\n" + previousImportPaths + "\n" + L10n.Tr("Importing again will override all changes you have made to it."); } else { warningMessage = L10n.Tr("A different version of the sample is already imported at") + "\n\n" + previousImportPaths + "\n" + L10n.Tr("It will be deleted when you update."); } } if (!string.IsNullOrEmpty(warningMessage) && !m_ApplicationProxy.DisplayDialog("importPackageSample", L10n.Tr("Importing package sample"), warningMessage + L10n.Tr(" Are you sure you want to continue?"), L10n.Tr("Yes"), L10n.Tr("No"))) { return; } if (previousImports.Count < 1) { PackageManagerWindowAnalytics.SendEvent("importSample", m_Version.uniqueId); } else { PackageManagerWindowAnalytics.SendEvent("reimportSample", m_Version.uniqueId); } if (m_Sample.Import(Sample.ImportOptions.OverridePreviousImports)) { RefreshImportStatus(); if (m_Sample.isImported) { // Highlight import path var currentPath = m_IOProxy.CurrentDirectory; var importRelativePath = m_Sample.importPath.Replace(currentPath + Path.DirectorySeparatorChar, ""); var obj = m_AssetDatabase.LoadMainAssetAtPath(importRelativePath); m_Selection.activeObject = obj; EditorGUIUtility.PingObject(obj); } } }
protected override bool TriggerAction(IList <IPackageVersion> versions) { m_PackageDatabase.Install(versions.Select(v => GetTargetVersion(v))); // The current multi-select UI does not allow users to install non-recommended versions // Should this change in the future, we'll need to update the analytics event accordingly. PackageManagerWindowAnalytics.SendEvent("installUpdateRecommended", packageIds: versions.Select(v => v.uniqueId)); return(true); }
protected override bool TriggerAction(IPackageVersion version) { m_PageManager.SetPackagesUserUnlockedState(new string[1] { version.packageUniqueId }, true); PackageManagerWindowAnalytics.SendEvent("unlock", version.packageUniqueId); return(true); }
private void ShowReadMoreLink(UIError error, IPackageVersion packageVersion) { m_ReadMoreLinkAction = () => { PackageManagerWindowAnalytics.SendEvent($"alertreadmore_{error.errorCode.ToString()}", packageVersion?.uniqueId); Application.OpenURL(error.readMoreURL); }; UIUtils.SetElementDisplay(alertReadMoreLink, true); }
protected override bool TriggerAction(IList <IPackageVersion> versions) { m_PageManager.RemoveSelection(versions.Select(v => new PackageAndVersionIdPair(v.packageUniqueId, v.uniqueId))); if (!string.IsNullOrEmpty(m_AnalyticsEventName)) { PackageManagerWindowAnalytics.SendEvent(m_AnalyticsEventName, packageIds: versions.Select(v => v.packageUniqueId)); } return(true); }
protected override bool TriggerAction(IPackageVersion version) { var canDownload = m_PackageDatabase.Download(version.package); if (canDownload) { PackageManagerWindowAnalytics.SendEvent("startDownloadNew", version.packageUniqueId); } return(canDownload); }
protected override bool TriggerAction(IList <IPackageVersion> versions) { var canDownload = m_PackageDatabase.Download(versions.Select(v => v.package)); if (canDownload) { PackageManagerWindowAnalytics.SendEvent("startDownloadNew", packageIds: versions.Select(v => v.packageUniqueId)); } return(canDownload); }
private void AuthorClick() { var authorLink = m_Version?.authorLink ?? string.Empty; if (!string.IsNullOrEmpty(authorLink)) { m_Application.OpenURL(authorLink); PackageManagerWindowAnalytics.SendEvent("viewAuthorLink", m_Version?.uniqueId); } }
private void SetFilterFromMenu(PackageFilterTab filter) { if (filter == m_PackageFiltering.currentFilterTab) { return; } SetCurrentSearch(string.Empty); SetFilter(filter); PackageManagerWindowAnalytics.SendEvent("changeFilter"); }
private void ShowOthersVersion() { if (m_Version?.package == null) { return; } m_PageManager.SetSeeAllVersions(m_Version.package, true); PackageManagerWindowAnalytics.SendEvent("seeAllVersions", m_Version.package.uniqueId); Refresh(m_Version); }
private void DelayedSearchEvent() { if (DateTime.Now.Ticks - m_SearchTextChangeTimestamp > k_SearchEventDelayTicks) { EditorApplication.update -= DelayedSearchEvent; var value = searchToolbar.value.Trim(); m_PackageFiltering.currentSearchText = value; if (!string.IsNullOrEmpty(value)) { PackageManagerWindowAnalytics.SendEvent("search"); } } }
protected override bool TriggerAction(IPackageVersion version) { if (version.HasTag(PackageTag.Custom)) { if (!m_Application.DisplayDialog(L10n.Tr("Unity Package Manager"), L10n.Tr("You will lose all your changes (if any) if you delete a package in development. Are you sure?"), L10n.Tr("Yes"), L10n.Tr("No"))) { return(false); } m_PackageDatabase.RemoveEmbedded(version.package); PackageManagerWindowAnalytics.SendEvent("removeEmbedded", version.uniqueId); return(true); } return(false); }
protected override bool TriggerAction(IPackageVersion version) { IPackage[] packageToUninstall = null; if (version.HasTag(PackageTag.Feature)) { var customizedDependencies = m_PackageDatabase.GetCustomizedDependencies(version, true); if (customizedDependencies.Any()) { var packageNameAndVersions = string.Join("\n\u2022 ", customizedDependencies.Select(package => $"{package.displayName} - {package.versions.lifecycleVersion.version}").ToArray()); var title = string.Format(L10n.Tr("Installing {0}"), version.package.GetDescriptor()); var message = customizedDependencies.Length == 1 ? string.Format( L10n.Tr("This {0} includes a package version that is different from what's already installed. Would you like to reset the following package to the required version?\n\u2022 {1}"), version.package.GetDescriptor(), packageNameAndVersions) : string.Format( L10n.Tr("This {0} includes package versions that are different from what are already installed. Would you like to reset the following packages to the required versions?\n\u2022 {1}"), version.package.GetDescriptor(), packageNameAndVersions); var result = m_Application.DisplayDialogComplex("installPackageWithCustomizedDependencies", title, message, L10n.Tr("Install and Reset"), L10n.Tr("Cancel"), L10n.Tr("Install Only")); if (result == 1) // Cancel { return(false); } if (result == 0) // Install and reset { packageToUninstall = customizedDependencies; } } } if (packageToUninstall?.Any() == true) { m_PackageDatabase.InstallAndResetDependencies(version, packageToUninstall); PackageManagerWindowAnalytics.SendEvent("installAndReset", version.uniqueId); } else { m_PackageDatabase.Install(version); var installRecommended = version.package.versions.recommended == version ? "Recommended" : "NonRecommended"; var eventName = $"installNew{installRecommended}"; PackageManagerWindowAnalytics.SendEvent(eventName, version.uniqueId); } return(true); }
public void AddDropdownItem(DropdownMenu menu, int value) { var textValue = value == (int)AssetsToLoad.All ? k_All : value.ToString(); textValue = L10n.Tr(textValue); menu.AppendAction(textValue, a => { loadAssetsDropdown.text = textValue; m_SettingsProxy.loadAssets = value; m_SettingsProxy.Save(); UpdateLoadBarMessage(); LoadItemsClicked(); UpdateMenu(); PackageManagerWindowAnalytics.SendEvent($"load {value}"); }, a => m_SettingsProxy.loadAssets == value ? DropdownMenuAction.Status.Checked : DropdownMenuAction.Status.Normal); }
private void InstallByNameAndVersion(string packageName, string packageVersion = null) { var packageId = string.IsNullOrEmpty(packageVersion) ? packageName : $"{packageName}@{packageVersion}"; m_UpmClient.AddById(packageId); PackageManagerWindowAnalytics.SendEvent("addByNameAndVersion", packageId); Close(); var package = m_PackageDatabase.GetPackage(packageName); if (package != null) { m_PackageFiltering.currentFilterTab = m_PageManager.FindTab(package); m_PageManager.SetSelected(package, package.versions?.FirstOrDefault(v => v.versionString == packageVersion)); } }
private static void OnConfigureClicked(PackageSelectionArgs args) { var database = ServicesContainer.instance.Resolve <PackageDatabase>(); var package = database.GetPackage(args.package.uniqueId); var installedVersion = package?.versions?.installed; if (installedVersion == null) { return; } var editorGameService = GetEditorGameServiceField(installedVersion.packageInfo); var configurePath = GetConfigurePathField(editorGameService); if (!string.IsNullOrEmpty(configurePath)) { PackageManagerWindowAnalytics.SendEvent("configureService", args.package.uniqueId); } SettingsService.OpenProjectSettings(configurePath); }
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"); } } }
private void SeeAllVersionsClick() { m_PageManager.SetSeeAllVersions(package, true); PackageManagerWindowAnalytics.SendEvent("seeAllVersions", targetVersion?.uniqueId); }
private void SetupAdvancedMenu() { toolbarSettingsMenu.tooltip = L10n.Tr("Advanced"); var dropdownItem = toolbarSettingsMenu.AddBuiltInDropdownItem(); dropdownItem.text = L10n.Tr("Project Settings"); dropdownItem.action = () => { if (!m_SettingsProxy.advancedSettingsExpanded) { m_SettingsProxy.advancedSettingsExpanded = true; m_SettingsProxy.Save(); } SettingsWindow.Show(SettingsScope.Project, PackageManagerProjectSettingsProvider.k_PackageManagerSettingsPath); PackageManagerWindowAnalytics.SendEvent("advancedProjectSettings"); }; dropdownItem = toolbarSettingsMenu.AddBuiltInDropdownItem(); dropdownItem.text = L10n.Tr("Preferences"); dropdownItem.action = () => { SettingsWindow.Show(SettingsScope.User, PackageManagerUserSettingsProvider.k_PackageManagerUserSettingsPath); PackageManagerWindowAnalytics.SendEvent("packageManagerUserSettings"); }; dropdownItem = toolbarSettingsMenu.AddBuiltInDropdownItem(); dropdownItem.insertSeparatorBefore = true; dropdownItem.text = L10n.Tr("Manual resolve"); dropdownItem.action = () => { if (!EditorApplication.isPlaying) { m_UpmClient.Resolve(); } }; dropdownItem = toolbarSettingsMenu.AddBuiltInDropdownItem(); dropdownItem.insertSeparatorBefore = true; dropdownItem.text = L10n.Tr("Reset Packages to defaults"); dropdownItem.action = () => { EditorApplication.ExecuteMenuItem(k_ResetPackagesMenuPath); m_PageManager.Refresh(RefreshOptions.UpmListOffline); PackageManagerWindowAnalytics.SendEvent("resetToDefaults"); }; if (Unsupported.IsDeveloperBuild()) { dropdownItem = toolbarSettingsMenu.AddBuiltInDropdownItem(); dropdownItem.insertSeparatorBefore = true; dropdownItem.text = L10n.Tr("Reset Package Database"); dropdownItem.action = () => { PackageManagerWindow.instance?.Close(); m_PageManager.Reload(); ServicesContainer.instance.Resolve <AssetStoreCallQueue>().ClearFetchDetails(); }; dropdownItem = toolbarSettingsMenu.AddBuiltInDropdownItem(); dropdownItem.text = L10n.Tr("Reset Stylesheets"); dropdownItem.action = () => { PackageManagerWindow.instance?.Close(); m_ResourceLoader.Reset(); }; } }
protected override bool TriggerAction(IPackageVersion version) { var result = 0; if (version.HasTag(PackageTag.BuiltIn)) { if (!m_PackageManagerPrefs.skipDisableConfirmation) { result = m_Application.DisplayDialogComplex(L10n.Tr("Disable Built-In Package"), L10n.Tr("Are you sure you want to disable this built-in package?"), L10n.Tr("Disable"), L10n.Tr("Cancel"), L10n.Tr("Never ask")); } } else { var isPartOfFeature = m_PackageDatabase.GetFeatureDependents(version).Any(featureSet => featureSet.isInstalled); if (isPartOfFeature || !m_PackageManagerPrefs.skipRemoveConfirmation) { var descriptor = version.package.GetDescriptor(); var title = string.Format(L10n.Tr("Removing {0}"), CultureInfo.InvariantCulture.TextInfo.ToTitleCase(descriptor)); if (isPartOfFeature) { var message = string.Format(L10n.Tr("Are you sure you want to remove this {0} that is used by at least one installed feature?"), descriptor); var removeIt = m_Application.DisplayDialog(title, message, L10n.Tr("Remove"), L10n.Tr("Cancel")); result = removeIt ? 0 : 1; } else { var message = string.Format(L10n.Tr("Are you sure you want to remove this {0}?"), descriptor); result = m_Application.DisplayDialogComplex(title, message, L10n.Tr("Remove"), L10n.Tr("Cancel"), L10n.Tr("Never ask")); } } } // Cancel if (result == 1) { return(false); } // Do not ask again if (result == 2) { if (version.HasTag(PackageTag.BuiltIn)) { m_PackageManagerPrefs.skipDisableConfirmation = true; } else { m_PackageManagerPrefs.skipRemoveConfirmation = true; } } // If the user is removing a package that is part of a feature set, lock it after removing from manifest // Having this check condition should be more optimal once we implement caching of Feature Set Dependents for each package if (m_PackageDatabase.GetFeatureDependents(version.package.versions.installed)?.Any() == true) { m_PageManager.SetPackagesUserUnlockedState(new List <string> { version.packageUniqueId }, false); } // Remove m_PackageDatabase.Uninstall(version.package); PackageManagerWindowAnalytics.SendEvent("uninstall", version?.uniqueId); return(true); }
private void SetupAddMenu() { var dropdownItem = addMenu.AddBuiltInDropdownItem(); dropdownItem.text = L10n.Tr("Add package from disk..."); dropdownItem.userData = "AddFromDisk"; dropdownItem.action = () => { var path = m_Application.OpenFilePanelWithFilters(L10n.Tr("Select package on disk"), "", new[] { "package.json file", "json" }); if (string.IsNullOrEmpty(path)) { return; } try { if (m_IOProxy.GetFileName(path) != "package.json") { Debug.Log(L10n.Tr("[Package Manager Window] Please select a valid package.json file in a package folder.")); return; } if (!m_PackageDatabase.isInstallOrUninstallInProgress) { m_PackageDatabase.InstallFromPath(m_IOProxy.GetParentDirectory(path), out var tempPackageId); PackageManagerWindowAnalytics.SendEvent("addFromDisk"); var package = m_PackageDatabase.GetPackage(tempPackageId); if (package != null) { m_PackageFiltering.currentFilterTab = PackageFilterTab.InProject; m_PageManager.SetSelected(package); } } } catch (System.IO.IOException e) { Debug.Log($"[Package Manager Window] Cannot add package from disk {path}: {e.Message}"); } }; dropdownItem = addMenu.AddBuiltInDropdownItem(); dropdownItem.text = L10n.Tr("Add package from tarball..."); dropdownItem.userData = "AddFromTarball"; dropdownItem.action = () => { var path = m_Application.OpenFilePanelWithFilters(L10n.Tr("Select package on disk"), "", new[] { "Package tarball", "tgz, tar.gz" }); if (!string.IsNullOrEmpty(path) && !m_PackageDatabase.isInstallOrUninstallInProgress) { m_PackageDatabase.InstallFromPath(path, out var tempPackageId); PackageManagerWindowAnalytics.SendEvent("addFromTarball"); var package = m_PackageDatabase.GetPackage(tempPackageId); if (package != null) { m_PackageFiltering.currentFilterTab = PackageFilterTab.InProject; m_PageManager.SetSelected(package); } } }; dropdownItem = addMenu.AddBuiltInDropdownItem(); dropdownItem.text = L10n.Tr("Add package from git URL..."); dropdownItem.userData = "AddFromGit"; dropdownItem.action = () => { var args = new InputDropdownArgs { title = L10n.Tr("Add package from git URL"), iconUssClass = "git", placeholderText = L10n.Tr("URL"), submitButtonText = L10n.Tr("Add"), onInputSubmitted = url => { if (!m_PackageDatabase.isInstallOrUninstallInProgress) { m_PackageDatabase.InstallFromUrl(url); PackageManagerWindowAnalytics.SendEvent("addFromGitUrl", url); var package = m_PackageDatabase.GetPackage(url); if (package != null) { m_PackageFiltering.currentFilterTab = PackageFilterTab.InProject; m_PageManager.SetSelected(package); } } }, windowSize = new Vector2(resolvedStyle.width, 50) }; addMenu.ShowInputDropdown(args); }; dropdownItem = addMenu.AddBuiltInDropdownItem(); dropdownItem.text = L10n.Tr("Add package by name..."); dropdownItem.userData = "AddByName"; dropdownItem.action = () => { // Same as above, the worldBound of the toolbar is used rather than the addMenu var rect = GUIUtility.GUIToScreenRect(worldBound); var dropdown = new AddPackageByNameDropdown(m_ResourceLoader, m_PackageFiltering, m_UpmClient, m_PackageDatabase, m_PageManager, PackageManagerWindow.instance) { position = rect }; DropdownContainer.ShowDropdown(dropdown); }; }
protected override bool TriggerAction(IList <IPackageVersion> versions) { m_PackageDatabase.AbortDownload(versions.Select(v => v.package)); PackageManagerWindowAnalytics.SendEvent("abortDownload", packageIds: versions.Select(v => v.packageUniqueId)); return(true); }
protected override bool TriggerAction(IPackageVersion version) { var installedVersion = version.package.versions.installed; var targetVersion = GetTargetVersion(version); if (installedVersion != null && !installedVersion.isDirectDependency && installedVersion != targetVersion) { var featureSetDependents = m_PackageDatabase.GetFeatureDependents(installedVersion); // if the installed version is being used by a Feature Set show the more specific // Feature Set dialog instead of the generic one if (featureSetDependents.Any()) { var message = string.Format(L10n.Tr("Changing a {0} that is part of a feature can lead to errors. Are you sure you want to proceed?"), version.package.GetDescriptor()); if (!m_Application.DisplayDialog(L10n.Tr("Warning"), message, L10n.Tr("Yes"), L10n.Tr("No"))) { return(false); } } else { var message = L10n.Tr("This version of the package is being used by other packages. Upgrading a different version might break your project. Are you sure you want to continue?"); if (!m_Application.DisplayDialog(L10n.Tr("Unity Package Manager"), message, L10n.Tr("Yes"), L10n.Tr("No"))) { return(false); } } } IPackage[] packageToUninstall = null; if (targetVersion.HasTag(PackageTag.Feature)) { var customizedDependencies = m_PackageDatabase.GetCustomizedDependencies(targetVersion, true); if (customizedDependencies.Any()) { var packageNameAndVersions = string.Join("\n\u2022 ", customizedDependencies.Select(package => $"{package.displayName} - {package.versions.lifecycleVersion.version}").ToArray()); var message = customizedDependencies.Length == 1 ? string.Format( L10n.Tr("This {0} includes a package version that is different from what's already installed. Would you like to reset the following package to the required version?\n\u2022 {1}"), version.package.GetDescriptor(), packageNameAndVersions) : string.Format( L10n.Tr("This {0} includes package versions that are different from what are already installed. Would you like to reset the following packages to the required versions?\n\u2022 {1}"), version.package.GetDescriptor(), packageNameAndVersions); var result = m_Application.DisplayDialogComplex(L10n.Tr("Unity Package Manager"), message, L10n.Tr("Install and Reset"), L10n.Tr("Cancel"), L10n.Tr("Install Only")); if (result == 1) // Cancel { return(false); } if (result == 0) // Install and reset { packageToUninstall = customizedDependencies; } } } if (packageToUninstall?.Any() == true) { m_PackageDatabase.InstallAndResetDependencies(targetVersion, packageToUninstall); PackageManagerWindowAnalytics.SendEvent("installAndReset", targetVersion?.uniqueId); } else { m_PackageDatabase.Install(targetVersion); var installRecommended = version.package.versions.recommended == targetVersion ? "Recommended" : "NonRecommended"; var eventName = $"installUpdate{installRecommended}"; PackageManagerWindowAnalytics.SendEvent(eventName, targetVersion?.uniqueId); } return(true); }
protected override bool TriggerAction(IPackageVersion version) { m_PackageDatabase.AbortDownload(version.package); PackageManagerWindowAnalytics.SendEvent("abortDownload", version.packageUniqueId); return(true); }
private void OnDeselectLockedSelectionsClicked() { m_PageManager.RemoveSelection(m_UnlockFoldout.versions.Select(s => new PackageAndVersionIdPair(s.packageUniqueId, s.uniqueId))); PackageManagerWindowAnalytics.SendEvent("deselectLocked", packageIds: m_UnlockFoldout.versions.Select(v => v.packageUniqueId)); }
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(); } }); }; }