first commit

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Changesets/ChangesetListViewItem.cs

@@ -0,0 +1,17 @@
+using UnityEditor.IMGUI.Controls;
+
+namespace Unity.PlasticSCM.Editor.Views.Changesets
+{
+    class ChangesetListViewItem : TreeViewItem
+    {
+        internal object ObjectInfo { get; private set; }
+
+        internal ChangesetListViewItem(int id, object objectInfo)
+            : base(id, 1)
+        {
+            ObjectInfo = objectInfo;
+
+            displayName = id.ToString();
+        }
+    }
+}

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

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

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Changesets/ChangesetsListHeaderState.cs

@@ -0,0 +1,139 @@
+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.Changesets
+{
+    internal enum ChangesetsListColumn
+    {
+        Name,
+        CreationDate,
+        CreatedBy,
+        Comment,
+        Branch,
+        Repository,
+        Guid
+    }
+
+    [Serializable]
+    internal class ChangesetsListHeaderState : MultiColumnHeaderState, ISerializationCallbackReceiver
+    {
+        internal static ChangesetsListHeaderState GetDefault()
+        {
+            return new ChangesetsListHeaderState(BuildColumns());
+        }
+
+        internal static List<string> GetColumnNames()
+        {
+            List<string> result = new List<string>();
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.NameColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.CreationDateColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.CreatedByColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.CommentColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.BranchColumn));
+            return result;
+        }
+
+        internal static string GetColumnName(ChangesetsListColumn column)
+        {
+            switch (column)
+            {
+                case ChangesetsListColumn.Name:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.NameColumn);
+                case ChangesetsListColumn.CreationDate:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.CreationDateColumn);
+                case ChangesetsListColumn.CreatedBy:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.CreatedByColumn);
+                case ChangesetsListColumn.Comment:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.CommentColumn);
+                case ChangesetsListColumn.Branch:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.BranchColumn);
+                default:
+                    return null;
+            }
+        }
+
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+            if (mHeaderTitles != null)
+                TreeHeaderColumns.SetTitles(columns, mHeaderTitles);
+
+            if (mColumsAllowedToggleVisibility != null)
+                TreeHeaderColumns.SetVisibilities(columns, mColumsAllowedToggleVisibility);
+        }
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
+        {
+        }
+
+        static Column[] BuildColumns()
+        {
+            return new Column[]
+            {
+                new Column()
+                {
+                    width = UnityConstants.ChangesetsColumns.CHANGESET_NUMBER_WIDTH,
+                    minWidth = UnityConstants.ChangesetsColumns.CHANGESET_NUMBER_MIN_WIDTH,
+                    headerContent = new GUIContent(
+                        GetColumnName(ChangesetsListColumn.Name)),
+                    allowToggleVisibility = false,
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = UnityConstants.ChangesetsColumns.CREATION_DATE_WIDTH,
+                    minWidth = UnityConstants.ChangesetsColumns.CREATION_DATE_MIN_WIDTH,
+                    headerContent = new GUIContent(
+                        GetColumnName(ChangesetsListColumn.CreationDate)),
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = UnityConstants.ChangesetsColumns.CREATED_BY_WIDTH,
+                    minWidth = UnityConstants.ChangesetsColumns.CREATED_BY_MIN_WIDTH,
+                    headerContent = new GUIContent(
+                        GetColumnName(ChangesetsListColumn.CreatedBy)),
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = UnityConstants.ChangesetsColumns.COMMENT_WIDTH,
+                    minWidth = UnityConstants.ChangesetsColumns.COMMENT_MIN_WIDTH,
+                    headerContent = new GUIContent(
+                        GetColumnName(ChangesetsListColumn.Comment)),
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = UnityConstants.ChangesetsColumns.BRANCH_WIDTH,
+                    minWidth = UnityConstants.ChangesetsColumns.BRANCH_MIN_WIDTH,
+                    headerContent = new GUIContent(
+                        GetColumnName(ChangesetsListColumn.Branch)),
+                    sortingArrowAlignment = TextAlignment.Right
+                }
+            };
+        }
+
+        ChangesetsListHeaderState(Column[] columns)
+            : base(columns)
+        {
+            if (mHeaderTitles == null)
+                mHeaderTitles = TreeHeaderColumns.GetTitles(columns);
+
+            if (mColumsAllowedToggleVisibility == null)
+                mColumsAllowedToggleVisibility = TreeHeaderColumns.GetVisibilities(columns);
+        }
+
+        [SerializeField]
+        string[] mHeaderTitles;
+
+        [SerializeField]
+        bool[] mColumsAllowedToggleVisibility;
+    }
+}

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

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

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Changesets/ChangesetsListView.cs

