Adaug proiectul Unity

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/UVCSToolbarBoostrap.cs

@@ -0,0 +1,59 @@
+#if UNITY_6000_3_OR_NEWER
+using UnityEditor;
+using UnityEngine;
+using UnityEditor.Toolbars;
+
+using Unity.PlasticSCM.Editor.Toolbar;
+
+namespace Assets.Plugins.PlasticSCM.Editor.Toolbar
+{
+    [InitializeOnLoad]
+    static class UVCSToolbarBoostrap
+    {
+        static UVCSToolbarBoostrap()
+        {
+            UVCSToolbar.Controller.OnToolbarInvalidated += RebuildToolbarButton;
+            UVCSToolbar.Controller.OnToolbarButtonInvalidated += RebuildToolbarButton;
+        }
+
+        [MainToolbarElement(ToolbarController.ToolbarButtonPath, defaultDockPosition = MainToolbarDockPosition.Left, defaultDockIndex = 13)]
+        [UnityOnlyMainToolbarPreset]
+        static MainToolbarDropdown CreateControl()
+        {
+            UVCSToolbarButtonData buttonData = UVCSToolbar.Controller.GetButtonData();
+
+            if (!buttonData.IsVisible)
+                return null;
+
+            return new MainToolbarDropdown(
+                new MainToolbarContent(
+                    Truncate(buttonData.Text, mMaxTextLength),
+                    buttonData.Icon as Texture2D,
+                    buttonData.Tooltip),
+                OpenDropdown);
+        }
+
+        static string Truncate(string text, int maxTextLength)
+        {
+            const string ellipsis = "...";
+
+            if (text.Length <= maxTextLength)
+                return text;
+
+            return string.Concat(text.Substring(0, maxTextLength - ellipsis.Length), ellipsis);
+        }
+
+        static void RebuildToolbarButton()
+        {
+            MainToolbar.Refresh(ToolbarController.ToolbarButtonPath);
+        }
+
+        static void OpenDropdown(Rect rect)
+        {
+            UVCSToolbar.Controller.PopupClicked(rect);
+        }
+
+        const int mMaxTextLength = 35;
+    }
+}
+#endif

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/UVCSToolbarBoostrap.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/UVCSToolbarBoostrap_Legacy.cs

@@ -0,0 +1,55 @@
+#if !UNITY_6000_3_OR_NEWER
+using UnityEditor;
+
+using Unity.PlasticSCM.Editor;
+using Unity.PlasticSCM.Editor.Configuration;
+using Unity.PlasticSCM.Editor.Toolbar;
+
+namespace Unity.Cloud.Collaborate
+{
+    [InitializeOnLoad]
+    static class UVCSToolbarBoostrap
+    {
+        static UVCSToolbarBoostrap()
+        {
+            mDropDownButton = new UVCSToolbarButton(
+                UVCSToolbar.Controller.PopupClicked,
+                Toolbar.RepaintToolbar);
+
+            Toolbar.AddSubToolbar(mDropDownButton);
+
+            UVCSToolbar.Controller.OnToolbarInvalidated += ToolbarInvalidated;
+            UVCSToolbar.Controller.OnToolbarButtonInvalidated += ButtonInvalidated;
+
+            // Wait for editor to be ready to invalidate the button
+            Execute.WhenEditorIsReady(ButtonInvalidated);
+        }
+
+        static void ToolbarInvalidated()
+        {
+            Toolbar.RepaintToolbar();
+        }
+
+        static void ButtonInvalidated()
+        {
+            UVCSToolbarButtonData buttonData = UVCSToolbar.Controller.GetButtonData();
+
+            mDropDownButton.BeginUpdate();
+
+            try
+            {
+                mDropDownButton.Text = buttonData.Text;
+                mDropDownButton.Tooltip = buttonData.Tooltip;
+                mDropDownButton.Icon = buttonData.Icon;
+                mDropDownButton.IsVisible = buttonData.IsVisible;
+            }
+            finally
+            {
+                mDropDownButton.EndUpdate();
+            }
+        }
+
+        static UVCSToolbarButton mDropDownButton;
+    }
+}
+#endif

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/UVCSToolbarBoostrap_Legacy.cs.meta

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

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/UVCSToolbarButton_Legacy.cs

