Adaug proiectul Unity

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/DiffAndMergeOptionsFoldout.cs

@@ -0,0 +1,292 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.Common;
+using Codice.CM.Client.Differences;
+using Codice.CM.Client.Differences.Merge;
+using MergetoolGui;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Settings
+{
+    class DiffAndMergeOptionsFoldout
+    {
+        internal void OnActivate()
+        {
+            PlasticGuiConfigData data = PlasticGuiConfig.Get().Configuration;
+
+            mComparisonMethodSelectedIndex = ComparisonMethod.GetTypeIndexFromString(data.ComparisonMethod);
+            mDefaultEncodingSelectedIndex = GetEncodingIndex(data.Encoding);
+            mResultEncodingSelectedIndex = GetEncodingIndex(data.ResultEncoding);
+
+            mManualConflictResolution = data.MergeResolutionType == MergeResolutionType.OnlyOne.ToString();
+            mAutomaticConflictResolution = !mManualConflictResolution;
+
+            mCloseMergeView = data.CloseMergeAndOpenPendingChanges;
+            mMergeWithChanges = ClientConfig.Get().MergeWithPendingChanges();
+        }
+
+        internal void Save()
+        {
+            PlasticGuiConfigData guiConfigData = PlasticGuiConfig.Get().Configuration;
+
+            guiConfigData.ComparisonMethod = ComparisonMethod.GetStringFromTypeIndex(mComparisonMethodSelectedIndex);
+            guiConfigData.Encoding = GetEncodingValue(mDefaultEncodingSelectedIndex);
+            guiConfigData.ResultEncoding = GetEncodingValue(mResultEncodingSelectedIndex);
+
+            guiConfigData.MergeResolutionType = mAutomaticConflictResolution ?
+                MergeResolutionType.Forced.ToString() : MergeResolutionType.OnlyOne.ToString();
+
+            guiConfigData.CloseMergeAndOpenPendingChanges = mCloseMergeView;
+
+            ClientConfigData configData = ClientConfig.Get().GetClientConfigData();
+            configData.SetMergeWithPendingChanges(mMergeWithChanges);
+
+            ClientConfig.Get().Save(configData);
+            PlasticGuiConfig.Get().Save();
+        }
+
+        internal void OnGUI()
+        {
+            DrawSplitter.ForWidth(UnityConstants.SETTINGS_GUI_WIDTH);
+
+            DrawSettingsSection(DoDiffAndMergePreferences);
+        }
+
+        internal void SelectComparisonMethodForTesting(ComparisonMethodTypes comparisonMethod)
+        {
+            mComparisonMethodSelectedIndex = (int)comparisonMethod;
+        }
+
+        internal void SelectDefaultEncodingForTesting(string defaultEncoding)
+        {
+            mDefaultEncodingSelectedIndex = Array.IndexOf(mEncodingValues, defaultEncoding);
+        }
+
+        internal void SelectResultEncodingForTesting(string resultEncoding)
+        {
+            mResultEncodingSelectedIndex = Array.IndexOf(mEncodingValues, resultEncoding);
+        }
+
+        internal void AutomaticConflictResolutionRadioButtonRaiseCheckedForTesting()
+        {
+            mAutomaticConflictResolution = true;
+            mManualConflictResolution = false;
+        }
+
+        internal void ManualConflictResolutionRadioButtonRaiseCheckedForTesting()
+        {
+            mManualConflictResolution = true;
+            mAutomaticConflictResolution = false;
+        }
+
+        internal void CloseMergeViewCheckboxRaiseCheckedForTesting()
+        {
+            mCloseMergeView = true;
+        }
+
+        internal void CloseMergeViewCheckboxRaiseUncheckedForTesting()
+        {
+            mCloseMergeView = false;
+        }
+
+        internal void MergeWithChangesCheckBoxRaiseCheckedForTesting()
+        {
+            mMergeWithChanges = true;
+        }
+
+        internal void MergeWithChangesCheckBoxRaiseUncheckedForTesting()
+        {
+            mMergeWithChanges = false;
+        }
+
+        static int GetEncodingIndex(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+                return 0;
+
+            int index = Array.IndexOf(mEncodingValues, value);
+
+            return index == -1 ? 0 : index;
+        }
+
+        void DoDiffAndMergePreferences()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            DoComparisonMethodAndEncodingSettings();
+
+            DoMergeConflictResolutionSettings();
+
+            DoMergeViewBehaviorSettings();
+
+            if (EditorGUI.EndChangeCheck())
+                Save();
+        }
+
+        void DoComparisonMethodAndEncodingSettings()
+        {
+            GUILayout.Label(
+                PlasticLocalization.Name.ComparisonMethodAndEncodingTitle.GetString(),
+                UnityStyles.ProjectSettings.SectionTitle);
+
+            mComparisonMethodSelectedIndex = EditorGUILayout.Popup(
+                PlasticLocalization.Name.ComparisonMethod.GetString(),
+                mComparisonMethodSelectedIndex,
+                mComparisonMethods);
+
+            mDefaultEncodingSelectedIndex = EditorGUILayout.Popup(
+                MergetoolLocalization.Name.DefaultEncoding.GetString(),
+                mDefaultEncodingSelectedIndex,
+                mEncodingValuesToDisplay);
+
+            mResultEncodingSelectedIndex = EditorGUILayout.Popup(
+                MergetoolLocalization.Name.ResultEncoding.GetString(),
+                mResultEncodingSelectedIndex,
+                mEncodingValuesToDisplay);
+        }
+
+        void DoMergeConflictResolutionSettings()
+        {
+            EditorGUILayout.Space(10);
+            GUILayout.Label(
+                PlasticLocalization.Name.ConflictResolutionTitle.GetString(),
+                UnityStyles.ProjectSettings.SectionTitle);
+
+            if (EditorGUILayout.Toggle(
+                Styles.ManualConflictResolution,
+                mManualConflictResolution,
+                new GUIStyle(EditorStyles.radioButton)))
+            {
+                mManualConflictResolution = true;
+                mAutomaticConflictResolution = false;
+            }
+
+            if (EditorGUILayout.Toggle(
+                Styles.AutomaticConflictResolution,
+                mAutomaticConflictResolution,
+                new GUIStyle(EditorStyles.radioButton)))
+            {
+                mAutomaticConflictResolution = true;
+                mManualConflictResolution = false;
+            }
+        }
+
+        void DoMergeViewBehaviorSettings()
+        {
+            EditorGUILayout.Space(10);
+            GUILayout.Label(
+                PlasticLocalization.Name.MergeViewBehaviorTitle.GetString(),
+                UnityStyles.ProjectSettings.SectionTitle);
+
+            mCloseMergeView = EditorGUILayout.Toggle(Styles.CloseMergeView, mCloseMergeView);
+            mMergeWithChanges = EditorGUILayout.Toggle(Styles.MergeWithChanges, mMergeWithChanges);
+        }
+
+        static void DrawSettingsSection(Action drawSettings)
+        {
+            float originalLabelWidth = EditorGUIUtility.labelWidth;
+
+            try
+            {
+                EditorGUIUtility.labelWidth = UnityConstants.SETTINGS_GUI_WIDTH;
+
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    GUILayout.Space(10);
+
+                    using (new EditorGUILayout.VerticalScope())
+                    {
+                        GUILayout.Space(10);
+
+                        drawSettings();
+
+                        GUILayout.Space(10);
+                    }
+
+                    GUILayout.Space(10);
+                }
+            }
+            finally
+            {
+                EditorGUIUtility.labelWidth = originalLabelWidth;
+            }
+        }
+
+        class Styles
+        {
+            internal static GUIContent ManualConflictResolution =
+                new GUIContent(
+                    PlasticLocalization.Name.ManualConflictResolution.GetString(),
+                    PlasticLocalization.Name.ManualConflictResolutionTooltip.GetString());
+
+            internal static GUIContent AutomaticConflictResolution =
+                new GUIContent(
+                    PlasticLocalization.Name.AutomaticConflictResolution.GetString(),
+                    PlasticLocalization.Name.AutomaticConflictResolutionTooltip.GetString());
+
+            internal static GUIContent CloseMergeView =
+                new GUIContent(
+                    PlasticLocalization.Name.CloseMergeAndOpenPendingChanges.GetString());
+
+            internal static GUIContent MergeWithChanges =
+                new GUIContent(
+                    PlasticLocalization.Name.MergeWithPendingChanges.GetString(),
+                    PlasticLocalization.Name.MergeWithPendingChangesExplanation.GetString());
+        }
+
+        string GetEncodingValue(int selectedIndex)
+        {
+            if (selectedIndex < 0 || selectedIndex > mEncodingValues.Length)
+                return string.Empty;
+
+            return mEncodingValues[selectedIndex];
+        }
+
+        static string[] GetEncodingValuesToDisplay()
+        {
+            List<string> encodingValues = new List<string>();
+
+            encodingValues.AddRange(EncodingManager.GetPredefinedEncodings());
+
+            IEnumerable<Encoding> systemEncodings = EncodingManager.GetSystemEncodings()
+                .Select(ei => ei.GetEncoding())
+                .OrderBy(e => e.EncodingName);
+
+            foreach (Encoding encoding in systemEncodings)
+            {
+                encodingValues.Add(
+                    UnityMenuItem.EscapedText(
+                        string.Format("{0} {1} ({2})",
+                            encoding.EncodingName, encoding.WebName, encoding.CodePage.ToString())));
+            }
+
+            return encodingValues.ToArray();
+        }
+
+        static string[] mComparisonMethods = {
+                MergetoolLocalization.GetString(MergetoolLocalization.Name.IgnoreEol),
+                MergetoolLocalization.GetString(MergetoolLocalization.Name.IgnoreWhitespace),
+                MergetoolLocalization.GetString(MergetoolLocalization.Name.IgnoreEolWhitespace),
+                MergetoolLocalization.GetString(MergetoolLocalization.Name.RecognizeAll) };
+
+        static string[] mEncodingValues = EncodingManager.GetEncodingValues();
+        static string[] mEncodingValuesToDisplay = GetEncodingValuesToDisplay();
+
+        int mComparisonMethodSelectedIndex;
+        int mDefaultEncodingSelectedIndex;
+        int mResultEncodingSelectedIndex;
+
+        bool mManualConflictResolution;
+        bool mAutomaticConflictResolution;
+
+        bool mCloseMergeView;
+        bool mMergeWithChanges;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/DiffAndMergeOptionsFoldout.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1c9b352f456640c9925a381f736ecb5d
+timeCreated: 1729607607

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/OpenUVCSProjectSettings.cs

