Created unity project

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/ChangeCategoryTreeViewItem.cs

@@ -0,0 +1,17 @@
+using UnityEditor.IMGUI.Controls;
+
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal class ChangeCategoryTreeViewItem : TreeViewItem
+    {
+        internal MergeChangesCategory Category { get; private set; }
+
+        internal ChangeCategoryTreeViewItem(int id, MergeChangesCategory category)
+            : base(id, 0, category.CategoryType.ToString())
+        {
+            Category = category;
+        }
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/ChangeCategoryTreeViewItem.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/ChangeTreeViewItem.cs

@@ -0,0 +1,19 @@
+using UnityEditor.IMGUI.Controls;
+
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal class ChangeTreeViewItem : TreeViewItem
+    {
+        internal MergeChangeInfo ChangeInfo { get; private set; }
+
+        internal ChangeTreeViewItem(int id, MergeChangeInfo change)
+            : base(id, 1)
+        {
+            ChangeInfo = change;
+
+            displayName = id.ToString();
+        }
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/ChangeTreeViewItem.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/AddMoveMenu.cs

@@ -0,0 +1,81 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class AddMoveMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal AddMoveMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewDestination_Click()
+        {
+            mMergeViewMenuOperations.OpenDstRevision();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void DiffSourceDestination_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithDestination();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            menu.AddItem(mViewSourceMenuItemContent, false, ViewSource_Click);
+
+            menu.AddItem(mViewDestinationMenuItemContent, false, ViewDestination_Click);
+
+            if (info.SelectedConflict.DirectoryConflict.SourceAndDestinationAreSameType())
+                menu.AddItem(mDiffSourceDestinationMenuItemContent, false, DiffSourceDestination_Click);
+        }
+
+        void BuildComponents()
+        {
+            mViewSourceMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.AddMoveConflictViewSource.GetString());
+
+            mViewDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.AddMoveConflictViewDestination.GetString());
+
+            mDiffSourceDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DiffSourceWithDestinationAddMove.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mViewSourceMenuItemContent;
+        GUIContent mViewDestinationMenuItemContent;
+        GUIContent mDiffSourceDestinationMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/AddMoveMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/ChangeDeleteMenu.cs

@@ -0,0 +1,93 @@
+using UnityEditor;
+using UnityEngine;
+
+using Codice.CM.Common.Merge;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class ChangeDeleteMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal ChangeDeleteMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewDestination_Click()
+        {
+            mMergeViewMenuOperations.OpenDstRevision();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void DiffSourcePrevious_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithAncestor();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            bool isAddedDeleted = IsAddedDeleted(info.SelectedConflict.DirectoryConflict);
+
+            if (!isAddedDeleted)
+                menu.AddItem(mDiffSourcePreviousMenuItemContent, false, DiffSourcePrevious_Click);
+
+            mViewSourceAddedMenuItemContent.text = isAddedDeleted ?
+                PlasticLocalization.Name.ChangeDeleteConflictViewSourceAdded.GetString() :
+                PlasticLocalization.Name.ChangeDeleteConflictViewSourceChanged.GetString();
+            menu.AddItem(mViewSourceAddedMenuItemContent, false, ViewSource_Click);
+
+            menu.AddItem(mViewDestinationMenuItemContent, false, ViewDestination_Click);
+        }
+
+        static bool IsAddedDeleted(DirectoryConflict conflict)
+        {
+            return ((ChangeDeleteConflict)conflict).Src.Status == Difference.DiffNodeStatus.Added;
+
+            // otherwise is modified - deleted
+        }
+
+        void BuildComponents()
+        {
+            mDiffSourcePreviousMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DiffSourceWithDestinationChangeDelete.GetString());
+
+            mViewSourceAddedMenuItemContent = new GUIContent();
+
+            mViewDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.ChangeDeleteConflictViewDestination.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mDiffSourcePreviousMenuItemContent;
+        GUIContent mViewSourceAddedMenuItemContent;
+        GUIContent mViewDestinationMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/ChangeDeleteMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/ConflictResolutionState.cs

@@ -0,0 +1,39 @@
+using Codice.Client.BaseCommands.Merge;
+using Codice.CM.Common.Merge;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class ConflictResolutionState
+    {
+        internal DirectoryConflictResolveActions ResolveAction { get; set; }
+        internal string RenameValue { get; set; }
+        internal bool IsApplyActionsForNextConflictsChecked { get; set; }
+
+        internal static ConflictResolutionState Build(
+            DirectoryConflict directoryConflict,
+            DirectoryConflictAction[] conflictActions)
+        {
+            bool hasRenameOption = DirectoryConflictResolutionInfo.HasRenameOption(
+                conflictActions);
+
+            ConflictResolutionState result = new ConflictResolutionState()
+            {
+                IsApplyActionsForNextConflictsChecked = false,
+                ResolveAction = (hasRenameOption) ?
+                    DirectoryConflictResolveActions.Rename :
+                    DirectoryConflictResolveActions.KeepSource,
+            };
+
+            if (!hasRenameOption)
+                return result;
+
+
+            result.RenameValue = DirectoryConflictResolutionInfo.GetProposeNewItemName(
+                directoryConflict, "dst");
+
+            return result;
+        }
+
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/ConflictResolutionState.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/CycleMoveMenu.cs

@@ -0,0 +1,81 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class CycleMoveMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal CycleMoveMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewDestination_Click()
+        {
+            mMergeViewMenuOperations.OpenDstRevision();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void DiffSourceDestination_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithDestination();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            menu.AddItem(mViewSourceMenuItemContent, false, ViewSource_Click);
+
+            menu.AddItem(mViewDestinationMenuItemContent, false, ViewDestination_Click);
+
+            if (info.SelectedConflict.DirectoryConflict.SourceAndDestinationAreSameType())
+                menu.AddItem(mDiffSourceDestinationMenuItemContent, false, DiffSourceDestination_Click);
+        }
+
+        void BuildComponents()
+        {
+            mViewSourceMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.CycleMoveConflictViewSource.GetString());
+
+            mViewDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.CycleMoveConflictViewDestination.GetString());
+
+            mDiffSourceDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DiffSourceWithDestinationCycleMove.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mViewSourceMenuItemContent;
+        GUIContent mViewDestinationMenuItemContent;
+        GUIContent mDiffSourceDestinationMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/CycleMoveMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/DeleteChangeMenu.cs

@@ -0,0 +1,93 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+using Codice.CM.Common.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class DeleteChangeMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal DeleteChangeMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewDestination_Click()
+        {
+            mMergeViewMenuOperations.OpenDstRevision();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void DiffDestinationPrevious_Click()
+        {
+            mMergeViewMenuOperations.DiffDestinationWithAncestor();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            bool isDeleteAdded = IsDeletedAdded(info.SelectedConflict.DirectoryConflict);
+
+            if (!isDeleteAdded)
+                menu.AddItem(mDiffDestinationPreviousMenuItemContent, false, DiffDestinationPrevious_Click);
+
+            menu.AddItem(mViewSourceAddedMenuItemContent, false, ViewSource_Click);
+
+            mViewDestinationMenuItemContent.text = isDeleteAdded ?
+                PlasticLocalization.Name.DeleteChangeConflictViewDestinationAdded.GetString() :
+                PlasticLocalization.Name.DeleteChangeConflictViewDestinationChanged.GetString();
+            menu.AddItem(mViewDestinationMenuItemContent, false, ViewDestination_Click);
+        }
+
+        static bool IsDeletedAdded(DirectoryConflict conflict)
+        {
+            return ((ChangeDeleteConflict)conflict).Dst.Status == Difference.DiffNodeStatus.Added;
+
+            // otherwise is delete - modified
+        }
+
+        void BuildComponents()
+        {
+            mDiffDestinationPreviousMenuItemContent = new GUIContent(
+                 PlasticLocalization.Name.DiffSourceWithDestinationDeleteChange.GetString());
+
+            mViewSourceAddedMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DeleteChangeConflictViewSource.GetString());
+
+            mViewDestinationMenuItemContent = new GUIContent();
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mDiffDestinationPreviousMenuItemContent;
+        GUIContent mViewSourceAddedMenuItemContent;
+        GUIContent mViewDestinationMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/DeleteChangeMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/DeleteMoveMenu.cs

@@ -0,0 +1,81 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class DeleteMoveMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal DeleteMoveMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewDestination_Click()
+        {
+            mMergeViewMenuOperations.OpenDstRevision();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void DiffSourceDestination_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithDestination();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            menu.AddItem(mViewSourceMenuItemContent, false, ViewSource_Click);
+
+            menu.AddItem(mViewDestinationMenuItemContent, false, ViewDestination_Click);
+
+            if (info.SelectedConflict.DirectoryConflict.SourceAndDestinationAreSameType())
+                menu.AddItem(mDiffSourceDestinationMenuItemContent, false, DiffSourceDestination_Click);
+        }
+
+        void BuildComponents()
+        {
+            mViewSourceMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DeleteMoveConflictViewSource.GetString());
+
+            mViewDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DeleteMoveConflictViewDestination.GetString());
+
+            mDiffSourceDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DiffSourceWithDestinationDeleteMove.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mViewSourceMenuItemContent;
+        GUIContent mViewDestinationMenuItemContent;
+        GUIContent mDiffSourceDestinationMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/DeleteMoveMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/DivergentMoveMenu.cs

@@ -0,0 +1,55 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class DivergentMoveMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal DivergentMoveMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            menu.AddItem(mViewSourceMenuItemContent, false, ViewSource_Click);
+        }
+
+        void BuildComponents()
+        {
+            mViewSourceMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DivergentMoveViewSource.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mViewSourceMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/DivergentMoveMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/DrawDirectoryResolutionPanel.cs

@@ -0,0 +1,260 @@
+using System;
+
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.BaseCommands.Merge;
+using Codice.CM.Common.Merge;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal static class DrawDirectoryResolutionPanel
+    {
+        internal static void ForConflict(
+            MergeChangeInfo conflict,
+            int pendingConflictsCount,
+            DirectoryConflictUserInfo conflictUserInfo,
+            DirectoryConflictAction[] actions,
+            Action<MergeChangeInfo> resolveConflictAction,
+            GUIContent validationLabel,
+            ref ConflictResolutionState state)
+        {
+            bool isResolveButtonEnabled;
+            string validationMessage = null;
+
+            GetValidationData(
+                conflict,
+                state,
+                out isResolveButtonEnabled,
+                out validationMessage);
+
+            GUILayout.Space(2);
+            DoHeader(
+                conflictUserInfo.ConflictTitle,
+                conflict,
+                resolveConflictAction,
+                isResolveButtonEnabled,
+                ref state);
+            DoConflictExplanation(conflictUserInfo.ConflictExplanation);
+            DoSourceAndDestinationLabels(
+                conflictUserInfo.SourceOperation,
+                conflictUserInfo.DestinationOperation);
+            DoResolutionOptions(
+                actions,
+                validationLabel,
+                validationMessage,
+                ref state);
+            DoApplyActionsForNextConflictsCheck(pendingConflictsCount, ref state);
+            GUILayout.Space(10);
+        }
+
+        static void DoHeader(
+            string conflictName,
+            MergeChangeInfo conflict,
+            Action<MergeChangeInfo> resolveConflictAction,
+            bool isResolveButtonEnabled,
+            ref ConflictResolutionState state)
+        {
+            EditorGUILayout.BeginHorizontal();
+
+            GUILayout.Label(conflictName,
+                UnityStyles.DirectoryConflicts.TitleLabel);
+
+            GUI.enabled = isResolveButtonEnabled;
+
+            GUILayout.Space(5);
+
+            if (GUILayout.Button(PlasticLocalization.GetString(
+                PlasticLocalization.Name.ResolveDirectoryConflict)))
+            {
+                resolveConflictAction(conflict);
+            }
+
+            GUI.enabled = true;
+
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+        }
+
+        static void DoConflictExplanation(string explanation)
+        {
+            GUILayout.Space(5);
+            GUILayout.Label(explanation, EditorStyles.wordWrappedLabel);
+        }
+
+        static void DoSourceAndDestinationLabels(
+            string sourceOperation,
+            string destinationOperation)
+        {
+            GUILayout.Space(5);
+
+            GUIStyle boldLabelStyle = UnityStyles.DirectoryConflicts.BoldLabel;
+
+            GUIContent srcLabel = new GUIContent(
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.Source));
+
+            GUIContent dstLabel = new GUIContent(
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.Destination));
+
+            float maxWidth = GetMaxWidth(srcLabel, dstLabel, boldLabelStyle);
+
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.Space(25);
+            GUILayout.Label(srcLabel, boldLabelStyle, GUILayout.Width(maxWidth));
+            GUILayout.Label(sourceOperation, EditorStyles.label);
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.Space(25);
+            GUILayout.Label(dstLabel, boldLabelStyle, GUILayout.Width(maxWidth));
+            GUILayout.Label(destinationOperation, EditorStyles.label);
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+        }
+
+        static void DoResolutionOptions(
+            DirectoryConflictAction[] actions,
+            GUIContent validationLabel,
+            string validationMessage,
+            ref ConflictResolutionState state)
+        {
+            GUILayout.Space(10);
+            GUILayout.Label(PlasticLocalization.GetString(
+                PlasticLocalization.Name.ResolveDirectoryConflictChooseOption));
+
+            foreach (DirectoryConflictAction action in actions)
+            {
+                EditorGUILayout.BeginHorizontal();
+                GUILayout.Space(25);
+                if (GUILayout.Toggle(
+                    state.ResolveAction == action.ActionKind,
+                    action.ActionText,
+                    EditorStyles.radioButton))
+                {
+                    state.ResolveAction = action.ActionKind;
+                }
+
+                if (action.ActionKind == DirectoryConflictResolveActions.Rename)
+                {
+                    GUI.enabled = state.ResolveAction == DirectoryConflictResolveActions.Rename;
+                    state.RenameValue = GUILayout.TextField(
+                        state.RenameValue,
+                        UnityStyles.DirectoryConflicts.FileNameTextField,
+                        GUILayout.Width(250));
+                    GUI.enabled = true;
+
+                    if (!string.IsNullOrEmpty(validationMessage))
+                    {
+                        validationLabel.text = validationMessage;
+
+                        GUILayout.Label(
+                            validationLabel,
+                            UnityStyles.DirectoryConflictResolution.WarningLabel,
+                            GUILayout.Height(UnityConstants.DIR_CONFLICT_VALIDATION_WARNING_LABEL_HEIGHT));
+                    }
+                }
+
+                GUILayout.FlexibleSpace();
+                EditorGUILayout.EndHorizontal();
+            }
+        }
+
+        static void DoApplyActionsForNextConflictsCheck(
+            int pendingConflictsCount,
+            ref ConflictResolutionState state)
+        {
+            if (pendingConflictsCount == 0)
+                return;
+
+            GUILayout.Space(5);
+
+            bool isCheckEnabled = state.ResolveAction != DirectoryConflictResolveActions.Rename;
+            bool isChecked = state.IsApplyActionsForNextConflictsChecked & isCheckEnabled;
+
+            GUI.enabled = isCheckEnabled;
+            EditorGUILayout.BeginHorizontal();
+
+            state.IsApplyActionsForNextConflictsChecked = !GUILayout.Toggle(
+                isChecked,
+                GetApplyActionCheckButtonText(pendingConflictsCount));
+
+            if (!isCheckEnabled)
+                state.IsApplyActionsForNextConflictsChecked = false;
+
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+            GUI.enabled = true;
+        }
+
+        static bool IsValidName(
+            string name,
+            DirectoryConflict conflict,
+            out string errorMessage)
+        {
+            if (string.IsNullOrEmpty(name))
+            {
+                errorMessage = PlasticLocalization.GetString(
+                    PlasticLocalization.Name.InputItemNameMessage);
+                return false;
+            }
+
+            if (name == DirectoryConflictResolutionInfo.GetOldItemName(conflict))
+            {
+                errorMessage = PlasticLocalization.GetString(
+                    PlasticLocalization.Name.ProvideDifferentItemNameForRenameResolution);
+                return false;
+            }
+
+            errorMessage = null;
+            return true;
+        }
+
+        internal static void GetValidationData(
+            MergeChangeInfo conflict,
+            ConflictResolutionState state,
+            out bool isResolveButtonEnabled,
+            out string renameWarningMessage)
+        {
+            if (state.ResolveAction != DirectoryConflictResolveActions.Rename)
+            {
+                renameWarningMessage = string.Empty;
+                isResolveButtonEnabled = true;
+                return;
+            }
+
+            isResolveButtonEnabled = IsValidName(
+                state.RenameValue,
+                conflict.DirectoryConflict,
+                out renameWarningMessage);
+        }
+
+        static float GetMaxWidth(
+            GUIContent label1,
+            GUIContent label2,
+            GUIStyle style)
+        {
+            Vector2 srcLabelSize = style.CalcSize(label1);
+            Vector2 dstLabelSize = style.CalcSize(label2);
+
+            return Math.Max(srcLabelSize.x, dstLabelSize.x);
+        }
+
+        static string GetApplyActionCheckButtonText(int pendingConflictsCount)
+        {
+            if (pendingConflictsCount > 1)
+                return PlasticLocalization.GetString(
+                    PlasticLocalization.Name.ApplyActionForNextConflictsCheckButtonSingular,
+                    pendingConflictsCount);
+
+            return PlasticLocalization.GetString(
+                PlasticLocalization.Name.ApplyActionForNextConflictsCheckButtonPlural,
+                pendingConflictsCount);
+        }
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/DrawDirectoryResolutionPanel.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/EvilTwinMenu.cs

