Initial project commit

Library/PackageCache/com.unity.collab-proxy@1ec4e416a4af/Editor/Views/Locks/DrawLocksListViewItem.cs

@@ -0,0 +1,137 @@
+using System;
+using System.IO;
+using UnityEngine;
+
+using Codice.Client.Common;
+using Codice.CM.Common;
+using PlasticGui.WorkspaceWindow.Locks;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Avatar;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+using Time = Codice.Client.Common.Time;
+
+namespace Unity.PlasticSCM.Editor.Views.Locks
+{
+    internal static class DrawLocksListViewItem
+    {
+        internal static void ForCell(
+            RepositorySpec repSpec,
+            string wkPath,
+            Rect rect,
+            float rowHeight,
+            LockInfo lockInfo,
+            LocksListColumn column,
+            Action avatarLoadedAction,
+            bool isSelected,
+            bool isFocused)
+        {
+            var columnText = LockInfoView.GetColumnText(
+                repSpec,
+                lockInfo,
+                LocksListHeaderState.GetColumnName(column));
+
+            if (column == LocksListColumn.ItemPath)
+            {
+                DrawTreeViewItem.ForItemCell(
+                    rect,
+                    rowHeight,
+                    -1,
+                    GetIcon(wkPath, lockInfo),
+                    null,
+                    null,
+                    columnText,
+                    isSelected,
+                    isFocused,
+                    false,
+                    false,
+                    DrawTreeViewItem.TextTrimming.Path);
+
+                return;
+            }
+
+            if (column == LocksListColumn.Owner)
+            {
+                DrawTreeViewItem.ForItemCell(
+                    rect,
+                    rowHeight,
+                    -1,
+                    GetAvatar.ForEmail(columnText, avatarLoadedAction),
+                    null,
+                    null,
+                    columnText,
+                    isSelected,
+                    isFocused,
+                    false,
+                    false);
+
+                return;
+            }
+
+            if (column == LocksListColumn.LockType)
+            {
+                DrawTreeViewItem.ForItemCell(
+                    rect,
+                    rowHeight,
+                    -1,
+                    lockInfo.Status == LockInfo.LockStatus.Locked ?
+                        Images.GetLockIcon() : Images.GetLockRetainedIcon(),
+                    null,
+                    null,
+                    columnText,
+                    isSelected,
+                    isFocused,
+                    false,
+                    false);
+                return;
+            }
+
+            if (column == LocksListColumn.ModificationDate)
+            {
+                DrawTreeViewItem.ForLabel(
+                    rect,
+                    GetModificationDateContent(lockInfo.UtcTicks),
+                    isSelected,
+                    isFocused,
+                    false);
+                return;
+            }
+
+            DrawTreeViewItem.TextTrimming textTrimming = column == LocksListColumn.Branch ?
+                DrawTreeViewItem.TextTrimming.Path : DrawTreeViewItem.TextTrimming.None;
+
+            DrawTreeViewItem.ForLabel(
+                rect,
+                columnText,
+                isSelected,
+                isFocused,
+                false,
+                textTrimming);
+        }
+
+        static Texture GetIcon(
+            string wkPath,
+            LockInfo lockInfo)
+        {
+            string fullPath = WorkspacePath.GetWorkspacePathFromCmPath(
+                wkPath,
+                lockInfo.CmPath,
+                Path.DirectorySeparatorChar);
+
+            return Images.GetFileIcon(fullPath);
+        }
+
+        static GUIContent GetModificationDateContent(long utcTicks)
+        {
+            if (utcTicks <= 0)
+                return new GUIContent(string.Empty);
+
+            string dateFormat = ClientConfig.Get().GetClientConfigData().FindOutputDateFormat;
+            DateTime localDateTime = new DateTime(utcTicks, DateTimeKind.Utc).ToLocalTime();
+
+            return new GUIContent(
+                Time.GetLongTimeAgoString(localDateTime),
+                string.Format(string.Format("{{0:{0}}}", dateFormat), localDateTime));
+        }
+    }
+}

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

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