@@ -0,0 +1,40 @@
+using UnityEditor;
+
+using Unity.PlasticSCM.Editor.UI;
+
+#if !UNITY_6000_3_OR_NEWER
+using SettingsWindow = Unity.PlasticSCM.Editor.UnityInternals.UnityEditor.SettingsWindow;
+#endif
+
+namespace Unity.PlasticSCM.Editor.Settings
+{
+    internal static class OpenUVCSProjectSettings
+    {
+        internal static void ByDefault()
+        {
+            OpenVersionControlProjectSettings()?.OpenAllFoldouts();
+        }
+
+        internal static void InDiffAndMergeFoldout()
+        {
+            OpenVersionControlProjectSettings()?.OpenDiffAndMergeFoldout();
+        }
+
+        internal static void InShelveAndSwitchFoldout()
+        {
+            OpenVersionControlProjectSettings()?.OpenShelveAndSwitchFoldout();
+        }
+
+        internal static void InOtherFoldout()
+        {
+            OpenVersionControlProjectSettings()?.OpenOtherFoldout();
+        }
+
+        static UVCSProjectSettingsProvider OpenVersionControlProjectSettings()
+        {
+            SettingsWindow.Show(SettingsScope.Project, UnityConstants.PROJECT_SETTINGS_TAB_PATH);
+
+            return UVCSProjectSettingsProvider.GetIfActive();
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/OpenUVCSProjectSettings.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9731678ff16392a4d822454ca1052818
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/OtherOptionsFoldout.cs

@@ -0,0 +1,150 @@
+using System;
+
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Settings
+{
+    class OtherOptionsFoldout
+    {
+        internal void OnActivate()
+        {
+            PlasticGuiConfigData data = PlasticGuiConfig.Get().Configuration;
+
+            mNewCodeReviewCreateAndOpenInDesktop = data.NewCodeReviewBehavior == NewCodeReviewBehavior.CreateAndOpenInDesktop;
+            mNewCodeReviewRequestReviewInUnityCloud = data.NewCodeReviewBehavior == NewCodeReviewBehavior.RequestFromUnityCloud;
+            mNewCodeReviewAskAlways = data.NewCodeReviewBehavior == NewCodeReviewBehavior.Ask;
+        }
+
+        internal void Save()
+        {
+            PlasticGuiConfig plasticGuiConfig = PlasticGuiConfig.Get();
+            plasticGuiConfig.Configuration.NewCodeReviewBehavior = GetSelectedNewCodeReviewBehavior();
+            plasticGuiConfig.Save();
+        }
+
+        internal void OnGUI()
+        {
+            DrawSplitter.ForWidth(UnityConstants.SETTINGS_GUI_WIDTH);
+
+            DrawSettingsSection(DoNewCodeReviewBehaviorSettings);
+        }
+
+        internal void SelectNewCodeReviewBehaviorForTesting(NewCodeReviewBehavior shelveBehavior)
+        {
+            mNewCodeReviewCreateAndOpenInDesktop = shelveBehavior == NewCodeReviewBehavior.CreateAndOpenInDesktop;
+            mNewCodeReviewRequestReviewInUnityCloud = shelveBehavior == NewCodeReviewBehavior.RequestFromUnityCloud;
+            mNewCodeReviewAskAlways = shelveBehavior == NewCodeReviewBehavior.Ask;
+        }
+
+        NewCodeReviewBehavior GetSelectedNewCodeReviewBehavior()
+        {
+            if (mNewCodeReviewCreateAndOpenInDesktop)
+                return NewCodeReviewBehavior.CreateAndOpenInDesktop;
+
+            if (mNewCodeReviewRequestReviewInUnityCloud)
+                return NewCodeReviewBehavior.RequestFromUnityCloud;
+
+            return NewCodeReviewBehavior.Ask;
+        }
+
+        void DoNewCodeReviewBehaviorSettings()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            GUILayout.Label(
+                PlasticLocalization.Name.NewCodeReviewDefaultBehavior.GetString(),
+                UnityStyles.ProjectSettings.SectionTitle);
+
+            EditorGUILayout.Space(2);
+
+            if (EditorGUILayout.Toggle(
+                    Styles.NewCodeReviewCreateAndOpenInDesktop,
+                    mNewCodeReviewCreateAndOpenInDesktop,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mNewCodeReviewCreateAndOpenInDesktop = true;
+                mNewCodeReviewRequestReviewInUnityCloud = false;
+                mNewCodeReviewAskAlways = false;
+            }
+
+            if (EditorGUILayout.Toggle(
+                    Styles.NewCodeReviewRequestReviewInUnityCloud,
+                    mNewCodeReviewRequestReviewInUnityCloud,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mNewCodeReviewCreateAndOpenInDesktop = false;
+                mNewCodeReviewRequestReviewInUnityCloud = true;
+                mNewCodeReviewAskAlways = false;
+            }
+
+            if (EditorGUILayout.Toggle(
+                    Styles.NewCodeReviewAskAlways,
+                    mNewCodeReviewAskAlways,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mNewCodeReviewCreateAndOpenInDesktop = false;
+                mNewCodeReviewRequestReviewInUnityCloud = false;
+                mNewCodeReviewAskAlways = true;
+            }
+
+            if (EditorGUI.EndChangeCheck())
+                Save();
+        }
+
+        static void DrawSettingsSection(Action drawSettings)
+        {
+            float originalLabelWidth = EditorGUIUtility.labelWidth;
+
+            try
+            {
+                EditorGUIUtility.labelWidth = UnityConstants.SETTINGS_GUI_WIDTH;
+
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    GUILayout.Space(10);
+
+                    using (new EditorGUILayout.VerticalScope())
+                    {
+                        GUILayout.Space(10);
+
+                        drawSettings();
+
+                        GUILayout.Space(10);
+                    }
+
+                    GUILayout.Space(10);
+                }
+            }
+            finally
+            {
+                EditorGUIUtility.labelWidth = originalLabelWidth;
+            }
+        }
+
+        class Styles
+        {
+            internal static GUIContent NewCodeReviewAskAlways =
+                new GUIContent(
+                    PlasticLocalization.Name.NewCodeReviewAskAlways.GetString(),
+                    PlasticLocalization.Name.NewCodeReviewAskAlwaysExplanation.GetString());
+
+            internal static GUIContent NewCodeReviewCreateAndOpenInDesktop =
+                new GUIContent(
+                    PlasticLocalization.Name.OpenInDesktopApp.GetString(),
+                    PlasticLocalization.Name.CreateAndOpenCodeReviewInDesktopExplanation.GetString());
+
+            internal static GUIContent NewCodeReviewRequestReviewInUnityCloud =
+                new GUIContent(
+                    PlasticLocalization.Name.OpenInUnityCloud.GetString(),
+                    PlasticLocalization.Name.RequestCodeReviewFromUnityCloudExplanation.GetString());
+        }
+
+        bool mNewCodeReviewCreateAndOpenInDesktop;
+        bool mNewCodeReviewRequestReviewInUnityCloud;
+        bool mNewCodeReviewAskAlways;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/OtherOptionsFoldout.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 05c0641719e74f058e7530b150336e82
+timeCreated: 1736260811

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/PendingChangesOptionsFoldout.cs

@@ -0,0 +1,522 @@
+using System;
+
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.Commands;
+using Codice.Client.Common.FsNodeReaders;
+using Codice.Client.Common.Threading;
+using Codice.CM.Common;
+using Codice.Utils;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.PendingChanges;
+using Unity.PlasticSCM.Editor.AssetUtils.Processor;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Settings
+{
+    class PendingChangesOptionsFoldout
+    {
+        internal void OnActivate(WorkspaceInfo wkInfo)
+        {
+            mWkInfo = wkInfo;
+
+            CheckFsWatcher(mWkInfo);
+
+            mIsAutomaticAddEnabled = UVCSAssetPostprocessor.IsAutomaticAddEnabled;
+
+            mPendingChangesSavedOptions = new PendingChangesOptions();
+            mPendingChangesSavedOptions.LoadPendingChangesOptions();
+
+            SetPendingChangesOptions(mPendingChangesSavedOptions);
+        }
+
+        internal void Save()
+        {
+            if (mPendingChangesSavedOptions == null)
+                return;
+
+            UVCSAssetPostprocessor.SetAutomaticAddPreference(mIsAutomaticAddEnabled);
+
+            PendingChangesOptions newPendingChangesOptions = GetPendingChangesOptions();
+
+            if (mPendingChangesSavedOptions.AreSameOptions(newPendingChangesOptions))
+                return;
+
+            newPendingChangesOptions.SavePreferences();
+            mPendingChangesSavedOptions = newPendingChangesOptions;
+
+            IAutoRefreshView autoRefreshView = GetPendingChangesView();
+
+            if (autoRefreshView == null)
+                return;
+
+            autoRefreshView.ForceRefresh();
+        }
+
+        internal void OnGUI()
+        {
+            DrawSplitter.ForWidth(UnityConstants.SETTINGS_GUI_WIDTH);
+
+            DrawSettingsSection(
+                DoPendingChangesSettings);
+        }
+
+        internal void SetAutoRefreshForTesting(bool isEnabled)
+        {
+            mAutoRefresh = isEnabled;
+        }
+
+        internal void SetShowPrivateFilesForTesting(bool isEnabled)
+        {
+            mShowPrivateFields = isEnabled;
+        }
+
+        internal void SelectSimilarityPercentForTesting(int similarityPercent)
+        {
+            mSimilarityPercent = similarityPercent;
+        }
+
+        void DoPendingChangesSettings()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            DoGeneralSettings();
+
+            DoWhatToFindSettings();
+
+            DoWhatToShowSettings();
+
+            DoMoveDetectionSettings();
+
+            if (EditorGUI.EndChangeCheck())
+                mHasPendingSave = true;
+
+            if (mHasPendingSave && GUIUtility.hotControl == 0)
+            {
+                mHasPendingSave = false;
+                Save();
+            }
+        }
+
+        void DoGeneralSettings()
+        {
+            mIsAutomaticAddEnabled = EditorGUILayout.Toggle(Styles.AutomaticAdd, mIsAutomaticAddEnabled);
+            mAutoRefresh = EditorGUILayout.Toggle(Styles.AutoRefresh, mAutoRefresh);
+        }
+
+        void DoWhatToFindSettings()
+        {
+            EditorGUILayout.Space(10);
+            GUILayout.Label(
+                PlasticLocalization.Name.PendingChangesWhatToFindTab.GetString(),
+                UnityStyles.ProjectSettings.SectionTitle);
+
+            mShowCheckouts = EditorGUILayout.Toggle(Styles.ShowCheckouts, mShowCheckouts);
+            mShowChangedFiles = EditorGUILayout.Toggle(Styles.ShowChangedFiles, mShowChangedFiles);
+
+            DrawTabbedContent(
+                DoCheckFileContentCheckbox);
+
+            DoFsWatcherMessage(mFSWatcherEnabled);
+        }
+
+        void DoCheckFileContentCheckbox()
+        {
+            mCheckFileContent = EditorGUILayout.Toggle(Styles.CheckFileContent, mCheckFileContent);
+        }
+
+        void DoFsWatcherMessage(bool isEnabled)
+        {
+            GUIContent message = new GUIContent(
+                isEnabled ?
+                    GetFsWatcherEnabledMessage() :
+                    GetFsWatcherDisabledMessage(),
+                isEnabled ?
+                    Images.GetInfoIcon() :
+                    Images.GetWarnIcon());
+
+            GUILayout.Label(message, UnityStyles.ProjectSettings.Title, GUILayout.Height(26));
+            GUILayout.Space(-4);
+
+            string formattedExplanation = isEnabled ?
+                GetFsWatcherEnabledExplanation() :
+                GetFsWatcherDisabledExplanation();
+
+            ExternalLink externalLink = new ExternalLink
+            {
+                Label = PlasticLocalization.Name.UnityVersionControlSupport.GetString(),
+                Url = SUPPORT_URL
+            };
+
+            // Since links are rendered as buttons we skip possible state changes produced by clicking the link
+            bool guiChanged = GUI.changed;
+
+            DrawTextBlockWithLink.ForExternalLink(
+                externalLink, formattedExplanation, UnityStyles.ProjectSettings.Paragraph);
+
+            GUI.changed = guiChanged;
+        }
+
+        void DoWhatToShowSettings()
+        {
+            EditorGUILayout.Space(10);
+            GUILayout.Label(
+                PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesWhatToShowTab),
+                UnityStyles.ProjectSettings.SectionTitle);
+
+            mUseChangeLists = EditorGUILayout.Toggle(Styles.UseChangeLists, mUseChangeLists);
+            mShowPrivateFields = EditorGUILayout.Toggle(Styles.ShowPrivateFields, mShowPrivateFields);
+            mShowIgnoredFiles = EditorGUILayout.Toggle(Styles.ShowIgnoredFields, mShowIgnoredFiles);
+            mShowHiddenFiles = EditorGUILayout.Toggle(Styles.ShowHiddenFields, mShowHiddenFiles);
+            mShowDeletedFiles = EditorGUILayout.Toggle(Styles.ShowDeletedFilesDirs, mShowDeletedFiles);
+        }
+
+        void DoMoveDetectionSettings()
+        {
+            EditorGUILayout.Space(10);
+            GUILayout.Label(
+                PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesMoveDetectionTab),
+                UnityStyles.ProjectSettings.SectionTitle);
+
+            mShowMovedFiles = EditorGUILayout.Toggle(Styles.ShowMovedFiles, mShowMovedFiles);
+
+            DrawTabbedContent(
+                DoMovedFilesCheckboxes);
+        }
+
+        void DoMovedFilesCheckboxes()
+        {
+            mMatchBinarySameExtension =
+                EditorGUILayout.Toggle(Styles.MatchBinarySameExtension, mMatchBinarySameExtension);
+            mMatchTextSameExtension = EditorGUILayout.Toggle(Styles.MatchTextSameExtension, mMatchTextSameExtension);
+            mSimilarityPercent = EditorGUILayout.IntSlider(Styles.SimilarityPercent, mSimilarityPercent, 0, 100);
+        }
+
+        void CheckFsWatcher(WorkspaceInfo wkInfo)
+        {
+            bool isFileSystemWatcherEnabled = false;
+
+            IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
+                waiter.Execute(
+                    /*threadOperationDelegate*/
+                    delegate
+                    {
+                        isFileSystemWatcherEnabled =
+                            IsFileSystemWatcherEnabled(wkInfo);
+                    },
+                    /*afterOperationDelegate*/
+                    delegate
+                    {
+                        if (waiter.Exception != null)
+                            return;
+
+                        mFSWatcherEnabled = isFileSystemWatcherEnabled;
+                    });
+        }
+
+        void SetPendingChangesOptions(PendingChangesOptions options)
+        {
+            mShowCheckouts = IsEnabled(
+                WorkspaceStatusOptions.FindCheckouts, options.WorkspaceStatusOptions);
+            mAutoRefresh = options.AutoRefresh;
+
+            mShowChangedFiles = IsEnabled(
+                WorkspaceStatusOptions.FindChanged, options.WorkspaceStatusOptions);
+            mCheckFileContent = options.CheckFileContentForChanged;
+
+            mUseChangeLists = options.UseChangeLists;
+
+            mShowPrivateFields = IsEnabled(
+                WorkspaceStatusOptions.FindPrivates, options.WorkspaceStatusOptions);
+            mShowIgnoredFiles = IsEnabled(
+                WorkspaceStatusOptions.ShowIgnored, options.WorkspaceStatusOptions);
+            mShowHiddenFiles = IsEnabled(
+                WorkspaceStatusOptions.ShowHiddenChanges, options.WorkspaceStatusOptions);
+            mShowDeletedFiles = IsEnabled(
+                WorkspaceStatusOptions.FindLocallyDeleted, options.WorkspaceStatusOptions);
+
+            mShowMovedFiles = IsEnabled(
+                WorkspaceStatusOptions.CalculateLocalMoves, options.WorkspaceStatusOptions);
+            mMatchBinarySameExtension =
+                options.MovedMatchingOptions.bBinMatchingOnlySameExtension;
+            mMatchTextSameExtension =
+                options.MovedMatchingOptions.bTxtMatchingOnlySameExtension;
+            mSimilarityPercent = (int)((1 - options.MovedMatchingOptions.AllowedChangesPerUnit) * 100f);
+        }
+
+        PendingChangesOptions GetPendingChangesOptions()
+        {
+            WorkspaceStatusOptions resultWkStatusOptions =
+                WorkspaceStatusOptions.None;
+
+            if (mShowCheckouts)
+            {
+                resultWkStatusOptions |= WorkspaceStatusOptions.FindCheckouts;
+                resultWkStatusOptions |= WorkspaceStatusOptions.FindReplaced;
+                resultWkStatusOptions |= WorkspaceStatusOptions.FindCopied;
+            }
+
+            if (mShowChangedFiles)
+                resultWkStatusOptions |= WorkspaceStatusOptions.FindChanged;
+            if (mShowPrivateFields)
+                resultWkStatusOptions |= WorkspaceStatusOptions.FindPrivates;
+            if (mShowIgnoredFiles)
+                resultWkStatusOptions |= WorkspaceStatusOptions.ShowIgnored;
+            if (mShowHiddenFiles)
+                resultWkStatusOptions |= WorkspaceStatusOptions.ShowHiddenChanges;
+            if (mShowDeletedFiles)
+                resultWkStatusOptions |= WorkspaceStatusOptions.FindLocallyDeleted;
+            if (mShowMovedFiles)
+                resultWkStatusOptions |= WorkspaceStatusOptions.CalculateLocalMoves;
+
+            MovedMatchingOptions matchingOptions = new MovedMatchingOptions();
+            matchingOptions.AllowedChangesPerUnit =
+                (100 - mSimilarityPercent) / 100f;
+            matchingOptions.bBinMatchingOnlySameExtension =
+                mMatchBinarySameExtension;
+            matchingOptions.bTxtMatchingOnlySameExtension =
+                mMatchTextSameExtension;
+
+            return new PendingChangesOptions(
+                resultWkStatusOptions,
+                matchingOptions,
+                mUseChangeLists,
+                true,
+                false,
+                mAutoRefresh,
+                false,
+                mCheckFileContent);
+        }
+
+        static void DrawSettingsSection(Action drawSettings)
+        {
+            float originalLabelWidth = EditorGUIUtility.labelWidth;
+
+            try
+            {
+                EditorGUIUtility.labelWidth = UnityConstants.SETTINGS_GUI_WIDTH;
+
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    GUILayout.Space(10);
+
+                    using (new EditorGUILayout.VerticalScope())
+                    {
+                        GUILayout.Space(10);
+
+                        drawSettings();
+
+                        GUILayout.Space(10);
+                    }
+
+                    GUILayout.Space(10);
+                }
+            }
+            finally
+            {
+                EditorGUIUtility.labelWidth = originalLabelWidth;
+            }
+        }
+
+        static void DrawTabbedContent(Action drawContent)
+        {
+            float originalLabelWidth = EditorGUIUtility.labelWidth;
+
+            try
+            {
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    EditorGUILayout.Space(15);
+                    EditorGUIUtility.labelWidth -= 15;
+                    using (new EditorGUILayout.VerticalScope())
+                    {
+                        GUILayout.Space(0);
+                        drawContent();
+                    }
+
+                    GUILayout.FlexibleSpace();
+                }
+            }
+            finally
+            {
+                EditorGUIUtility.labelWidth = originalLabelWidth;
+            }
+        }
+
+        static IAutoRefreshView GetPendingChangesView()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return null;
+
+            return window.GetPendingChangesView();
+        }
+
+        static string GetFsWatcherEnabledMessage()
+        {
+            if (PlatformIdentifier.IsWindows() || PlatformIdentifier.IsMac())
+                return PlasticLocalization.GetString(
+                    PlasticLocalization.Name.PendingChangesFilesystemWatcherEnabled);
+
+            return PlasticLocalization.GetString(
+                PlasticLocalization.Name.PendingChangesINotifyEnabled);
+        }
+
+        static string GetFsWatcherDisabledMessage()
+        {
+            if (PlatformIdentifier.IsWindows() || PlatformIdentifier.IsMac())
+                return PlasticLocalization.GetString(
+                    PlasticLocalization.Name.PendingChangesFilesystemWatcherDisabled);
+
+            return PlasticLocalization.GetString(
+                PlasticLocalization.Name.PendingChangesINotifyDisabled);
+        }
+
+        static string GetFsWatcherEnabledExplanation()
+        {
+            if (PlatformIdentifier.IsWindows() || PlatformIdentifier.IsMac())
+                return PlasticLocalization.GetString(
+                    PlasticLocalization.Name.PendingChangesFilesystemWatcherEnabledExplanationUnityVCS);
+
+            return PlasticLocalization.GetString(
+            PlasticLocalization.Name.PendingChangesINotifyEnabledExplanation);
+        }
+
+        static string GetFsWatcherDisabledExplanation()
+        {
+            if (PlatformIdentifier.IsWindows() || PlatformIdentifier.IsMac())
+            {
+                return PlasticLocalization.GetString(
+                    PlasticLocalization.Name.PendingChangesFilesystemWatcherDisabledExplanationUnityVCS)
+                    .Replace("[[HELP_URL|{0}]]", "");
+            }
+
+            return PlasticLocalization.GetString(
+                PlasticLocalization.Name.PendingChangesINotifyDisabledExplanation);
+        }
+
+        static bool IsFileSystemWatcherEnabled(
+            WorkspaceInfo wkInfo)
+        {
+            return WorkspaceWatcherFsNodeReadersCache.Get().
+                IsWatcherEnabled(wkInfo);
+        }
+
+        static bool IsEnabled(
+            WorkspaceStatusOptions option,
+            WorkspaceStatusOptions options)
+        {
+            return (options & option) == option;
+        }
+
+        internal interface IAutoRefreshView
+        {
+            void ForceRefresh();
+        }
+
+        class Styles
+        {
+            internal static GUIContent AutomaticAdd =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.ProjectSettingsAutomaticAdd),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.ProjectSettingsAutomaticAddExplanation));
+            internal static GUIContent ShowCheckouts =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowCheckouts),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowCheckoutsExplanation));
+            internal static GUIContent AutoRefresh =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesAutoRefresh),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesAutoRefreshExplanation));
+            internal static GUIContent ShowChangedFiles =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesFindChanged),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesFindChangedExplanation));
+            internal static GUIContent CheckFileContent =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesCheckFileContent),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesCheckFileContentExplanation));
+            internal static GUIContent UseChangeLists =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesGroupInChangeLists),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesGroupInChangeListsExplanation));
+            internal static GUIContent ShowPrivateFields =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowPrivateFiles),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowPrivateFilesExplanation));
+            internal static GUIContent ShowIgnoredFields =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowIgnoredFiles),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowIgnoredFilesExplanation));
+            internal static GUIContent ShowHiddenFields =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowHiddenFiles),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowHiddenFilesExplanation));
+            internal static GUIContent ShowDeletedFilesDirs =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowDeletedFiles),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesShowDeletedFilesExplanation));
+            internal static GUIContent ShowMovedFiles =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesFindMovedFiles),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesFindMovedFilesExplanation));
+            internal static GUIContent MatchBinarySameExtension =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesMatchBinarySameExtension),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesMatchBinarySameExtensionExplanation));
+            internal static GUIContent MatchTextSameExtension =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesMatchTextSameExtension),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesMatchTextSameExtensionExplanation));
+            internal static GUIContent SimilarityPercent =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesSimilarityPercentage),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.PendingChangesSimilarityPercentageExplanation));
+        }
+
+        WorkspaceInfo mWkInfo;
+        PendingChangesOptions mPendingChangesSavedOptions;
+
+        bool mIsAutomaticAddEnabled;
+        bool mShowCheckouts;
+        bool mAutoRefresh;
+        bool mFSWatcherEnabled;
+
+        // We need this one to be a member field so it survives while the sliders are being dragged
+        bool mHasPendingSave;
+
+        bool mShowChangedFiles;
+        bool mCheckFileContent;
+
+        bool mUseChangeLists;
+        bool mShowPrivateFields;
+        bool mShowIgnoredFiles;
+        bool mShowHiddenFiles;
+        bool mShowDeletedFiles;
+
+        bool mShowMovedFiles;
+        bool mMatchBinarySameExtension;
+        bool mMatchTextSameExtension;
+        int mSimilarityPercent;
+
+        const string SUPPORT_URL = "https://support.unity.com/hc/en-us/requests/new?ticket_form_id=360001051792";
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/PendingChangesOptionsFoldout.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4646098fa06b7764b843d936862b4d71
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/ShelveAndSwitchOptionsFoldout.cs