@@ -0,0 +1,450 @@
+using System;
+using System.Collections.Generic;
+
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.QueryViews;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Avatar;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+namespace Unity.PlasticSCM.Editor.Views.Changesets
+{
+    internal class ChangesetsListView : TreeView
+    {
+        internal GenericMenu Menu { get { return mMenu.Menu; } }
+
+        internal ChangesetsListView(
+            ChangesetsListHeaderState headerState,
+            List<string> columnNames,
+            ChangesetsViewMenu menu,
+            Action sizeChangedAction,
+            Action selectionChangedAction,
+            Action doubleClickAction)
+            : base(new TreeViewState())
+        {
+            mColumnNames = columnNames;
+            mMenu = menu;
+            mSizeChangedAction = sizeChangedAction;
+            mSelectionChangedAction = selectionChangedAction;
+            mDoubleClickAction = doubleClickAction;
+
+            multiColumnHeader = new MultiColumnHeader(headerState);
+            multiColumnHeader.canSort = true;
+            multiColumnHeader.sortingChanged += SortingChanged;
+
+            rowHeight = UnityConstants.TREEVIEW_ROW_HEIGHT;
+            showAlternatingRowBackgrounds = false;
+
+            mCooldownFilterAction = new CooldownWindowDelayer(
+                DelayedSearchChanged, UnityConstants.SEARCH_DELAYED_INPUT_ACTION_INTERVAL);
+
+            mCooldownSelectionAction = new CooldownWindowDelayer(
+                DelayedSelectionChanged, UnityConstants.SELECTION_DELAYED_INPUT_ACTION_INTERVAL);
+        }
+
+        protected override void SelectionChanged(IList<int> selectedIds)
+        {
+            mCooldownSelectionAction.Ping();
+        }
+
+        public override IList<TreeViewItem> GetRows()
+        {
+            return mRows;
+        }
+
+        internal void SetLoadedChangesetId(long loadedChangesetId)
+        {
+            mLoadedChangesetId = loadedChangesetId;
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            return new TreeViewItem(0, -1, string.Empty);
+        }
+
+        protected override IList<TreeViewItem> BuildRows(
+            TreeViewItem rootItem)
+        {
+            if (mQueryResult == null)
+            {
+                ClearRows(rootItem, mRows);
+
+                return mRows;
+            }
+
+            RegenerateRows(
+                mListViewItemIds,
+                mQueryResult.GetObjects(),
+                rootItem, mRows);
+
+            return mRows;
+        }
+
+        protected override void SearchChanged(string newSearch)
+        {
+            mCooldownFilterAction.Ping();
+        }
+
+        protected override void ContextClickedItem(int id)
+        {
+            mMenu.Popup();
+            Repaint();
+        }
+
+        public override void OnGUI(Rect rect)
+        {
+            if (Event.current.type == EventType.Layout)
+            {
+                if (IsSizeChanged(treeViewRect, mLastRect))
+                    mSizeChangedAction();
+            }
+
+            mLastRect = treeViewRect;
+
+            base.OnGUI(rect);
+
+            Event e = Event.current;
+
+            if (e.type != EventType.KeyDown)
+                return;
+
+            bool isProcessed = mMenu.ProcessKeyActionIfNeeded(e);
+
+            if (isProcessed)
+                e.Use();
+        }
+
+        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 ChangesetListViewItem)
+            {
+                ChangesetListViewItem changesetListViewItem = (ChangesetListViewItem)args.item;
+                ChangesetInfo changesetInfo = (ChangesetInfo)changesetListViewItem.ObjectInfo;
+
+                ChangesetsListViewItemGUI(
+                    mQueryResult,
+                    rowHeight,
+                    changesetListViewItem,
+                    args,
+                    changesetInfo.ChangesetId == mLoadedChangesetId,
+                    Repaint);
+                return;
+            }
+
+            base.RowGUI(args);
+        }
+
+        protected override void DoubleClickedItem(int id)
+        {
+            if (!HasSelection())
+                return;
+
+            mDoubleClickAction();
+        }
+
+        internal void BuildModel(
+            ViewQueryResult queryResult,
+            long loadedChangesetId)
+        {
+            mListViewItemIds.Clear();
+
+            mQueryResult = queryResult;
+            mLoadedChangesetId = loadedChangesetId;
+        }
+
+        internal void Refilter()
+        {
+            if (mQueryResult == null)
+                return;
+
+            Filter filter = new Filter(searchString);
+            mQueryResult.ApplyFilter(filter, mColumnNames);
+        }
+
+        internal void Sort()
+        {
+            if (mQueryResult == null)
+                return;
+
+            int sortedColumnIdx = multiColumnHeader.state.sortedColumnIndex;
+            bool sortAscending = multiColumnHeader.IsSortedAscending(sortedColumnIdx);
+
+            mQueryResult.Sort(
+                mColumnNames[sortedColumnIdx],
+                sortAscending);
+        }
+
+        internal List<RepositorySpec> GetSelectedRepositories()
+        {
+            List<RepositorySpec> result = new List<RepositorySpec>();
+
+            IList<int> selectedIds = GetSelection();
+
+            if (selectedIds.Count == 0)
+                return result;
+
+            foreach (KeyValuePair<object, int> item
+                in mListViewItemIds.GetInfoItems())
+            {
+                if (!selectedIds.Contains(item.Value))
+                    continue;
+
+                RepositorySpec repSpec =
+                    mQueryResult.GetRepositorySpec(item.Key);
+                result.Add(repSpec);
+            }
+
+            return result;
+        }
+
+        internal List<RepObjectInfo> GetSelectedRepObjectInfos()
+        {
+            List<RepObjectInfo> result = new List<RepObjectInfo>();
+
+            IList<int> selectedIds = GetSelection();
+
+            if (selectedIds.Count == 0)
+                return result;
+
+            foreach (KeyValuePair<object, int> item
+                in mListViewItemIds.GetInfoItems())
+            {
+                if (!selectedIds.Contains(item.Value))
+                    continue;
+
+                RepObjectInfo repObjectInfo =
+                    mQueryResult.GetRepObjectInfo(item.Key);
+                result.Add(repObjectInfo);
+            }
+
+            return result;
+        }
+
+        internal void SelectRepObjectInfos(
+            List<RepObjectInfo> repObjectsToSelect)
+        {
+            List<int> idsToSelect = new List<int>();
+
+            foreach (RepObjectInfo repObjectInfo in repObjectsToSelect)
+            {
+                int repObjectInfoId = GetTreeIdForItem(repObjectInfo);
+
+                if (repObjectInfoId == -1)
+                    continue;
+
+                idsToSelect.Add(repObjectInfoId);
+            }
+
+            TableViewOperations.SetSelectionAndScroll(this, idsToSelect);
+        }
+
+        int GetTreeIdForItem(RepObjectInfo repObjectInfo)
+        {
+            foreach (KeyValuePair<object, int> item in mListViewItemIds.GetInfoItems())
+            {
+                RepObjectInfo currentRepObjectInfo =
+                    mQueryResult.GetRepObjectInfo(item.Key);
+
+                if (!currentRepObjectInfo.Equals(repObjectInfo))
+                    continue;
+
+                if (!currentRepObjectInfo.GUID.Equals(repObjectInfo.GUID))
+                    continue;
+
+                return item.Value;
+            }
+
+            return -1;
+        }
+
+        void DelayedSearchChanged()
+        {
+            Refilter();
+
+            Sort();
+
+            Reload();
+
+            TableViewOperations.ScrollToSelection(this);
+        }
+
+        void DelayedSelectionChanged()
+        {
+            if (!HasSelection())
+                return;
+
+            mSelectionChangedAction();
+        }
+
+        void SortingChanged(MultiColumnHeader multiColumnHeader)
+        {
+            Sort();
+
+            Reload();
+        }
+
+        static void RegenerateRows(
+            ListViewItemIds<object> listViewItemIds,
+            List<object> objectInfos,
+            TreeViewItem rootItem,
+            List<TreeViewItem> rows)
+        {
+            ClearRows(rootItem, rows);
+
+            if (objectInfos.Count == 0)
+                return;
+
+            foreach (object objectInfo in objectInfos)
+            {
+                int objectId;
+                if (!listViewItemIds.TryGetInfoItemId(objectInfo, out objectId))
+                    objectId = listViewItemIds.AddInfoItem(objectInfo);
+
+                ChangesetListViewItem changesetListViewItem =
+                    new ChangesetListViewItem(objectId, objectInfo);
+
+                rootItem.AddChild(changesetListViewItem);
+                rows.Add(changesetListViewItem);
+            }
+        }
+
+        static void ClearRows(
+            TreeViewItem rootItem,
+            List<TreeViewItem> rows)
+        {
+            if (rootItem.hasChildren)
+                rootItem.children.Clear();
+
+            rows.Clear();
+        }
+
+        static void ChangesetsListViewItemGUI(
+            ViewQueryResult queryResult,
+            float rowHeight,
+            ChangesetListViewItem item,
+            RowGUIArgs args,
+            bool isBoldText,
+            Action avatarLoadedAction)
+        {
+            for (int visibleColumnIdx = 0; visibleColumnIdx < args.GetNumVisibleColumns(); visibleColumnIdx++)
+            {
+                Rect cellRect = args.GetCellRect(visibleColumnIdx);
+
+                if (visibleColumnIdx == 0)
+                {
+                    cellRect.x += UnityConstants.FIRST_COLUMN_WITHOUT_ICON_INDENT;
+                    cellRect.width -= UnityConstants.FIRST_COLUMN_WITHOUT_ICON_INDENT;
+                }
+
+                ChangesetsListColumn column =
+                    (ChangesetsListColumn)args.GetColumn(visibleColumnIdx);
+
+                ChangesetsListViewItemCellGUI(
+                    cellRect,
+                    rowHeight,
+                    queryResult,
+                    item,
+                    column,
+                    avatarLoadedAction,
+                    args.selected,
+                    args.focused,
+                    isBoldText);
+            }
+        }
+
+        static void ChangesetsListViewItemCellGUI(
+            Rect rect,
+            float rowHeight,
+            ViewQueryResult queryResult,
+            ChangesetListViewItem item,
+            ChangesetsListColumn column,
+            Action avatarLoadedAction,
+            bool isSelected,
+            bool isFocused,
+            bool isBoldText)
+        {
+            string columnText = RepObjectInfoView.GetColumnText(
+                queryResult.GetRepositorySpec(item.ObjectInfo),
+                queryResult.GetRepObjectInfo(item.ObjectInfo),
+                ChangesetsListHeaderState.GetColumnName(column));
+
+            if (column == ChangesetsListColumn.CreatedBy)
+            {
+                DrawTreeViewItem.ForItemCell(
+                    rect,
+                    rowHeight,
+                    -1,
+                    GetAvatar.ForEmail(columnText, avatarLoadedAction),
+                    null,
+                    columnText,
+                    isSelected,
+                    isFocused,
+                    isBoldText,
+                    false);
+                return;
+            }
+
+
+            if (column == ChangesetsListColumn.Branch ||
+                column == ChangesetsListColumn.Repository ||
+                column == ChangesetsListColumn.Guid)
+            {
+                DrawTreeViewItem.ForSecondaryLabel(
+                    rect, columnText, isSelected, isFocused, isBoldText);
+                return;
+            }
+
+            DrawTreeViewItem.ForLabel(
+                rect, columnText, isSelected, isFocused, isBoldText);
+        }
+
+        static bool IsSizeChanged(
+            Rect currentRect, Rect lastRect)
+        {
+            if (currentRect.width != lastRect.width)
+                return true;
+
+            if (currentRect.height != lastRect.height)
+                return true;
+
+            return false;
+        }
+
+        Rect mLastRect;
+
+        ListViewItemIds<object> mListViewItemIds = new ListViewItemIds<object>();
+        List<TreeViewItem> mRows = new List<TreeViewItem>();
+
+        ViewQueryResult mQueryResult;
+        long mLoadedChangesetId;
+
+        readonly CooldownWindowDelayer mCooldownFilterAction;
+        readonly CooldownWindowDelayer mCooldownSelectionAction;
+        readonly Action mDoubleClickAction;
+        readonly Action mSelectionChangedAction;
+        readonly Action mSizeChangedAction;
+        readonly ChangesetsViewMenu mMenu;
+        readonly List<string> mColumnNames;
+    }
+}

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

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

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Changesets/ChangesetsSelection.cs