@@ -0,0 +1,81 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class EvilTwinMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal EvilTwinMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewDestination_Click()
+        {
+            mMergeViewMenuOperations.OpenDstRevision();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void DiffSourceDestination_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithDestination();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            menu.AddItem(mViewSourceMenuItemContent, false, ViewSource_Click);
+
+            menu.AddItem(mViewDestinationMenuItemContent, false, ViewDestination_Click);
+
+            if (info.SelectedConflict.DirectoryConflict.SourceAndDestinationAreSameType())
+                menu.AddItem(mDiffSourceDestinationMenuItemContent, false, DiffSourceDestination_Click);
+        }
+
+        void BuildComponents()
+        {
+            mViewSourceMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.EvilTwinsConflictViewSource.GetString());
+
+            mViewDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.EvilTwinsConflictViewDestination.GetString());
+
+            mDiffSourceDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DiffSourceWithDestinationEvilTwin.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mViewSourceMenuItemContent;
+        GUIContent mViewDestinationMenuItemContent;
+        GUIContent mDiffSourceDestinationMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/EvilTwinMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/LoadedTwiceMenu.cs

@@ -0,0 +1,55 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class LoadedTwiceMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal LoadedTwiceMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            menu.AddItem(mViewSourceMenuItemContent, false, ViewSource_Click);
+        }
+
+        void BuildComponents()
+        {
+            mViewSourceMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.LoadedTwiceViewSource.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mViewSourceMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/LoadedTwiceMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/MergeViewDirectoryConflictMenu.cs

@@ -0,0 +1,190 @@
+using UnityEditor;
+
+using Codice.CM.Common.Merge;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class MergeViewDirectoryConflictMenu
+    {
+        internal interface IDirectoryConflictMenu
+        {
+            GenericMenu Menu { get; }
+            void Popup();
+        }
+
+        internal GenericMenu Menu { get { return mDirectoryConflictMenu != null ? mDirectoryConflictMenu.Menu : null; } }
+
+        internal MergeViewDirectoryConflictMenu(IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+        }
+
+        internal void Popup()
+        {
+            mDirectoryConflictMenu = GetMenu();
+
+            if (mDirectoryConflictMenu == null)
+                return;
+
+            mDirectoryConflictMenu.Popup();
+        }
+
+        IDirectoryConflictMenu GetMenu()
+        {
+            DirectoryConflict conflict = mMergeViewMenuOperations.
+                GetSelectedMergeChangesGroupInfo().SelectedConflict.DirectoryConflict;
+
+            if (conflict is AddMoveConflict)
+            {
+                AddMoveConflict addMove = conflict as AddMoveConflict;
+
+                return addMove.IsAddMove ? 
+                    GetAddMoveMenu() :
+                    GetMoveAddMenu();
+            }
+
+            if (conflict is ChangeDeleteConflict)
+            {
+                ChangeDeleteConflict changeDelete = conflict as ChangeDeleteConflict;
+
+                return changeDelete.IsChangeDelete ? 
+                    GetChangeDeletetMenu() :
+                    GetDeleteChangeMenu();
+            }
+
+            if (conflict is MoveDeleteConflict)
+            {
+                MoveDeleteConflict moveDelete = conflict as MoveDeleteConflict;
+
+                return moveDelete.IsMoveDelete ?
+                    GetMoveDeleteMenu() :
+                    GetDeleteMoveMenu();
+            }
+
+            if (conflict is EvilTwinConflict)
+            {
+                EvilTwinConflict evilTwin = conflict as EvilTwinConflict;
+
+                return evilTwin.IsMovedEvilTwin ?
+                    GetMovedEvilTwinMenu() :
+                    GetEvilTwinMenu();
+            }
+
+            if (conflict is CycleMoveConflict)
+                return GetCycleMoveMenu();
+
+            if (conflict is DivergentMoveConflict)
+                return GetDivergentMoveMenu();
+
+            if (conflict is LoadedTwiceConflict)
+                return GetLoadedTwiceMenu();
+
+            return null;
+        }
+
+        IDirectoryConflictMenu GetAddMoveMenu()
+        {
+            if (mAddMoveMenu == null)
+                mAddMoveMenu = new AddMoveMenu(mMergeViewMenuOperations);
+
+            return mAddMoveMenu;
+        }
+
+        IDirectoryConflictMenu GetChangeDeletetMenu()
+        {
+            if (mChangeDeleteMenu == null)
+                mChangeDeleteMenu = new ChangeDeleteMenu(mMergeViewMenuOperations);
+
+            return mChangeDeleteMenu;
+        }
+
+        IDirectoryConflictMenu GetCycleMoveMenu()
+        {
+            if (mCycleMoveMenu == null)
+                mCycleMoveMenu = new CycleMoveMenu(mMergeViewMenuOperations);
+
+            return mCycleMoveMenu;
+        }
+
+        IDirectoryConflictMenu GetDeleteChangeMenu()
+        {
+            if (mDeleteChangeMenu == null)
+                mDeleteChangeMenu = new DeleteChangeMenu(mMergeViewMenuOperations);
+
+            return mDeleteChangeMenu;
+        }
+
+        IDirectoryConflictMenu GetDeleteMoveMenu()
+        {
+            if (mDeleteMoveMenu == null)
+                mDeleteMoveMenu = new DeleteMoveMenu(mMergeViewMenuOperations);
+
+            return mDeleteMoveMenu;
+        }
+
+        IDirectoryConflictMenu GetDivergentMoveMenu()
+        {
+            if (mDivergentMoveMenu == null)
+                mDivergentMoveMenu = new DivergentMoveMenu(mMergeViewMenuOperations);
+
+            return mDivergentMoveMenu;
+        }
+
+        IDirectoryConflictMenu GetEvilTwinMenu()
+        {
+            if (mEvilTwinMenu == null)
+                mEvilTwinMenu = new EvilTwinMenu(mMergeViewMenuOperations);
+
+            return mEvilTwinMenu;
+        }
+
+        IDirectoryConflictMenu GetLoadedTwiceMenu()
+        {
+            if (mLoadedTwiceMenu == null)
+                 mLoadedTwiceMenu = new LoadedTwiceMenu(mMergeViewMenuOperations);
+ 
+            return mLoadedTwiceMenu;
+        }
+
+        IDirectoryConflictMenu GetMoveAddMenu()
+        {
+            if (mMoveAddMenu == null)
+                mMoveAddMenu = new MoveAddMenu(mMergeViewMenuOperations);
+
+            return mMoveAddMenu;
+        }
+
+        IDirectoryConflictMenu GetMoveDeleteMenu()
+        {
+            if (mMoveDeleteMenu == null)
+                mMoveDeleteMenu = new MoveDeleteMenu(mMergeViewMenuOperations);
+
+            return mMoveDeleteMenu;
+        }
+
+        IDirectoryConflictMenu GetMovedEvilTwinMenu()
+        {
+            if (mMovedEvilTwinMenu == null)
+                mMovedEvilTwinMenu = new MovedEvilTwinMenu(mMergeViewMenuOperations);
+
+            return mMovedEvilTwinMenu;
+        }
+
+        IDirectoryConflictMenu mDirectoryConflictMenu;
+
+        AddMoveMenu mAddMoveMenu;
+        ChangeDeleteMenu mChangeDeleteMenu;
+        CycleMoveMenu mCycleMoveMenu;
+        DeleteChangeMenu mDeleteChangeMenu;
+        DeleteMoveMenu mDeleteMoveMenu;
+        DivergentMoveMenu mDivergentMoveMenu;
+        EvilTwinMenu mEvilTwinMenu;
+        LoadedTwiceMenu mLoadedTwiceMenu;
+        MoveAddMenu mMoveAddMenu;
+        MoveDeleteMenu mMoveDeleteMenu;
+        MovedEvilTwinMenu mMovedEvilTwinMenu;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/MergeViewDirectoryConflictMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/MoveAddMenu.cs

@@ -0,0 +1,81 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class MoveAddMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal MoveAddMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewDestination_Click()
+        {
+            mMergeViewMenuOperations.OpenDstRevision();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void DiffSourceDestination_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithDestination();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            menu.AddItem(mViewSourceMenuItemContent, false, ViewSource_Click);
+
+            menu.AddItem(mViewDestinationMenuItemContent, false, ViewDestination_Click);
+
+            if (info.SelectedConflict.DirectoryConflict.SourceAndDestinationAreSameType())
+                menu.AddItem(mDiffSourceDestinationMenuItemContent, false, DiffSourceDestination_Click);
+        }
+
+        void BuildComponents()
+        {
+            mViewSourceMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.MoveAddConflictViewSource.GetString());
+
+            mViewDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.MoveAddConflictViewDestination.GetString());
+
+            mDiffSourceDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DiffSourceWithDestinationMoveAdd.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mViewSourceMenuItemContent;
+        GUIContent mViewDestinationMenuItemContent;
+        GUIContent mDiffSourceDestinationMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/MoveAddMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/MoveDeleteMenu.cs

@@ -0,0 +1,81 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class MoveDeleteMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal MoveDeleteMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewDestination_Click()
+        {
+            mMergeViewMenuOperations.OpenDstRevision();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void DiffSourceDestination_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithDestination();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            menu.AddItem(mViewSourceMenuItemContent, false, ViewSource_Click);
+
+            menu.AddItem(mViewDestinationMenuItemContent, false, ViewDestination_Click);
+
+            if (info.SelectedConflict.DirectoryConflict.SourceAndDestinationAreSameType())
+                menu.AddItem(mDiffSourceDestinationMenuItemContent, false, DiffSourceDestination_Click);
+        }
+
+        void BuildComponents()
+        {
+            mViewSourceMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.MoveDeleteConflictViewSource.GetString());
+
+            mViewDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.MoveDeleteConflictViewDestination.GetString());
+
+            mDiffSourceDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DiffSourceWithDestinationMoveDelete.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mViewSourceMenuItemContent;
+        GUIContent mViewDestinationMenuItemContent;
+        GUIContent mDiffSourceDestinationMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/MoveDeleteMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/MovedEvilTwinMenu.cs

