Adaug proiectul Unity

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/BranchExplorerOptionsWindow.cs

@@ -0,0 +1,262 @@
+using System;
+using System.Collections.Generic;
+using Codice.CM.Common;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Configuration;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.Views.BranchExplorer.Options.ConditionalFormat;
+using Unity.PlasticSCM.Editor.Views.BranchExplorer.Options.DisplayOptions;
+
+namespace Unity.PlasticSCM.Editor.Views.BranchExplorer.Options
+{
+    internal class BranchExplorerOptionsWindow : EditorWindow
+    {
+        internal interface IBranchExplorerView
+        {
+            void Redraw();
+            void Refresh();
+            void ClearSearchResults();
+        }
+
+        internal static void ShowWindow()
+        {
+            BranchExplorerOptionsWindow window =
+                GetWindow<BranchExplorerOptionsWindow>(
+                    false,
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.BrexOptionsWindowTitle));
+
+            window.titleContent.image = Images.GetSettingsIcon();
+            window.minSize = new Vector2(550, 320);
+            window.Show();
+        }
+
+        void OnEnable()
+        {
+            mUVCSPlugin = UVCSPlugin.Instance;
+            mUVCSPlugin.Enable();
+
+            if (!mUVCSPlugin.ConnectionMonitor.IsConnected)
+                return;
+
+            mWkInfo = FindWorkspace.InfoForApplicationPath(
+                ApplicationDataPath.Get(), PlasticGui.Plastic.API);
+        }
+
+        void CreateGUI()
+        {
+            if (TryInitialize())
+                return;
+
+            // On domain reload, the BranchExplorerWindow may not have
+            // finished its own CreateGUI yet
+            EditorApplication.delayCall += DelayedInitialize;
+        }
+
+        void DelayedInitialize()
+        {
+            if (!TryInitialize())
+                Close();
+        }
+
+        bool TryInitialize()
+        {
+            BranchExplorerWindow brExWindow = GetWindowIfOpened.BranchExplorer();
+
+            if (brExWindow == null || mWkInfo == null)
+                return false;
+
+            mBrExWindow = brExWindow;
+            BuildComponents();
+            LoadConfiguration();
+            return true;
+        }
+
+        void OnDestroy()
+        {
+            if (mSectionListView != null)
+#pragma warning disable CS0618 // onSelectionChange is obsolete in newer Unity but needed for backward compatibility
+                mSectionListView.onSelectionChange -= OnSectionSelectionChanged;
+#pragma warning restore CS0618
+
+            if (mDisplayOptionsPanel != null)
+                mDisplayOptionsPanel.Dispose();
+
+            if (mFiltersAndConditionalFormatPanel != null)
+                mFiltersAndConditionalFormatPanel.Dispose();
+        }
+
+        void LoadConfiguration()
+        {
+            WorkspaceUIConfiguration config =
+                WorkspaceUIConfiguration.Get(mWkInfo);
+
+            if (config == null)
+                return;
+
+            mDisplayOptionsPanel.SetWorkspaceUIConfiguration(config);
+            mDisplayOptionsPanel.LoadConfiguration();
+
+            mFiltersAndConditionalFormatPanel.SetWorkspaceUIConfiguration(config);
+            mFiltersAndConditionalFormatPanel.LoadConfigRules();
+        }
+
+        void BuildComponents()
+        {
+            rootVisualElement.Clear();
+
+            VisualElement container = new VisualElement();
+            container.style.flexDirection = FlexDirection.Row;
+            container.style.flexGrow = 1;
+
+            VisualElement leftPane = CreateLeftPane();
+            VisualElement rightPane = CreateRightPane();
+
+            container.Add(leftPane);
+            container.Add(rightPane);
+
+            rootVisualElement.Add(container);
+
+            mSectionListView.selectedIndex = DISPLAY_OPTIONS_INDEX;
+        }
+
+        VisualElement CreateLeftPane()
+        {
+            VisualElement leftPane = new VisualElement();
+            leftPane.style.marginTop = 4;
+            leftPane.style.width = LEFT_PANE_WIDTH;
+            leftPane.style.flexShrink = 0;
+            leftPane.style.borderRightWidth = 1;
+            leftPane.style.borderRightColor = UnityStyles.Colors.SplitLineColor;
+
+            mSectionNames = new List<string>
+            {
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.BrexDisplayOptions),
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.FiltersAndConditionalFormat)
+            };
+
+            mSectionListView = new ListView();
+            mSectionListView.itemsSource = mSectionNames;
+            mSectionListView.makeItem = CreateSectionItem;
+            mSectionListView.bindItem = BindSectionItem;
+            mSectionListView.fixedItemHeight = 16;
+            mSectionListView.selectionType = SelectionType.Single;
+            mSectionListView.style.flexGrow = 1;
+
+#pragma warning disable CS0618 // onSelectionChange is obsolete in newer Unity but needed for backward compatibility
+            mSectionListView.onSelectionChange += OnSectionSelectionChanged;
+#pragma warning restore CS0618
+
+            leftPane.Add(mSectionListView);
+
+            return leftPane;
+        }
+
+        VisualElement CreateRightPane()
+        {
+            mRightPane = new VisualElement();
+            mRightPane.style.flexGrow = 1;
+            mRightPane.style.minWidth = 360;
+
+            mSectionHeader = new Label();
+            mSectionHeader.style.unityFontStyleAndWeight = FontStyle.Bold;
+            mSectionHeader.style.fontSize = 18;
+            mSectionHeader.style.paddingLeft = 12;
+            mSectionHeader.style.paddingTop = 8;
+            mSectionHeader.style.paddingBottom = 8;
+            mRightPane.Add(mSectionHeader);
+
+            mDisplayOptionsPanel = new DisplayOptionsPanel(
+                mWkInfo,
+                GetBranchExplorerView);
+            mDisplayOptionsPanel.style.display = DisplayStyle.None;
+            mRightPane.Add(mDisplayOptionsPanel);
+
+            mFiltersAndConditionalFormatPanel = new FiltersAndConditionalFormatPanel(
+                mWkInfo,
+                GetBranchExplorerView);
+            mFiltersAndConditionalFormatPanel.style.display = DisplayStyle.None;
+            mRightPane.Add(mFiltersAndConditionalFormatPanel);
+
+            return mRightPane;
+        }
+
+        VisualElement CreateSectionItem()
+        {
+            Label label = new Label();
+            label.style.paddingLeft = 18;
+            label.style.paddingRight = 8;
+            label.style.unityTextAlign = TextAnchor.MiddleLeft;
+            return label;
+        }
+
+        void BindSectionItem(VisualElement element, int index)
+        {
+            ((Label)element).text = mSectionNames[index];
+        }
+
+        void OnSectionSelectionChanged(IEnumerable<object> selectedItems)
+        {
+            if (mSectionListView.selectedIndex < 0)
+                return;
+
+            SelectSection(mSectionListView.selectedIndex);
+        }
+
+        void SelectSection(int sectionIndex)
+        {
+            mSelectedSectionIndex = sectionIndex;
+            UpdateRightPaneContent();
+        }
+
+        void UpdateRightPaneContent()
+        {
+            mDisplayOptionsPanel.style.display = DisplayStyle.None;
+            mFiltersAndConditionalFormatPanel.style.display = DisplayStyle.None;
+
+            switch (mSelectedSectionIndex)
+            {
+                case DISPLAY_OPTIONS_INDEX:
+                    mSectionHeader.text = PlasticLocalization.GetString(
+                        PlasticLocalization.Name.BrexDisplayOptions);
+                    mDisplayOptionsPanel.style.display = DisplayStyle.Flex;
+                    break;
+
+                case FILTERS_AND_CONDITIONAL_FORMAT_INDEX:
+                    mSectionHeader.text = PlasticLocalization.GetString(
+                        PlasticLocalization.Name.FiltersAndConditionalFormat);
+                    mFiltersAndConditionalFormatPanel.style.display = DisplayStyle.Flex;
+                    break;
+            }
+        }
+
+        IBranchExplorerView GetBranchExplorerView()
+        {
+            return mBrExWindow.BranchExplorerView;
+        }
+
+        WorkspaceInfo mWkInfo;
+        BranchExplorerWindow mBrExWindow;
+        int mSelectedSectionIndex;
+
+        VisualElement mRightPane;
+        Label mSectionHeader;
+        ListView mSectionListView;
+        List<string> mSectionNames;
+
+        DisplayOptionsPanel mDisplayOptionsPanel;
+        FiltersAndConditionalFormatPanel mFiltersAndConditionalFormatPanel;
+
+        UVCSPlugin mUVCSPlugin;
+
+        const int DISPLAY_OPTIONS_INDEX = 0;
+        const int FILTERS_AND_CONDITIONAL_FORMAT_INDEX = 1;
+        const float LEFT_PANE_WIDTH = 180;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/BranchExplorerOptionsWindow.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/ConditionalFormat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3759a3b34c2714f738805af7001e839f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/ConditionalFormat/FiltersAndConditionalFormatPanel.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Collections.Generic;
+using Codice.CM.Common;
+using UnityEngine.UIElements;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Configuration;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.UIElements;
+
+namespace Unity.PlasticSCM.Editor.Views.BranchExplorer.Options.ConditionalFormat
+{
+    internal class FiltersAndConditionalFormatPanel : VisualElement
+    {
+        internal FiltersAndConditionalFormatPanel(
+            WorkspaceInfo wkInfo,
+            Func<BranchExplorerOptionsWindow.IBranchExplorerView> getBrExView)
+        {
+            mWkInfo = wkInfo;
+            mGetBrExView = getBrExView;
+            mFormatRuleMenu = new FormatRuleMenu(this);
+
+            CreateGUI();
+        }
+
+        internal void SetWorkspaceUIConfiguration(
+            WorkspaceUIConfiguration workspaceUIConfiguration)
+        {
+            mConfig = workspaceUIConfiguration;
+        }
+
+        internal void LoadConfigRules()
+        {
+            mRulesContainer.Clear();
+
+            foreach (Rule rule in mConfig.Rules)
+            {
+                RulePanel rulePanel = CreateRulePanel(rule);
+                rulePanel.CreateView(mRulesContainer);
+                mRulesContainer.Add(rulePanel);
+            }
+        }
+
+        internal void CreateNewRule(Rule.Type type, Rule.FormattedObject formatTarget)
+        {
+            RulePanel newRule = CreateRulePanel(type, formatTarget);
+            newRule.CreateView(mRulesContainer);
+            mRulesContainer.Add(newRule);
+            SaveAndRefresh();
+        }
+
+        internal void Dispose()
+        {
+            List<RulePanel> rulePanels = GetRulePanels();
+            foreach (RulePanel rulePanel in rulePanels)
+                rulePanel.Dispose();
+        }
+
+        void OnAddInclusionClicked()
+        {
+            CreateNewRule(Rule.Type.InclusionRule, Rule.FormattedObject.Branch);
+        }
+
+        void OnAddExclusionClicked()
+        {
+            CreateNewRule(Rule.Type.ExclusionRule, Rule.FormattedObject.Branch);
+        }
+
+        void OnAddFormatClicked()
+        {
+            mFormatRuleMenu.Popup();
+        }
+
+        RulePanel CreateRulePanel(
+            Rule.Type type,
+            Rule.FormattedObject formatTarget)
+        {
+            return new RulePanel(
+                type,
+                formatTarget,
+                SaveAndRefresh,
+                SaveAndRedraw);
+        }
+
+        RulePanel CreateRulePanel(Rule rule)
+        {
+            return new RulePanel(
+                rule,
+                SaveAndRefresh,
+                SaveAndRedraw);
+        }
+
+        void SaveAndRefresh()
+        {
+            SaveFilterRules();
+            mConfig.Save(mWkInfo);
+            mGetBrExView()?.Refresh();
+        }
+
+        void SaveAndRedraw()
+        {
+            SaveFilterRules();
+            mConfig.Save(mWkInfo);
+            mGetBrExView()?.Redraw();
+        }
+
+        void SaveFilterRules()
+        {
+            List<Rule> rules = new List<Rule>();
+            List<RulePanel> rulePanels = GetRulePanels();
+
+            foreach (RulePanel rulePanel in rulePanels)
+            {
+                Rule rule = rulePanel.GetRule();
+                rules.Add(rule);
+            }
+
+            mConfig.Rules = rules;
+        }
+
+        List<RulePanel> GetRulePanels()
+        {
+            List<RulePanel> result = new List<RulePanel>();
+            foreach (VisualElement child in mRulesContainer.Children())
+            {
+                if (child is RulePanel rulePanel)
+                    result.Add(rulePanel);
+            }
+            return result;
+        }
+
+        void CreateGUI()
+        {
+            style.flexGrow = 1;
+            style.paddingLeft = 8;
+            style.paddingTop = 8;
+            style.paddingRight = 8;
+            style.paddingBottom = 8;
+
+            VisualElement buttonsArea = CreateButtonsArea();
+            Add(buttonsArea);
+
+            VisualElement rulesArea = CreateRulesArea();
+            Add(rulesArea);
+        }
+
+        VisualElement CreateButtonsArea()
+        {
+            VisualElement buttonsArea = new VisualElement();
+            buttonsArea.style.flexDirection = FlexDirection.Row;
+            buttonsArea.style.alignItems = Align.Center;
+            buttonsArea.style.marginBottom = 8;
+
+            VisualElement centerButtons = new VisualElement();
+            centerButtons.style.flexGrow = 1;
+            centerButtons.style.flexDirection = FlexDirection.Row;
+            centerButtons.style.justifyContent = Justify.Center;
+
+            Button addInclusionButton = ControlBuilder.Button.CreateButton(
+                PlasticLocalization.Name.AddInclusion.GetString(),
+                OnAddInclusionClicked);
+            addInclusionButton.style.marginRight = 4;
+            centerButtons.Add(addInclusionButton);
+
+            Button addExclusionButton = ControlBuilder.Button.CreateButton(
+                PlasticLocalization.Name.AddExclusion.GetString(),
+                OnAddExclusionClicked);
+            addExclusionButton.style.marginRight = 4;
+            centerButtons.Add(addExclusionButton);
+
+            Button addFormatButton = ControlBuilder.Button.CreateDropDownButton(
+                PlasticLocalization.Name.AddFormat.GetString(),
+                OnAddFormatClicked);
+            centerButtons.Add(addFormatButton);
+
+            buttonsArea.Add(centerButtons);
+
+            return buttonsArea;
+        }
+
+        VisualElement CreateRulesArea()
+        {
+            VisualElement rulesArea = new VisualElement();
+            rulesArea.style.flexGrow = 1;
+
+            ScrollView scrollView = new ScrollView(ScrollViewMode.Vertical);
+            scrollView.style.flexGrow = 1;
+            scrollView.style.backgroundColor = new StyleColor(
+                UnityStyles.Colors.TreeViewBackground);
+
+            mRulesContainer = new VisualElement();
+            scrollView.Add(mRulesContainer);
+
+            rulesArea.Add(scrollView);
+
+            return rulesArea;
+        }
+
+        VisualElement mRulesContainer;
+        WorkspaceUIConfiguration mConfig;
+
+        readonly FormatRuleMenu mFormatRuleMenu;
+        readonly WorkspaceInfo mWkInfo;
+        readonly Func<BranchExplorerOptionsWindow.IBranchExplorerView> mGetBrExView;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/ConditionalFormat/FiltersAndConditionalFormatPanel.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/ConditionalFormat/FormatRuleMenu.cs

@@ -0,0 +1,61 @@
+using UnityEditor;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Configuration;
+
+namespace Unity.PlasticSCM.Editor.Views.BranchExplorer.Options.ConditionalFormat
+{
+    internal class FormatRuleMenu
+    {
+        internal FormatRuleMenu(FiltersAndConditionalFormatPanel view)
+        {
+            mView = view;
+        }
+
+        internal void Popup()
+        {
+            GenericMenu menu = new GenericMenu();
+
+            menu.AddItem(
+                new UnityEngine.GUIContent(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.BranchesWithPendingIntegrations)),
+                false,
+                () => CreateNewRule(Rule.Type.NonIntegrated, Rule.FormattedObject.Branch));
+
+            menu.AddItem(
+                new UnityEngine.GUIContent(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.ActiveBranch)),
+                false,
+                () => CreateNewRule(Rule.Type.CurrentBranchFormat, Rule.FormattedObject.Branch));
+
+            menu.AddSeparator(string.Empty);
+
+            menu.AddItem(
+                new UnityEngine.GUIContent(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.CustomBranchQuery)),
+                false,
+                () => CreateNewRule(Rule.Type.ConditionalFormat, Rule.FormattedObject.Branch));
+
+            menu.AddItem(
+                new UnityEngine.GUIContent(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.CustomChangesetQuery)),
+                false,
+                () => CreateNewRule(Rule.Type.ConditionalFormat, Rule.FormattedObject.Changeset));
+
+            menu.AddItem(
+                new UnityEngine.GUIContent(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.CustomLabelQuery)),
+                false,
+                () => CreateNewRule(Rule.Type.ConditionalFormat, Rule.FormattedObject.Label));
+
+            menu.ShowAsContext();
+        }
+
+        void CreateNewRule(Rule.Type type, Rule.FormattedObject targetFormat)
+        {
+            mView.CreateNewRule(type, targetFormat);
+        }
+
+        readonly FiltersAndConditionalFormatPanel mView;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/ConditionalFormat/FormatRuleMenu.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/ConditionalFormat/RuleData.cs