@@ -0,0 +1,68 @@
+using System.Collections.Generic;
+
+using Codice.CM.Common;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+namespace Unity.PlasticSCM.Editor.Views.Changesets
+{
+    internal static class ChangesetsSelection
+    {
+        internal static void SelectChangesets(
+            ChangesetsListView listView,
+            List<RepObjectInfo> csetsToSelect,
+            int defaultRow)
+        {
+            if (csetsToSelect == null || csetsToSelect.Count == 0)
+            {
+                TableViewOperations.SelectFirstRow(listView);
+                return;
+            }
+
+            listView.SelectRepObjectInfos(csetsToSelect);
+
+            if (listView.HasSelection())
+                return;
+
+            TableViewOperations.SelectDefaultRow(listView, defaultRow);
+
+            if (listView.HasSelection())
+                return;
+
+            TableViewOperations.SelectFirstRow(listView);
+        }
+
+        internal static List<RepObjectInfo> GetSelectedRepObjectInfos(
+            ChangesetsListView listView)
+        {
+            return listView.GetSelectedRepObjectInfos();
+        }
+
+        internal static int GetSelectedChangesetsCount(
+            ChangesetsListView listView)
+        {
+            return listView.GetSelection().Count;
+        }
+
+        internal static ChangesetExtendedInfo GetSelectedChangeset(
+            ChangesetsListView listView)
+        {
+            List<RepObjectInfo> selectedRepObjectsInfos = listView.GetSelectedRepObjectInfos();
+
+            if (selectedRepObjectsInfos.Count == 0)
+                return null;
+
+            return (ChangesetExtendedInfo)selectedRepObjectsInfos[0];
+        }
+
+        internal static RepositorySpec GetSelectedRepository(
+            ChangesetsListView listView)
+        {
+            List<RepositorySpec> selectedRepositories = listView.GetSelectedRepositories();
+
+            if (selectedRepositories.Count == 0)
+                return null;
+
+            return selectedRepositories[0];
+        }
+    }
+}

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

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

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

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

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Changesets/ChangesetsTab_Operations.cs

