first commit

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/DrawLocksListViewItem.cs

@@ -0,0 +1,54 @@
+using System;
+
+using UnityEngine;
+
+using Codice.CM.Common;
+using PlasticGui.WorkspaceWindow.Locks;
+using Unity.PlasticSCM.Editor.UI.Avatar;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+namespace Unity.PlasticSCM.Editor.Views.Locks
+{
+    internal static class DrawLocksListViewItem
+    {
+        internal static void ForCell(
+            RepositorySpec mRepSpec,
+            Rect rect,
+            float rowHeight,
+            LockInfo lockInfo,
+            LocksListColumn column,
+            Action avatarLoadedAction,
+            bool isSelected,
+            bool isFocused)
+        {
+            var columnText = LockInfoView.GetColumnText(
+                mRepSpec,
+                lockInfo,
+                LocksListHeaderState.GetColumnName(column));
+            
+            if (column == LocksListColumn.Owner)
+            {
+                DrawTreeViewItem.ForItemCell(
+                    rect,
+                    rowHeight,
+                    -1,
+                    GetAvatar.ForEmail(columnText, avatarLoadedAction),
+                    null,
+                    columnText,
+                    isSelected,
+                    isFocused,
+                    false,
+                    false);
+
+                return;
+            }
+
+            DrawTreeViewItem.ForLabel(
+                rect,
+                columnText,
+                isSelected,
+                isFocused,
+                false);
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/DrawLocksListViewItem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1a7e0200b2cf489bbe62e1410a7ed2e4
+timeCreated: 1700087540

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksListHeaderState.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+namespace Unity.PlasticSCM.Editor.Views.Locks
+{
+    internal enum LocksListColumn
+    {
+        ItemPath,
+        LockType,
+        ModificationDate,
+        Owner,
+        Branch,
+        DestinationBranch
+    }
+
+    [Serializable]
+    internal sealed class LocksListHeaderState : MultiColumnHeaderState, ISerializationCallbackReceiver
+    {
+        internal static LocksListHeaderState GetDefault()
+        {
+            return new LocksListHeaderState(BuildColumns());
+        }
+        
+        internal static List<string> GetColumnNames()
+        {
+            return new List<string>
+            {
+                PlasticLocalization.Name.ItemColumn.GetString(),
+                PlasticLocalization.Name.StatusColumn.GetString(),
+                PlasticLocalization.Name.DateModifiedColumn.GetString(),
+                PlasticLocalization.Name.OwnerColumn.GetString(),
+                PlasticLocalization.Name.BranchColumn.GetString(),
+                PlasticLocalization.Name.DestinationBranchColumn.GetString()
+            };
+        }
+
+        internal static string GetColumnName(LocksListColumn column)
+        {
+            switch (column)
+            {
+                case LocksListColumn.ItemPath:
+                    return PlasticLocalization.Name.ItemColumn.GetString();
+                case LocksListColumn.LockType:
+                    return PlasticLocalization.Name.StatusColumn.GetString();
+                case LocksListColumn.ModificationDate:
+                    return PlasticLocalization.Name.DateModifiedColumn.GetString();
+                case LocksListColumn.Owner:
+                    return PlasticLocalization.Name.OwnerColumn.GetString();
+                case LocksListColumn.Branch:
+                    return PlasticLocalization.Name.BranchColumn.GetString();
+                case LocksListColumn.DestinationBranch:
+                    return PlasticLocalization.Name.DestinationBranchColumn.GetString();
+                default:
+                    return null;
+            }
+        }
+
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+            if (mHeaderTitles != null)
+            {
+                TreeHeaderColumns.SetTitles(columns, mHeaderTitles);
+            }
+
+            if (mColumnsAllowedToggleVisibility != null)
+            {
+                TreeHeaderColumns.SetVisibilities(columns, mColumnsAllowedToggleVisibility);
+            }
+        }
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
+        {
+        }
+
+        static Column[] BuildColumns()
+        {
+            return new[]
+            {
+                new Column
+                {
+                    width = UnityConstants.LocksColumns.PATH_WIDTH,
+                    minWidth = UnityConstants.LocksColumns.PATH_MIN_WIDTH,
+                    headerContent = new GUIContent(GetColumnName(LocksListColumn.ItemPath)),
+                    allowToggleVisibility = false,
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column
+                {
+                    width = UnityConstants.LocksColumns.LOCK_TYPE_WIDTH,
+                    minWidth = UnityConstants.LocksColumns.LOCK_TYPE_MIN_WIDTH,
+                    headerContent = new GUIContent(GetColumnName(LocksListColumn.LockType)),
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column
+                {
+                    width = UnityConstants.LocksColumns.MODIFICATION_DATE_WIDTH,
+                    minWidth = UnityConstants.LocksColumns.MODIFICATION_DATE_MIN_WIDTH,
+                    headerContent = new GUIContent(GetColumnName(LocksListColumn.ModificationDate)),
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column
+                {
+                    width = UnityConstants.LocksColumns.OWNER_WIDTH,
+                    minWidth = UnityConstants.LocksColumns.OWNER_MIN_WIDTH,
+                    headerContent = new GUIContent(GetColumnName(LocksListColumn.Owner)),
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column
+                {
+                    width = UnityConstants.LocksColumns.BRANCH_NAME_WIDTH,
+                    minWidth = UnityConstants.LocksColumns.BRANCH_NAME_MIN_WIDTH,
+                    headerContent = new GUIContent(GetColumnName(LocksListColumn.Branch)),
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column
+                {
+                    width = UnityConstants.LocksColumns.DESTINATION_BRANCH_NAME_WIDTH,
+                    minWidth = UnityConstants.LocksColumns.DESTINATION_BRANCH_NAME_MIN_WIDTH,
+                    headerContent = new GUIContent(GetColumnName(LocksListColumn.DestinationBranch)),
+                    sortingArrowAlignment = TextAlignment.Right
+                }
+            };
+        }
+
+        LocksListHeaderState(Column[] columns)
+            : base(columns)
+        {
+            if (mHeaderTitles == null)
+            {
+                mHeaderTitles = TreeHeaderColumns.GetTitles(columns);
+            }
+
+            if (mColumnsAllowedToggleVisibility == null)
+            {
+                mColumnsAllowedToggleVisibility = TreeHeaderColumns.GetVisibilities(columns);
+            }
+        }
+
+        [SerializeField]
+        string[] mHeaderTitles;
+
+        [SerializeField]
+        bool[] mColumnsAllowedToggleVisibility;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksListHeaderState.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 200cab728add43369c716237d4f7b451
+timeCreated: 1699632149

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksListView.cs

@@ -0,0 +1,334 @@
+using System;
+using System.Collections.Generic;
+
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Locks;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+namespace Unity.PlasticSCM.Editor.Views.Locks
+{
+    internal sealed class LocksListView :
+        TreeView,
+        FillLocksTable.IShowContentView,
+        FillLocksTable.ILocksList
+    {
+        internal GenericMenu Menu { get { return mMenu.Menu; } }
+        internal string EmptyStateMessage { get { return mEmptyStateMessage; } }
+
+        internal LocksListView(
+            RepositorySpec repSpec,
+            LocksListHeaderState headerState,
+            List<string> columnNames,
+            LocksViewMenu menu,
+            Action selectionChangedAction)
+            : base(new TreeViewState())
+        {
+            mRepSpec = repSpec;
+            mColumnNames = columnNames;
+            mMenu = menu;
+            mSelectionChangedAction = selectionChangedAction;
+
+            mLocksSelector = new LocksSelector(this, mListViewItemIds);
+
+            mCooldownFilterAction = new CooldownWindowDelayer(
+                DelayedSearchChanged, UnityConstants.SEARCH_DELAYED_INPUT_ACTION_INTERVAL);
+
+            mCooldownSelectionAction = new CooldownWindowDelayer(
+                DelayedSelectionChanged, UnityConstants.SELECTION_DELAYED_INPUT_ACTION_INTERVAL);
+
+            SetupTreeView(headerState);
+        }
+
+        public override IList<TreeViewItem> GetRows()
+        {
+            return mRows;
+        }
+
+        public override void OnGUI(Rect rect)
+        {
+            base.OnGUI(rect);
+
+            if (mRows.Count == 0)
+                DrawTreeViewEmptyState.For(rect, mEmptyStateMessage);
+
+            Event e = Event.current;
+
+            if (e.type != EventType.KeyDown)
+                return;
+
+            bool isProcessed = mMenu.ProcessKeyActionIfNeeded(e);
+
+            if (isProcessed)
+                e.Use();
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            return new TreeViewItem(0, -1, string.Empty);
+        }
+
+        protected override IList<TreeViewItem> BuildRows(
+            TreeViewItem rootItem)
+        {
+            if (mLocksList == null)
+            {
+                ClearRows(rootItem, mRows);
+
+                return mRows;
+            }
+
+            RegenerateRows(
+                mListViewItemIds,
+                mLocksList,
+                rootItem,
+                mRows);
+
+            return mRows;
+        }
+
+        protected override void SearchChanged(string newSearch)
+        {
+            mCooldownFilterAction.Ping();
+        }
+
+        protected override void SelectionChanged(IList<int> selectedIds)
+        {
+            mCooldownSelectionAction.Ping();
+        }
+
+        protected override void ContextClickedItem(int id)
+        {
+            mMenu.Popup();
+            Repaint();
+        }
+
+        protected override void BeforeRowsGUI()
+        {
+            int firstRowVisible;
+            int lastRowVisible;
+            GetFirstAndLastVisibleRows(out firstRowVisible, out lastRowVisible);
+
+            GUI.DrawTexture(new Rect(0,
+                firstRowVisible * rowHeight,
+                GetRowRect(0).width,
+                (lastRowVisible * rowHeight) + 1000),
+                Images.GetTreeviewBackgroundTexture());
+
+            DrawTreeViewItem.InitializeStyles();
+            base.BeforeRowsGUI();
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            if (args.item is LocksListViewItem)
+            {
+                LocksListViewItemGUI(
+                    mRepSpec,
+                    rowHeight,
+                    ((LocksListViewItem)args.item).LockInfo,
+                    args,
+                    Repaint);
+                return;
+            }
+
+            base.RowGUI(args);
+        }
+
+        internal void OnDisable()
+        {
+            TreeHeaderSettings.Save(
+                multiColumnHeader.state,
+                UnityConstants.LOCKS_TABLE_SETTINGS_NAME);
+        }
+
+        internal List<LockInfo> GetSelectedLocks()
+        {
+            return mLocksSelector.GetSelectedLocks();
+        }
+
+        void FillLocksTable.IShowContentView.ShowContentPanel()
+        {
+            mEmptyStateMessage = null;
+
+            Reload();
+
+            mLocksSelector.RestoreSelectedLocks();
+        }
+
+        void FillLocksTable.IShowContentView.ShowEmptyStatePanel(string explanationText)
+        {
+            mEmptyStateMessage = explanationText;
+
+            Reload();
+        }
+
+        void FillLocksTable.IShowContentView.ShowErrorPanel(string errorText)
+        {
+            Debug.LogErrorFormat(
+                PlasticLocalization.Name.LoadLocksErrorExplanation.GetString(),
+                errorText);
+
+            mEmptyStateMessage = PlasticLocalization.Name.LoadLocksError.GetString();
+
+            mLocksList = null;
+            mListViewItemIds.Clear();
+
+            Reload();
+        }
+
+        void FillLocksTable.ILocksList.Fill(LockInfoList lockInfoList, Filter filter)
+        {
+            mLocksSelector.SaveSelectedLocks();
+
+            mListViewItemIds.Clear();
+
+            mLocksList = lockInfoList;
+
+            Filter();
+            Sort();
+        }
+
+        void Filter()
+        {
+            if (mLocksList == null)
+                return;
+
+            mLocksList.Filter(new Filter(searchString));
+        }
+
+        void Sort()
+        {
+            if (mLocksList == null)
+                return;
+
+            int sortedColumnIdx = multiColumnHeader.state.sortedColumnIndex;
+            bool sortAscending = multiColumnHeader.IsSortedAscending(sortedColumnIdx);
+
+            mLocksList.Sort(mColumnNames[sortedColumnIdx], sortAscending);
+        }
+
+        void DelayedSearchChanged()
+        {
+            Filter();
+
+            Reload();
+
+            TableViewOperations.ScrollToSelection(this);
+        }
+
+        void DelayedSelectionChanged()
+        {
+            mSelectionChangedAction();
+        }
+
+        void SortingChanged(MultiColumnHeader header)
+        {
+            Sort();
+
+            Reload();
+        }
+
+        void SetupTreeView(LocksListHeaderState headerState)
+        {
+            TreeHeaderSettings.Load(
+                headerState,
+                UnityConstants.LOCKS_TABLE_SETTINGS_NAME,
+                (int)LocksListColumn.ModificationDate,
+                false);
+
+            multiColumnHeader = new MultiColumnHeader(headerState);
+            multiColumnHeader.canSort = true;
+            multiColumnHeader.sortingChanged += SortingChanged;
+
+            rowHeight = UnityConstants.TREEVIEW_ROW_HEIGHT;
+            showAlternatingRowBackgrounds = false;
+        }
+
+        static void RegenerateRows(
+            ListViewItemIds<LockInfo> listViewItemIds,
+            LockInfoList locksList,
+            TreeViewItem rootItem,
+            List<TreeViewItem> rows)
+        {
+            ClearRows(rootItem, rows);
+
+            if (locksList == null)
+                return;
+
+            foreach (LockInfo lockInfo in locksList.GetLocks())
+            {
+                int objectId;
+                if (!listViewItemIds.TryGetInfoItemId(lockInfo, out objectId))
+                    objectId = listViewItemIds.AddInfoItem(lockInfo);
+
+                LocksListViewItem lockListViewItem =
+                    new LocksListViewItem(objectId, lockInfo);
+
+                rootItem.AddChild(lockListViewItem);
+                rows.Add(lockListViewItem);
+            }
+        }
+
+        static void ClearRows(
+            TreeViewItem rootItem,
+            List<TreeViewItem> rows)
+        {
+            if (rootItem.hasChildren)
+                rootItem.children.Clear();
+
+            rows.Clear();
+        }
+
+        static void LocksListViewItemGUI(
+            RepositorySpec repSpec,
+            float rowHeight,
+            LockInfo item,
+            RowGUIArgs args,
+            Action avatarLoadedAction)
+        {
+            for (var visibleColumnIdx = 0; visibleColumnIdx < args.GetNumVisibleColumns(); visibleColumnIdx++)
+            {
+                var cellRect = args.GetCellRect(visibleColumnIdx);
+
+                if (visibleColumnIdx == 0)
+                {
+                    cellRect.x += UnityConstants.FIRST_COLUMN_WITHOUT_ICON_INDENT;
+                    cellRect.width -= UnityConstants.FIRST_COLUMN_WITHOUT_ICON_INDENT;
+                }
+
+                var column = (LocksListColumn) args.GetColumn(visibleColumnIdx);
+                
+                DrawLocksListViewItem.ForCell(
+                    repSpec,
+                    cellRect,
+                    rowHeight,
+                    item,
+                    column,
+                    avatarLoadedAction,
+                    args.selected,
+                    args.focused);
+            }
+        }
+
+
+        ListViewItemIds<LockInfo> mListViewItemIds = new ListViewItemIds<LockInfo>();
+        List<TreeViewItem> mRows = new List<TreeViewItem>();
+
+        LockInfoList mLocksList;
+        string mEmptyStateMessage;
+
+        readonly CooldownWindowDelayer mCooldownFilterAction;
+        readonly CooldownWindowDelayer mCooldownSelectionAction;
+        readonly LocksSelector mLocksSelector;
+        readonly Action mSelectionChangedAction;
+        readonly LocksViewMenu mMenu;
+        readonly List<string> mColumnNames;
+        readonly RepositorySpec mRepSpec;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksListView.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4ad84899006a47b9b710662c93ec6448
+timeCreated: 1699628090

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksListViewItem.cs

@@ -0,0 +1,18 @@
+using Codice.CM.Common;
+using UnityEditor.IMGUI.Controls;
+
+namespace Unity.PlasticSCM.Editor.Views.Locks
+{
+    internal sealed class LocksListViewItem : TreeViewItem
+    {
+        internal LockInfo LockInfo { get; private set; }
+
+        internal LocksListViewItem(int id, LockInfo lockInfo)
+            : base(id, 1)
+        {
+            LockInfo = lockInfo;
+
+            displayName = id.ToString();
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksListViewItem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f4519099779a46cdb95ca9e1d96b7895
+timeCreated: 1699887741

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksSelector.cs

@@ -0,0 +1,99 @@
+using System.Collections.Generic;
+
+using Codice.CM.Common;
+using Unity.PlasticSCM.Editor.UI.Tree;
+using UnityEditor.IMGUI.Controls;
+
+namespace Unity.PlasticSCM.Editor.Views.Locks
+{
+    internal sealed class LocksSelector
+    {
+        internal LocksSelector(TreeView treeView, ListViewItemIds<LockInfo> listViewItemIds)
+        {
+            mTreeView = treeView;
+            mListViewItemIds = listViewItemIds;
+        }
+
+        internal void SaveSelectedLocks()
+        {
+            mSelectedLocks = GetSelectedLocks();
+        }
+
+        internal List<LockInfo> GetSelectedLocks()
+        {
+            var result = new List<LockInfo>();
+
+            var selectedIds = mTreeView.GetSelection();
+
+            if (selectedIds.Count == 0)
+            {
+                return result;
+            }
+
+            foreach (var item in mListViewItemIds.GetInfoItems())
+            {
+                if (selectedIds.Contains(item.Value))
+                {
+                    result.Add(item.Key);
+                }
+            }
+
+            return result;
+        }
+
+        internal void RestoreSelectedLocks()
+        {
+            if (mSelectedLocks == null || mSelectedLocks.Count == 0)
+            {
+                TableViewOperations.SelectFirstRow(mTreeView);
+                return;
+            }
+
+            SelectLockItems(mSelectedLocks);
+
+            if (!mTreeView.HasSelection())
+            {
+                TableViewOperations.SelectFirstRow(mTreeView);
+            }
+        }
+
+        void SelectLockItems(List<LockInfo> locksToSelect)
+        {
+            var idsToSelect = new List<int>();
+
+            foreach (var lockInfo in locksToSelect)
+            {
+                var lockInfoId = GetTreeIdForItem(lockInfo);
+
+                if (lockInfoId == -1)
+                {
+                    continue;
+                }
+
+                idsToSelect.Add(lockInfoId);
+            }
+
+            TableViewOperations.SetSelectionAndScroll(mTreeView, idsToSelect);
+        }
+
+        int GetTreeIdForItem(LockInfo lockInfo)
+        {
+            foreach (var item in mListViewItemIds.GetInfoItems())
+            {
+                if (!lockInfo.ItemGuid.Equals(item.Key.ItemGuid))
+                {
+                    continue;
+                }
+
+                return item.Value;
+            }
+
+            return -1;
+        }
+
+        List<LockInfo> mSelectedLocks;
+
+        readonly TreeView mTreeView;
+        readonly ListViewItemIds<LockInfo> mListViewItemIds;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksSelector.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8456e83060fd4354a0695680eea6b3cd
+timeCreated: 1699974140

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksTab.cs

@@ -0,0 +1,249 @@
+using System.Collections.Generic;
+using System.Linq;
+
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.Help.Actions;
+using PlasticGui.WorkspaceWindow.Locks;
+using Unity.PlasticSCM.Editor.AssetUtils;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Progress;
+
+namespace Unity.PlasticSCM.Editor.Views.Locks
+{
+    internal sealed class LocksTab :
+        IRefreshableView,
+        ILockMenuOperations
+    {
+        internal LocksListView Table { get { return mLocksListView; } }
+
+        internal ILockMenuOperations Operations { get { return this; } }
+
+        internal LocksTab(
+            RepositorySpec repSpec,
+            IRefreshView refreshView,
+            EditorWindow parentWindow)
+        {
+            mRepSpec = repSpec;
+            mRefreshView = refreshView;
+            mParentWindow = parentWindow;
+            mProgressControls = new ProgressControlsForViews();
+            mFillLocksTable = new FillLocksTable();
+
+            BuildComponents(mRepSpec);
+
+            ((IRefreshableView) this).Refresh();
+        }
+
+        internal void OnEnable()
+        {
+            mSearchField.downOrUpArrowKeyPressed +=
+                SearchField_OnDownOrUpArrowKeyPressed;
+        }
+
+        internal void OnDisable()
+        {
+            mSearchField.downOrUpArrowKeyPressed -= 
+                SearchField_OnDownOrUpArrowKeyPressed;
+
+            mLocksListView.OnDisable();
+        }
+
+        internal void Update()
+        {
+            mProgressControls.UpdateProgress(mParentWindow);
+        }
+
+        internal void OnGUI()
+        {
+            DoActionsToolbar(
+                mRepSpec.Server,
+                mProgressControls,
+                this,
+                mIsReleaseLocksButtonEnabled,
+                mIsRemoveLocksButtonEnabled);
+
+            DoLocksArea(
+                mLocksListView,
+                mProgressControls.IsOperationRunning());
+        }
+
+        internal void DrawSearchFieldForLocksTab()
+        {
+            DrawSearchField.For(
+                mSearchField,
+                mLocksListView,
+                UnityConstants.SEARCH_FIELD_WIDTH);
+        }
+
+        void IRefreshableView.Refresh()
+        {
+            mFillLocksTable.FillTable(
+                mRepSpec,
+                null,
+                mLocksListView,
+                mLocksListView,
+                mProgressControls);
+        }
+
+        List<LockInfo.LockStatus> ILockMenuOperations.GetSelectedLocksStatus()
+        {
+            return mLocksListView.GetSelectedLocks().
+                Select(lockInfo => lockInfo.Status).ToList();
+        }
+
+        void ILockMenuOperations.ReleaseLocks()
+        {
+            LockOperations.ReleaseLocks(
+                mRepSpec,
+                mLocksListView.GetSelectedLocks(),
+                this,
+                mRefreshView,
+                mProgressControls,
+                RefreshAsset.VersionControlCache);
+        }
+
+        void ILockMenuOperations.RemoveLocks()
+        {
+            LockOperations.RemoveLocks(
+                mRepSpec,
+                mLocksListView.GetSelectedLocks(),
+                this,
+                mRefreshView,
+                mProgressControls,
+                RefreshAsset.VersionControlCache);
+        }
+
+        void SearchField_OnDownOrUpArrowKeyPressed()
+        {
+            mLocksListView.SetFocusAndEnsureSelectedItem();
+        }
+
+        void OnSelectionChanged()
+        {
+            LockMenuOperations operations = LockMenuUpdater.GetAvailableMenuOperations(
+                ((ILockMenuOperations)this).GetSelectedLocksStatus());
+
+            mIsReleaseLocksButtonEnabled = operations.HasFlag(
+                LockMenuOperations.Release);
+            mIsRemoveLocksButtonEnabled = operations.HasFlag(
+                LockMenuOperations.Remove);
+        }
+
+        static void DoActionsToolbar(
+            string server,
+            ProgressControlsForViews progressControls,
+            ILockMenuOperations lockMenuOperations,
+            bool isReleaseLocksButtonEnabled,
+            bool isRemoveLocksButtonEnabled)
+        {
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
+
+            DoReleaseLocksButton(
+                lockMenuOperations,
+                isReleaseLocksButtonEnabled);
+
+            DoRemoveLocksButton(
+                lockMenuOperations,
+                isRemoveLocksButtonEnabled);
+
+            if (progressControls.IsOperationRunning())
+            {
+                DrawProgressForViews.ForIndeterminateProgress(
+                    progressControls.ProgressData);
+            }
+
+            GUILayout.FlexibleSpace();
+
+            DoConfigureLockRulesButton(server);
+
+            EditorGUILayout.EndHorizontal();
+        }
+
+        static void DoLocksArea(
+            LocksListView locksListView,
+            bool isOperationRunning)
+        {
+            GUI.enabled = !isOperationRunning;
+
+            var rect = GUILayoutUtility.GetRect(0, 100000, 0, 100000);
+
+            locksListView.OnGUI(rect);
+
+            GUI.enabled = true;
+        }
+
+        static void DoReleaseLocksButton(
+            ILockMenuOperations lockMenuOperations,
+            bool isEnabled)
+        {
+            GUI.enabled = isEnabled;
+
+            if (DrawActionButton.For(
+                    PlasticLocalization.Name.ReleaseLocksButton.GetString(),
+                    PlasticLocalization.Name.ReleaseLocksButtonTooltip.GetString()))
+            {
+                lockMenuOperations.ReleaseLocks();
+            }
+
+            GUI.enabled = true;
+        }
+
+        static void DoRemoveLocksButton(
+            ILockMenuOperations lockMenuOperations,
+            bool isEnabled)
+        {
+            GUI.enabled = isEnabled;
+
+            if (DrawActionButton.For(
+                    PlasticLocalization.Name.RemoveLocksButton.GetString(),
+                    PlasticLocalization.Name.RemoveLocksButtonTooltip.GetString()))
+            {
+                lockMenuOperations.RemoveLocks();
+            }
+
+            GUI.enabled = true;
+        }
+
+        static void DoConfigureLockRulesButton(string server)
+        {
+            if (DrawActionButton.For(PlasticLocalization.Name.
+                    ConfigureLockRules.GetString()))
+            {
+                OpenConfigureLockRulesPage.Run(server);
+            }
+        }
+
+        void BuildComponents(RepositorySpec repSpec)
+        {
+            mSearchField = new SearchField();
+            mSearchField.downOrUpArrowKeyPressed += 
+                SearchField_OnDownOrUpArrowKeyPressed;
+
+            mLocksListView = new LocksListView(
+                repSpec,
+                LocksListHeaderState.GetDefault(),
+                LocksListHeaderState.GetColumnNames(),
+                new LocksViewMenu(this),
+                OnSelectionChanged);
+
+            mLocksListView.Reload();
+        }
+
+        bool mIsReleaseLocksButtonEnabled;
+        bool mIsRemoveLocksButtonEnabled;
+
+        SearchField mSearchField;
+        LocksListView mLocksListView;
+
+        readonly ProgressControlsForViews mProgressControls;
+        readonly FillLocksTable mFillLocksTable;
+        readonly EditorWindow mParentWindow;
+        readonly IRefreshView mRefreshView;
+        readonly RepositorySpec mRepSpec;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksTab.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2f536f0e9a974d75b293f6aee8e2cdf2
+timeCreated: 1699615699

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksViewMenu.cs

@@ -0,0 +1,140 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Locks;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Views.Locks
+{
+    internal class LocksViewMenu
+    {
+        internal GenericMenu Menu { get { return mMenu; } }
+
+        internal LocksViewMenu(
+            ILockMenuOperations lockMenuOperations)
+        {
+            mLockMenuOperations = lockMenuOperations;
+
+            BuildComponents();
+        }
+
+        internal void Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        internal bool ProcessKeyActionIfNeeded(Event e)
+        {
+            LockMenuOperations operationToExecute = GetMenuOperations(e);
+
+            if (operationToExecute == LockMenuOperations.None)
+                return false;
+
+            LockMenuOperations operations = LockMenuUpdater.GetAvailableMenuOperations(
+                mLockMenuOperations.GetSelectedLocksStatus());
+
+            if (!operations.HasFlag(operationToExecute))
+                return false;
+
+            ProcessMenuOperation(operationToExecute, mLockMenuOperations);
+            return true;
+        }
+
+        internal void UpdateMenuItems(GenericMenu menu)
+        {
+            LockMenuOperations operations = LockMenuUpdater.GetAvailableMenuOperations(
+                mLockMenuOperations.GetSelectedLocksStatus());
+
+            if (operations == LockMenuOperations.None)
+            {
+                menu.AddDisabledItem(GetNoActionMenuItemContent(), false);
+                return;
+            }
+
+            AddLockMenuItem(
+                mReleaseLockMenuItemContent,
+                menu,
+                operations,
+                LockMenuOperations.Release,
+                mLockMenuOperations.ReleaseLocks);
+
+            AddLockMenuItem(
+                mRemoveLockMenuItemContent,
+                menu,
+                operations,
+                LockMenuOperations.Remove,
+                mLockMenuOperations.RemoveLocks);
+        }
+
+        static void AddLockMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            LockMenuOperations operations,
+            LockMenuOperations operationsToCheck,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(operationsToCheck))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static void ProcessMenuOperation(
+            LockMenuOperations operationToExecute,
+            ILockMenuOperations lockMenuOperations)
+        {
+            if (operationToExecute == LockMenuOperations.Remove)
+            {
+                lockMenuOperations.RemoveLocks();
+                return;
+            }
+        }
+
+        static LockMenuOperations GetMenuOperations(Event e)
+        {
+            if (Keyboard.IsKeyPressed(e, KeyCode.Delete))
+                return LockMenuOperations.Remove;
+
+            return LockMenuOperations.None;
+        }
+
+        GUIContent GetNoActionMenuItemContent()
+        {
+            if (mNoActionMenuItemContent == null)
+            {
+                mNoActionMenuItemContent = new GUIContent(
+                    PlasticLocalization.Name.NoActionMenuItem.GetString());
+            }
+
+            return mNoActionMenuItemContent;
+        }
+
+        void BuildComponents()
+        {
+            mReleaseLockMenuItemContent = new GUIContent(PlasticLocalization.
+                Name.LockMenuItemReleaseLock.GetString());
+            mRemoveLockMenuItemContent = new GUIContent(string.Format("{0} {1}", 
+                PlasticLocalization.Name.LockMenuItemRemoveLock.GetString(),
+                GetPlasticShortcut.ForDelete()));
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mNoActionMenuItemContent;
+        GUIContent mReleaseLockMenuItemContent;
+        GUIContent mRemoveLockMenuItemContent;
+
+        readonly ILockMenuOperations mLockMenuOperations;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Locks/LocksViewMenu.cs.meta

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