@@ -0,0 +1,81 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts
+{
+    internal class MovedEvilTwinMenu : MergeViewDirectoryConflictMenu.IDirectoryConflictMenu
+    {
+        internal MovedEvilTwinMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+
+            BuildComponents();
+        }
+
+        GenericMenu MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Menu
+        {
+            get { return mMenu; }
+        }
+
+        void MergeViewDirectoryConflictMenu.IDirectoryConflictMenu.Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        void ViewDestination_Click()
+        {
+            mMergeViewMenuOperations.OpenDstRevision();
+        }
+
+        void ViewSource_Click()
+        {
+            mMergeViewMenuOperations.OpenSrcRevision();
+        }
+
+        void DiffSourceDestination_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithDestination();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            menu.AddItem(mViewSourceMenuItemContent, false, ViewSource_Click);
+
+            menu.AddItem(mViewDestinationMenuItemContent, false, ViewDestination_Click);
+
+            if (info.SelectedConflict.DirectoryConflict.SourceAndDestinationAreSameType())
+                menu.AddItem(mDiffSourceDestinationMenuItemContent, false, DiffSourceDestination_Click);
+        }
+
+        void BuildComponents()
+        {
+            mViewSourceMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.MovedEvilConflictViewSource.GetString());
+
+            mViewDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.MovedEvilConflictViewDestination.GetString());
+
+            mDiffSourceDestinationMenuItemContent = new GUIContent(
+                PlasticLocalization.Name.DiffSourceWithDestinationMoveEvilTwin.GetString());
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mViewSourceMenuItemContent;
+        GUIContent mViewDestinationMenuItemContent;
+        GUIContent mDiffSourceDestinationMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/DirectoryConflicts/MovedEvilTwinMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/IsCurrent.cs