@@ -0,0 +1,51 @@
+using UnityEditor;
+
+using Codice.CM.Common;
+using GluonGui.WorkspaceWindow.Views.WorkspaceExplorer.Explorer;
+using Unity.PlasticSCM.Editor.AssetUtils;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Views.Changesets
+{
+    internal partial class ChangesetsTab
+    {
+        void SwitchToChangesetForMode(bool isGluonMode)
+        {
+            if (isGluonMode)
+            {
+                SwitchToChangesetForGluon();
+                return;
+            }
+
+            SwitchToChangesetForDeveloper();
+        }
+
+        void SwitchToChangesetForDeveloper()
+        {
+            mChangesetOperations.SwitchToChangeset(
+                ChangesetsSelection.GetSelectedRepository(mChangesetsListView),
+                ChangesetsSelection.GetSelectedChangeset(mChangesetsListView),
+                RefreshAsset.BeforeLongAssetOperation,
+                RefreshAsset.AfterLongAssetOperation);
+        }
+
+        void SwitchToChangesetForGluon()
+        {
+            ChangesetExtendedInfo csetInfo = ChangesetsSelection.GetSelectedChangeset(mChangesetsListView);
+
+            SwitchToUIOperation.SwitchToChangeset(
+                mWkInfo,
+                csetInfo.BranchName,
+                csetInfo.ChangesetId,
+                mViewHost,
+                null,
+                new UnityPlasticGuiMessage(),
+                mProgressControls,
+                mWorkspaceWindow.GluonProgressOperationHandler,
+                mGluonUpdateReport,
+                mWorkspaceWindow,
+                RefreshAsset.BeforeLongAssetOperation,
+                RefreshAsset.AfterLongAssetOperation);
+        }
+    }
+}

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

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

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Changesets/ChangesetsViewMenu.cs