@@ -0,0 +1,269 @@
+using System;
+
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.Common;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.PendingChanges;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Settings
+{
+    class ShelveAndSwitchOptionsFoldout
+    {
+        internal void OnActivate()
+        {
+            PlasticGuiConfigData data = PlasticGuiConfig.Get().Configuration;
+
+            mUndoChangesAfterShelve = data.ShelvingUndoBehavior == UndoShelveBehavior.UndoChanges;
+            mKeepChangesAfterShelve = data.ShelvingUndoBehavior == UndoShelveBehavior.KeepChanges;
+            mAskAlwaysAfterShelve = data.ShelvingUndoBehavior == UndoShelveBehavior.Ask;
+
+            mSwitchActionShelveOption  = ClientConfig.Get().GetPendingChangesOnSwitchAction() == UserAction.Shelve;
+            mSwitchActionAllowOption = ClientConfig.Get().GetPendingChangesOnSwitchAction() == UserAction.None;
+            mSwitchActionWarnOption = ClientConfig.Get().GetPendingChangesOnSwitchAction() == UserAction.Warn;
+            mSwitchActionFailOption = ClientConfig.Get().GetPendingChangesOnSwitchAction() == UserAction.Fail ||
+                                      ClientConfig.Get().GetPendingChangesOnSwitchAction() == UserAction.NotDefined;
+        }
+
+        internal void Save()
+        {
+            PlasticGuiConfig plasticGuiConfig = PlasticGuiConfig.Get();
+            plasticGuiConfig.Configuration.ShelvingUndoBehavior = GetSelectedShelvingUndoBehavior();
+            plasticGuiConfig.Save();
+
+            ClientConfigData configData = ClientConfig.Get().GetClientConfigData();
+            configData.SetPendingChangesOnSwitchAction(GetSelectedSwitchBehavior());
+            ClientConfig.Get().Save(configData);
+        }
+
+        internal void OnGUI()
+        {
+            DrawSplitter.ForWidth(UnityConstants.SETTINGS_GUI_WIDTH);
+
+            DrawSettingsSection(DoDiffAndMergePreferences);
+        }
+
+        internal void SelectShelvingUndoBehaviorForTesting(UndoShelveBehavior shelveBehavior)
+        {
+            mUndoChangesAfterShelve = shelveBehavior == UndoShelveBehavior.UndoChanges;
+            mKeepChangesAfterShelve = shelveBehavior == UndoShelveBehavior.KeepChanges;
+            mAskAlwaysAfterShelve = shelveBehavior == UndoShelveBehavior.Ask;
+        }
+
+        internal void SelectSwitchActionForTesting(UserAction switchAction)
+        {
+            mSwitchActionShelveOption  = switchAction == UserAction.Shelve;
+            mSwitchActionAllowOption = switchAction == UserAction.None;
+            mSwitchActionWarnOption = switchAction == UserAction.Warn;
+            mSwitchActionFailOption = switchAction == UserAction.Fail ||
+                                      switchAction == UserAction.NotDefined;
+        }
+
+        UndoShelveBehavior GetSelectedShelvingUndoBehavior()
+        {
+            if (mUndoChangesAfterShelve)
+                return UndoShelveBehavior.UndoChanges;
+
+            if (mKeepChangesAfterShelve)
+                return UndoShelveBehavior.KeepChanges;
+
+            return UndoShelveBehavior.Ask;
+        }
+
+        UserAction GetSelectedSwitchBehavior()
+        {
+            if (mSwitchActionAllowOption)
+                return UserAction.None;
+
+            if (mSwitchActionWarnOption)
+                return UserAction.Warn;
+
+            if (mSwitchActionFailOption)
+                return UserAction.Fail;
+
+            return UserAction.Shelve;
+        }
+
+        void DoDiffAndMergePreferences()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            DoUndoAfterShelveBehaviorSettings();
+
+            DoSwitchActionSettings();
+
+            if (EditorGUI.EndChangeCheck())
+                Save();
+        }
+
+        void DoUndoAfterShelveBehaviorSettings()
+        {
+            GUILayout.Label(
+                PlasticLocalization.Name.UndoChangesAfterShelveDefaultBehavior.GetString(),
+                UnityStyles.ProjectSettings.SectionTitle);
+            EditorGUILayout.Space(2);
+
+            if (EditorGUILayout.Toggle(
+                    Styles.UndoChangesAfterShelve,
+                    mUndoChangesAfterShelve,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mUndoChangesAfterShelve = true;
+                mKeepChangesAfterShelve = false;
+                mAskAlwaysAfterShelve = false;
+            }
+
+            if (EditorGUILayout.Toggle(
+                    Styles.KeepChangesAfterShelve,
+                    mKeepChangesAfterShelve,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mUndoChangesAfterShelve = false;
+                mKeepChangesAfterShelve = true;
+                mAskAlwaysAfterShelve = false;
+            }
+
+            if (EditorGUILayout.Toggle(
+                    Styles.AskAlwaysAfterShelve,
+                    mAskAlwaysAfterShelve,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mUndoChangesAfterShelve = false;
+                mKeepChangesAfterShelve = false;
+                mAskAlwaysAfterShelve = true;
+            }
+        }
+
+        void DoSwitchActionSettings()
+        {
+            EditorGUILayout.Space(10);
+            GUILayout.Label(
+                PlasticLocalization.Name.SwitchActionOptionsTitle.GetString(),
+                UnityStyles.ProjectSettings.SectionTitle);
+            EditorGUILayout.Space(2);
+
+            if (EditorGUILayout.Toggle(
+                    Styles.SwitchActionShelve,
+                    mSwitchActionShelveOption,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mSwitchActionShelveOption = true;
+                mSwitchActionAllowOption = false;
+                mSwitchActionWarnOption = false;
+                mSwitchActionFailOption = false;
+            }
+
+            if (EditorGUILayout.Toggle(
+                    Styles.SwitchActionAllow,
+                    mSwitchActionAllowOption,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mSwitchActionShelveOption = false;
+                mSwitchActionAllowOption = true;
+                mSwitchActionWarnOption = false;
+                mSwitchActionFailOption = false;
+            }
+
+            if (EditorGUILayout.Toggle(
+                    Styles.SwitchActionWarn,
+                    mSwitchActionWarnOption,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mSwitchActionShelveOption = false;
+                mSwitchActionAllowOption = false;
+                mSwitchActionWarnOption = true;
+                mSwitchActionFailOption = false;
+            }
+
+            if (EditorGUILayout.Toggle(
+                    Styles.SwitchActionFail,
+                    mSwitchActionFailOption,
+                    new GUIStyle(EditorStyles.radioButton)))
+            {
+                mSwitchActionShelveOption = false;
+                mSwitchActionAllowOption = false;
+                mSwitchActionWarnOption = false;
+                mSwitchActionFailOption = true;
+            }
+        }
+
+        static void DrawSettingsSection(Action drawSettings)
+        {
+            float originalLabelWidth = EditorGUIUtility.labelWidth;
+
+            try
+            {
+                EditorGUIUtility.labelWidth = UnityConstants.SETTINGS_GUI_WIDTH;
+
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    GUILayout.Space(10);
+
+                    using (new EditorGUILayout.VerticalScope())
+                    {
+                        GUILayout.Space(10);
+
+                        drawSettings();
+
+                        GUILayout.Space(10);
+                    }
+
+                    GUILayout.Space(10);
+                }
+            }
+            finally
+            {
+                EditorGUIUtility.labelWidth = originalLabelWidth;
+            }
+        }
+
+        class Styles
+        {
+            internal static GUIContent UndoChangesAfterShelve =
+                new GUIContent(
+                    PlasticLocalization.Name.UndoChangesAfterShelve.GetString(),
+                    PlasticLocalization.Name.UndoChangesAfterShelveExplanation.GetString());
+
+            internal static GUIContent KeepChangesAfterShelve =
+                new GUIContent(
+                    PlasticLocalization.Name.KeepChangesAfterShelve.GetString(),
+                    PlasticLocalization.Name.KeepChangesAfterShelveExplanation.GetString());
+
+            internal static GUIContent AskAlwaysAfterShelve =
+                new GUIContent(
+                    PlasticLocalization.Name.AskAlwaysAfterShelve.GetString(),
+                    PlasticLocalization.Name.AskAlwaysAfterShelveExplanation.GetString());
+
+            internal static GUIContent SwitchActionShelve =
+                new GUIContent(
+                    PlasticLocalization.Name.SwitchActionShelveOption.GetString(),
+                    PlasticLocalization.Name.SwitchActionShelveExplanation.GetString());
+
+            internal static GUIContent SwitchActionAllow =
+                new GUIContent(
+                    PlasticLocalization.Name.SwitchActionAllowOption.GetString(),
+                    PlasticLocalization.Name.SwitchActionAllowExplanation.GetString());
+
+            internal static GUIContent SwitchActionWarn =
+                new GUIContent(
+                    PlasticLocalization.Name.SwitchActionWarnOption.GetString(),
+                    PlasticLocalization.Name.SwitchActionWarnExplanation.GetString());
+
+            internal static GUIContent SwitchActionFail =
+                new GUIContent(
+                    PlasticLocalization.Name.SwitchActionFailOption.GetString(),
+                    PlasticLocalization.Name.SwitchActionFailExplanation.GetString());
+        }
+
+        bool mUndoChangesAfterShelve;
+        bool mKeepChangesAfterShelve;
+        bool mAskAlwaysAfterShelve;
+
+        bool mSwitchActionShelveOption;
+        bool mSwitchActionAllowOption;
+        bool mSwitchActionWarnOption;
+        bool mSwitchActionFailOption;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/ShelveAndSwitchOptionsFoldout.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c64851962d9c48068897eb736be4bed1
+timeCreated: 1731661639

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/UVCSProjectSettingsProvider.cs

@@ -0,0 +1,352 @@
+using System;
+
+using UnityEditor;
+using UnityEditor.VersionControl;
+using UnityEngine;
+
+using Codice.Client.Common.EventTracking;
+using Codice.CM.Common;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.Toolbar;
+using Unity.PlasticSCM.Editor.UI;
+
+using SettingsWindow = Unity.PlasticSCM.Editor.UnityInternals.UnityEditor.SettingsWindow;
+
+namespace Unity.PlasticSCM.Editor.Settings
+{
+    /// <summary>
+    /// Project Settings UI for Unity Version Control.
+    /// <para>
+    /// Unity associates this object with the
+    /// &quot;Unity Version Control&quot; entry in <b>Version Control</b> mode (see
+    /// <see cref="VersionControlObject"/> and <see cref="VersionControlAttribute"/>).
+    /// When the user picks that mode, Unity shows this provider&apos;s inspector for editing
+    /// version-control-related project settings.
+    /// </para>
+    /// <para>
+    /// <see cref="OnActivate"/> is called when this provider becomes the active Version Control
+    /// mode, after the user selects &quot;Unity Version Control&quot; in the mode dropdown.
+    /// </para>
+    /// <para>
+    /// <see cref="OnDeactivate"/> is called when this provider stops being the active Version Control mode.
+    /// </para>
+    /// </summary>
+    [VersionControl("Unity Version Control")]
+    internal class UVCSProjectSettingsProvider : VersionControlObject, ISettingsInspectorExtension
+    {
+        void OnEnable()
+        {
+            PlasticApp.InitializeIfNeeded();
+
+            mUVCSPlugin = UVCSPlugin.Instance;
+            mUpdateToolbarButtonVisibility = UVCSToolbar.Controller;
+
+            ReloadSettings();
+        }
+
+        public override void OnActivate()
+        {
+            // Early exit to avoid GPU device error when running a build in batchmode
+            if (Application.isBatchMode)
+                return;
+
+            EditorWindow currentWindow = EditorWindow.focusedWindow;
+
+            SwitchUVCSPlugin.OnIfNeeded(mUVCSPlugin);
+
+            if (SettingsWindow.IsProjectSettingsWindow(currentWindow))
+            {
+                currentWindow.Focus();
+            }
+        }
+
+        public override void OnDeactivate()
+        {
+            EditorWindow currentWindow = EditorWindow.focusedWindow;
+
+            SwitchUVCSPlugin.Off(mUVCSPlugin);
+
+            if (SettingsWindow.IsProjectSettingsWindow(currentWindow))
+            {
+                currentWindow.Focus();
+            }
+        }
+
+        internal static UVCSProjectSettingsProvider GetIfActive()
+        {
+            return VersionControlManager.activeVersionControlObject as UVCSProjectSettingsProvider;
+        }
+
+        internal void ReloadSettings()
+        {
+            if (mUVCSPlugin == null)
+                return;
+
+            mIsUVCSPluginEnabled = UVCSPluginIsEnabledPreference.IsEnabled();
+            mShowToolbarButton = UVCSToolbarButtonIsShownPreference.IsEnabled();
+
+            mWkInfo = FindWorkspace.InfoForApplicationPath(
+                ApplicationDataPath.Get(), PlasticGui.Plastic.API);
+
+            if (mWkInfo == null)
+                return;
+
+            OpenAllFoldouts();
+            ActivateFoldouts();
+
+            EditorUtility.SetDirty(this);
+        }
+
+        internal void OpenAllFoldouts()
+        {
+            mIsPendingChangesFoldoutOpen = true;
+            mIsDiffAndMergeFoldoutOpen = true;
+            mIsShelveAndSwitchFoldoutOpen = true;
+            mIsOtherFoldoutOpen = true;
+        }
+
+        internal void OpenDiffAndMergeFoldout()
+        {
+            mIsDiffAndMergeFoldoutOpen = true;
+            mIsPendingChangesFoldoutOpen = false;
+            mIsShelveAndSwitchFoldoutOpen = false;
+            mIsOtherFoldoutOpen = false;
+        }
+
+        internal void OpenShelveAndSwitchFoldout()
+        {
+            mIsShelveAndSwitchFoldoutOpen = true;
+            mIsPendingChangesFoldoutOpen = false;
+            mIsDiffAndMergeFoldoutOpen = false;
+            mIsOtherFoldoutOpen = false;
+        }
+
+        internal void OpenOtherFoldout()
+        {
+            mIsOtherFoldoutOpen = true;
+            mIsPendingChangesFoldoutOpen = false;
+            mIsDiffAndMergeFoldoutOpen = false;
+            mIsShelveAndSwitchFoldoutOpen = false;
+        }
+
+        internal void ShowToolbarButtonCheckboxRaiseCheckedForTesting()
+        {
+            mShowToolbarButton = true;
+        }
+
+        internal void ShowToolbarButtonCheckboxRaiseUncheckedForTesting()
+        {
+            mShowToolbarButton = false;
+        }
+
+        void ISettingsInspectorExtension.OnInspectorGUI()
+        {
+            GUILayout.Space(10);
+
+            DrawSettingsSection(DoIsEnabledSetting);
+
+            if (!mIsUVCSPluginEnabled)
+                return;
+
+#if !UNITY_6000_3_OR_NEWER
+            DrawSettingsSection(DoShowToolbarButtonSetting);
+#endif
+
+            if (mWkInfo == null)
+                return;
+
+            mIsPendingChangesFoldoutOpen = DrawFoldout(
+                mIsPendingChangesFoldoutOpen,
+                PlasticLocalization.Name.PendingChangesOptionsSectionTitle.GetString(),
+                mPendingChangesOptionsFoldout.OnGUI);
+
+            mIsDiffAndMergeFoldoutOpen = DrawFoldout(
+                mIsDiffAndMergeFoldoutOpen,
+                PlasticLocalization.Name.DiffAndMergeOptionsSectionTitle.GetString(),
+                mDiffAndMergeOptionsFoldout.OnGUI);
+
+            mIsShelveAndSwitchFoldoutOpen = DrawFoldout(
+                mIsShelveAndSwitchFoldoutOpen,
+                PlasticLocalization.Name.ShelveAndSwitchOptionsSectionTitle.GetString(),
+                mShelveAndSwitchOptionsFoldout.OnGUI);
+
+            mIsOtherFoldoutOpen = DrawFoldout(
+                mIsOtherFoldoutOpen,
+                PlasticLocalization.Name.OtherOptionsSectionTitle.GetString(),
+                mOtherOptionsFoldout.OnGUI);
+        }
+
+        void ActivateFoldouts()
+        {
+            mPendingChangesOptionsFoldout.OnActivate(mWkInfo);
+            mDiffAndMergeOptionsFoldout.OnActivate();
+            mShelveAndSwitchOptionsFoldout.OnActivate();
+            mOtherOptionsFoldout.OnActivate();
+        }
+
+        void DoIsEnabledSetting()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                string message = PlasticLocalization.GetString(
+                    mIsUVCSPluginEnabled ?
+                        PlasticLocalization.Name.UnityVCSIsActive :
+                        PlasticLocalization.Name.UnityVCSIsPaused);
+
+                GUILayout.Label(
+                    message,
+                    EditorStyles.boldLabel,
+                    GUILayout.Height(20));
+
+                EditorGUILayout.Space(8);
+
+                DoIsEnabledButton();
+
+                GUILayout.FlexibleSpace();
+            }
+        }
+
+        void DoIsEnabledButton()
+        {
+            if (!GUILayout.Button(PlasticLocalization.GetString(
+                        mIsUVCSPluginEnabled ?
+                            PlasticLocalization.Name.PauseButton :
+                            PlasticLocalization.Name.ResumeButton),
+                    UnityStyles.ProjectSettings.ToggleOn))
+            {
+                return;
+            }
+
+            EditorWindow currentWindow = EditorWindow.focusedWindow;
+
+            if (mIsUVCSPluginEnabled)
+            {
+                mIsUVCSPluginEnabled = false;
+
+                TrackFeatureEvent(
+                    mWkInfo,
+                    TrackFeatureUseEvent.Features.UnityPackage.DisableManually);
+
+                SwitchUVCSPlugin.Off(mUVCSPlugin);
+            }
+            else
+            {
+                mIsUVCSPluginEnabled = true;
+
+                TrackFeatureEvent(
+                    mWkInfo,
+                    TrackFeatureUseEvent.Features.UnityPackage.EnableManually);
+
+                SwitchUVCSPlugin.On(mUVCSPlugin);
+            }
+
+            currentWindow.Focus();
+        }
+
+        void DoShowToolbarButtonSetting()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                bool wasChecked = mShowToolbarButton;
+
+                bool isChecked = EditorGUILayout.Toggle(Styles.ShowToolbarButton, wasChecked);
+
+                if (!wasChecked && isChecked)
+                {
+                    mShowToolbarButton = true;
+                    mUpdateToolbarButtonVisibility.Show();
+                    return;
+                }
+
+                if (wasChecked && !isChecked)
+                {
+                    mShowToolbarButton = false;
+                    mUpdateToolbarButtonVisibility.Hide();
+                    return;
+                }
+            }
+        }
+
+        static void DrawSettingsSection(Action drawSettings)
+        {
+            float originalLabelWidth = EditorGUIUtility.labelWidth;
+
+            try
+            {
+                EditorGUIUtility.labelWidth = UnityConstants.SETTINGS_GUI_WIDTH_MAIN_SECTION;
+
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    using (new EditorGUILayout.VerticalScope())
+                    {
+                        GUILayout.Space(10);
+
+                        drawSettings();
+
+                        GUILayout.Space(10);
+                    }
+                }
+            }
+            finally
+            {
+                EditorGUIUtility.labelWidth = originalLabelWidth;
+            }
+        }
+
+        static bool DrawFoldout(
+            bool isFoldoutOpen,
+            string title,
+            Action drawContent)
+        {
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            bool result =
+                EditorGUILayout.BeginFoldoutHeaderGroup(
+                    isFoldoutOpen,
+                    title,
+                    UnityStyles.ProjectSettings.FoldoutHeader);
+
+            if (result)
+                drawContent();
+
+            EditorGUILayout.EndFoldoutHeaderGroup();
+            EditorGUILayout.EndVertical();
+
+            return result;
+        }
+
+        static void TrackFeatureEvent(WorkspaceInfo wkInfo, string eventName)
+        {
+            if (wkInfo == null)
+                return;
+
+            TrackFeatureUseEvent.For(
+                PlasticGui.Plastic.API.GetRepositorySpec(wkInfo),
+                eventName);
+        }
+
+        class Styles
+        {
+            internal static GUIContent ShowToolbarButton =
+                new GUIContent(
+                    PlasticLocalization.Name.ShowUnityVersionControlToolbarButton.GetString());
+        }
+
+        bool mIsPendingChangesFoldoutOpen;
+        bool mIsDiffAndMergeFoldoutOpen;
+        bool mIsShelveAndSwitchFoldoutOpen;
+        bool mIsOtherFoldoutOpen;
+        bool mShowToolbarButton;
+        bool mIsUVCSPluginEnabled;
+
+        WorkspaceInfo mWkInfo;
+
+        PendingChangesOptionsFoldout mPendingChangesOptionsFoldout = new PendingChangesOptionsFoldout();
+        DiffAndMergeOptionsFoldout mDiffAndMergeOptionsFoldout = new DiffAndMergeOptionsFoldout();
+        ShelveAndSwitchOptionsFoldout mShelveAndSwitchOptionsFoldout = new ShelveAndSwitchOptionsFoldout();
+        OtherOptionsFoldout mOtherOptionsFoldout = new OtherOptionsFoldout();
+
+        IUpdateToolbarButtonVisibility mUpdateToolbarButtonVisibility;
+        UVCSPlugin mUVCSPlugin;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Settings/UVCSProjectSettingsProvider.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d097a5d507694ba7ac97bc9a9f2942e3
+timeCreated: 1729521930