Initial commit

Library/PackageCache/com.unity.collab-proxy@c854d1f7d97f/Editor/Gluon/Errors/ErrorListViewItem.cs

@@ -0,0 +1,19 @@
+using UnityEditor.IMGUI.Controls;
+
+using Codice.CM.Common;
+
+namespace Unity.PlasticSCM.Editor.Gluon.Errors
+{
+    internal class ErrorListViewItem : TreeViewItem
+    {
+        internal ErrorMessage ErrorMessage { get; private set; }
+
+        internal ErrorListViewItem(int id, ErrorMessage errorMessage)
+            : base(id, 0)
+        {
+            ErrorMessage = errorMessage;
+
+            displayName = errorMessage.Path;
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@c854d1f7d97f/Editor/Gluon/Errors/ErrorListViewItem.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@c854d1f7d97f/Editor/Gluon/Errors/ErrorsListHeaderState.cs

@@ -0,0 +1,93 @@
+using System;
+
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+namespace Unity.PlasticSCM.Editor.Gluon.Errors
+{
+    internal enum ErrorsListColumn
+    {
+        Path,
+        Reason
+    }
+
+    [Serializable]
+    internal class ErrorsListHeaderState : MultiColumnHeaderState, ISerializationCallbackReceiver
+    {
+        internal static ErrorsListHeaderState GetDefault()
+        {
+            return new ErrorsListHeaderState(BuildColumns());
+        }
+
+        static string GetColumnName(ErrorsListColumn column)
+        {
+            switch (column)
+            {
+                case ErrorsListColumn.Path:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.PathColumn);
+                case ErrorsListColumn.Reason:
+                    return PlasticLocalization.GetString(PlasticLocalization.Name.Reason);
+                default:
+                    return null;
+            }
+        }
+
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+            if (mHeaderTitles != null)
+                TreeHeaderColumns.SetTitles(columns, mHeaderTitles);
+
+            if (mColumnsAllowedToggleVisibility != null)
+                TreeHeaderColumns.SetVisibilities(columns, mColumnsAllowedToggleVisibility);
+        }
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
+        {
+        }
+
+        static Column[] BuildColumns()
+        {
+            return new Column[]
+                {
+                    new Column()
+                    {
+                        width = 300,
+                        headerContent = new GUIContent(
+                            GetColumnName(ErrorsListColumn.Path)),
+                        minWidth = 200,
+                        allowToggleVisibility = false,
+                        canSort = false,
+                        sortingArrowAlignment = TextAlignment.Right
+                    },
+                    new Column()
+                    {
+                        width = 600,
+                        headerContent = new GUIContent(
+                            GetColumnName(ErrorsListColumn.Reason)),
+                        minWidth = 200,
+                        canSort = false,
+                        sortingArrowAlignment = TextAlignment.Right
+                    }
+                };
+        }
+
+        ErrorsListHeaderState(Column[] columns)
+            : base(columns)
+        {
+            if (mHeaderTitles == null)
+                mHeaderTitles = TreeHeaderColumns.GetTitles(columns);
+
+            if (mColumnsAllowedToggleVisibility == null)
+                mColumnsAllowedToggleVisibility = TreeHeaderColumns.GetVisibilities(columns);
+        }
+
+        [SerializeField]
+        string[] mHeaderTitles;
+
+        [SerializeField]
+        bool[] mColumnsAllowedToggleVisibility;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@c854d1f7d97f/Editor/Gluon/Errors/ErrorsListHeaderState.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@c854d1f7d97f/Editor/Gluon/Errors/ErrorsListView.cs

@@ -0,0 +1,148 @@
+using System.Collections.Generic;
+
+using UnityEngine;
+using UnityEditor.IMGUI.Controls;
+
+using Codice.CM.Common;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+namespace Unity.PlasticSCM.Editor.Gluon.Errors
+{
+    internal class ErrorsListView : PlasticTreeView
+    {
+        internal ErrorsListView(ErrorsListHeaderState headerState)
+        {
+            multiColumnHeader = new MultiColumnHeader(headerState);
+            multiColumnHeader.canSort = false;
+
+            showAlternatingRowBackgrounds = true;
+        }
+
+        protected override IList<TreeViewItem> BuildRows(TreeViewItem rootItem)
+        {
+            RegenerateRows(
+                this, mErrorMessages, rootItem, mRows);
+
+            return mRows;
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            if (args.item is ErrorListViewItem)
+            {
+                ErrorListViewItemGUI((ErrorListViewItem)args.item, args);
+                return;
+            }
+
+            base.RowGUI(args);
+        }
+
+        internal void BuildModel(List<ErrorMessage> errorMessages)
+        {
+            mErrorMessages = errorMessages;
+        }
+
+        internal ErrorMessage GetSelectedError()
+        {
+            List<ErrorMessage> selectedErrors = GetSelectedErrors(this);
+
+            if (selectedErrors.Count != 1)
+                return null;
+
+            return selectedErrors[0];
+        }
+
+        static List<ErrorMessage> GetSelectedErrors(
+            ErrorsListView listView)
+        {
+            List<ErrorMessage> result = new List<ErrorMessage>();
+
+            IList<int> selectedIds = listView.GetSelection();
+
+            if (selectedIds.Count == 0)
+                return result;
+
+            foreach (ErrorListViewItem treeViewItem in
+                listView.FindRows(selectedIds))
+            {
+                result.Add(treeViewItem.ErrorMessage);
+            }
+
+            return result;
+        }
+
+        static void RegenerateRows(
+            ErrorsListView listView,
+            List<ErrorMessage> errorMessages,
+            TreeViewItem rootItem,
+            List<TreeViewItem> rows)
+        {
+            ClearRows(rootItem, rows);
+
+            if (errorMessages.Count == 0)
+                return;
+
+            for (int i = 0; i < errorMessages.Count; i++)
+            {
+                ErrorListViewItem errorListViewItem =
+                    new ErrorListViewItem(i + 1, errorMessages[i]);
+
+                rootItem.AddChild(errorListViewItem);
+                rows.Add(errorListViewItem);
+            }
+
+            listView.SetSelection(new List<int> { 1 });
+        }
+
+        static void ClearRows(
+            TreeViewItem rootItem,
+            List<TreeViewItem> rows)
+        {
+            if (rootItem.hasChildren)
+                rootItem.children.Clear();
+
+            rows.Clear();
+        }
+
+        static void ErrorListViewItemGUI(
+            ErrorListViewItem item,
+            RowGUIArgs args)
+        {
+            for (int visibleColumnIdx = 0; visibleColumnIdx < args.GetNumVisibleColumns(); visibleColumnIdx++)
+            {
+                Rect cellRect = args.GetCellRect(visibleColumnIdx);
+
+                ErrorsListColumn column =
+                    (ErrorsListColumn)args.GetColumn(visibleColumnIdx);
+
+                ErrorListViewItemCellGUI(
+                    cellRect, item, column, args.selected, args.focused);
+            }
+        }
+
+        static void ErrorListViewItemCellGUI(
+            Rect rect,
+            ErrorListViewItem item,
+            ErrorsListColumn column,
+            bool isSelected,
+            bool isFocused)
+        {
+            ErrorMessage errorMessage = item.ErrorMessage;
+
+            string label = column == ErrorsListColumn.Path ?
+                errorMessage.Path : errorMessage.Error;
+
+            if (column == ErrorsListColumn.Path)
+            {
+                DrawTreeViewItem.ForLabel(
+                    rect, label, isSelected, isFocused, false);
+                return;
+            }
+
+            DrawTreeViewItem.ForSecondaryLabel(
+                rect, label, isSelected, isFocused, false);
+        }
+
+        List<ErrorMessage> mErrorMessages = new List<ErrorMessage>();
+    }
+}

Library/PackageCache/com.unity.collab-proxy@c854d1f7d97f/Editor/Gluon/Errors/ErrorsListView.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@c854d1f7d97f/Editor/Gluon/Errors/ErrorsPanel.cs

@@ -0,0 +1,127 @@
+using System.Collections.Generic;
+
+using UnityEditor;
+using UnityEngine;
+
+using Codice.CM.Common;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Tree;
+
+namespace Unity.PlasticSCM.Editor.Gluon.Errors
+{
+    internal class ErrorsPanel
+    {
+        internal bool IsVisible { get; private set; }
+
+        internal ErrorsPanel(
+            string title,
+            string treeSettingsName)
+        {
+            mTitle = title;
+
+            ErrorsListHeaderState errorsListHeaderState =
+                ErrorsListHeaderState.GetDefault();
+            TreeHeaderSettings.Load(
+                errorsListHeaderState,
+                treeSettingsName,
+                UnityConstants.UNSORT_COLUMN_ID);
+
+            mErrorsListView = new ErrorsListView(errorsListHeaderState);
+            mErrorsListView.Reload();
+
+            mErrorDetailsSplitterState = PlasticSplitterGUILayout.InitSplitterState(
+                new float[] { 0.60f, 0.40f },
+                new int[] { 100, 100 },
+                new int[] { 100000, 100000 }
+            );
+        }
+
+        internal void UpdateErrorsList(List<ErrorMessage> errorMessages)
+        {
+            mErrorsListView.BuildModel(errorMessages);
+            mErrorsListView.Reload();
+
+            IsVisible = errorMessages.Count > 0;
+        }
+
+        internal void OnDisable()
+        {
+            TreeHeaderSettings.Save(
+                mErrorsListView.multiColumnHeader.state,
+                UnityConstants.GLUON_INCOMING_ERRORS_TABLE_SETTINGS_NAME);
+        }
+
+        internal void OnGUI()
+        {
+            EditorGUILayout.BeginVertical();
+
+            DrawSplitter.ForHorizontalIndicator();
+            DoErrorsListArea(mErrorsListView, mErrorDetailsSplitterState);
+
+            EditorGUILayout.EndVertical();
+        }
+
+        void DoErrorsListArea(
+            ErrorsListView errorsListView,
+            object splitterState)
+        {
+            EditorGUILayout.BeginVertical();
+
+            GUILayout.Label(
+                mTitle,
+                EditorStyles.boldLabel);
+
+            DoErrorsListSplitViewArea(
+                errorsListView, splitterState);
+
+            EditorGUILayout.EndVertical();
+        }
+
+        void DoErrorsListSplitViewArea(
+            ErrorsListView errorsListView,
+            object splitterState)
+        {
+            EditorGUILayout.BeginHorizontal();
+
+            PlasticSplitterGUILayout.BeginHorizontalSplit(splitterState);
+
+            DoErrorsListViewArea(errorsListView);
+
+            DoErrorDetailsTextArea(errorsListView.GetSelectedError());
+
+            PlasticSplitterGUILayout.EndHorizontalSplit();
+
+            EditorGUILayout.EndHorizontal();
+        }
+
+        static void DoErrorsListViewArea(
+            ErrorsListView errorsListView)
+        {
+            Rect treeRect = GUILayoutUtility.GetRect(0, 100000, 0, 100000);
+
+            errorsListView.OnGUI(treeRect);
+        }
+
+        void DoErrorDetailsTextArea(ErrorMessage selectedErrorMessage)
+        {
+            string errorDetailsText = selectedErrorMessage == null ?
+                string.Empty : selectedErrorMessage.Error;
+
+            mErrorDetailsScrollPosition = GUILayout.BeginScrollView(
+                mErrorDetailsScrollPosition);
+
+            GUILayout.TextArea(
+                errorDetailsText, UnityStyles.TextFieldWithWrapping,
+                GUILayout.ExpandHeight(true));
+
+            GUILayout.EndScrollView();
+        }
+
+        Vector2 mErrorDetailsScrollPosition;
+
+        readonly string mTitle;
+        readonly ErrorsListView mErrorsListView;
+        readonly object mErrorDetailsSplitterState;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@c854d1f7d97f/Editor/Gluon/Errors/ErrorsPanel.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 79a84f5f92624d57ae40a84a53bd9d24
+timeCreated: 1737719456