@@ -0,0 +1,369 @@
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.Common.EventTracking;
+using Codice.CM.Common;
+using PlasticGui.WorkspaceWindow.QueryViews.Changesets;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.Tool;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Views.Changesets
+{
+    internal class ChangesetsViewMenu
+    {
+        internal GenericMenu Menu { get { return mMenu; } }
+
+        public interface IMenuOperations
+        {
+            void DiffBranch();
+            ChangesetExtendedInfo GetSelectedChangeset();
+        }
+
+        internal ChangesetsViewMenu(
+            WorkspaceInfo wkInfo,
+            IChangesetMenuOperations changesetMenuOperations,
+            IMenuOperations menuOperations,
+            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
+            bool isGluonMode)
+        {
+            mWkInfo = wkInfo;
+            mChangesetMenuOperations = changesetMenuOperations;
+            mMenuOperations = menuOperations;
+            mShowDownloadPlasticExeWindow = showDownloadPlasticExeWindow;
+            mIsGluonMode = isGluonMode;
+            
+            BuildComponents();
+        }
+
+        internal void Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        internal bool ProcessKeyActionIfNeeded(Event e)
+        {
+            int selectedChangesetsCount = mChangesetMenuOperations.GetSelectedChangesetsCount();
+
+            ChangesetMenuOperations operationToExecute = GetMenuOperations(
+                e, selectedChangesetsCount > 1);
+
+            if (operationToExecute == ChangesetMenuOperations.None)
+                return false;
+
+            ChangesetMenuOperations operations = ChangesetMenuUpdater.GetAvailableMenuOperations(
+                selectedChangesetsCount,
+                mIsGluonMode,
+                mMenuOperations.GetSelectedChangeset().BranchId,
+                mLoadedBranchId,
+                false);
+
+            if (!operations.HasFlag(operationToExecute))
+                return false;
+
+            ProcessMenuOperation(operationToExecute, mChangesetMenuOperations);
+            return true;
+        }
+
+        internal void SetLoadedBranchId(long loadedBranchId)
+        {
+            mLoadedBranchId = loadedBranchId;
+        }
+
+        void DiffChangesetMenuItem_Click()
+        {
+            if (mShowDownloadPlasticExeWindow.Show(
+                   mWkInfo,
+                   mIsGluonMode,
+                   TrackFeatureUseEvent.Features.InstallPlasticCloudFromDiffChangeset,
+                   TrackFeatureUseEvent.Features.InstallPlasticEnterpriseFromDiffChangeset,
+                   TrackFeatureUseEvent.Features.CancelPlasticInstallationFromDiffChangeset))
+                return;
+
+            mChangesetMenuOperations.DiffChangeset();
+        }
+
+        void DiffSelectedChangesetsMenuItem_Click()
+        {
+            if (mShowDownloadPlasticExeWindow.Show(
+                    mWkInfo,
+                    mIsGluonMode,
+                    TrackFeatureUseEvent.Features.InstallPlasticCloudFromDiffSelectedChangesets,
+                    TrackFeatureUseEvent.Features.InstallPlasticEnterpriseFromDiffSelectedChangesets,
+                    TrackFeatureUseEvent.Features.CancelPlasticInstallationFromDiffSelectedChangesets))
+                return;
+
+            mChangesetMenuOperations.DiffSelectedChangesets();
+        }
+
+        void RevertToChangesetMenuItem_Click()
+        {
+            mChangesetMenuOperations.RevertToChangeset();
+        }
+
+        void DiffBranchMenuItem_Click()
+        {
+            mMenuOperations.DiffBranch();
+        }
+
+        void SwitchToChangesetMenuItem_Click()
+        {
+            mChangesetMenuOperations.SwitchToChangeset();
+        }
+
+        internal void UpdateMenuItems(GenericMenu menu)
+        {
+            ChangesetExtendedInfo singleSelectedChangeset = mMenuOperations.GetSelectedChangeset();
+
+            ChangesetMenuOperations operations = ChangesetMenuUpdater.GetAvailableMenuOperations(
+                mChangesetMenuOperations.GetSelectedChangesetsCount(),
+                mIsGluonMode,
+                singleSelectedChangeset.BranchId,
+                mLoadedBranchId,
+                false);
+
+            AddDiffChangesetMenuItem(
+                mDiffChangesetMenuItemContent,
+                menu,
+                singleSelectedChangeset,
+                operations,
+                DiffChangesetMenuItem_Click);
+
+            AddDiffSelectedChangesetsMenuItem(
+                mDiffSelectedChangesetsMenuItemContent,
+                menu,
+                operations,
+                DiffSelectedChangesetsMenuItem_Click);
+
+            if (!IsOnMainBranch(singleSelectedChangeset))
+            {
+                menu.AddSeparator(string.Empty);
+
+                AddDiffBranchMenuItem(
+                    mDiffBranchMenuItemContent,
+                    menu,
+                    singleSelectedChangeset,
+                    operations,
+                    DiffBranchMenuItem_Click);
+            }
+
+            menu.AddSeparator(string.Empty);
+
+            AddSwitchToChangesetMenuItem(
+                mSwitchToChangesetMenuItemContent,
+                menu,
+                operations,
+                SwitchToChangesetMenuItem_Click);
+
+            if (mIsGluonMode)
+                return;
+
+            AddBackToMenuItem(
+                   mRevertToChangesetMenuItemContent,
+                   menu,
+                   operations,
+                   RevertToChangesetMenuItem_Click);
+        }
+
+        void ProcessMenuOperation(
+            ChangesetMenuOperations operationToExecute,
+            IChangesetMenuOperations changesetMenuOperations)
+        {
+            if (operationToExecute == ChangesetMenuOperations.DiffChangeset)
+            {
+                DiffChangesetMenuItem_Click();
+                return;
+            }
+
+            if (operationToExecute == ChangesetMenuOperations.DiffSelectedChangesets)
+            {
+                DiffSelectedChangesetsMenuItem_Click();
+                return;
+            }
+        }
+
+        static void AddDiffChangesetMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            ChangesetExtendedInfo changeset,
+            ChangesetMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            string changesetName =
+                changeset != null ?
+                changeset.ChangesetId.ToString() :
+                string.Empty;
+
+            menuItemContent.text = string.Format("{0} {1}",
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.AnnotateDiffChangesetMenuItem,
+                        changesetName),
+                    GetPlasticShortcut.ForDiff());
+
+            if (operations.HasFlag(ChangesetMenuOperations.DiffChangeset))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+                return;
+            }
+
+            menu.AddDisabledItem(
+                menuItemContent);
+        }
+
+        static void AddDiffSelectedChangesetsMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            ChangesetMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(ChangesetMenuOperations.DiffSelectedChangesets))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static void AddBackToMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            ChangesetMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(ChangesetMenuOperations.RevertToChangeset))
+            {
+                menu.AddItem(
+                menuItemContent,
+                false,
+                menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static void AddDiffBranchMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            ChangesetExtendedInfo changeset,
+            ChangesetMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            string branchName = GetBranchName(changeset);
+
+            menuItemContent.text =
+                PlasticLocalization.GetString(PlasticLocalization.Name.AnnotateDiffBranchMenuItem,
+                branchName);
+
+            if (operations.HasFlag(ChangesetMenuOperations.DiffChangeset))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+                return;
+            }
+
+            menu.AddDisabledItem(
+                menuItemContent);
+        }
+
+        static void AddSwitchToChangesetMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            ChangesetMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(ChangesetMenuOperations.SwitchToChangeset))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }       
+
+        static string GetBranchName(ChangesetExtendedInfo changesetInfo)
+        {
+            if (changesetInfo == null)
+                return string.Empty;
+
+            string branchName = changesetInfo.BranchName;
+
+            int lastIndex = changesetInfo.BranchName.LastIndexOf("/");
+
+            if (lastIndex == -1)
+                return branchName;
+
+            return branchName.Substring(lastIndex + 1);
+        }
+
+        static bool IsOnMainBranch(ChangesetExtendedInfo singleSeletedChangeset)
+        {
+            if (singleSeletedChangeset == null)
+                return false;
+
+            return singleSeletedChangeset.BranchName == MAIN_BRANCH_NAME;
+        }
+
+        static ChangesetMenuOperations GetMenuOperations(
+            Event e, bool isMultipleSelection)
+        {
+            if (Keyboard.IsControlOrCommandKeyPressed(e) &&
+                Keyboard.IsKeyPressed(e, KeyCode.D))
+                return isMultipleSelection ?
+                    ChangesetMenuOperations.DiffSelectedChangesets :
+                    ChangesetMenuOperations.DiffChangeset;
+
+            return ChangesetMenuOperations.None;
+        }
+
+        void BuildComponents()
+        {
+            mDiffChangesetMenuItemContent = new GUIContent(string.Empty);
+            mDiffSelectedChangesetsMenuItemContent = new GUIContent(string.Format("{0} {1}",
+                PlasticLocalization.GetString(PlasticLocalization.Name.ChangesetMenuItemDiffSelected),
+                GetPlasticShortcut.ForDiff()));
+            mDiffBranchMenuItemContent = new GUIContent();
+            mSwitchToChangesetMenuItemContent = new GUIContent(
+                PlasticLocalization.GetString(PlasticLocalization.Name.ChangesetMenuItemSwitchToChangeset));
+            mRevertToChangesetMenuItemContent = new GUIContent(
+                PlasticLocalization.GetString(PlasticLocalization.Name.ChangesetMenuItemRevertToChangeset));
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mDiffChangesetMenuItemContent;
+        GUIContent mDiffSelectedChangesetsMenuItemContent;
+        GUIContent mDiffBranchMenuItemContent;
+        GUIContent mSwitchToChangesetMenuItemContent;
+        GUIContent mRevertToChangesetMenuItemContent;
+
+        readonly WorkspaceInfo mWkInfo;
+        readonly IChangesetMenuOperations mChangesetMenuOperations;
+        readonly IMenuOperations mMenuOperations;
+        readonly LaunchTool.IShowDownloadPlasticExeWindow mShowDownloadPlasticExeWindow;
+        readonly bool mIsGluonMode;
+
+        long mLoadedBranchId = -1;
+
+        const string MAIN_BRANCH_NAME = "/main";
+    }
+}

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

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

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Changesets/DateFilter.cs