@@ -0,0 +1,37 @@
+using Codice.Client.BaseCommands.Merge;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    // internal for testing purpuses
+    internal static class IsCurrent
+    {
+        internal static bool Conflict(
+            MergeChangeInfo changeInfo,
+            MergeChangeInfo metaChangeInfo,
+            MergeSolvedFileConflicts solvedFileConflicts)
+        {
+            if (solvedFileConflicts == null)
+                return false;
+
+            MergeSolvedFileConflicts.CurrentConflict currentConflict;
+
+            if (!solvedFileConflicts.TryGetCurrentConflict(out currentConflict))
+                return false;
+
+            return IsSameConflict(currentConflict, changeInfo) ||
+                   IsSameConflict(currentConflict, metaChangeInfo);
+        }
+
+        static bool IsSameConflict(
+            MergeSolvedFileConflicts.CurrentConflict currentConflict,
+            MergeChangeInfo changeInfo)
+        {
+            if (changeInfo == null)
+                return false;
+
+            return currentConflict.MountId.Equals(changeInfo.GetMount().Id)
+                && currentConflict.ItemId == changeInfo.GetRevision().ItemId;
+        }
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/IsCurrent.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/IsResolved.cs

@@ -0,0 +1,54 @@
+using Codice.Client.BaseCommands.Merge;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal static class IsSolved
+    {
+        internal static bool Conflict(
+            MergeChangeInfo changeInfo,
+            MergeChangeInfo metaChangeInfo,
+            MergeSolvedFileConflicts solvedFileConflicts)
+        {
+            if (IsDirectoryConflict(changeInfo))
+            {
+                if (metaChangeInfo == null)
+                    return IsDirectoryConflictResolved(changeInfo);
+
+                return IsDirectoryConflictResolved(changeInfo) &&
+                       IsDirectoryConflictResolved(metaChangeInfo);
+            }
+
+            if (metaChangeInfo == null)
+            {
+                return IsFileConflictResolved(
+                    changeInfo, solvedFileConflicts);
+            }
+
+            return IsFileConflictResolved(changeInfo, solvedFileConflicts) && 
+                   IsFileConflictResolved(metaChangeInfo, solvedFileConflicts);
+        }
+
+        static bool IsFileConflictResolved(
+            MergeChangeInfo changeInfo,
+            MergeSolvedFileConflicts solvedFileConflicts)
+        {
+            if (solvedFileConflicts == null)
+                return false;
+
+            return solvedFileConflicts.IsResolved(
+                changeInfo.GetMount().Id,
+                changeInfo.GetRevision().ItemId);
+        }
+
+        static bool IsDirectoryConflictResolved(MergeChangeInfo changeInfo)
+        {
+            return changeInfo.DirectoryConflict.IsResolved();
+        }
+
+        static bool IsDirectoryConflict(MergeChangeInfo changeInfo)
+        {
+            return (changeInfo.DirectoryConflict != null);
+        }
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/IsResolved.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeOptionsDialog.cs

@@ -0,0 +1,457 @@
+using System;
+
+using Codice.Client.Commands;
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.Common;
+using Codice.CM.Client.Differences.Merge;
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Progress;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal class MergeOptionsDialog : PlasticDialog
+    {
+        internal bool MergeBothRadioToggleIsChecked { get { return mMergeBothRadioToggle; } }
+        internal bool MergeFromDestinationRadioToggleIsChecked { get { return mMergeFromDestinationRadioToggle; } }
+        internal bool MergeFromSourceRadioToggleIsChecked { get { return mMergeFromSourceRadioToggle; } }
+        internal bool OnlyOneRadioToggleIsChecked { get { return mOnlyOneRadioToggle; } }
+        internal bool ForcedRadioToggleIsChecked { get { return mForcedRadioToggle; } }
+        internal bool IgnoreMergeTrackingToggleIsChecked
+        {
+            get { return mIgnoreMergeTrackingToggle; }
+            set { mIgnoreMergeTrackingToggle = value; }
+        }
+        internal bool AutomaticAncestorRadioToggleIsChecked { get { return mAutomaticAncestorRadioToggle; } }
+        internal bool ManualAncestorRadioToggleIsChecked { get { return mManualAncestorRadioToggle; } }
+        internal string AncestorTextField { set { mAncestorTextField = value; } }
+
+        internal static bool MergeOptions(MergeDialogParameters mergeDialogParameters)
+        {
+            MergeOptionsDialog dialog = Create(
+                mergeDialogParameters,
+                new ProgressControlsForDialogs());
+
+            dialog.SetMergeOptions();
+
+            return dialog.RunModal(focusedWindow) == ResponseType.Ok;
+        }
+
+        internal static MergeOptionsDialog MergeOptionsForTesting(MergeDialogParameters mergeDialogParameters)
+        {
+            MergeOptionsDialog dialog = Create(
+                mergeDialogParameters,
+                new ProgressControlsForDialogs());
+
+            dialog.SetMergeOptions();
+            return dialog;
+        }
+
+        protected override Rect DefaultRect
+        {
+            get
+            {
+                var baseRect = base.DefaultRect;
+                return new Rect(baseRect.x, baseRect.y, 600, 450);
+            }
+        }
+
+        protected override string GetTitle()
+        {
+            return PlasticLocalization.GetString(
+                PlasticLocalization.Name.MergeOptionsTitle);
+        }
+
+        protected override void OnModalGUI()
+        {
+            GUILayout.Label(
+                PlasticLocalization.Name.MergeOptionsTitle.GetString(),
+                UnityStyles.Dialog.MessageTitle);
+
+            GUILayout.Label(
+                PlasticLocalization.Name.MergeOptionsExplanation.GetString(),
+                UnityStyles.Paragraph);
+
+            DrawSection(
+                PlasticLocalization.Name.MergeOptionsContributorsTitle.GetString(),
+                DoMergeContributorsArea);
+
+            DrawSection(
+                PlasticLocalization.Name.ConflictResolutionTitle.GetString(),
+                DoMergeConflictResolutionArea);
+
+            DrawSection(
+                PlasticLocalization.Name.MergeOptionSkipMergeTrackingTitle.GetString(),
+                DoSkipMergeTrackingArea);
+
+            DrawSection(
+                PlasticLocalization.Name.MergeOptionAdvancedTitle.GetString(),
+                DoAdvancedArea);
+
+            DrawProgressForDialogs.For(
+                mProgressControls.ProgressData);
+
+            DoButtonsArea();
+
+            mProgressControls.ForcedUpdateProgress(this);
+        }
+
+        void DoMergeContributorsArea()
+        {
+            if (GUILayout.Toggle(
+                    mMergeBothRadioToggle,
+                    PlasticLocalization.Name.MergeOptionBoth.GetString(),
+                    UnityStyles.Dialog.RadioToggle))
+            {
+                CheckMergeBothRadioToggle();
+            }
+
+            GUI.enabled = mParameters.IsRegularMerge();
+
+            if (GUILayout.Toggle(
+                    mMergeFromDestinationRadioToggle,
+                    PlasticLocalization.Name.MergeOptionFromDestination.GetString(),
+                    UnityStyles.Dialog.RadioToggle))
+            {
+                CheckMergeFromDestinationRadioToggle();
+            }
+
+            if (GUILayout.Toggle(
+                    mMergeFromSourceRadioToggle,
+                    PlasticLocalization.Name.MergeOptionFromSource.GetString(),
+                    UnityStyles.Dialog.RadioToggle))
+            {
+                CheckMergeFromSourceRadioToggle();
+            }
+
+            GUI.enabled = true;
+        }
+
+        internal void CheckMergeBothRadioToggle()
+        {
+            mMergeBothRadioToggle = true;
+            mMergeFromDestinationRadioToggle = false;
+            mMergeFromSourceRadioToggle = false;
+        }
+
+        internal void CheckMergeFromDestinationRadioToggle()
+        {
+            mMergeBothRadioToggle = false;
+            mMergeFromDestinationRadioToggle = true;
+            mMergeFromSourceRadioToggle = false;
+        }
+
+        internal void CheckMergeFromSourceRadioToggle()
+        {
+            mMergeBothRadioToggle = false;
+            mMergeFromDestinationRadioToggle = false;
+            mMergeFromSourceRadioToggle = true;
+        }
+
+        void DoMergeConflictResolutionArea()
+        {
+            if (GUILayout.Toggle(
+                mOnlyOneRadioToggle,
+                Styles.ManualConflictResolution,
+                UnityStyles.Dialog.RadioToggle))
+            {
+                CheckOnlyOneRadioToggle();
+            }
+
+            if (GUILayout.Toggle(
+                mForcedRadioToggle,
+                Styles.AutomaticConflictResolution,
+                UnityStyles.Dialog.RadioToggle))
+            {
+                CheckForcedRadioToggle();
+            }
+        }
+
+        internal void CheckOnlyOneRadioToggle()
+        {
+            mOnlyOneRadioToggle = true;
+            mForcedRadioToggle = false;
+        }
+
+        internal void CheckForcedRadioToggle()
+        {
+            mOnlyOneRadioToggle = false;
+            mForcedRadioToggle = true;
+        }
+
+        void DoSkipMergeTrackingArea()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUI.enabled = !mParameters.IsRegularMerge();
+
+                mIgnoreMergeTrackingToggle = GUILayout.Toggle(
+                    mIgnoreMergeTrackingToggle,
+                    PlasticLocalization.Name.MergeOptionSkipMergeTrackingExplanation.GetString(),
+                    UnityStyles.Dialog.CheckBox);
+
+                GUI.enabled = true;
+
+                if (GUILayout.Button(Images.GetInfoIcon(), UnityStyles.Dialog.FlatButton))
+                {
+                    ShowSkipMergeTrackingHelp();
+                }
+
+                GUILayout.FlexibleSpace();
+            }
+        }
+
+        void ShowSkipMergeTrackingHelp()
+        {
+            GuiMessage.ShowInformation(
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.MergeOptionSkipMergeTrackingHelpTitle),
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.MergeOptionSkipMergeTrackingHelp));
+        }
+
+        void DoAdvancedArea()
+        {
+            GUI.enabled = mParameters.IsRegularMerge();
+
+            if (GUILayout.Toggle(
+                    mAutomaticAncestorRadioToggle,
+                    PlasticLocalization.Name.MergeOptionAutomaticCalculateAncestor.GetString(),
+                    UnityStyles.Dialog.RadioToggle))
+            {
+                CheckAutomaticAncestorRadioToggle();
+            }
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                if (GUILayout.Toggle(
+                        mManualAncestorRadioToggle,
+                        PlasticLocalization.Name.MergeOptionManualSpecifyAncestor.GetString(),
+                        UnityStyles.Dialog.RadioToggle))
+                {
+                    CheckManualAncestorRadioToggle();
+                }
+
+                GUI.enabled = mParameters.IsRegularMerge() && mManualAncestorRadioToggle;
+
+                GUILayout.Space(5);
+
+                mAncestorTextField = GUILayout.TextField(mAncestorTextField, GUILayout.Width(90));
+
+                if (mManualAncestorRadioToggle)
+                {
+                    GUILayout.Label(PlasticLocalization.Name.
+                        MergeOptionManualSpecifyAncestorExample.GetString());
+                }
+
+                GUILayout.FlexibleSpace();
+            }
+
+            GUI.enabled = true;
+        }
+
+        internal void CheckAutomaticAncestorRadioToggle()
+        {
+            mAutomaticAncestorRadioToggle = true;
+            mManualAncestorRadioToggle = false;
+        }
+
+        internal void CheckManualAncestorRadioToggle()
+        {
+            mAutomaticAncestorRadioToggle = false;
+            mManualAncestorRadioToggle = true;
+        }
+
+        void DoButtonsArea()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+
+                if (Application.platform == RuntimePlatform.WindowsEditor)
+                {
+                    DoSaveButton();
+                    DoCancelButton();
+                    return;
+                }
+
+                DoCancelButton();
+                DoSaveButton();
+            }
+        }
+
+        void DoSaveButton()
+        {
+            if (!AcceptButton(PlasticLocalization.Name.SaveButton.GetString()))
+                return;
+
+            OkButtonWithValidationAction();
+        }
+
+        void DoCancelButton()
+        {
+            if (!NormalButton(PlasticLocalization.Name.CancelButton.GetString()))
+                return;
+
+            CancelButtonAction();
+        }
+
+        void SetMergeOptions()
+        {
+            if (mParameters.Options == null)
+                return;
+
+            MergeDialogOptions mergeOptions = mParameters.Options;
+
+            SetMergeContributorOptions(mergeOptions);
+            SetSkipMergeTrackingOptions(mergeOptions);
+            SetConflictResolutionOptions(mergeOptions);
+            SetResolutionStrategyOptions(mParameters);
+        }
+
+        void SetMergeContributorOptions(MergeDialogOptions mergeOptions)
+        {
+            switch (mergeOptions.Contributor)
+            {
+                case MergeContributorType.MergeContributors:
+                {
+                    mMergeBothRadioToggle = true;
+                    break;
+                }
+                case MergeContributorType.KeepDestination:
+                {
+                    mMergeFromDestinationRadioToggle = true;
+                    break;
+                }
+                case MergeContributorType.KeepSource:
+                {
+                    mMergeFromSourceRadioToggle = true;
+                    break;
+                }
+            }
+        }
+
+        void SetSkipMergeTrackingOptions(MergeDialogOptions mergeOptions)
+        {
+            mIgnoreMergeTrackingToggle = mergeOptions.IgnoreMergeTracking;
+        }
+
+        void SetConflictResolutionOptions(MergeDialogOptions mergeOptions)
+        {
+            switch (mergeOptions.ResolutionType)
+            {
+                case MergeResolutionType.OnlyOne:
+                {
+                    mOnlyOneRadioToggle = true;
+                    break;
+                }
+                default:
+                {
+                    mForcedRadioToggle = true;
+                    break;
+                }
+            }
+        }
+
+        void SetResolutionStrategyOptions(MergeDialogParameters parameters)
+        {
+            if (parameters.Strategy == MergeStrategy.Manual && parameters.AncestorSpec != null)
+            {
+                mManualAncestorRadioToggle = true;
+                mAncestorTextField = parameters.AncestorSpec.csNumber.ToString();
+            }
+            else
+            {
+                mAutomaticAncestorRadioToggle = true;
+            }
+        }
+
+        internal void OkButtonWithValidationAction()
+        {
+            mParameters.SaveParameters(
+                mMergeBothRadioToggle,
+                mMergeFromDestinationRadioToggle,
+                mMergeFromSourceRadioToggle,
+                mIgnoreMergeTrackingToggle,
+                mOnlyOneRadioToggle,
+                mAutomaticAncestorRadioToggle);
+
+            if (mParameters.Strategy != MergeStrategy.Manual)
+            {
+                OkButtonAction();
+                return;
+            }
+
+            MergeDialogValidation.AsyncValidation(
+                mParameters,
+                mAncestorTextField,
+                this,
+                mProgressControls);
+        }
+
+        static void DrawSection(string title, Action drawContent)
+        {
+            EditorGUILayout.Space(10);
+            GUILayout.Label(
+                title,
+                UnityStyles.Dialog.SectionTitle);
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUILayout.Space(15);
+
+                using (new EditorGUILayout.VerticalScope())
+                {
+                    drawContent();
+                }
+
+                GUILayout.FlexibleSpace();
+            }
+        }
+
+        static MergeOptionsDialog Create(
+            MergeDialogParameters parameters,
+            ProgressControlsForDialogs progressControls)
+        {
+            var instance = CreateInstance<MergeOptionsDialog>();
+            instance.mParameters = parameters;
+            instance.mProgressControls = progressControls;
+            instance.mEscapeKeyAction = instance.CancelButtonAction;
+            return instance;
+        }
+
+        class Styles
+        {
+            internal static GUIContent ManualConflictResolution =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.ManualConflictResolution),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.ManualConflictResolutionTooltip));
+            internal static GUIContent AutomaticConflictResolution =
+                new GUIContent(PlasticLocalization.GetString(
+                        PlasticLocalization.Name.AutomaticConflictResolution),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.AutomaticConflictResolutionTooltip));
+        }
+
+        bool mMergeBothRadioToggle;
+        bool mMergeFromDestinationRadioToggle;
+        bool mMergeFromSourceRadioToggle;
+
+        bool mOnlyOneRadioToggle;
+        bool mForcedRadioToggle;
+
+        bool mIgnoreMergeTrackingToggle;
+
+        bool mAutomaticAncestorRadioToggle;
+        bool mManualAncestorRadioToggle;
+        string mAncestorTextField;
+
+        ProgressControlsForDialogs mProgressControls;
+        MergeDialogParameters mParameters;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeOptionsDialog.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeSelection.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal static class MergeSelection
+    {
+        internal static List<string> GetPathsFromSelectedFileConflictsIncludingMeta(
+            MergeTreeView treeView)
+        {
+            List<string> result = new List<string>();
+
+            List<MergeChangeInfo> selection =
+                treeView.GetSelectedFileConflicts();
+
+            treeView.FillWithMeta(selection);
+
+            foreach (MergeChangeInfo mergeChange in selection)
+            {
+                result.Add(mergeChange.GetPath());
+            }
+
+            return result;
+        }
+
+        internal static SelectedMergeChangesGroupInfo GetSelectedGroupInfo(
+            MergeTreeView treeView, bool isIncomingMerge)
+        {
+            List<MergeChangeInfo> selectedMergeChanges =
+                treeView.GetSelectedMergeChanges();
+
+            return GetSelectedMergeChangesGroupInfo.For(
+                selectedMergeChanges, isIncomingMerge);
+        }
+
+        internal static MergeChangeInfo GetSingleSelectedMergeChange(
+            MergeTreeView treeView)
+        {
+            return treeView.GetSelectedMergeChange();
+        }
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeSelection.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeTab.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeTreeHeaderState.cs

@@ -0,0 +1,177 @@
+using System;
+using System.Collections.Generic;
+
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal enum MergeTreeColumn
+    {
+        Path,
+        Size,
+        Author,
+        Details,
+        Resolution,
+        DateModified,
+        Comment
+    }
+
+    [Serializable]
+    internal class MergeTreeHeaderState : MultiColumnHeaderState, ISerializationCallbackReceiver
+    {
+        internal static MergeTreeHeaderState GetDefault()
+        {
+            MergeTreeHeaderState headerState =
+                new MergeTreeHeaderState(BuildColumns());
+
+            headerState.visibleColumns = GetDefaultVisibleColumns();
+
+            return headerState;
+        }
+
+        internal static List<string> GetColumnNames()
+        {
+            List<string> result = new List<string>();
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.PathColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.SizeColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.CreatedByColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.DetailsColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.ResolutionMethodColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.DateModifiedColumn));
+            result.Add(PlasticLocalization.GetString(PlasticLocalization.Name.CommentColumn));
+            return result;
+        }
+
+        internal static string GetColumnName(MergeTreeColumn column)
+        {
+            switch (column)
+            {
+                case MergeTreeColumn.Path:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.PathColumn);
+                case MergeTreeColumn.Size:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.SizeColumn);
+                case MergeTreeColumn.Author:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.AuthorColumn);
+                case MergeTreeColumn.Details:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.DetailsColumn);
+                case MergeTreeColumn.Resolution:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.ResolutionMethodColumn);
+                case MergeTreeColumn.DateModified:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.DateModifiedColumn);
+                case MergeTreeColumn.Comment:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.CommentColumn);
+                default:
+                    return null;
+            }
+        }
+
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+            if (mHeaderTitles != null)
+                TreeHeaderColumns.SetTitles(columns, mHeaderTitles);
+
+            if (mColumsAllowedToggleVisibility != null)
+                TreeHeaderColumns.SetVisibilities(columns, mColumsAllowedToggleVisibility);
+        }
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
+        {
+        }
+
+        static int[] GetDefaultVisibleColumns()
+        {
+            List<int> result = new List<int>();
+            result.Add((int)MergeTreeColumn.Path);
+            result.Add((int)MergeTreeColumn.Size);
+            result.Add((int)MergeTreeColumn.Author);
+            result.Add((int)MergeTreeColumn.Resolution);
+            result.Add((int)MergeTreeColumn.DateModified);
+            result.Add((int)MergeTreeColumn.Comment);
+            return result.ToArray();
+        }
+
+        static Column[] BuildColumns()
+        {
+            return new Column[]
+            {
+                new Column()
+                {
+                    width = 450,
+                    headerContent = new GUIContent(
+                        GetColumnName(MergeTreeColumn.Path)),
+                    minWidth = 200,
+                    allowToggleVisibility = false,
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = 150,
+                    headerContent = new GUIContent(
+                        GetColumnName(MergeTreeColumn.Size)),
+                    minWidth = 45,
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = 150,
+                    headerContent = new GUIContent(
+                        GetColumnName(MergeTreeColumn.Author)),
+                    minWidth = 80,
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = 200,
+                    headerContent = new GUIContent(
+                        GetColumnName(MergeTreeColumn.Details)),
+                    minWidth = 100,
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = 250,
+                    headerContent = new GUIContent(
+                        GetColumnName(MergeTreeColumn.Resolution)),
+                    minWidth = 120,
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = 330,
+                    headerContent = new GUIContent(
+                        GetColumnName(MergeTreeColumn.DateModified)),
+                    minWidth = 100,
+                    sortingArrowAlignment = TextAlignment.Right
+                },
+                new Column()
+                {
+                    width = 400,
+                    headerContent = new GUIContent(
+                        GetColumnName(MergeTreeColumn.Comment)),
+                    minWidth = 100,
+                    sortingArrowAlignment = TextAlignment.Right
+                }
+            };
+        }
+
+        MergeTreeHeaderState(Column[] columns)
+            : base(columns)
+        {
+            if (mHeaderTitles == null)
+                mHeaderTitles = TreeHeaderColumns.GetTitles(columns);
+
+            if (mColumsAllowedToggleVisibility == null)
+                mColumsAllowedToggleVisibility = TreeHeaderColumns.GetVisibilities(columns);
+        }
+
+        [SerializeField]
+        string[] mHeaderTitles;
+
+        [SerializeField]
+        bool[] mColumsAllowedToggleVisibility;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeTreeHeaderState.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeTreeView.cs