@@ -0,0 +1,273 @@
+#if !UNITY_6000_3_OR_NEWER
+using System;
+
+using UnityEditor;
+using UnityEngine;
+
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.Cloud.Collaborate
+{
+    internal class UVCSToolbarButton : SubToolbar
+    {
+        internal UVCSToolbarButton(
+            Action<Rect> buttonClicked,
+            Action repaintToolbar)
+        {
+            mButtonClicked = buttonClicked;
+            mRepaintToolbar = repaintToolbar;
+
+            mTruncatedTextGUIContent = new GUIContent();
+            mTooltipButtonGUIContent = new GUIContent();
+        }
+
+        internal bool IsVisible
+        {
+            get { return mIsVisible; }
+            set
+            {
+                if (mIsVisible == value)
+                    return;
+
+                mIsVisible = value;
+                InvalidateLayout();
+            }
+        }
+
+        internal int MaxTextLength
+        {
+            get { return mMaxTextLenght; }
+            set
+            {
+                if (mMaxTextLenght == value || value < 6)
+                    return;
+
+                mMaxTextLenght = value;
+                mTruncatedTextGUIContent.text = Truncate(mText, MaxTextLength);
+                InvalidateLayout();
+            }
+        }
+
+        internal string Text
+        {
+            get { return mText; }
+            set
+            {
+                if (mText == value)
+                    return;
+
+                mText = value;
+                mTruncatedTextGUIContent.text = Truncate(mText, MaxTextLength);
+                InvalidateLayout();
+            }
+        }
+
+        internal string Tooltip
+        {
+            get { return mTooltipButtonGUIContent.tooltip; }
+            set
+            {
+                if (mTooltipButtonGUIContent.tooltip == value)
+                    return;
+
+                mTooltipButtonGUIContent.tooltip = value;
+                RequestRepaint();
+            }
+        }
+
+        internal Texture Icon
+        {
+            get { return mIcon; }
+            set
+            {
+                if (mIcon == value)
+                    return;
+
+                mIcon = value;
+                InvalidateLayout();
+            }
+        }
+
+        internal void BeginUpdate()
+        {
+            mBatchUpdateCount++;
+        }
+
+        internal void EndUpdate()
+        {
+            mBatchUpdateCount--;
+
+            if (mBatchUpdateCount <= 0)
+            {
+                mBatchUpdateCount = 0;
+                InvalidateLayout();
+            }
+        }
+
+        void InvalidateLayout()
+        {
+            if (mBatchUpdateCount > 0)
+                return;
+
+            mIsLayoutValid = false;
+            mRepaintToolbar();
+        }
+
+        void RequestRepaint()
+        {
+            if (mBatchUpdateCount > 0)
+                return;
+
+            mRepaintToolbar();
+        }
+
+        public override void OnGUI(Rect rect)
+        {
+            if (!mIsVisible)
+            {
+                Width = 0;
+                return;
+            }
+
+            if (mDropDownIcon == null)
+                mDropDownIcon = Images.GetDropDownIcon();
+
+            if (mButtonStyle == null)
+                mButtonStyle = UnityStyles.EditorToolbar.Button.AppCmdButton;
+
+            if (mTextStyle == null)
+                mTextStyle = UnityStyles.EditorToolbar.Button.ButtonText;
+
+            if (!mIsLayoutValid)
+            {
+                UpdateLayout();
+                Width = mLayout.TotalWidth;
+            }
+
+            if (rect.width == 0)
+                return;
+
+            Rect buttonRect = DrawButton(rect);
+
+            DrawIcon(buttonRect);
+            DrawText(buttonRect);
+            DrawDropDownIcon(buttonRect);
+        }
+
+        Rect DrawButton(Rect rect)
+        {
+            Rect buttonRect = new Rect(
+                rect.x,
+                rect.y,
+                mLayout.TotalWidth,
+                rect.height);
+
+            if (GUI.Button(buttonRect, mTooltipButtonGUIContent, mButtonStyle))
+            {
+                mButtonClicked.Invoke(buttonRect);
+            }
+
+            return buttonRect;
+        }
+
+        void DrawIcon(Rect buttonRect)
+        {
+            if (Icon == null)
+                return;
+
+            Rect iconRect = new Rect(
+                mLayout.IconX,
+                buttonRect.y + (buttonRect.height - Layout.ICON_SIZE) / 2,
+                Layout.ICON_SIZE,
+                Layout.ICON_SIZE);
+
+            GUI.DrawTexture(iconRect, Icon);
+        }
+
+        void DrawText(Rect buttonRect)
+        {
+            Rect textRect = new Rect(
+                mLayout.TextX,
+                buttonRect.y + (buttonRect.height - mLayout.TextSize.y) / 2,
+                mLayout.TextSize.x,
+                mLayout.TextSize.y);
+
+            GUI.Label(textRect, mTruncatedTextGUIContent, mTextStyle);
+        }
+
+        void DrawDropDownIcon(Rect buttonRect)
+        {
+            if (mDropDownIcon == null)
+                return;
+
+            Rect dropDownIconRect = new Rect(
+                mLayout.DropDownIconX,
+                buttonRect.y + (buttonRect.height - Layout.DROPDOWN_ICON_SIZE) / 2,
+                Layout.DROPDOWN_ICON_SIZE,
+                Layout.DROPDOWN_ICON_SIZE);
+
+            GUI.DrawTexture(dropDownIconRect, mDropDownIcon);
+        }
+
+        void UpdateLayout()
+        {
+            mLayout.TextSize = mTextStyle.CalcSize(mTruncatedTextGUIContent);
+
+            int margin = 2;
+
+            mLayout.IconX = mButtonStyle.margin.left + mButtonStyle.padding.left;
+            mLayout.TextX = Icon != null ? mLayout.IconX + Layout.ICON_SIZE + margin : mLayout.IconX;
+            mLayout.DropDownIconX = mLayout.TextX + mLayout.TextSize.x + margin;
+            mLayout.TotalWidth =
+                mLayout.DropDownIconX +
+                (mDropDownIcon != null ? Layout.DROPDOWN_ICON_SIZE : 0) +
+                mButtonStyle.margin.right +
+                mButtonStyle.margin.right;
+
+            mIsLayoutValid = true;
+        }
+
+        static string Truncate(string text, int maxTextLength)
+        {
+            const string ellipsis = "...";
+
+            if (text.Length <= maxTextLength)
+                return text;
+
+            return string.Concat(text.Substring(0, maxTextLength - ellipsis.Length), ellipsis);
+        }
+
+        readonly Action<Rect> mButtonClicked;
+        readonly Action mRepaintToolbar;
+
+        readonly GUIContent mTruncatedTextGUIContent;
+        readonly GUIContent mTooltipButtonGUIContent;
+
+        bool mIsVisible;
+        bool mIsLayoutValid;
+
+        Texture mIcon;
+        Texture mDropDownIcon;
+
+        int mMaxTextLenght = 35;
+        string mText;
+        GUIStyle mButtonStyle;
+        GUIStyle mTextStyle;
+
+        Layout mLayout;
+        int mBatchUpdateCount;
+
+        struct Layout
+        {
+            internal const int DROPDOWN_ICON_SIZE = 12;
+            internal const int ICON_SIZE = 16;
+
+            internal float IconX;
+            internal Vector2 TextSize;
+            internal float TextX;
+            internal float DropDownIconX;
+            internal float TotalWidth;
+        }
+    }
+}
+#endif

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/UVCSToolbarButton_Legacy.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1b769279d1324508b645aea1a29bae8c
+timeCreated: 1746456706

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/Unity.CollabProxy.Editor.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "Unity.CollabProxy.Editor",
+    "rootNamespace": "",
+    "references": [
+        "Unity.PlasticSCM.Editor"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/Unity.CollabProxy.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 17b36165d09634a48bf5a0e4bb27f4bd
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/UnityInternalsInjector.cs

@@ -0,0 +1,223 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+using UnityInternals = Unity.PlasticSCM.Editor.UnityInternals;
+
+namespace Unity.Cloud.Collaborate
+{
+    [InitializeOnLoad]
+    static class UnityInternalsInjector
+    {
+        static UnityInternalsInjector()
+        {
+            UnityInternals.UnityEditor.EditorGUI.ScrollableTextAreaInternal =
+                (Rect position, string text, ref Vector2 scrollPosition, GUIStyle style) =>
+                {
+                    return EditorGUI.ScrollableTextAreaInternal(position, text, ref scrollPosition, style);
+                };
+
+            UnityInternals.UnityEditor.InternalEditorGUIUtility.HasCurrentWindowKeyFocus =
+                () =>
+                {
+                    return EditorGUIUtility.HasCurrentWindowKeyFocus();
+                };
+
+            UnityInternals.UnityEditor.EditorGUI.DrawOutline =
+                (Rect rect, float size, Color color) =>
+                {
+                    EditorGUI.DrawOutline(rect, size, color);
+                };
+
+            UnityInternals.UnityEditor.EditorGUI.RecycledTextEditor.InternalEndEditing =
+                (UnityInternals.UnityEditor.EditorGUI.RecycledTextEditor recycledTextEditor) =>
+                {
+                    ((EditorGUI.RecycledTextEditor)recycledTextEditor.InternalObject).EndEditing();
+                };
+
+            UnityInternals.UnityEditor.SettingsWindow.ShowInternal =
+                (SettingsScope scopes, string settingsPath) =>
+                {
+                    SettingsWindow settingsWindow = SettingsWindow.Show(scopes, settingsPath);
+
+                    if (settingsWindow == null)
+                        return null;
+
+                    return new UnityInternals.UnityEditor.SettingsWindow(settingsWindow);
+                };
+
+            UnityInternals.UnityEditor.SettingsWindow.IsProjectSettingsWindowInternal =
+                (EditorWindow editorWindow) =>
+                {
+                    return editorWindow != null && editorWindow is ProjectSettingsWindow;
+                };
+
+            UnityInternals.UnityEditor.DockArea.AddTabInternal =
+                (UnityInternals.UnityEditor.DockArea dockArea, EditorWindow pane, bool sendPaneEvents) =>
+                {
+                    ((DockArea)dockArea.InternalObject).AddTab(pane, sendPaneEvents);
+                };
+
+            UnityInternals.UnityEditor.UnityEditorExtensions.m_ParentInternal =
+                (EditorWindow editorWindow) =>
+                {
+                    HostView hostView = editorWindow.m_Parent;
+
+                    if (hostView == null)
+                        return null;
+
+                    return new UnityInternals.UnityEditor.HostView(hostView);
+                };
+
+            UnityInternals.UnityEditor.HostView.GetActualViewInternal =
+                (UnityInternals.UnityEditor.HostView hostView) =>
+                {
+                    FieldInfo actualViewField = typeof(HostView).GetField(
+                        "m_ActualView",
+                        BindingFlags.Instance | BindingFlags.NonPublic);
+                    return actualViewField?.GetValue(hostView.InternalObject) as EditorWindow;
+                };
+
+            UnityInternals.UnityEditor.Menu.AddMenuItem =
+                (string name, string shortcut, bool @checked, int priority, Action execute, Func<bool> validate) =>
+                {
+                    Menu.AddMenuItem(name, shortcut, @checked, priority, execute, validate);
+                };
+
+            UnityInternals.UnityEditor.Menu.RemoveMenuItem =
+                (string name) =>
+                {
+                    Menu.RemoveMenuItem(name);
+                };
+
+            UnityInternals.UnityEditor.EditorUtility.Internal_UpdateAllMenus =
+                () =>
+                {
+                    EditorUtility.Internal_UpdateAllMenus();
+                };
+
+            UnityInternals.UnityEditor.Unsupported.GetFileIDHint =
+                (UnityEngine.Object obj) =>
+                {
+                    return Unsupported.GetFileIDHint(obj);
+                };
+
+            UnityInternals.UnityEditor.HostView.GetWindow =
+                (UnityInternals.UnityEditor.HostView hostView) =>
+                {
+                    ContainerWindow containerWindow = ((HostView)hostView.InternalObject).window;
+
+                    if (containerWindow == null)
+                        return null;
+
+                    return new UnityInternals.UnityEditor.ContainerWindow(containerWindow);
+                };
+
+            UnityInternals.UnityEditor.EditorWindow.Internal_MakeModal =
+                (UnityInternals.UnityEditor.ContainerWindow containerWindow) =>
+                {
+                    EditorWindow.Internal_MakeModal((ContainerWindow)containerWindow.InternalObject);
+                };
+
+            UnityInternals.UnityEditor.EditorWindow.GetInspectorWindow =
+                () =>
+                {
+                    return EditorWindow.GetWindow<UnityEditor.InspectorWindow>(
+                        title: null, focus: false);
+                };
+
+            UnityInternals.UnityEditor.UnityEditorExtensions.ShowWithModeInternal =
+                (EditorWindow editorWindow, int mode) =>
+                {
+                    editorWindow.ShowWithMode((ShowMode)mode);
+                };
+
+            UnityInternals.UnityEditor.SavedGUIState.Create =
+                () =>
+                {
+                    return new UnityInternals.UnityEditor.SavedGUIState(SavedGUIState.Create());
+                };
+
+            UnityInternals.UnityEditor.SavedGUIState.ApplyAndForgetInternal =
+                (UnityInternals.UnityEditor.SavedGUIState savedGUIState) =>
+                {
+                    ((SavedGUIState)savedGUIState.InternalObject).ApplyAndForget();
+                };
+
+            UnityInternals.UnityEditor.SplitterState.Constructor =
+                (float[] relativeSizes, int[] minSizes, int[] maxSizes) =>
+                {
+                    return new SplitterState(relativeSizes, minSizes, maxSizes);
+                };
+
+            UnityInternals.UnityEditor.SplitterState.GetRelativeSizes =
+                (UnityInternals.UnityEditor.SplitterState splitterState) =>
+                {
+                    return ((SplitterState)splitterState.InternalObject).relativeSizes;
+                };
+
+            UnityInternals.UnityEditor.SplitterGUILayout.BeginHorizontalSplit =
+                (UnityInternals.UnityEditor.SplitterState splitterState,
+                    GUILayoutOption[] guiLayoutOptions) =>
+                {
+                    SplitterGUILayout.BeginHorizontalSplit(
+                        (SplitterState)splitterState.InternalObject, guiLayoutOptions);
+                };
+
+            UnityInternals.UnityEditor.SplitterGUILayout.EndHorizontalSplit =
+                () =>
+                {
+                    SplitterGUILayout.EndHorizontalSplit();
+                };
+
+            UnityInternals.UnityEditor.SplitterGUILayout.BeginVerticalSplit =
+                (UnityInternals.UnityEditor.SplitterState splitterState,
+                    GUILayoutOption[] guiLayoutOptions) =>
+                {
+                    SplitterGUILayout.BeginVerticalSplit(
+                        (SplitterState)splitterState.InternalObject, guiLayoutOptions);
+                };
+
+            UnityInternals.UnityEditor.SplitterGUILayout.EndVerticalSplit =
+                () =>
+                {
+                    SplitterGUILayout.EndVerticalSplit();
+                };
+
+            UnityInternals.UnityEditor.SceneManagement.PrefabStageExtensions.SaveInternal =
+                (PrefabStage prefabStage) =>
+                {
+                    return prefabStage.Save();
+                };
+
+            UnityInternals.UnityEditor.GenericMenuExtensions.GetMenuItems =
+                (GenericMenu genericMenu) =>
+                {
+                    List<GenericMenu.MenuItem> menuItems = genericMenu.menuItems;
+
+                    if (menuItems == null)
+                        return null;
+
+                    return menuItems.Select(menuItem =>
+                        new UnityInternals.UnityEditor.GenericMenu.MenuItem(menuItem)).ToList();
+                };
+
+            UnityInternals.UnityEditor.GenericMenu.MenuItem.GetContent =
+                (UnityInternals.UnityEditor.GenericMenu.MenuItem menuItem) =>
+                {
+                    return ((GenericMenu.MenuItem)menuItem.InternalObject).content;
+                };
+
+            UnityInternals.UnityEditor.GenericMenu.MenuItem.GetFunc =
+                (UnityInternals.UnityEditor.GenericMenu.MenuItem menuItem) =>
+                {
+                    return ((GenericMenu.MenuItem)menuItem.InternalObject).func;
+                };
+        }
+    }
+}

Library/PackageCache/com.unity.collab-proxy@4628d2ba6ea4/Editor/UnityInternals/UnityInternalsInjector.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 660c279d5b14417c81d49ee4152e99a7
+timeCreated: 1763115824