Library/PackageCache/com.unity.collab-proxy@1ec4e416a4af/Editor/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,
+        Owner,
+        LockType,
+        ModificationDate,
+        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.OwnerColumn.GetString(),
+                PlasticLocalization.Name.StatusColumn.GetString(),
+                PlasticLocalization.Name.DateModifiedColumn.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.Owner:
+                    return PlasticLocalization.Name.OwnerColumn.GetString();
+                case LocksListColumn.LockType:
+                    return PlasticLocalization.Name.StatusColumn.GetString();
+                case LocksListColumn.ModificationDate:
+                    return PlasticLocalization.Name.DateModifiedColumn.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.OWNER_WIDTH,
+                    minWidth = UnityConstants.LocksColumns.OWNER_MIN_WIDTH,
+                    headerContent = new GUIContent(GetColumnName(LocksListColumn.Owner)),
+                    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.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@1ec4e416a4af/Editor/Views/Locks/LocksListHeaderState.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@1ec4e416a4af/Editor/Views/Locks/LocksListView.cs

@@ -0,0 +1,337 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+using Codice.Client.Common;
+
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Locks;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+#if UNITY_6000_2_OR_NEWER
+using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem<int>;
+#endif
+
+namespace Unity.PlasticSCM.Editor.Views.Locks
+{
+    internal sealed class LocksListView :
+        PlasticTreeView,
+        FillLocksTable.IShowContentView,
+        FillLocksTable.ILocksList
+    {
+        internal GenericMenu Menu { get { return mMenu.Menu; } }
+        internal string EmptyStateMessage { get { return mEmptyStatePanel.Text; } }
+
+        internal LocksListView(
+            WorkspaceInfo wkInfo,
+            RepositorySpec repSpec,
+            LocksListHeaderState headerState,
+            List<string> columnNames,
+            LocksViewMenu menu,
+            Action selectionChangedAction,
+            Action<IEnumerable<LockInfo>> afterItemsChangedAction,
+            Action repaintAction)
+        {
+            mWkInfo = wkInfo;
+            mRepSpec = repSpec;
+            mColumnNames = columnNames;
+            mMenu = menu;
+            mSelectionChangedAction = selectionChangedAction;
+            mAfterItemsChangedAction = afterItemsChangedAction;
+            mEmptyStatePanel = new EmptyStatePanel(repaintAction);
+            mMultiLinkLabelData =  new MultiLinkLabelData(
+                PlasticLocalization.Name.LocksTutorialLabel.GetString(),
+                new List<string> { PlasticLocalization.Name.LocksTutorialButton.GetString() },
+                new List<Action> { () => { Codice.Utils.OpenBrowser.TryOpen(LOCKS_TUTORIAL_LINK); } });
+
+            mLocksSelector = new LocksSelector(this, mListViewItemIds);
+
+            mDelayedFilterAction = new DelayedActionBySecondsRunner(
+                DelayedSearchChanged, UnityConstants.SEARCH_DELAYED_INPUT_ACTION_INTERVAL);
+
+            mDelayedSelectionAction = new DelayedActionBySecondsRunner(
+                DelayedSelectionChanged, UnityConstants.SELECTION_DELAYED_INPUT_ACTION_INTERVAL);
+
+            SetupTreeView(headerState);
+        }
+
+        public override void OnGUI(Rect rect)
+        {
+            base.OnGUI(rect);
+
+            if (mRows.Count == 0 && !mEmptyStatePanel.IsEmpty())
+                mEmptyStatePanel.OnGUI(rect);
+
+            if (!HasKeyboardFocus())
+                return;
+
+            Event e = Event.current;
+
+            if (e.type != EventType.KeyDown)
+                return;
+
+            bool isProcessed = mMenu.ProcessKeyActionIfNeeded(e);
+
+            if (isProcessed)
+                e.Use();
+        }
+
+        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)
+        {
+            mDelayedFilterAction.Run();
+        }
+
+        protected override void SelectionChanged(IList<int> selectedIds)
+        {
+            mDelayedSelectionAction.Run();
+        }
+
+        protected override void ContextClickedItem(int id)
+        {
+            mMenu.Popup();
+            Repaint();
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            if (args.item is LocksListViewItem)
+            {
+                LocksListViewItemGUI(
+                    mRepSpec,
+                    mWkInfo.ClientPath,
+                    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()
+        {
+            mEmptyStatePanel.UpdateContent(
+                string.Empty,
+                multiLinkLabelData: mMultiLinkLabelData);
+
+            Reload();
+
+            mLocksSelector.RestoreSelectedLocks();
+        }
+
+        void FillLocksTable.IShowContentView.ShowEmptyStatePanel(string explanationText)
+        {
+            mEmptyStatePanel.UpdateContent(
+                explanationText,
+                multiLinkLabelData: string.IsNullOrEmpty(searchString) ? mMultiLinkLabelData : null);
+
+            Reload();
+        }
+
+        void FillLocksTable.IShowContentView.ShowErrorPanel(string errorText)
+        {
+            Debug.LogErrorFormat(
+                PlasticLocalization.Name.LoadLocksErrorExplanation.GetString(),
+                errorText);
+
+            mEmptyStatePanel.UpdateContent(
+                PlasticLocalization.Name.LoadLocksError.GetString(),
+                multiLinkLabelData: mMultiLinkLabelData);
+
+            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));
+            mAfterItemsChangedAction(mLocksList.GetLocks());
+        }
+
+        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;
+        }
+
+        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,
+            string wkPath,
+            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,
+                    wkPath,
+                    cellRect,
+                    rowHeight,
+                    item,
+                    column,
+                    avatarLoadedAction,
+                    args.selected,
+                    args.focused);
+            }
+        }
+
+        ListViewItemIds<LockInfo> mListViewItemIds = new ListViewItemIds<LockInfo>();
+
+        LockInfoList mLocksList;
+
+        readonly EmptyStatePanel mEmptyStatePanel;
+        readonly MultiLinkLabelData mMultiLinkLabelData;
+        readonly DelayedActionBySecondsRunner mDelayedFilterAction;
+        readonly DelayedActionBySecondsRunner mDelayedSelectionAction;
+        readonly LocksSelector mLocksSelector;
+        readonly Action mSelectionChangedAction;
+        readonly Action<IEnumerable<LockInfo>> mAfterItemsChangedAction;
+        readonly LocksViewMenu mMenu;
+        readonly List<string> mColumnNames;
+        readonly RepositorySpec mRepSpec;
+        readonly WorkspaceInfo mWkInfo;
+
+        const string LOCKS_TUTORIAL_LINK = "https://learn.unity.com/tutorial/6650a6abedbc2a2ccccb05a4";
+    }
+}

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

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