@@ -0,0 +1,627 @@
+using System.Collections.Generic;
+using System.IO;
+
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+using Codice.Client.BaseCommands.Merge;
+using Codice.Client.Common;
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Tree;
+using UnityEditor;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal class MergeTreeView : TreeView
+    {
+        internal GenericMenu Menu { get { return mMenu.Menu; } }
+
+        internal MergeTreeView(
+            WorkspaceInfo wkInfo,
+            MergeTreeHeaderState headerState,
+            List<string> columnNames,
+            MergeViewMenu menu)
+            : base(new TreeViewState())
+        {
+            mWkInfo = wkInfo;
+            mColumnNames = columnNames;
+            mMenu = menu;
+
+            multiColumnHeader = new MultiColumnHeader(headerState);
+            multiColumnHeader.canSort = true;
+            multiColumnHeader.sortingChanged += SortingChanged;
+
+            customFoldoutYOffset = UnityConstants.TREEVIEW_FOLDOUT_Y_OFFSET;
+            rowHeight = UnityConstants.TREEVIEW_ROW_HEIGHT;
+            showAlternatingRowBackgrounds = false;
+
+            mCooldownFilterAction = new CooldownWindowDelayer(
+                DelayedSearchChanged, UnityConstants.SEARCH_DELAYED_INPUT_ACTION_INTERVAL);
+        }
+
+        public override IList<TreeViewItem> GetRows()
+        {
+            return mRows;
+        }
+
+        protected override bool CanChangeExpandedState(TreeViewItem item)
+        {
+            return item is ChangeCategoryTreeViewItem;
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            return new TreeViewItem(0, -1, string.Empty);
+        }
+
+        protected override IList<TreeViewItem> BuildRows(TreeViewItem rootItem)
+        {
+            try
+            {
+                RegenerateRows(
+                    mMergeTree,
+                    mTreeViewItemIds,
+                    this,
+                    rootItem,
+                    mRows,
+                    mExpandCategories);
+            }
+            finally
+            {
+                mExpandCategories = false;
+            }
+
+            return mRows;
+        }
+
+        protected override void CommandEventHandling()
+        {
+            // NOTE - empty override to prevent crash when pressing ctrl-a in the treeview
+        }
+
+        protected override void SearchChanged(string newSearch)
+        {
+            mCooldownFilterAction.Ping();
+        }
+
+        protected override void ContextClickedItem(int id)
+        {
+            mMenu.Popup();
+            Repaint();
+        }
+
+        public override void OnGUI(Rect rect)
+        {
+            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 ChangeCategoryTreeViewItem)
+            {
+                ChangeCategoryTreeViewItem categoryItem =
+                    (ChangeCategoryTreeViewItem)args.item;
+
+                CategoryTreeViewItemGUI(
+                    args.rowRect,
+                    categoryItem,
+                    GetSolvedChildrenCount(categoryItem.Category, mSolvedFileConflicts),
+                    args.selected,
+                    args.focused);
+                return;
+            }
+
+            if (args.item is ChangeTreeViewItem)
+            {
+                ChangeTreeViewItem changeTreeViewItem =
+                    (ChangeTreeViewItem)args.item;
+
+                MergeChangeInfo changeInfo =
+                    changeTreeViewItem.ChangeInfo;
+
+                bool isCurrentConflict = IsCurrent.Conflict(
+                    changeInfo,
+                    mMergeTree.GetMetaChange(changeInfo),
+                    mSolvedFileConflicts);
+
+                bool isSolvedConflict = IsSolved.Conflict(
+                    changeInfo,
+                    mMergeTree.GetMetaChange(changeInfo),
+                    mSolvedFileConflicts);
+
+                MergeTreeViewItemGUI(
+                    mWkInfo.ClientPath,
+                    mMergeTree,
+                    this,
+                    changeTreeViewItem,
+                    args,
+                    isCurrentConflict,
+                    isSolvedConflict);
+                return;
+            }
+
+            base.RowGUI(args);
+        }
+
+        internal void SelectFirstUnsolvedDirectoryConflict()
+        {
+            foreach (MergeChangesCategory category in mMergeTree.GetNodes())
+            {
+                if (category.CategoryType != MergeChangesCategory.Type.DirectoryConflicts)
+                    continue;
+
+                foreach (MergeChangeInfo changeInfo in category.GetChanges())
+                {
+                    if (changeInfo.DirectoryConflict.IsResolved())
+                        continue;
+
+                    int itemId = -1;
+                    if (mTreeViewItemIds.TryGetInfoItemId(changeInfo, out itemId))
+                    {
+                        SetSelection(new List<int>() { itemId });
+                        return;
+                    }
+                }
+            }
+        }
+
+        internal void BuildModel(UnityMergeTree tree)
+        {
+            mTreeViewItemIds.Clear();
+
+            mMergeTree = tree;
+            mSolvedFileConflicts = null;
+
+            mExpandCategories = true;
+        }
+
+        internal void Refilter()
+        {
+            Filter filter = new Filter(searchString);
+            mMergeTree.Filter(filter, mColumnNames);
+
+            mExpandCategories = true;
+        }
+
+        internal void Sort()
+        {
+            if (mMergeTree == null)
+                return;
+
+            int sortedColumnIdx = multiColumnHeader.state.sortedColumnIndex;
+            bool sortAscending = multiColumnHeader.IsSortedAscending(sortedColumnIdx);
+
+            mMergeTree.Sort(mColumnNames[sortedColumnIdx], sortAscending);
+        }
+
+        internal void UpdateSolvedFileConflicts(
+            MergeSolvedFileConflicts solvedFileConflicts)
+        {
+            mSolvedFileConflicts = solvedFileConflicts;
+        }
+
+        internal MergeChangeInfo GetMetaChange(MergeChangeInfo change)
+        {
+            if (change == null)
+                return null;
+
+            return mMergeTree.GetMetaChange(change);
+        }
+
+        internal void FillWithMeta(List<MergeChangeInfo> changes)
+        {
+            mMergeTree.FillWithMeta(changes);
+        }
+
+        internal bool SelectionHasMeta()
+        {
+            MergeChangeInfo selectedChangeInfo = GetSelectedMergeChange();
+
+            if (selectedChangeInfo == null)
+                return false;
+
+            return mMergeTree.HasMeta(selectedChangeInfo);
+        }
+
+        internal MergeChangeInfo GetSelectedMergeChange()
+        {
+            IList<int> selectedIds = GetSelection();
+
+            if (selectedIds.Count != 1)
+                return null;
+
+            int selectedId = selectedIds[0];
+
+            foreach (KeyValuePair<MergeChangeInfo, int> item
+                in mTreeViewItemIds.GetInfoItems())
+            {
+                if (selectedId == item.Value)
+                    return item.Key;
+            }
+
+            return null;
+        }
+
+        internal List<MergeChangeInfo> GetSelectedMergeChanges()
+        {
+            List<MergeChangeInfo> result = new List<MergeChangeInfo>();
+
+            IList<int> selectedIds = GetSelection();
+
+            if (selectedIds.Count == 0)
+                return result;
+
+            foreach (KeyValuePair<MergeChangeInfo, int> item
+                in mTreeViewItemIds.GetInfoItems())
+            {
+                if (!selectedIds.Contains(item.Value))
+                    continue;
+
+                result.Add(item.Key);
+            }
+
+            return result;
+        }
+
+        internal List<MergeChangeInfo> GetSelectedFileConflicts()
+        {
+            List<MergeChangeInfo> result = new List<MergeChangeInfo>();
+
+            IList<int> selectedIds = GetSelection();
+
+            if (selectedIds.Count == 0)
+                return result;
+
+            foreach (KeyValuePair<MergeChangeInfo, int> item
+                in mTreeViewItemIds.GetInfoItems())
+            {
+                if (!selectedIds.Contains(item.Value))
+                    continue;
+
+                if (item.Key.CategoryType !=
+                        MergeChangesCategory.Type.FileConflicts)
+                    continue;
+
+                result.Add(item.Key);
+            }
+
+            return result;
+        }
+
+        void DelayedSearchChanged()
+        {
+            Refilter();
+
+            Sort();
+
+            Reload();
+
+            TableViewOperations.ScrollToSelection(this);
+        }
+
+        void SortingChanged(MultiColumnHeader multiColumnHeader)
+        {
+            Sort();
+
+            Reload();
+        }
+
+        static void RegenerateRows(
+            UnityMergeTree mergeTree,
+            TreeViewItemIds<MergeChangesCategory, MergeChangeInfo> treeViewItemIds,
+            MergeTreeView treeView,
+            TreeViewItem rootItem,
+            List<TreeViewItem> rows,
+            bool expandCategories)
+        {
+            if (mergeTree == null)
+                return;
+
+            ClearRows(rootItem, rows);
+
+            List<MergeChangesCategory> categories = mergeTree.GetNodes();
+
+            if (categories == null)
+                return;
+
+            List<int> categoriesToExpand = new List<int>();
+
+            foreach (MergeChangesCategory category in categories)
+            {
+                int categoryId;
+                if (!treeViewItemIds.TryGetCategoryItemId(category, out categoryId))
+                    categoryId = treeViewItemIds.AddCategoryItem(category);
+
+                ChangeCategoryTreeViewItem categoryTreeViewItem =
+                    new ChangeCategoryTreeViewItem(categoryId, category);
+
+                rootItem.AddChild(categoryTreeViewItem);
+                rows.Add(categoryTreeViewItem);
+
+                if (!ShouldExpandCategory(
+                        treeView,
+                        categoryTreeViewItem,
+                        expandCategories,
+                        categories.Count))
+                    continue;
+
+                categoriesToExpand.Add(categoryTreeViewItem.id);
+
+                foreach (MergeChangeInfo changeInfo in category.GetChanges())
+                {
+                    int differenceId;
+                    if (!treeViewItemIds.TryGetInfoItemId(changeInfo, out differenceId))
+                        differenceId = treeViewItemIds.AddInfoItem(changeInfo);
+
+                    TreeViewItem changeTreeViewItem =
+                        new ChangeTreeViewItem(differenceId, changeInfo);
+
+                    categoryTreeViewItem.AddChild(changeTreeViewItem);
+                    rows.Add(changeTreeViewItem);
+                }
+            }
+
+            treeView.state.expandedIDs = categoriesToExpand;
+        }
+
+        static void ClearRows(
+            TreeViewItem rootItem,
+            List<TreeViewItem> rows)
+        {
+            if (rootItem.hasChildren)
+                rootItem.children.Clear();
+
+            rows.Clear();
+        }
+
+        static void CategoryTreeViewItemGUI(
+            Rect rowRect,
+            ChangeCategoryTreeViewItem item,
+            int solvedChildrenCount,
+            bool isSelected,
+            bool isFocused)
+        {
+            string label = item.Category.GetCategoryName();
+            string infoLabel = item.Category.GetChildrenCountText();
+
+            DefaultStyles.label = GetCategoryStyle(
+                item.Category,
+                solvedChildrenCount,
+                isSelected);
+
+            DrawTreeViewItem.ForCategoryItem(
+                rowRect,
+                item.depth,
+                label,
+                infoLabel,
+                isSelected,
+                isFocused);
+
+            DefaultStyles.label = UnityStyles.Tree.Label;
+        }
+
+        static void MergeTreeViewItemGUI(
+            string wkPath,
+            UnityMergeTree mergeTree,
+            MergeTreeView treeView,
+            ChangeTreeViewItem item,
+            RowGUIArgs args,
+            bool isCurrentConflict,
+            bool isSolvedConflict)
+        {
+            for (int visibleColumnIdx = 0; visibleColumnIdx < args.GetNumVisibleColumns(); visibleColumnIdx++)
+            {
+                Rect cellRect = args.GetCellRect(visibleColumnIdx);
+
+                MergeTreeColumn column =
+                    (MergeTreeColumn)args.GetColumn(visibleColumnIdx);
+
+                MergeTreeViewItemCellGUI(
+                    wkPath,
+                    cellRect,
+                    treeView.rowHeight,
+                    mergeTree,
+                    treeView,
+                    item,
+                    column,
+                    args.selected,
+                    args.focused,
+                    isCurrentConflict,
+                    isSolvedConflict);
+            }
+        }
+
+        static void MergeTreeViewItemCellGUI(
+            string wkPath,
+            Rect rect,
+            float rowHeight,
+            UnityMergeTree mergeTree,
+            MergeTreeView treeView,
+            ChangeTreeViewItem item,
+            MergeTreeColumn column,
+            bool isSelected,
+            bool isFocused,
+            bool isCurrentConflict,
+            bool isSolvedConflict)
+        {
+            MergeChangeInfo mergeChange = item.ChangeInfo;
+
+            string label = mergeChange.GetColumnText(
+                MergeTreeHeaderState.GetColumnName(column));
+
+            if (column == MergeTreeColumn.Path)
+            {
+                if (mergeTree.HasMeta(item.ChangeInfo))
+                    label = string.Concat(label, UnityConstants.TREEVIEW_META_LABEL);
+
+                Texture icon = GetIcon(wkPath, mergeChange);
+
+                Texture overlayIcon =
+                    GetChangesOverlayIcon.ForPlasticMergeChange(
+                        mergeChange, isSolvedConflict);
+
+                DrawTreeViewItem.ForItemCell(
+                    rect,
+                    rowHeight,
+                    item.depth,
+                    icon,
+                    overlayIcon,
+                    label,
+                    isSelected,
+                    isFocused,
+                    isCurrentConflict,
+                    false);
+
+                return;
+            }
+
+            if (column == MergeTreeColumn.Size)
+            {
+                // If there is a meta file, add the meta file to the file size so that it is consistent
+                // with the Merge overview
+                if (mergeTree.HasMeta(item.ChangeInfo))
+                {
+                    MergeChangeInfo metaFileInfo = mergeTree.GetMetaChange(mergeChange);
+                    long metaFileSize = metaFileInfo.GetSize();
+                    long fileSize = mergeChange.GetSize();
+
+                    label = SizeConverter.ConvertToSizeString(fileSize + metaFileSize);
+                }
+
+                DrawTreeViewItem.ForSecondaryLabelRightAligned(
+                    rect, label, isSelected, isFocused, isCurrentConflict);
+                return;
+            }
+
+            DrawTreeViewItem.ForSecondaryLabel(
+                rect, label, isSelected, isFocused, isCurrentConflict);
+        }
+
+        static Texture GetIcon(
+            string wkPath,
+            MergeChangeInfo mergeChange)
+        {
+            RevisionInfo revInfo = mergeChange.GetRevision();
+            bool isDirectory = revInfo.
+                Type == EnumRevisionType.enDirectory;
+
+            if (isDirectory || mergeChange.IsXLink())
+                return Images.GetDirectoryIcon();
+
+            string fullPath = WorkspacePath.GetWorkspacePathFromCmPath(
+                wkPath,
+                mergeChange.GetPath(),
+                Path.DirectorySeparatorChar);
+
+            return Images.GetFileIcon(fullPath);
+        }
+
+        static GUIStyle GetCategoryStyle(
+            MergeChangesCategory category,
+            int solvedChildrenCount,
+            bool isSelected)
+        {
+            if (isSelected)
+                return UnityStyles.Tree.Label;
+
+            if (category.CategoryType == MergeChangesCategory.Type.FileConflicts ||
+                category.CategoryType == MergeChangesCategory.Type.DirectoryConflicts)
+            {
+                return category.GetChildrenCount() > solvedChildrenCount ?
+                    UnityStyles.Tree.RedLabel : UnityStyles.Tree.GreenLabel;
+            }
+
+            return UnityStyles.Tree.Label;
+        }
+
+        static bool ShouldExpandCategory(
+            MergeTreeView treeView,
+            ChangeCategoryTreeViewItem categoryTreeViewItem,
+            bool expandCategories,
+            int categoriesCount)
+        {
+            if (expandCategories)
+            {
+                if (categoriesCount == 1)
+                    return true;
+
+                if (categoryTreeViewItem.Category.CategoryType ==
+                    MergeChangesCategory.Type.FileConflicts)
+                    return true;
+
+                if (categoryTreeViewItem.Category.GetChildrenCount() >
+                    NODES_TO_EXPAND_CATEGORY)
+                    return false;
+
+                return true;
+            }
+
+            return treeView.IsExpanded(categoryTreeViewItem.id);
+        }
+
+        static int GetSolvedChildrenCount(
+            MergeChangesCategory category,
+            MergeSolvedFileConflicts solvedFileConflicts)
+        {
+            int solvedDirConflicts = 0;
+            if (category.CategoryType == MergeChangesCategory.Type.DirectoryConflicts)
+            {
+                foreach (MergeChangeInfo change in category.GetChanges())
+                {
+                    if (change.DirectoryConflict.IsResolved())
+                        solvedDirConflicts++;
+                }
+
+                return solvedDirConflicts;
+            }
+
+            return (solvedFileConflicts == null) ? 0 :
+                solvedFileConflicts.GetCount();
+        }
+
+        bool mExpandCategories;
+
+        TreeViewItemIds<MergeChangesCategory, MergeChangeInfo> mTreeViewItemIds =
+            new TreeViewItemIds<MergeChangesCategory, MergeChangeInfo>();
+        List<TreeViewItem> mRows = new List<TreeViewItem>();
+
+        MergeSolvedFileConflicts mSolvedFileConflicts;
+        UnityMergeTree mMergeTree;
+        CooldownWindowDelayer mCooldownFilterAction;
+
+        readonly MergeViewMenu mMenu;
+        readonly List<string> mColumnNames;
+        readonly WorkspaceInfo mWkInfo;
+
+        const int NODES_TO_EXPAND_CATEGORY = 10;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeTreeView.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeViewFileConflictMenu.cs