@@ -0,0 +1,44 @@
+using System;
+using PlasticGui.WorkspaceWindow.QueryViews;
+
+namespace Unity.PlasticSCM.Editor.Views.Changesets
+{
+    internal class DateFilter
+    {
+        internal enum Type
+        {
+            LastWeek,
+            Last15Days,
+            LastMonth,
+            Last3Months,
+            LastYear,
+            AllTime
+        }
+
+        internal Type FilterType;
+
+        internal DateFilter(Type filterType)
+        {
+            FilterType = filterType;
+        }
+
+        internal string GetTimeAgo()
+        {
+            switch (FilterType)
+            {
+                case DateFilter.Type.LastWeek:
+                    return QueryConstants.OneWeekAgo;
+                case DateFilter.Type.Last15Days:
+                    return QueryConstants.HalfMonthAgo;
+                case DateFilter.Type.LastMonth:
+                    return QueryConstants.OneMonthAgo;
+                case DateFilter.Type.Last3Months:
+                    return QueryConstants.ThreeMonthsAgo;
+                case DateFilter.Type.LastYear:
+                    return QueryConstants.OneYearAgo;
+            }
+
+            return string.Empty;
+        }
+    }
+}

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

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

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Views/Changesets/LaunchDiffOperations.cs

@@ -0,0 +1,137 @@
+using Codice.CM.Common;
+using Unity.PlasticSCM.Editor.Tool;
+
+namespace Unity.PlasticSCM.Editor.Views.Changesets
+{
+    static class LaunchDiffOperations
+    {
+        internal static void DiffChangeset(
+            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
+            LaunchTool.IProcessExecutor processExecutor,
+            RepositorySpec repSpec,
+            long changesetId,
+            bool isGluonMode)
+        {
+            if (changesetId == -1)
+                return;
+
+            string changesetFullSpec = GetChangesetFullSpec(
+                repSpec, changesetId);
+
+            LaunchTool.OpenChangesetDiffs(
+                showDownloadPlasticExeWindow,
+                processExecutor,
+                repSpec,
+                changesetFullSpec,
+                isGluonMode);
+        }
+
+        internal static void DiffChangeset(
+            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
+            LaunchTool.IProcessExecutor processExecutor,
+            RepositorySpec repSpec,
+            ChangesetInfo changesetInfo,
+            bool isGluonMode)
+        {
+            if (changesetInfo == null)
+                return;
+
+            string changesetFullSpec = GetChangesetFullSpec(
+                repSpec, changesetInfo.ChangesetId);
+
+            LaunchTool.OpenChangesetDiffs(
+                showDownloadPlasticExeWindow,
+                processExecutor,
+                repSpec,
+                changesetFullSpec,
+                isGluonMode);
+        }
+
+        internal static void DiffSelectedChangesets(
+            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
+            LaunchTool.IProcessExecutor processExecutor,
+            RepositorySpec repSpec,
+            ChangesetInfo cset1,
+            ChangesetInfo cset2,
+            bool isGluonMode)
+        {
+            ChangesetInfo srcChangesetInfo;
+            ChangesetInfo dstChangesetInfo;
+
+            GetSrcAndDstCangesets(
+                cset1,
+                cset2,
+                out srcChangesetInfo,
+                out dstChangesetInfo);
+
+            string srcChangesetFullSpec = GetChangesetFullSpec(
+                repSpec, srcChangesetInfo.ChangesetId);
+
+            string dstChangesetFullSpec = GetChangesetFullSpec(
+                repSpec, dstChangesetInfo.ChangesetId);
+
+            LaunchTool.OpenSelectedChangesetsDiffs(
+                showDownloadPlasticExeWindow,
+                processExecutor,
+                repSpec,
+                srcChangesetFullSpec,
+                dstChangesetFullSpec,
+                isGluonMode);
+        }
+
+        internal static void DiffBranch(
+            LaunchTool.IShowDownloadPlasticExeWindow showDownloadPlasticExeWindow,
+            LaunchTool.IProcessExecutor processExecutor,
+            RepositorySpec repSpec,
+            ChangesetExtendedInfo changesetExtendedInfo,
+            bool isGluonMode)
+        {
+            if (changesetExtendedInfo == null)
+                return;
+
+            string branchFullSpec = GetBranchFullSpec(
+                repSpec, changesetExtendedInfo);
+
+            LaunchTool.OpenBranchDiffs(
+                showDownloadPlasticExeWindow,
+                processExecutor,
+                repSpec,
+                branchFullSpec,
+                isGluonMode);
+        }
+
+        static void GetSrcAndDstCangesets(
+            ChangesetInfo cset1,
+            ChangesetInfo cset2,
+            out ChangesetInfo srcChangesetInfo,
+            out ChangesetInfo dstChangesetInfo)
+        {
+            if (cset1.LocalTimeStamp < cset2.LocalTimeStamp)
+            {
+                srcChangesetInfo = cset1;
+                dstChangesetInfo = cset2;
+                return;
+            }
+
+            srcChangesetInfo = cset2;
+            dstChangesetInfo = cset1;
+        }
+
+        static string GetChangesetFullSpec(
+            RepositorySpec repSpec,
+            long changesetId)
+        {
+            return string.Format("cs:{0}@{1}",
+                changesetId, repSpec.ToString());
+        }
+
+        static string GetBranchFullSpec(
+            RepositorySpec repSpec,
+            ChangesetExtendedInfo changesetExtendedInfo)
+        {
+            return string.Format("br:{0}@{1}",
+                changesetExtendedInfo.BranchName,
+                repSpec.ToString());
+        }
+    }
+}

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

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