Library/PackageCache/com.unity.collab-proxy@1ec4e416a4af/Editor/Views/Locks/LocksListViewItem.cs

@@ -0,0 +1,21 @@
+using Codice.CM.Common;
+using UnityEditor.IMGUI.Controls;
+#if UNITY_6000_2_OR_NEWER
+using TreeViewItem = UnityEditor.IMGUI.Controls.TreeViewItem<int>;
+#endif
+
+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@1ec4e416a4af/Editor/Views/Locks/LocksListViewItem.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@1ec4e416a4af/Editor/Views/Locks/LocksSelector.cs

@@ -0,0 +1,118 @@
+using System.Collections.Generic;
+
+using Codice.CM.Common;
+using Unity.PlasticSCM.Editor.UI.Tree;
+using UnityEditor.IMGUI.Controls;
+
+#if UNITY_6000_2_OR_NEWER
+using TreeView = UnityEditor.IMGUI.Controls.TreeView<int>;
+#endif
+
+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>();
+            var rows = mTreeView.GetRows();
+            var existingIds = new HashSet<int>();
+
+            foreach (var row in rows)
+            {
+                existingIds.Add(row.id);
+            }
+
+            foreach (var lockInfo in locksToSelect)
+            {
+                var lockInfoId = GetTreeIdForItem(lockInfo);
+
+                if (lockInfoId == -1)
+                {
+                    continue;
+                }
+
+                if (!existingIds.Contains(lockInfoId))
+                {
+                    continue;
+                }
+
+                idsToSelect.Add(lockInfoId);
+            }
+
+            if (idsToSelect.Count == 0)
+                return;
+
+            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@1ec4e416a4af/Editor/Views/Locks/LocksSelector.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@1ec4e416a4af/Editor/Views/Locks/LocksTab.cs