@@ -0,0 +1,493 @@
+using UnityEditor;
+using UnityEngine;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal class MergeViewFileConflictMenu
+    {
+        internal interface IMetaMenuOperations
+        {
+            void DiffSourceWithAncestor();
+            void DiffDestinationWithAncestor();
+            void DiffSourceWithDestination();
+            void ShowHistory();
+            bool SelectionHasMeta();
+        }
+
+        internal GenericMenu Menu { get { return mMenu; } }
+
+        internal MergeViewFileConflictMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations,
+            IMetaMenuOperations mergeMetaMenuOperations,
+            bool isIncomingMerge,
+            bool isMergeTo)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+            mMergeMetaMenuOperations = mergeMetaMenuOperations;
+
+            BuildComponents(isIncomingMerge, isMergeTo);
+        }
+
+        internal void Popup()
+        {
+            mMenu = new GenericMenu();
+
+            UpdateMenuItems(mMenu);
+
+            mMenu.ShowAsContext();
+        }
+
+        internal bool ProcessKeyActionIfNeeded(Event e)
+        {
+            MergeMenuOperations operationToExecute = GetMenuOperations(e);
+
+            if (operationToExecute == MergeMenuOperations.None)
+                return false;
+
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+            MergeMenuOperations operations =
+                UpdateMergeMenu.GetAvailableMenuOperations(info);
+
+            if (!operations.HasFlag(operationToExecute))
+                return false;
+
+            ProcessMenuOperation(operationToExecute, mMergeViewMenuOperations);
+            return true;
+        }
+
+        void MergeSelectedFilesMenuItem_Click()
+        {
+            mMergeViewMenuOperations.MergeContributors();
+        }
+
+        void MergeKeepingSourceChangesMenuItem_Click()
+        {
+            mMergeViewMenuOperations.MergeKeepingSourceChanges();
+        }
+
+        void MergeKeepingWorkspaceChangesMenuItem_Click()
+        {
+            mMergeViewMenuOperations.MergeKeepingWorkspaceChanges();
+        }
+
+        void DiffSourceWithDestinationMenuItem_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithDestination();
+        }
+
+        void DiffDestinationWithAncestorMenuItem_Click()
+        {
+            mMergeViewMenuOperations.DiffDestinationWithAncestor();
+        }
+
+        void DiffSourceWithAncestorMenuItem_Click()
+        {
+            mMergeViewMenuOperations.DiffSourceWithAncestor();
+        }
+
+        void DiffMetaSourceWithDestinationMenuItem_Click()
+        {
+            mMergeMetaMenuOperations.DiffSourceWithDestination();
+        }
+
+        void DiffMetaDestinationWithAncestorMenuItem_Click()
+        {
+            mMergeMetaMenuOperations.DiffDestinationWithAncestor();
+        }
+
+        void DiffMetaSourceWithAncestorMenuItem_Click()
+        {
+            mMergeMetaMenuOperations.DiffSourceWithAncestor();
+        }
+
+        void HistoryMetaMenuItem_Click()
+        {
+            mMergeMetaMenuOperations.ShowHistory();
+        }
+
+        void CopyFilePathMenuItem_Click()
+        {
+            mMergeViewMenuOperations.CopyFilePath(relativePath: false);
+        }
+
+        void CopyRelativeFilePathMenuItem_Click()
+        {
+            mMergeViewMenuOperations.CopyFilePath(relativePath: true);
+        }
+
+        void HistoryMenuItem_Click()
+        {
+            mMergeViewMenuOperations.ShowHistory();
+        }
+
+        void UpdateMenuItems(GenericMenu menu)
+        {
+            SelectedMergeChangesGroupInfo info =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+            MergeMenuOperations operations =
+                UpdateMergeMenu.GetAvailableMenuOperations(info);
+
+            if (operations == MergeMenuOperations.None)
+            {
+                menu.AddDisabledItem(GetNoActionMenuItemContent());
+                return;
+            }
+
+            AddMergeActions(menu, operations);
+
+            menu.AddSeparator(string.Empty);
+
+            AddDiffActions(menu, info, operations);
+
+            if (mMergeMetaMenuOperations.SelectionHasMeta())
+            {
+                menu.AddSeparator(string.Empty);
+
+                AddMetaActions(menu, info, operations);
+            }
+
+            menu.AddSeparator(string.Empty);
+
+            AddCopyFilePathActions(menu, operations);
+
+            menu.AddSeparator(string.Empty);
+
+            AddHistoryMenuItem(mHistoryMenuItemContent, menu, operations, HistoryMenuItem_Click);
+        }
+
+        void AddMergeActions(
+            GenericMenu menu,
+            MergeMenuOperations operations)
+        {
+            AddMergeSelectedFilesMenuItem(
+                mMergeSelectedFilesMenuItemContent, menu, operations, MergeSelectedFilesMenuItem_Click);
+
+            AddMergeKeepingSourceChangesMenuItem(
+                mMergeKeepingSourceChangesMenuItemContent, menu, operations, MergeKeepingSourceChangesMenuItem_Click);
+
+            AddMergeKeepingWorkspaceChangesMenuItem(
+                mMergeKeepingWorkspaceChangesMenuItemContent, menu, operations, MergeKeepingWorkspaceChangesMenuItem_Click);
+        }
+
+        void AddDiffActions(
+            GenericMenu menu,
+            SelectedMergeChangesGroupInfo info,
+            MergeMenuOperations operations)
+        {
+            mDiffSourceWithDestinationMenuItemContent.text =
+                UnityMenuItem.EscapedText(info.DiffSourceWithDestinationMenuItemText);
+            AddDiffSourceWithDestinationMenuItem(
+                mDiffSourceWithDestinationMenuItemContent, menu, operations, DiffSourceWithDestinationMenuItem_Click);
+
+            AddDiffDestinationWithAncestorMenuItem(
+                mDiffDestinationWithAncestorMenuItemContent, menu, operations, DiffDestinationWithAncestorMenuItem_Click);
+
+            AddDiffSourceWithAncestorMenuItem(
+                mDiffSourceWithAncestorMenuItem, menu, operations, DiffSourceWithAncestorMenuItem_Click);
+        }
+
+        void AddMetaActions(
+            GenericMenu menu,
+            SelectedMergeChangesGroupInfo info,
+            MergeMenuOperations operations)
+        {
+            mDiffMetaSourceWithDestinationMenuItemContent.text = string.Format(
+                "{0}/{1}",
+                MetaPath.META_EXTENSION,
+                UnityMenuItem.EscapedText(info.DiffSourceWithDestinationMenuItemText));
+            AddDiffSourceWithDestinationMenuItem(
+                mDiffMetaSourceWithDestinationMenuItemContent, menu, operations, DiffMetaSourceWithDestinationMenuItem_Click);
+
+            AddDiffDestinationWithAncestorMenuItem(
+                mDiffMetaDestinationWithAncestorMenuItemContent, menu, operations, DiffMetaDestinationWithAncestorMenuItem_Click);
+
+            AddDiffSourceWithAncestorMenuItem(
+                mDiffMetaSourceWithAncestorMenuItemContent, menu, operations, DiffMetaSourceWithAncestorMenuItem_Click);
+
+            AddHistoryMenuItem(
+                mHistoryMetaMenuItemContent, menu, operations, HistoryMetaMenuItem_Click);
+        }
+
+        void AddCopyFilePathActions(
+            GenericMenu menu,
+            MergeMenuOperations operations)
+        {
+            AddCopyFilePathMenuItem(
+                mCopyFilePathMenuItemContent, menu, operations, CopyFilePathMenuItem_Click);
+
+            AddCopyFilePathMenuItem(
+                mCopyRelativeFilePathMenuItemContent, menu, operations, CopyRelativeFilePathMenuItem_Click);
+        }
+
+        GUIContent GetNoActionMenuItemContent()
+        {
+            if (mNoActionMenuItemContent == null)
+            {
+                mNoActionMenuItemContent = new GUIContent(
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.NoActionMenuItem));
+            }
+
+            return mNoActionMenuItemContent;
+        }
+
+        static void AddMergeSelectedFilesMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            MergeMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(MergeMenuOperations.MergeContributors))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static void AddMergeKeepingSourceChangesMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            MergeMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(MergeMenuOperations.MergeKeepingSourceChanges))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static void AddMergeKeepingWorkspaceChangesMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            MergeMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(MergeMenuOperations.MergeKeepingWorkspaceChanges))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static void AddDiffSourceWithDestinationMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            MergeMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(MergeMenuOperations.DiffSourceWithDestination))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static void AddDiffDestinationWithAncestorMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            MergeMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (!operations.HasFlag(MergeMenuOperations.DiffDestinationWithAncestor))
+                return;
+
+            menu.AddItem(
+                menuItemContent,
+                false,
+                menuFunction);
+        }
+
+        static void AddDiffSourceWithAncestorMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            MergeMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(MergeMenuOperations.DiffSourceWithAncestor))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static void AddCopyFilePathMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            MergeMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(MergeMenuOperations.CopyFilePath))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static void AddHistoryMenuItem(
+            GUIContent menuItemContent,
+            GenericMenu menu,
+            MergeMenuOperations operations,
+            GenericMenu.MenuFunction menuFunction)
+        {
+            if (operations.HasFlag(MergeMenuOperations.ShowHistory))
+            {
+                menu.AddItem(
+                    menuItemContent,
+                    false,
+                    menuFunction);
+
+                return;
+            }
+
+            menu.AddDisabledItem(menuItemContent);
+        }
+
+        static MergeMenuOperations GetMenuOperations(Event e)
+        {
+            if (Keyboard.IsControlOrCommandKeyPressed(e) &&
+                Keyboard.IsKeyPressed(e, KeyCode.H))
+                return MergeMenuOperations.ShowHistory;
+
+            return MergeMenuOperations.None;
+        }
+
+        static void ProcessMenuOperation(
+            MergeMenuOperations operationToExecute,
+            IMergeViewMenuOperations mergeViewMenuOperations)
+        {
+            if (operationToExecute == MergeMenuOperations.ShowHistory)
+            {
+                mergeViewMenuOperations.ShowHistory();
+                return;
+            }
+        }
+
+        void BuildComponents(
+            bool isIncomingMerge,
+            bool isMergeTo)
+        {
+            mMergeSelectedFilesMenuItemContent = new GUIContent(
+                PlasticLocalization.GetString(PlasticLocalization.
+                    Name.MergeSelectedFiles));
+
+            mMergeKeepingSourceChangesMenuItemContent = new GUIContent(
+                UnityMenuItem.EscapedText(
+                    MergeViewTexts.GetMergeKeepingSourceChangesMenuItemText(
+                        isIncomingMerge, isMergeTo)));
+
+            mMergeKeepingWorkspaceChangesMenuItemContent = new GUIContent(
+                UnityMenuItem.EscapedText(
+                    MergeViewTexts.GetMergeKeepingWorkspaceChangesMenuItemText(
+                        isIncomingMerge, isMergeTo)));
+
+            string diffSourceWithAncestorText = UnityMenuItem.EscapedText(
+                MergeViewTexts.GetDiffSourceWithAncestorMenuItemText(isIncomingMerge));
+
+            mDiffSourceWithDestinationMenuItemContent = new GUIContent(string.Empty);
+
+            mDiffDestinationWithAncestorMenuItemContent = new GUIContent(
+                UnityMenuItem.EscapedText(
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.DiffDestinationWithAncestor)));
+
+            mDiffSourceWithAncestorMenuItem = new GUIContent(
+                diffSourceWithAncestorText);
+
+            mDiffMetaSourceWithDestinationMenuItemContent = new GUIContent(string.Empty);
+            mDiffMetaDestinationWithAncestorMenuItemContent = new GUIContent(
+                string.Format(
+                    "{0}/{1}",
+                    MetaPath.META_EXTENSION,
+                    UnityMenuItem.EscapedText(
+                        PlasticLocalization.GetString(
+                            PlasticLocalization.Name.DiffDestinationWithAncestor))));
+
+            mDiffMetaSourceWithAncestorMenuItemContent = new GUIContent(
+                string.Format(
+                    "{0}/{1}",
+                    MetaPath.META_EXTENSION,
+                    diffSourceWithAncestorText));
+
+            mHistoryMetaMenuItemContent = new GUIContent(
+                string.Format(
+                    "{0}/{1}",
+                    MetaPath.META_EXTENSION,
+                    PlasticLocalization.Name.ItemsMenuItemHistory.GetString()));
+
+            mCopyFilePathMenuItemContent = new GUIContent(PlasticLocalization.Name.CopyFilePathMenuItem.GetString());
+
+            mCopyRelativeFilePathMenuItemContent =
+                new GUIContent(PlasticLocalization.Name.CopyRelativeFilePathMenuItem.GetString());
+
+            mHistoryMenuItemContent = new GUIContent(string.Format("{0} {1}",
+                PlasticLocalization.Name.ItemsMenuItemHistory.GetString(),
+                    GetPlasticShortcut.ForHistory()));
+        }
+
+        GenericMenu mMenu;
+
+        GUIContent mNoActionMenuItemContent;
+
+        GUIContent mMergeSelectedFilesMenuItemContent;
+        GUIContent mMergeKeepingSourceChangesMenuItemContent;
+        GUIContent mMergeKeepingWorkspaceChangesMenuItemContent;
+
+        GUIContent mDiffSourceWithDestinationMenuItemContent;
+        GUIContent mDiffDestinationWithAncestorMenuItemContent;
+        GUIContent mDiffSourceWithAncestorMenuItem;
+
+        GUIContent mDiffMetaSourceWithDestinationMenuItemContent;
+        GUIContent mDiffMetaDestinationWithAncestorMenuItemContent;
+        GUIContent mDiffMetaSourceWithAncestorMenuItemContent;
+        GUIContent mHistoryMetaMenuItemContent;
+
+        GUIContent mCopyFilePathMenuItemContent;
+        GUIContent mCopyRelativeFilePathMenuItemContent;
+        GUIContent mHistoryMenuItemContent;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+        readonly IMetaMenuOperations mMergeMetaMenuOperations;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeViewFileConflictMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeViewMenu.cs

@@ -0,0 +1,101 @@
+using UnityEditor;
+
+using PlasticGui.WorkspaceWindow.Merge;
+using Unity.PlasticSCM.Editor.Views.Merge.Developer.DirectoryConflicts;
+using UnityEngine;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal class MergeViewMenu
+    {
+        internal GenericMenu Menu
+        {
+            get
+            {
+                return mMergeViewFileConflictMenu != null ?
+                       mMergeViewFileConflictMenu.Menu : mMergeViewDirectoryConflictMenu != null ?
+                           mMergeViewDirectoryConflictMenu.Menu : null;
+            }
+        }
+
+        internal MergeViewMenu(
+            IMergeViewMenuOperations mergeViewMenuOperations,
+            MergeViewFileConflictMenu.IMetaMenuOperations mergeMetaMenuOperations,
+            bool isIncomingMerge,
+            bool isMergeTo)
+        {
+            mMergeViewMenuOperations = mergeViewMenuOperations;
+            mMergeMetaMenuOperations = mergeMetaMenuOperations;
+            mIsIncomingMerge = isIncomingMerge;
+            mIsMergeTo = isMergeTo;
+        }
+
+        internal void Popup()
+        {
+            SelectedMergeChangesGroupInfo selectedGroupInfo =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            if (selectedGroupInfo.SelectedConflict == null)
+                return;
+
+            if (selectedGroupInfo.IsDirectoryConflictsSelection)
+            {
+                GetMergeViewDirectoryConflictMenu().Popup();
+                return;
+            }
+
+            GetMergeViewFileConflictMenu().Popup();
+        }
+
+        internal bool ProcessKeyActionIfNeeded(Event e)
+        {
+            SelectedMergeChangesGroupInfo selectedGroupInfo =
+                mMergeViewMenuOperations.GetSelectedMergeChangesGroupInfo();
+
+            if (selectedGroupInfo.SelectedConflict == null)
+                return false;
+
+            if (selectedGroupInfo.IsDirectoryConflictsSelection)
+                return false;
+
+            if (mMergeViewFileConflictMenu == null)
+                return false;
+
+            return mMergeViewFileConflictMenu.ProcessKeyActionIfNeeded(e);
+        }
+
+        MergeViewFileConflictMenu GetMergeViewFileConflictMenu()
+        {
+            if (mMergeViewFileConflictMenu == null)
+            {
+                mMergeViewFileConflictMenu =
+                    new MergeViewFileConflictMenu(
+                        mMergeViewMenuOperations,
+                        mMergeMetaMenuOperations,
+                        mIsIncomingMerge,
+                        mIsMergeTo);
+            }
+
+            return mMergeViewFileConflictMenu;
+        }
+
+        MergeViewDirectoryConflictMenu GetMergeViewDirectoryConflictMenu()
+        {
+            if (mMergeViewDirectoryConflictMenu == null)
+            {
+                mMergeViewDirectoryConflictMenu =
+                    new MergeViewDirectoryConflictMenu(mMergeViewMenuOperations);
+            }
+
+            return mMergeViewDirectoryConflictMenu;
+        }
+
+        MergeViewFileConflictMenu mMergeViewFileConflictMenu;
+        MergeViewDirectoryConflictMenu mMergeViewDirectoryConflictMenu;
+
+        readonly IMergeViewMenuOperations mMergeViewMenuOperations;
+        readonly MergeViewFileConflictMenu.IMetaMenuOperations mMergeMetaMenuOperations;
+        readonly bool mIsIncomingMerge;
+        readonly bool mIsMergeTo;
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/MergeViewMenu.cs.meta

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

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/UnityMergeTree.cs

@@ -0,0 +1,188 @@
+using System.Collections.Generic;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Views.Merge.Developer
+{
+    internal class UnityMergeTree
+    {
+        internal static UnityMergeTree BuildMergeCategories(
+            MergeChangesTree tree)
+        {
+            return new UnityMergeTree(tree);
+        }
+
+        UnityMergeTree(
+            MergeChangesTree tree)
+        {
+            mInnerTree = tree;
+
+            mMetaCache.Build(mInnerTree.GetNodes());
+        }
+
+        internal List<MergeChangesCategory> GetNodes()
+        {
+            return mInnerTree.GetNodes();
+        }
+
+        internal bool HasMeta(MergeChangeInfo changeInfo)
+        {
+            return mMetaCache.ContainsMeta(changeInfo);
+        }
+
+        internal MergeChangeInfo GetMetaChange(MergeChangeInfo change)
+        {
+            return mMetaCache.GetExistingMeta(change);
+        }
+
+        internal void FillWithMeta(List<MergeChangeInfo> changes)
+        {
+            changes.AddRange(
+                mMetaCache.GetExistingMeta(changes));
+        }
+
+        internal void Filter(Filter filter, List<string> columnNames)
+        {
+            mInnerTree.Filter(filter, columnNames);
+        }
+
+        internal void Sort(string key, bool isAscending)
+        {
+            mInnerTree.Sort(key, isAscending);
+        }
+
+        internal void ResolveUserNames(
+            MergeChangesTree.ResolveUserName resolveUserName)
+        {
+            mInnerTree.ResolveUserNames(resolveUserName);
+        }
+
+        MetaCache mMetaCache = new MetaCache();
+        MergeChangesTree mInnerTree;
+
+        class MetaCache
+        {
+            internal bool ContainsMeta(MergeChangeInfo changeInfo)
+            {
+                string key = BuildKey.ForMetaChange(changeInfo);
+
+                return mCache.ContainsKey(key);
+            }
+
+            internal MergeChangeInfo GetExistingMeta(MergeChangeInfo change)
+            {
+                MergeChangeInfo result;
+
+                if (!mCache.TryGetValue(BuildKey.ForMetaChange(change), out result))
+                    return null;
+
+                return result;
+            }
+
+            internal List<MergeChangeInfo> GetExistingMeta(
+                List<MergeChangeInfo> changes)
+            {
+                List<MergeChangeInfo> result = new List<MergeChangeInfo>();
+
+                foreach (MergeChangeInfo change in changes)
+                {
+                    string key = BuildKey.ForMetaChange(change);
+
+                    MergeChangeInfo metaChange;
+                    if (!mCache.TryGetValue(key, out metaChange))
+                        continue;
+
+                    result.Add(metaChange);
+                }
+
+                return result;
+            }
+
+            internal void Build(List<MergeChangesCategory> mergeChangesCategories)
+            {
+                mCache.Clear();
+
+                foreach (MergeChangesCategory category in mergeChangesCategories)
+                {
+                    ExtractMetaToCache(category, mCache);
+                }
+            }
+
+            static void ExtractMetaToCache(
+                MergeChangesCategory category,
+                Dictionary<string, MergeChangeInfo> cache)
+            {
+                List<MergeChangeInfo> changes = category.GetChanges();
+
+                HashSet<string> indexedKeys = BuildIndexedKeys(
+                    changes);
+
+                for (int i = changes.Count - 1; i >= 0; i--)
+                {
+                    MergeChangeInfo currentChange = changes[i];
+
+                    string path = currentChange.GetPath();
+
+                    if (!MetaPath.IsMetaPath(path))
+                        continue;
+
+                    string realPath = MetaPath.GetPathFromMetaPath(path);
+
+                    if (!indexedKeys.Contains(BuildKey.BuildCacheKey(
+                        currentChange.CategoryType, realPath)))
+                        continue;
+
+                    // found foo.c and foo.c.meta - move .meta to cache
+                    cache.Add(BuildKey.ForChange(currentChange), currentChange);
+                    changes.RemoveAt(i);
+                }
+            }
+
+            static HashSet<string> BuildIndexedKeys(
+                List<MergeChangeInfo> changes)
+            {
+                HashSet<string> result = new HashSet<string>();
+
+                foreach (MergeChangeInfo change in changes)
+                {
+                    if (MetaPath.IsMetaPath(change.GetPath()))
+                        continue;
+
+                    result.Add(BuildKey.ForChange(change));
+                }
+
+                return result;
+            }
+
+            Dictionary<string, MergeChangeInfo> mCache =
+                new Dictionary<string, MergeChangeInfo>();
+
+            static class BuildKey
+            {
+                internal static string ForChange(
+                    MergeChangeInfo change)
+                {
+                    return BuildCacheKey(
+                        change.CategoryType,
+                        change.GetPath());
+                }
+
+                internal static string ForMetaChange(
+                    MergeChangeInfo change)
+                {
+                    return BuildCacheKey(
+                        change.CategoryType,
+                        MetaPath.GetMetaPath(change.GetPath()));
+                }
+
+                internal static string BuildCacheKey(
+                    MergeChangesCategory.Type type,
+                    string path)
+                {
+                    return string.Concat(type, ":", path);
+                }
+            }
+        }
+    }
+}

3D FPS/Library/PackageCache/com.unity.collab-proxy@2.6.0/Editor/Views/Merge/Developer/UnityMergeTree.cs.meta

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