@@ -0,0 +1,74 @@
+using CodiceApp;
+using Codice.CM.Common;
+using Codice.Client.BaseCommands.BranchExplorer.Layout;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.BranchExplorer;
+using PlasticGui.WorkspaceWindow.Configuration;
+
+namespace Unity.PlasticSCM.Editor.Views.BranchExplorer.Options.ConditionalFormat
+{
+    internal class RuleData
+    {
+        internal Rule.Type Type { get { return mType; } }
+        internal Rule.FormattedObject FormatTarget { get { return mFormatTarget; } }
+        internal bool IsEnabled { get { return mIsEnabled; } }
+        internal string Description { get { return mDescription; } set { mDescription = value; } }
+        internal string Condition { get { return mCondition; } set { mCondition = value; } }
+        internal RelatedBranchFlags Options { get { return mOptions; } set { mOptions = value; } }
+
+        internal RuleData(Rule.Type type, Rule.FormattedObject formatTarget)
+        {
+            mType = type;
+            mFormatTarget = formatTarget;
+
+            mIsEnabled = true;
+            mDescription = ConditionalFormatRuleText.ForDescription(mType, null);
+            mCondition = DefaultConditionalFormatConditions
+                .GetDefaultCondition(mType, mFormatTarget);
+            mOptions = RelatedBranchFlags.None;
+            mColor = null;
+        }
+
+        internal RuleData(Rule rule)
+        {
+            mType = rule.RuleType;
+            mIsEnabled = rule.Enabled;
+            mFormatTarget = rule.FormatTarget;
+            mDescription = ConditionalFormatRuleText
+                .ForDescription(mType, rule.Description);
+            mCondition = rule.Condition ?? string.Empty;
+            mColor = rule.Color;
+            mOptions = rule.Options;
+        }
+
+        internal ColorRGB GetColor()
+        {
+            if (mType == Rule.Type.InclusionRule || mType == Rule.Type.ExclusionRule)
+                return new ColorRGB(1, 1, 1, 1);
+
+            return mColor ?? DefaultColorProvider.GetDefaultColor();
+        }
+
+        internal BrExLayoutFilter GetFilter(WorkspaceInfo wkInfo, RepositorySpec repSpec)
+        {
+            return new BrExLayoutFilter(
+                PlasticGui.Plastic.API.FindGuids(repSpec, wkInfo, Condition, ObjectType.Branch),
+                mOptions);
+        }
+
+        internal bool HasDefaultCondition()
+        {
+            return DefaultConditionalFormatConditions.IsDefaultCondition(mCondition);
+        }
+
+        readonly Rule.Type mType;
+        readonly Rule.FormattedObject mFormatTarget;
+
+        string mDescription;
+        string mCondition;
+        RelatedBranchFlags mOptions;
+
+        readonly bool mIsEnabled;
+        readonly ColorRGB mColor;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/ConditionalFormat/RuleData.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/ConditionalFormat/RulePanel.cs

@@ -0,0 +1,531 @@
+using System;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using CodiceApp;
+using Codice.Client.BaseCommands.BranchExplorer.Layout;
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Configuration;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.UIElements;
+
+namespace Unity.PlasticSCM.Editor.Views.BranchExplorer.Options.ConditionalFormat
+{
+    internal class RulePanel : VisualElement
+    {
+        internal Rule.Type RuleType { get { return mRuleData.Type; } }
+        internal Rule.FormattedObject FormatTarget { get { return mRuleData.FormatTarget; } }
+
+        internal RulePanel(
+            Rule.Type type,
+            Rule.FormattedObject formatTarget,
+            Action onRuleChanged,
+            Action onRuleColorChanged)
+        {
+            mRuleData = new RuleData(type, formatTarget);
+            mOnRuleChanged = onRuleChanged;
+            mOnRuleColorChanged = onRuleColorChanged;
+        }
+
+        internal RulePanel(
+            Rule rule,
+            Action onRuleChanged,
+            Action onRuleColorChanged)
+        {
+            mRuleData = new RuleData(rule);
+            mOnRuleChanged = onRuleChanged;
+            mOnRuleColorChanged = onRuleColorChanged;
+        }
+
+        internal BrExLayoutFilter GetFilter(WorkspaceInfo wkInfo, RepositorySpec repSpec)
+        {
+            return mRuleData.GetFilter(wkInfo, repSpec);
+        }
+
+        internal Rule GetRule()
+        {
+            Rule rule = new Rule();
+            rule.RuleType = mRuleData.Type;
+            rule.Enabled = GetEnabledFromField();
+            rule.Description = GetDescriptionFromField();
+            rule.Condition = GetConditionFromField();
+            rule.Color = GetColorFromColorField();
+            rule.FormatTarget = mRuleData.FormatTarget;
+            rule.Options = mRuleData.Options;
+            return rule;
+        }
+
+        internal void CreateView(VisualElement parentPanel)
+        {
+            if (mbInitialized)
+                return;
+
+            mParentPanel = parentPanel;
+
+            DoCreateView();
+
+            mbInitialized = true;
+        }
+
+        internal void OpenEditionPanel()
+        {
+            EnableEdition();
+        }
+
+        internal void Dispose()
+        {
+            if (mDescriptionToggle != null)
+                mDescriptionToggle.UnregisterValueChangedCallback(OnDescriptionToggleValueChanged);
+
+            if (mColorField != null)
+                mColorField.UnregisterValueChangedCallback(OnColorValueChanged);
+        }
+
+        void DoCreateView()
+        {
+            style.paddingTop = 4;
+            style.paddingBottom = 4;
+            style.paddingLeft = 4;
+            style.paddingRight = 4;
+
+            VisualElement mainRow = new VisualElement();
+            mainRow.style.flexDirection = FlexDirection.Row;
+            mainRow.style.alignItems = Align.FlexStart;
+
+            VisualElement leftBox = CreateLeftIndicator(
+                RuleType, FormatTarget, mRuleData.GetColor());
+
+            VisualElement fieldArea = new VisualElement();
+            fieldArea.style.flexGrow = 1;
+            fieldArea.style.marginLeft = 4;
+
+            mDescriptionRow = new VisualElement();
+            mDescriptionRow.style.flexDirection = FlexDirection.Row;
+            mDescriptionRow.style.alignItems = Align.Center;
+            mDescriptionRow.style.marginBottom = 2;
+
+            mDescriptionToggle = new Toggle();
+            mDescriptionToggle.style.marginLeft = 0;
+            mDescriptionToggle.style.marginTop = 3;
+            mDescriptionToggle.style.marginRight = 0;
+            mDescriptionToggle.style.marginBottom = 0;
+            mDescriptionToggle.value = mRuleData.IsEnabled;
+            mDescriptionToggle.RegisterValueChangedCallback(
+                OnDescriptionToggleValueChanged);
+
+            mDescriptionLabel = new Label(mRuleData.Description);
+            mDescriptionLabel.style.marginLeft = 6;
+            mDescriptionLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+
+            mDescriptionRow.Add(mDescriptionToggle);
+            mDescriptionRow.Add(mDescriptionLabel);
+
+            mConditionLabel = new Label(mRuleData.Condition);
+            mConditionLabel.style.fontSize = 11;
+            mConditionLabel.style.marginLeft = 20;
+            mConditionLabel.style.overflow = Overflow.Hidden;
+            mConditionLabel.style.textOverflow = TextOverflow.Ellipsis;
+            mConditionLabel.style.color = new StyleColor(
+                UnityStyles.Colors.SecondaryLabel);
+
+            mDescriptionEdit = new TextField();
+            mDescriptionEdit.value = mRuleData.Description;
+            mDescriptionEdit.style.marginBottom = 4;
+            mDescriptionEdit.style.display = DisplayStyle.None;
+
+            mConditionEdit = new TextField();
+            mConditionEdit.value = mRuleData.Condition;
+            mConditionEdit.style.display = DisplayStyle.None;
+
+            fieldArea.Add(mDescriptionRow);
+            fieldArea.Add(mConditionLabel);
+            fieldArea.Add(mDescriptionEdit);
+            fieldArea.Add(mConditionEdit);
+
+            VisualElement buttonArea = new VisualElement();
+            buttonArea.style.flexDirection = FlexDirection.Row;
+            buttonArea.style.alignItems = Align.FlexStart;
+
+            bool isEditable = mRuleData.Type != Rule.Type.NonIntegrated
+                && mRuleData.Type != Rule.Type.CurrentBranchFormat;
+
+            int buttonSize = 22;
+
+            if (isEditable)
+            {
+                mEditButton = ControlBuilder.Button.CreateImageButton(
+                    Images.GetEditIcon(),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.EditButton),
+                    OnEditRuleClicked);
+                mEditButton.style.marginRight = 2;
+                mEditButton.style.width = buttonSize;
+                mEditButton.style.height = buttonSize;
+                mEditButton.style.paddingLeft = 0;
+                mEditButton.style.paddingRight = 0;
+                buttonArea.Add(mEditButton);
+            }
+
+            mDeleteButton = ControlBuilder.Button.CreateImageButton(
+                Images.GetIconCloseButton(),
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.RemoveButton),
+                OnDeleteRuleClicked);
+            mDeleteButton.style.width = buttonSize;
+            mDeleteButton.style.height = buttonSize;
+            mDeleteButton.style.paddingLeft = 0;
+            mDeleteButton.style.paddingRight = 0;
+            buttonArea.Add(mDeleteButton);
+
+            mainRow.Add(leftBox);
+            mainRow.Add(fieldArea);
+            mainRow.Add(buttonArea);
+
+            Add(mainRow);
+
+            mEditionPanel = CreateEditionPanel();
+            mEditionPanel.style.display = DisplayStyle.None;
+            Add(mEditionPanel);
+
+            VisualElement separator = new VisualElement();
+            separator.style.height = 1;
+            separator.style.marginTop = 4;
+            separator.style.backgroundColor = new StyleColor(
+                UnityStyles.Colors.SplitLineColor);
+            Add(separator);
+        }
+
+        VisualElement CreateLeftIndicator(
+            Rule.Type type,
+            Rule.FormattedObject formatTarget,
+            ColorRGB defaultColor)
+        {
+            VisualElement container = new VisualElement();
+            container.style.width = 20;
+            container.style.alignItems = Align.Center;
+            container.style.marginTop = 2;
+
+            if (type == Rule.Type.InclusionRule)
+            {
+                Image icon = new Image();
+                icon.image = Images.GetInclusionRuleIcon();
+                icon.style.width = 16;
+                icon.style.height = 16;
+                container.Add(icon);
+                return container;
+            }
+
+            if (type == Rule.Type.ExclusionRule)
+            {
+                Image icon = new Image();
+                icon.image = Images.GetExclusionRuleIcon();
+                icon.style.width = 16;
+                icon.style.height = 16;
+                container.Add(icon);
+                return container;
+            }
+
+            Texture2D targetIcon = GetFormatTargetIcon(formatTarget);
+            if (targetIcon != null)
+            {
+                Image iconImage = new Image();
+                iconImage.image = targetIcon;
+                iconImage.style.width = 16;
+                iconImage.style.height = 16;
+                iconImage.style.marginBottom = 2;
+                container.Add(iconImage);
+            }
+
+            mColorField = new ColorField();
+            mColorField.style.width = 16;
+            mColorField.style.height = 16;
+            mColorField.showAlpha = false;
+            mColorField.showEyeDropper = false;
+            mColorField.value = new Color(defaultColor.R, defaultColor.G, defaultColor.B, defaultColor.A);
+            mColorField.RegisterValueChangedCallback(
+                OnColorValueChanged);
+            container.Add(mColorField);
+
+            return container;
+        }
+
+        static Texture2D GetFormatTargetIcon(Rule.FormattedObject formatTarget)
+        {
+            switch (formatTarget)
+            {
+                case Rule.FormattedObject.Branch:
+                    return Images.GetBranchIcon();
+                case Rule.FormattedObject.Changeset:
+                    return Images.GetChangesetsIcon();
+                case Rule.FormattedObject.Label:
+                    return Images.GetLabelIcon();
+                default:
+                    return null;
+            }
+        }
+
+        VisualElement CreateEditionPanel()
+        {
+            VisualElement panel = new VisualElement();
+            panel.style.marginLeft = 24;
+            panel.style.marginTop = 8;
+            panel.style.marginBottom = 4;
+
+            Label titleText = new Label(
+                ConditionalFormatRuleText.ForTitle(RuleType, FormatTarget));
+            titleText.style.unityFontStyleAndWeight = FontStyle.Bold;
+            titleText.style.marginBottom = 4;
+            panel.Add(titleText);
+
+            Label helpText = new Label(
+                ConditionalFormatRuleText.ForHelp(FormatTarget));
+            helpText.style.fontSize = 11;
+            helpText.style.marginBottom = 8;
+            panel.Add(helpText);
+
+            if (mRuleData.Type == Rule.Type.InclusionRule
+                || mRuleData.Type == Rule.Type.ExclusionRule)
+            {
+                VisualElement checksContainer = CreateCheckBoxesContainer();
+                panel.Add(checksContainer);
+            }
+
+            VisualElement buttonsPanel = new VisualElement();
+            buttonsPanel.style.flexDirection = FlexDirection.Row;
+            buttonsPanel.style.justifyContent = Justify.FlexEnd;
+            buttonsPanel.style.marginTop = 8;
+
+            Button saveButton = new Button(OnSaveClicked);
+            saveButton.text = PlasticLocalization.GetString(
+                PlasticLocalization.Name.SaveButton);
+            saveButton.style.marginRight = 4;
+            buttonsPanel.Add(saveButton);
+
+            Button cancelButton = new Button(OnCancelClicked);
+            cancelButton.text = PlasticLocalization.GetString(
+                PlasticLocalization.Name.CancelButton);
+            buttonsPanel.Add(cancelButton);
+
+            panel.Add(buttonsPanel);
+
+            return panel;
+        }
+
+        VisualElement CreateCheckBoxesContainer()
+        {
+            VisualElement container = new VisualElement();
+            container.style.marginTop = 4;
+            container.style.marginBottom = 4;
+
+            mAddChildBranches = CreateCheckToggle(
+                PlasticLocalization.Name.AddChildBranches,
+                RelatedBranchFlags.IncludeChildBranches);
+
+            mAddParentBranches = CreateCheckToggle(
+                PlasticLocalization.Name.AddParentBranches,
+                RelatedBranchFlags.IncludeParentBranches);
+
+            mAddBranchesSource = CreateCheckToggle(
+                PlasticLocalization.Name.AddBranchesSourceOfMerge,
+                RelatedBranchFlags.IncludeMergeSourceBranches);
+
+            mAddBranchesDestination = CreateCheckToggle(
+                PlasticLocalization.Name.AddBranchesDestinationOfMerge,
+                RelatedBranchFlags.IncludeMergeDestinationBranches);
+
+            container.Add(mAddChildBranches);
+            container.Add(mAddParentBranches);
+            container.Add(mAddBranchesSource);
+            container.Add(mAddBranchesDestination);
+
+            return container;
+        }
+
+        Toggle CreateCheckToggle(
+            PlasticLocalization.Name localizationName,
+            RelatedBranchFlags flag)
+        {
+            Toggle toggle = new Toggle(
+                PlasticLocalization.GetString(localizationName));
+            toggle.value = (mRuleData.Options & flag) == flag;
+            toggle.style.marginBottom = 2;
+            toggle.labelElement.style.minWidth = 230;
+            return toggle;
+        }
+
+        void EnableEdition()
+        {
+            mEditionPanel.style.display = DisplayStyle.Flex;
+            mDescriptionEdit.style.display = DisplayStyle.Flex;
+            mConditionEdit.style.display = DisplayStyle.Flex;
+            mDescriptionRow.style.display = DisplayStyle.None;
+            mConditionLabel.style.display = DisplayStyle.None;
+
+            mDescriptionEdit.value = mRuleData.Description;
+            mConditionEdit.value = mRuleData.Condition;
+            SetFieldsFromOptions(mRuleData.Options);
+
+            mDescriptionEdit.Focus();
+        }
+
+        void DisableEdition()
+        {
+            if (!mbInitialized)
+                return;
+
+            mEditionPanel.style.display = DisplayStyle.None;
+            mDescriptionEdit.style.display = DisplayStyle.None;
+            mConditionEdit.style.display = DisplayStyle.None;
+            mDescriptionRow.style.display = DisplayStyle.Flex;
+            mConditionLabel.style.display = DisplayStyle.Flex;
+        }
+
+        void OnEditRuleClicked()
+        {
+            OpenEditionPanel();
+        }
+
+        void OnDescriptionToggleValueChanged(ChangeEvent<bool> evt)
+        {
+            mOnRuleChanged?.Invoke();
+        }
+
+        void OnColorValueChanged(ChangeEvent<Color> evt)
+        {
+            mOnRuleColorChanged?.Invoke();
+        }
+
+        void OnDeleteRuleClicked()
+        {
+            mParentPanel.Remove(this);
+            Dispose();
+            mOnRuleChanged?.Invoke();
+        }
+
+        void OnSaveClicked()
+        {
+            mRuleData.Description = GetDescriptionFromField();
+            mRuleData.Condition = mConditionEdit.value;
+            mRuleData.Options = GetOptionsFromFields();
+            mDescriptionLabel.text = mDescriptionEdit.value;
+            mConditionLabel.text = mConditionEdit.value;
+
+            DisableEdition();
+            mOnRuleChanged?.Invoke();
+        }
+
+        void OnCancelClicked()
+        {
+            DisableEdition();
+
+            SetFieldsFromOptions(mRuleData.Options);
+            mDescriptionEdit.value = mDescriptionLabel.text;
+            mConditionEdit.value = mConditionLabel.text;
+        }
+
+        ColorRGB GetColorFromColorField()
+        {
+            if (mRuleData.Type == Rule.Type.InclusionRule
+                || mRuleData.Type == Rule.Type.ExclusionRule)
+            {
+                return null;
+            }
+
+            if (mColorField == null)
+                return mRuleData.GetColor();
+
+            Color color = mColorField.value;
+            return new ColorRGB(color.r, color.g, color.b, color.a);
+        }
+
+        string GetConditionFromField()
+        {
+            if (string.IsNullOrEmpty(mConditionEdit.value))
+                return null;
+
+            return mConditionEdit.value;
+        }
+
+        string GetDescriptionFromField()
+        {
+            if (DescriptionEditContainsDefaultText())
+                return string.Empty;
+
+            return mDescriptionEdit.value;
+        }
+
+        bool GetEnabledFromField()
+        {
+            return mDescriptionToggle.value;
+        }
+
+        RelatedBranchFlags GetOptionsFromFields()
+        {
+            RelatedBranchFlags result = RelatedBranchFlags.None;
+
+            if (mAddChildBranches != null && mAddChildBranches.value)
+                result |= RelatedBranchFlags.IncludeChildBranches;
+
+            if (mAddParentBranches != null && mAddParentBranches.value)
+                result |= RelatedBranchFlags.IncludeParentBranches;
+
+            if (mAddBranchesSource != null && mAddBranchesSource.value)
+                result |= RelatedBranchFlags.IncludeMergeSourceBranches;
+
+            if (mAddBranchesDestination != null && mAddBranchesDestination.value)
+                result |= RelatedBranchFlags.IncludeMergeDestinationBranches;
+
+            return result;
+        }
+
+        void SetFieldsFromOptions(RelatedBranchFlags flags)
+        {
+            if (mAddChildBranches != null)
+                mAddChildBranches.value =
+                    (flags & RelatedBranchFlags.IncludeChildBranches) == RelatedBranchFlags.IncludeChildBranches;
+
+            if (mAddParentBranches != null)
+                mAddParentBranches.value =
+                    (flags & RelatedBranchFlags.IncludeParentBranches) == RelatedBranchFlags.IncludeParentBranches;
+
+            if (mAddBranchesSource != null)
+                mAddBranchesSource.value =
+                    (flags & RelatedBranchFlags.IncludeMergeSourceBranches) == RelatedBranchFlags.IncludeMergeSourceBranches;
+
+            if (mAddBranchesDestination != null)
+                mAddBranchesDestination.value =
+                    (flags & RelatedBranchFlags.IncludeMergeDestinationBranches) == RelatedBranchFlags.IncludeMergeDestinationBranches;
+        }
+
+        bool DescriptionEditContainsDefaultText()
+        {
+            return mDescriptionEdit.value ==
+                PlasticLocalization.GetString(PlasticLocalization.Name.TypeDescription);
+        }
+
+        VisualElement mEditionPanel;
+        VisualElement mDescriptionRow;
+        TextField mDescriptionEdit;
+        TextField mConditionEdit;
+        Toggle mDescriptionToggle;
+        Label mDescriptionLabel;
+        Label mConditionLabel;
+        ColorField mColorField;
+        Button mEditButton;
+        Button mDeleteButton;
+        Toggle mAddChildBranches;
+        Toggle mAddParentBranches;
+        Toggle mAddBranchesSource;
+        Toggle mAddBranchesDestination;
+
+        VisualElement mParentPanel;
+
+        bool mbInitialized;
+        readonly RuleData mRuleData;
+        readonly Action mOnRuleChanged;
+        readonly Action mOnRuleColorChanged;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/ConditionalFormat/RulePanel.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/DisplayOptions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 046453f671b3d46c9a39b23fc4d10a39
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/DisplayOptions/DisplayOptionsPanel.cs

@@ -0,0 +1,286 @@
+using System;
+using UnityEngine.UIElements;
+
+using Codice.Client.BaseCommands.BranchExplorer.Layout;
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Configuration;
+
+namespace Unity.PlasticSCM.Editor.Views.BranchExplorer.Options.DisplayOptions
+{
+    internal class DisplayOptionsPanel : VisualElement
+    {
+        internal DisplayOptionsPanel(
+            WorkspaceInfo wkInfo,
+            Func<BranchExplorerOptionsWindow.IBranchExplorerView> getBrExView)
+        {
+            mWkInfo = wkInfo;
+            mGetBrExView = getBrExView;
+
+            CreateGUI();
+        }
+
+        internal void SetWorkspaceUIConfiguration(
+            WorkspaceUIConfiguration workspaceUIConfiguration)
+        {
+            mConfig = workspaceUIConfiguration;
+        }
+
+        internal void LoadConfiguration()
+        {
+            mIsLoadingConfiguration = true;
+
+            try
+            {
+                mDisplayBranchesToggle.value =
+                    mConfig.DisplayOptions.DisplayBranches;
+
+                mDisplayFullBranchNamesToggle.value =
+                    mConfig.DisplayOptions.DisplayFullBranchNames;
+
+                mDisplayMergeLinksToggle.value =
+                    mConfig.DisplayOptions.DisplayMergeLinks;
+
+                mDisplayCrossBranchChangesetLinksToggle.value =
+                    mConfig.DisplayOptions.DisplayCrossBranchChangesetLinks;
+
+                mDisplayLabelsToggle.value =
+                    mConfig.DisplayOptions.DisplayLabels;
+
+                mDisplayBranchTaskInfoToggle.value =
+                    mConfig.DisplayOptions.DisplayTaskInfoOnBranches;
+
+                mDisplayChangesetCommentsToggle.value =
+                    mConfig.DisplayOptions.DisplayChangesetComments;
+
+                mDisplayChangesetNumbersToggle.value =
+                    mConfig.DisplayOptions.DisplayChangesetNumbers;
+
+                mDisplayUserAvatarToggle.value =
+                    mConfig.DisplayOptions.DisplayUserAvatar;
+            }
+            finally
+            {
+                mIsLoadingConfiguration = false;
+            }
+        }
+
+        internal void Dispose()
+        {
+            mDisplayBranchesToggle.UnregisterValueChangedCallback(
+                OnDisplayBranchesChanged);
+            mDisplayFullBranchNamesToggle.UnregisterValueChangedCallback(
+                OnDisplayFullBranchNamesChanged);
+            mDisplayMergeLinksToggle.UnregisterValueChangedCallback(
+                OnDisplayMergeLinksChanged);
+            mDisplayCrossBranchChangesetLinksToggle.UnregisterValueChangedCallback(
+                OnDisplayCrossBranchChangesetLinksChanged);
+            mDisplayLabelsToggle.UnregisterValueChangedCallback(
+                OnDisplayLabelsChanged);
+            mDisplayBranchTaskInfoToggle.UnregisterValueChangedCallback(
+                OnDisplayBranchTaskInfoChanged);
+            mDisplayChangesetCommentsToggle.UnregisterValueChangedCallback(
+                OnDisplayChangesetCommentsChanged);
+            mDisplayChangesetNumbersToggle.UnregisterValueChangedCallback(
+                OnDisplayChangesetNumbersChanged);
+            mDisplayUserAvatarToggle.UnregisterValueChangedCallback(
+                OnColorChangesetsByUserChanged);
+        }
+
+        void OnDisplayBranchesChanged(ChangeEvent<bool> evt)
+        {
+            if (mIsLoadingConfiguration)
+                return;
+
+            mConfig.DisplayOptions.DisplayBranches = evt.newValue;
+            mConfig.Save(mWkInfo);
+
+            mGetBrExView()?.Redraw();
+        }
+
+        void OnDisplayFullBranchNamesChanged(ChangeEvent<bool> evt)
+        {
+            if (mIsLoadingConfiguration)
+                return;
+
+            mConfig.DisplayOptions.DisplayFullBranchNames = evt.newValue;
+            mConfig.Save(mWkInfo);
+
+            mGetBrExView()?.ClearSearchResults();
+            mGetBrExView()?.Redraw();
+        }
+
+        void OnDisplayMergeLinksChanged(ChangeEvent<bool> evt)
+        {
+            if (mIsLoadingConfiguration)
+                return;
+
+            mConfig.DisplayOptions.DisplayMergeLinks = evt.newValue;
+            mConfig.Save(mWkInfo);
+
+            mGetBrExView()?.Redraw();
+        }
+
+        void OnDisplayCrossBranchChangesetLinksChanged(ChangeEvent<bool> evt)
+        {
+            if (mIsLoadingConfiguration)
+                return;
+
+            mConfig.DisplayOptions.DisplayCrossBranchChangesetLinks = evt.newValue;
+            mConfig.Save(mWkInfo);
+
+            mGetBrExView()?.Redraw();
+        }
+
+        void OnDisplayLabelsChanged(ChangeEvent<bool> evt)
+        {
+            if (mIsLoadingConfiguration)
+                return;
+
+            mConfig.DisplayOptions.DisplayLabels = evt.newValue;
+            mConfig.Save(mWkInfo);
+
+            mGetBrExView()?.Redraw();
+        }
+
+        void OnDisplayBranchTaskInfoChanged(ChangeEvent<bool> evt)
+        {
+            if (mIsLoadingConfiguration)
+                return;
+
+            mConfig.DisplayOptions.DisplayTaskInfoOnBranches = evt.newValue;
+            mConfig.Save(mWkInfo);
+
+            mGetBrExView()?.Redraw();
+        }
+
+        void OnDisplayChangesetCommentsChanged(ChangeEvent<bool> evt)
+        {
+            if (mIsLoadingConfiguration)
+                return;
+
+            mConfig.DisplayOptions.DisplayChangesetComments = evt.newValue;
+            mConfig.Save(mWkInfo);
+
+            mGetBrExView()?.Redraw();
+        }
+
+        void OnDisplayChangesetNumbersChanged(ChangeEvent<bool> evt)
+        {
+            if (mIsLoadingConfiguration)
+                return;
+
+            mConfig.DisplayOptions.DisplayChangesetNumbers = evt.newValue;
+            mConfig.Save(mWkInfo);
+
+            mGetBrExView()?.Redraw();
+        }
+
+        void OnColorChangesetsByUserChanged(ChangeEvent<bool> evt)
+        {
+            if (mIsLoadingConfiguration)
+                return;
+
+            mConfig.DisplayOptions.DisplayUserAvatar = evt.newValue;
+
+            mConfig.Save(mWkInfo);
+
+            mGetBrExView()?.Redraw();
+        }
+
+        void CreateGUI()
+        {
+            style.flexGrow = 1;
+
+            ScrollView scrollView = new ScrollView(ScrollViewMode.Vertical);
+            scrollView.style.flexGrow = 1;
+            scrollView.style.paddingLeft = 4;
+            scrollView.style.paddingTop = 8;
+            scrollView.style.paddingRight = 8;
+
+            mDisplayBranchesToggle = CreateToggle(
+                PlasticLocalization.Name.BrexDisplayBranches);
+            mDisplayBranchesToggle.RegisterValueChangedCallback(
+                OnDisplayBranchesChanged);
+
+            mDisplayFullBranchNamesToggle = CreateToggle(
+                PlasticLocalization.Name.BrexDisplayFullBranchNames);
+            mDisplayFullBranchNamesToggle.RegisterValueChangedCallback(
+                OnDisplayFullBranchNamesChanged);
+
+            mDisplayMergeLinksToggle = CreateToggle(
+                PlasticLocalization.Name.BrexDisplayMergeLinks);
+            mDisplayMergeLinksToggle.RegisterValueChangedCallback(
+                OnDisplayMergeLinksChanged);
+
+            mDisplayCrossBranchChangesetLinksToggle = CreateToggle(
+                PlasticLocalization.Name.BrexDisplayCrossBranchCsetLinks);
+            mDisplayCrossBranchChangesetLinksToggle.RegisterValueChangedCallback(
+                OnDisplayCrossBranchChangesetLinksChanged);
+
+            mDisplayLabelsToggle = CreateToggle(
+                PlasticLocalization.Name.BrexDisplayLabels);
+            mDisplayLabelsToggle.RegisterValueChangedCallback(
+                OnDisplayLabelsChanged);
+
+            mDisplayBranchTaskInfoToggle = CreateToggle(
+                PlasticLocalization.Name.BrexDisplayBranchTaskInfo);
+            mDisplayBranchTaskInfoToggle.RegisterValueChangedCallback(
+                OnDisplayBranchTaskInfoChanged);
+
+            mDisplayChangesetCommentsToggle = CreateToggle(
+                PlasticLocalization.Name.BrexDisplayChangesetComments);
+            mDisplayChangesetCommentsToggle.RegisterValueChangedCallback(
+                OnDisplayChangesetCommentsChanged);
+
+            mDisplayChangesetNumbersToggle = CreateToggle(
+                PlasticLocalization.Name.BrexDisplayChangesetNumbers);
+            mDisplayChangesetNumbersToggle.RegisterValueChangedCallback(
+                OnDisplayChangesetNumbersChanged);
+
+            mDisplayUserAvatarToggle = CreateToggle(
+                PlasticLocalization.Name.BrexDisplayUserAvatar);
+            mDisplayUserAvatarToggle.RegisterValueChangedCallback(
+                OnColorChangesetsByUserChanged);
+
+            scrollView.Add(mDisplayBranchesToggle);
+            scrollView.Add(mDisplayFullBranchNamesToggle);
+            scrollView.Add(mDisplayMergeLinksToggle);
+            scrollView.Add(mDisplayCrossBranchChangesetLinksToggle);
+            scrollView.Add(mDisplayLabelsToggle);
+            scrollView.Add(mDisplayBranchTaskInfoToggle);
+            scrollView.Add(mDisplayChangesetCommentsToggle);
+            scrollView.Add(mDisplayChangesetNumbersToggle);
+            scrollView.Add(mDisplayUserAvatarToggle);
+
+            Add(scrollView);
+        }
+
+        static Toggle CreateToggle(
+            PlasticLocalization.Name localizationName)
+        {
+            Toggle toggle = new Toggle(
+                PlasticLocalization.GetString(localizationName));
+            toggle.style.marginLeft = 10;
+            toggle.style.marginBottom = 6;
+            toggle.labelElement.style.minWidth = 250;
+            return toggle;
+        }
+
+        Toggle mDisplayBranchesToggle;
+        Toggle mDisplayFullBranchNamesToggle;
+        Toggle mDisplayMergeLinksToggle;
+        Toggle mDisplayCrossBranchChangesetLinksToggle;
+        Toggle mDisplayLabelsToggle;
+        Toggle mDisplayBranchTaskInfoToggle;
+        Toggle mDisplayChangesetCommentsToggle;
+        Toggle mDisplayChangesetNumbersToggle;
+        Toggle mDisplayUserAvatarToggle;
+
+        WorkspaceUIConfiguration mConfig;
+        bool mIsLoadingConfiguration;
+
+        readonly WorkspaceInfo mWkInfo;
+        readonly Func<BranchExplorerOptionsWindow.IBranchExplorerView> mGetBrExView;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/Views/BranchExplorer/Options/DisplayOptions/DisplayOptionsPanel.cs.meta

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