@@ -0,0 +1,301 @@
+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 PlasticGui.WorkspaceWindow.QueryViews;
+using Unity.PlasticSCM.Editor.AssetsOverlays.Cache;
+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,
+        IGetFilter
+    {
+        internal LocksListView Table { get { return mLocksListView; } }
+
+        internal ILockMenuOperations Operations { get { return this; } }
+
+        internal LocksTab(
+            WorkspaceInfo wkInfo,
+            RepositorySpec repSpec,
+            IRefreshView refreshView,
+            IAssetStatusCache assetStatusCache,
+            EditorWindow parentWindow)
+        {
+            mRepSpec = repSpec;
+            mRefreshView = refreshView;
+            mAssetStatusCache = assetStatusCache;
+            mParentWindow = parentWindow;
+            mProgressControls = new ProgressControlsForViews();
+
+            BuildComponents(wkInfo, mRepSpec);
+
+            mFillLocksTable = new FillLocksTable(this, mLocksListView);
+
+            ((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);
+
+            if (mConfigureLockRulesButtonClicked)
+            {
+                OpenConfigureLockRulesPage.Run(mRepSpec.Server);
+                mConfigureLockRulesButtonClicked = false;
+            }
+        }
+
+        internal void OnGUI()
+        {
+            DoActionsToolbar(
+                mProgressControls,
+                mSearchField,
+                mLocksListView,
+                this,
+                mIsReleaseLocksButtonEnabled,
+                mIsRemoveLocksButtonEnabled,
+                this);
+
+            Rect viewRect = OverlayProgress.CaptureViewRectangle();
+
+            DoLocksArea(
+                mLocksListView,
+                mProgressControls.IsOperationRunning());
+
+            if (mProgressControls.IsOperationRunning())
+            {
+                OverlayProgress.DoOverlayProgress(
+                    viewRect,
+                    mProgressControls.ProgressData.ProgressPercent,
+                    mProgressControls.ProgressData.ProgressMessage);
+            }
+        }
+
+        void IRefreshableView.Refresh()
+        {
+            mFillLocksTable.FillTable(
+                mRepSpec,
+                mLocksListView,
+                mProgressControls);
+
+            if (mAssetStatusCache != null)
+                mAssetStatusCache.ClearLocks();
+        }
+
+        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(mAssetStatusCache));
+        }
+
+        void ILockMenuOperations.RemoveLocks()
+        {
+            LockOperations.RemoveLocks(
+                mRepSpec,
+                mLocksListView.GetSelectedLocks(),
+                this,
+                mRefreshView,
+                mProgressControls,
+                () => RefreshAsset.VersionControlCache(mAssetStatusCache));
+        }
+
+        Filter IGetFilter.Get()
+        {
+            return new Filter(mLocksListView.searchString);
+        }
+
+        void IGetFilter.Clear()
+        {
+            // Not used by the Plugin, needed for the Reset filters button
+        }
+
+        void SearchField_OnDownOrUpArrowKeyPressed()
+        {
+            mLocksListView.SetFocusAndEnsureSelectedItem();
+        }
+
+        void OnSelectionChanged()
+        {
+            LockMenuOperations operations = LockMenuUpdater.GetAvailableMenuOperations(
+                ((ILockMenuOperations)this).GetSelectedLocksStatus());
+
+            mIsReleaseLocksButtonEnabled = operations.HasFlag(
+                LockMenuOperations.Release);
+            mIsRemoveLocksButtonEnabled = operations.HasFlag(
+                LockMenuOperations.Remove);
+        }
+
+        void OnItemsChanged(IEnumerable<LockInfo> items)
+        {
+            mFillLocksTable.ShowContentOrEmptyStatePanel(items);
+        }
+
+        void DoActionsToolbar(
+            ProgressControlsForViews progressControls,
+            SearchField searchField,
+            LocksListView locksListView,
+            ILockMenuOperations lockMenuOperations,
+            bool isReleaseLocksButtonEnabled,
+            bool isRemoveLocksButtonEnabled,
+            IRefreshableView view)
+        {
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
+
+            if (GUILayout.Button(
+                    new GUIContent(Images.GetRefreshIcon(),
+                        PlasticLocalization.Name.RefreshButton.GetString()),
+                    UnityStyles.ToolbarButtonLeft,
+                    GUILayout.Width(UnityConstants.TOOLBAR_ICON_BUTTON_WIDTH)))
+            {
+                view.Refresh();
+            }
+
+            DoReleaseLocksButton(
+                lockMenuOperations,
+                isReleaseLocksButtonEnabled);
+
+            DoRemoveLocksButton(
+                lockMenuOperations,
+                isRemoveLocksButtonEnabled);
+
+            GUILayout.FlexibleSpace();
+
+            mConfigureLockRulesButtonClicked = DoConfigureLockRulesButton();
+
+            GUILayout.Space(2);
+
+            DrawSearchField.For(
+                searchField,
+                locksListView,
+                UnityConstants.SEARCH_FIELD_WIDTH);
+
+            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 (GUILayout.Button(new GUIContent(
+                    PlasticLocalization.Name.ReleaseLocksButton.GetString(),
+                    PlasticLocalization.Name.ReleaseLocksButtonTooltip.GetString()),
+                    EditorStyles.toolbarButton))
+            {
+                lockMenuOperations.ReleaseLocks();
+            }
+
+            GUI.enabled = true;
+        }
+
+        static void DoRemoveLocksButton(
+            ILockMenuOperations lockMenuOperations,
+            bool isEnabled)
+        {
+            GUI.enabled = isEnabled;
+
+            if (GUILayout.Button(new GUIContent(
+                    PlasticLocalization.Name.RemoveLocksButton.GetString(),
+                    PlasticLocalization.Name.RemoveLocksButtonTooltip.GetString()),
+                    EditorStyles.toolbarButton))
+            {
+                lockMenuOperations.RemoveLocks();
+            }
+
+            GUI.enabled = true;
+        }
+
+        bool DoConfigureLockRulesButton()
+        {
+            return GUILayout.Button(PlasticLocalization.Name.
+                    ConfigureLockRules.GetString(),
+                    EditorStyles.toolbarButton);
+        }
+
+        void BuildComponents(
+            WorkspaceInfo wkInfo,
+            RepositorySpec repSpec)
+        {
+            mSearchField = new SearchField();
+            mSearchField.downOrUpArrowKeyPressed +=
+                SearchField_OnDownOrUpArrowKeyPressed;
+
+            mLocksListView = new LocksListView(
+                wkInfo,
+                repSpec,
+                LocksListHeaderState.GetDefault(),
+                LocksListHeaderState.GetColumnNames(),
+                new LocksViewMenu(this),
+                OnSelectionChanged,
+                OnItemsChanged,
+                mParentWindow.Repaint);
+
+            mLocksListView.Reload();
+        }
+
+        bool mIsReleaseLocksButtonEnabled;
+        bool mIsRemoveLocksButtonEnabled;
+        bool mConfigureLockRulesButtonClicked;
+
+        SearchField mSearchField;
+        LocksListView mLocksListView;
+
+        readonly ProgressControlsForViews mProgressControls;
+        readonly FillLocksTable mFillLocksTable;
+        readonly EditorWindow mParentWindow;
+        readonly IRefreshView mRefreshView;
+        readonly RepositorySpec mRepSpec;
+        readonly IAssetStatusCache mAssetStatusCache;
+    }
+}

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

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

Library/PackageCache/com.unity.collab-proxy@1ec4e416a4af/Editor/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;
+        }
+
+        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@1ec4e416a4af/Editor/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: