虚拟列表和循环列表提交

UnityGame/Assets/Scripts/ThirdParty/LoopList/Editor/LoopScrollRectInspector.cs

@@ -0,0 +1,311 @@
+using UnityEditor;
+using UnityEditor.AnimatedValues;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.UI
+{
+    [CustomEditor(typeof(LoopScrollRectBase), true)]
+    public class LoopScrollRectInspector : Editor
+    {
+        SerializedProperty m_Content;
+        SerializedProperty m_Horizontal;
+        SerializedProperty m_Vertical;
+        SerializedProperty m_MovementType;
+        SerializedProperty m_Elasticity;
+        SerializedProperty m_Inertia;
+        SerializedProperty m_DecelerationRate;
+        SerializedProperty m_ScrollSensitivity;
+        SerializedProperty m_Viewport;
+        SerializedProperty m_HorizontalScrollbar;
+        SerializedProperty m_VerticalScrollbar;
+        SerializedProperty m_HorizontalScrollbarVisibility;
+        SerializedProperty m_VerticalScrollbarVisibility;
+        SerializedProperty m_HorizontalScrollbarSpacing;
+        SerializedProperty m_VerticalScrollbarSpacing;
+        SerializedProperty m_OnValueChanged;
+        AnimBool m_ShowElasticity;
+        AnimBool m_ShowDecelerationRate;
+        bool m_ViewportIsNotChild, m_HScrollbarIsNotChild, m_VScrollbarIsNotChild;
+        static string s_HError = "For this visibility mode, the Viewport property and the Horizontal Scrollbar property both needs to be set to a Rect Transform that is a child to the Scroll Rect.";
+        static string s_VError = "For this visibility mode, the Viewport property and the Vertical Scrollbar property both needs to be set to a Rect Transform that is a child to the Scroll Rect.";
+
+        //==========LoopScrollRect==========
+        SerializedProperty totalCount;
+        SerializedProperty reverseDirection;
+        
+        int firstItem = 0, lastItem = 0, scrollIndex = 0;
+        float firstOffset = 0.0f, lastOffset = 0.0f, scrollOffset = 0;
+        LoopScrollRectBase.ScrollMode scrollMode = LoopScrollRectBase.ScrollMode.ToStart;
+        float scrollSpeed = 1000, scrollTime = 1;
+
+        protected virtual void OnEnable()
+        {
+            m_Content = serializedObject.FindProperty("m_Content");
+            m_Horizontal = serializedObject.FindProperty("m_Horizontal");
+            m_Vertical = serializedObject.FindProperty("m_Vertical");
+            m_MovementType = serializedObject.FindProperty("m_MovementType");
+            m_Elasticity = serializedObject.FindProperty("m_Elasticity");
+            m_Inertia = serializedObject.FindProperty("m_Inertia");
+            m_DecelerationRate = serializedObject.FindProperty("m_DecelerationRate");
+            m_ScrollSensitivity = serializedObject.FindProperty("m_ScrollSensitivity");
+            m_Viewport = serializedObject.FindProperty("m_Viewport");
+            m_HorizontalScrollbar = serializedObject.FindProperty("m_HorizontalScrollbar");
+            m_VerticalScrollbar = serializedObject.FindProperty("m_VerticalScrollbar");
+            m_HorizontalScrollbarVisibility = serializedObject.FindProperty("m_HorizontalScrollbarVisibility");
+            m_VerticalScrollbarVisibility = serializedObject.FindProperty("m_VerticalScrollbarVisibility");
+            m_HorizontalScrollbarSpacing = serializedObject.FindProperty("m_HorizontalScrollbarSpacing");
+            m_VerticalScrollbarSpacing = serializedObject.FindProperty("m_VerticalScrollbarSpacing");
+            m_OnValueChanged = serializedObject.FindProperty("m_OnValueChanged");
+
+            m_ShowElasticity = new AnimBool(Repaint);
+            m_ShowDecelerationRate = new AnimBool(Repaint);
+            SetAnimBools(true);
+
+            //==========LoopScrollRect==========
+            totalCount = serializedObject.FindProperty("totalCount");
+            reverseDirection = serializedObject.FindProperty("reverseDirection");
+        }
+
+        protected virtual void OnDisable()
+        {
+            m_ShowElasticity.valueChanged.RemoveListener(Repaint);
+            m_ShowDecelerationRate.valueChanged.RemoveListener(Repaint);
+        }
+
+        void SetAnimBools(bool instant)
+        {
+            SetAnimBool(m_ShowElasticity, !m_MovementType.hasMultipleDifferentValues && m_MovementType.enumValueIndex == (int)ScrollRect.MovementType.Elastic, instant);
+            SetAnimBool(m_ShowDecelerationRate, !m_Inertia.hasMultipleDifferentValues && m_Inertia.boolValue == true, instant);
+        }
+
+        void SetAnimBool(AnimBool a, bool value, bool instant)
+        {
+            if (instant)
+                a.value = value;
+            else
+                a.target = value;
+        }
+
+        void CalculateCachedValues()
+        {
+            m_ViewportIsNotChild = false;
+            m_HScrollbarIsNotChild = false;
+            m_VScrollbarIsNotChild = false;
+            if (targets.Length == 1)
+            {
+                Transform transform = ((LoopScrollRectBase)target).transform;
+                if (m_Viewport.objectReferenceValue == null || ((RectTransform)m_Viewport.objectReferenceValue).transform.parent != transform)
+                    m_ViewportIsNotChild = true;
+                if (m_HorizontalScrollbar.objectReferenceValue == null || ((Scrollbar)m_HorizontalScrollbar.objectReferenceValue).transform.parent != transform)
+                    m_HScrollbarIsNotChild = true;
+                if (m_VerticalScrollbar.objectReferenceValue == null || ((Scrollbar)m_VerticalScrollbar.objectReferenceValue).transform.parent != transform)
+                    m_VScrollbarIsNotChild = true;
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            SetAnimBools(false);
+
+            serializedObject.Update();
+            // Once we have a reliable way to know if the object changed, only re-cache in that case.
+            CalculateCachedValues();
+
+            EditorGUILayout.LabelField("Scroll Rect", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_Content);
+
+            EditorGUILayout.PropertyField(m_Horizontal);
+            EditorGUILayout.PropertyField(m_Vertical);
+
+            EditorGUILayout.PropertyField(m_MovementType);
+            if (EditorGUILayout.BeginFadeGroup(m_ShowElasticity.faded))
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_Elasticity);
+                EditorGUI.indentLevel--;
+            }
+            EditorGUILayout.EndFadeGroup();
+
+            EditorGUILayout.PropertyField(m_Inertia);
+            if (EditorGUILayout.BeginFadeGroup(m_ShowDecelerationRate.faded))
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_DecelerationRate);
+                EditorGUI.indentLevel--;
+            }
+            EditorGUILayout.EndFadeGroup();
+
+            EditorGUILayout.PropertyField(m_ScrollSensitivity);
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(m_Viewport);
+
+            EditorGUILayout.PropertyField(m_HorizontalScrollbar);
+            if (m_HorizontalScrollbar.objectReferenceValue && !m_HorizontalScrollbar.hasMultipleDifferentValues)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_HorizontalScrollbarVisibility, EditorGUIUtility.TrTextContent("Visibility"));
+
+                if ((ScrollRect.ScrollbarVisibility)m_HorizontalScrollbarVisibility.enumValueIndex == ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport
+                    && !m_HorizontalScrollbarVisibility.hasMultipleDifferentValues)
+                {
+                    if (m_ViewportIsNotChild || m_HScrollbarIsNotChild)
+                        EditorGUILayout.HelpBox(s_HError, MessageType.Error);
+                    EditorGUILayout.PropertyField(m_HorizontalScrollbarSpacing, EditorGUIUtility.TrTextContent("Spacing"));
+                }
+
+                EditorGUI.indentLevel--;
+            }
+
+            EditorGUILayout.PropertyField(m_VerticalScrollbar);
+            if (m_VerticalScrollbar.objectReferenceValue && !m_VerticalScrollbar.hasMultipleDifferentValues)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_VerticalScrollbarVisibility, EditorGUIUtility.TrTextContent("Visibility"));
+
+                if ((ScrollRect.ScrollbarVisibility)m_VerticalScrollbarVisibility.enumValueIndex == ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport
+                    && !m_VerticalScrollbarVisibility.hasMultipleDifferentValues)
+                {
+                    if (m_ViewportIsNotChild || m_VScrollbarIsNotChild)
+                        EditorGUILayout.HelpBox(s_VError, MessageType.Error);
+                    EditorGUILayout.PropertyField(m_VerticalScrollbarSpacing, EditorGUIUtility.TrTextContent("Spacing"));
+                }
+
+                EditorGUI.indentLevel--;
+            }
+        
+            EditorGUILayout.PropertyField(m_OnValueChanged);
+
+            //==========LoopScrollRect==========
+            EditorGUILayout.LabelField("Loop Scroll Rect", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(totalCount);
+            EditorGUILayout.PropertyField(reverseDirection);
+        
+            serializedObject.ApplyModifiedProperties();
+            
+            LoopScrollRectBase scroll = (LoopScrollRectBase)target;
+            GUI.enabled = Application.isPlaying;
+            const float buttonWidth = 100f;
+
+            #region Basic Test
+            EditorGUILayout.LabelField("Basic Test", EditorStyles.boldLabel);
+            
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Clear existing items");
+            GUILayout.FlexibleSpace();
+            if (GUILayout.Button("Clear", GUILayout.Width(buttonWidth)))
+            {
+                scroll.ClearCells();
+            }
+            EditorGUILayout.EndHorizontal();
+            
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Refresh existing items(only update data)");
+            GUILayout.FlexibleSpace();
+            if (GUILayout.Button("Refresh", GUILayout.Width(buttonWidth)))
+            {
+                scroll.RefreshCells();
+            }
+            EditorGUILayout.EndHorizontal();
+            
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Refill(0, 0.0f)");
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("Refill", GUILayout.Width(buttonWidth)))
+            {
+                scroll.RefillCells();
+            }
+            EditorGUILayout.EndHorizontal();
+            
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("RefillFromEnd(0, 0.0f)");
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("RefillFromEnd", GUILayout.Width(buttonWidth)))
+            {
+                scroll.RefillCellsFromEnd();
+            }
+            EditorGUILayout.EndHorizontal();
+            #endregion
+
+            #region Refill Test
+            EditorGUILayout.LabelField("Refill Test", EditorStyles.boldLabel);
+            
+            firstItem = EditorGUILayout.IntField("FirstItem", firstItem);
+            firstOffset = EditorGUILayout.FloatField("FirstOffset", firstOffset);
+            
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Get first item and offset");
+            GUILayout.FlexibleSpace();
+            if (GUILayout.Button("GetFirstItem", GUILayout.Width(buttonWidth)))
+            {
+                firstItem = scroll.GetFirstItem(out firstOffset);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Refill with first item and offset");
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("Refill", GUILayout.Width(buttonWidth)))
+            {
+                scroll.RefillCells(scroll.reverseDirection ? (scroll.totalCount - firstItem) : firstItem, firstOffset);
+            }
+            EditorGUILayout.EndHorizontal();
+            #endregion
+            
+            #region Refill Test
+            EditorGUILayout.LabelField("RefillFromEnd Test", EditorStyles.boldLabel);
+            
+            lastItem = EditorGUILayout.IntField("LastItem", lastItem);
+            lastOffset = EditorGUILayout.FloatField("LastOffset", lastOffset);
+            
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Get last item and offset");
+            GUILayout.FlexibleSpace();
+            if (GUILayout.Button("GetLastItem", GUILayout.Width(buttonWidth)))
+            {
+                lastItem = scroll.GetLastItem(out lastOffset);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("RefillFromEnd with last item and offset");
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("RefillFromEnd", GUILayout.Width(buttonWidth)))
+            {
+                scroll.RefillCellsFromEnd(scroll.reverseDirection ? lastItem : (scroll.totalCount - lastItem), lastOffset);
+            }
+            EditorGUILayout.EndHorizontal();
+            #endregion
+
+            #region Scroll Test
+            EditorGUILayout.LabelField("Scroll Test", EditorStyles.boldLabel);
+            scrollIndex = EditorGUILayout.IntField("ScrollIndex", scrollIndex);
+            scrollOffset = EditorGUILayout.FloatField("ScrollOffset", scrollOffset);
+            scrollMode = (LoopScrollRectBase.ScrollMode)EditorGUILayout.EnumPopup("Mode", scrollMode);
+            
+            scrollSpeed = EditorGUILayout.FloatField("Speed", scrollSpeed);
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Scroll to index and offset with speed");
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("ScrollToCell", GUILayout.Width(buttonWidth)))
+            {
+                scroll.ScrollToCell(scrollIndex, scrollSpeed, scrollOffset, scrollMode);
+            }
+            EditorGUILayout.EndHorizontal();
+        
+            scrollTime = EditorGUILayout.FloatField("Time", scrollTime);
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Scroll to index and offset whtin time");
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("ScrollToCellWithinTime", GUILayout.Width(buttonWidth)))
+            {
+                scroll.ScrollToCellWithinTime(scrollIndex, scrollTime, scrollOffset, scrollMode);
+            }
+            EditorGUILayout.EndHorizontal();
+            #endregion
+        }
+    }
+}

UnityGame/Assets/Scripts/ThirdParty/LoopList/Editor/LoopScrollRectInspector.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 216d44a40b90b944db6c5f4624768e58
+timeCreated: 1439395663
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityGame/Assets/Scripts/ThirdParty/LoopList/Editor/SGDefaultControls.cs

@@ -0,0 +1,182 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace UnityEngine.UI
+{
+    public static class SGDefaultControls
+    {
+        #region code from DefaultControls.cs
+        public struct Resources
+        {
+            public Sprite standard;
+            public Sprite background;
+            public Sprite inputField;
+            public Sprite knob;
+            public Sprite checkmark;
+            public Sprite dropdown;
+            public Sprite mask;
+        }
+
+        private const float kWidth = 160f;
+        private const float kThickHeight = 30f;
+        private const float kThinHeight = 20f;
+        //private static Vector2 s_ThickElementSize = new Vector2(kWidth, kThickHeight);
+        //private static Vector2 s_ThinElementSize = new Vector2(kWidth, kThinHeight);
+        //private static Vector2 s_ImageElementSize = new Vector2(100f, 100f);
+        //private static Color s_DefaultSelectableColor = new Color(1f, 1f, 1f, 1f);
+        //private static Color s_PanelColor = new Color(1f, 1f, 1f, 0.392f);
+        private static Color s_TextColor = new Color(50f / 255f, 50f / 255f, 50f / 255f, 1f);
+
+        // Helper methods at top
+
+        private static GameObject CreateUIElementRoot(string name, Vector2 size)
+        {
+            GameObject child = new GameObject(name);
+            RectTransform rectTransform = child.AddComponent<RectTransform>();
+            rectTransform.sizeDelta = size;
+            return child;
+        }
+
+        static GameObject CreateUIObject(string name, GameObject parent)
+        {
+            GameObject go = new GameObject(name);
+            go.AddComponent<RectTransform>();
+            SetParentAndAlign(go, parent);
+            return go;
+        }
+
+        private static void SetDefaultTextValues(Text lbl)
+        {
+            // Set text values we want across UI elements in default controls.
+            // Don't set values which are the same as the default values for the Text component,
+            // since there's no point in that, and it's good to keep them as consistent as possible.
+            lbl.color = s_TextColor;
+        }
+
+        private static void SetDefaultColorTransitionValues(Selectable slider)
+        {
+            ColorBlock colors = slider.colors;
+            colors.highlightedColor = new Color(0.882f, 0.882f, 0.882f);
+            colors.pressedColor = new Color(0.698f, 0.698f, 0.698f);
+            colors.disabledColor = new Color(0.521f, 0.521f, 0.521f);
+        }
+
+        private static void SetParentAndAlign(GameObject child, GameObject parent)
+        {
+            if (parent == null)
+                return;
+
+            child.transform.SetParent(parent.transform, false);
+            SetLayerRecursively(child, parent.layer);
+        }
+
+        private static void SetLayerRecursively(GameObject go, int layer)
+        {
+            go.layer = layer;
+            Transform t = go.transform;
+            for (int i = 0; i < t.childCount; i++)
+                SetLayerRecursively(t.GetChild(i).gameObject, layer);
+        }
+        #endregion
+        
+        public static GameObject CreateLoopHorizontalScrollRect(DefaultControls.Resources resources)
+        {
+            GameObject root = CreateUIElementRoot("Loop Horizontal Scroll Rect", new Vector2(200, 200));
+            
+            GameObject viewport = CreateUIObject("Viewport", root);
+            
+            RectTransform viewportRT = viewport.GetComponent<RectTransform>();
+            viewportRT.anchorMin = new Vector2(0, 0);
+            viewportRT.anchorMax = new Vector2(1, 1);
+            viewportRT.sizeDelta = new Vector2(0, 0);
+            viewportRT.pivot = new Vector2(0.5f, 0.5f);
+
+            viewport.AddComponent<RectMask2D>();
+            
+            GameObject content = CreateUIObject("Content", viewport);
+
+            RectTransform contentRT = content.GetComponent<RectTransform>();
+            contentRT.anchorMin = new Vector2(0, 0);
+            contentRT.anchorMax = new Vector2(0, 1);
+            contentRT.sizeDelta = new Vector2(0, 0);
+            contentRT.pivot = new Vector2(0, 0.5f);
+
+            // Setup UI components.
+
+            LoopHorizontalScrollRect scrollRect = root.AddComponent<LoopHorizontalScrollRect>();
+            scrollRect.content = contentRT;
+            scrollRect.viewport = viewportRT;
+            scrollRect.horizontalScrollbar = null;
+            scrollRect.verticalScrollbar = null;
+            scrollRect.horizontal = true;
+            scrollRect.vertical = false;
+            scrollRect.horizontalScrollbarVisibility = LoopScrollRect.ScrollbarVisibility.Permanent;
+            scrollRect.verticalScrollbarVisibility = LoopScrollRect.ScrollbarVisibility.Permanent;
+            scrollRect.horizontalScrollbarSpacing = 0;
+            scrollRect.verticalScrollbarSpacing = 0;
+
+            root.AddComponent<CreatGame.UI.UILoopList>();
+            
+            HorizontalLayoutGroup layoutGroup = content.AddComponent<HorizontalLayoutGroup>();
+            layoutGroup.childAlignment = TextAnchor.MiddleLeft;
+            layoutGroup.childForceExpandWidth = false;
+            layoutGroup.childForceExpandHeight = true;
+
+            ContentSizeFitter sizeFitter = content.AddComponent<ContentSizeFitter>();
+            sizeFitter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
+            sizeFitter.verticalFit = ContentSizeFitter.FitMode.Unconstrained;
+
+            return root;
+        }
+
+        public static GameObject CreateLoopVerticalScrollRect(DefaultControls.Resources resources)
+        {
+            GameObject root = CreateUIElementRoot("Loop Vertical Scroll Rect", new Vector2(200, 200));
+            
+            GameObject viewport = CreateUIObject("Viewport", root);
+            
+            RectTransform viewportRT = viewport.GetComponent<RectTransform>();
+            viewportRT.anchorMin = new Vector2(0, 0);
+            viewportRT.anchorMax = new Vector2(1, 1);
+            viewportRT.sizeDelta = new Vector2(0, 0);
+            viewportRT.pivot = new Vector2(0.5f, 0.5f);
+
+            viewport.AddComponent<RectMask2D>();
+            
+            GameObject content = CreateUIObject("Content", viewport);
+            
+            RectTransform contentRT = content.GetComponent<RectTransform>();
+            contentRT.anchorMin = new Vector2(0, 1);
+            contentRT.anchorMax = new Vector2(1, 1);
+            contentRT.sizeDelta = new Vector2(0, 0);
+            contentRT.pivot = new Vector2(0.5f, 1);
+
+            // Setup UI components.
+
+            LoopVerticalScrollRect scrollRect = root.AddComponent<LoopVerticalScrollRect>();
+            scrollRect.content = contentRT;
+            scrollRect.viewport = viewportRT;
+            scrollRect.horizontalScrollbar = null;
+            scrollRect.verticalScrollbar = null;
+            scrollRect.horizontal = false;
+            scrollRect.vertical = true;
+            scrollRect.horizontalScrollbarVisibility = LoopScrollRect.ScrollbarVisibility.Permanent;
+            scrollRect.verticalScrollbarVisibility = LoopScrollRect.ScrollbarVisibility.Permanent;
+            scrollRect.horizontalScrollbarSpacing = 0;
+            scrollRect.verticalScrollbarSpacing = 0;
+            
+            root.AddComponent<CreatGame.UI.UILoopList>();
+
+            VerticalLayoutGroup layoutGroup = content.AddComponent<VerticalLayoutGroup>();
+            layoutGroup.childAlignment = TextAnchor.UpperCenter;
+            layoutGroup.childForceExpandWidth = true;
+            layoutGroup.childForceExpandHeight = false;
+
+            ContentSizeFitter sizeFitter = content.AddComponent<ContentSizeFitter>();
+            sizeFitter.horizontalFit = ContentSizeFitter.FitMode.Unconstrained;
+            sizeFitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+
+            return root;
+        }
+    }
+}

UnityGame/Assets/Scripts/ThirdParty/LoopList/Editor/SGDefaultControls.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9e2cfa47387224a4eb069fc6dc8ac8b3
+timeCreated: 1476279563
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityGame/Assets/Scripts/ThirdParty/LoopList/Editor/SGMenuOptions.cs

@@ -0,0 +1,151 @@
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace UnityEditor.UI
+{
+    static internal class SGMenuOptions
+    {
+        #region code from MenuOptions.cs
+        private const string kUILayerName = "UI";
+
+        private const string kStandardSpritePath = "UI/Skin/UISprite.psd";
+        private const string kBackgroundSpritePath = "UI/Skin/Background.psd";
+        private const string kInputFieldBackgroundPath = "UI/Skin/InputFieldBackground.psd";
+        private const string kKnobPath = "UI/Skin/Knob.psd";
+        private const string kCheckmarkPath = "UI/Skin/Checkmark.psd";
+        private const string kDropdownArrowPath = "UI/Skin/DropdownArrow.psd";
+        private const string kMaskPath = "UI/Skin/UIMask.psd";
+
+        static private DefaultControls.Resources s_StandardResources;
+
+        static private DefaultControls.Resources GetStandardResources()
+        {
+            if (s_StandardResources.standard == null)
+            {
+                s_StandardResources.standard = AssetDatabase.GetBuiltinExtraResource<Sprite>(kStandardSpritePath);
+                s_StandardResources.background = AssetDatabase.GetBuiltinExtraResource<Sprite>(kBackgroundSpritePath);
+                s_StandardResources.inputField = AssetDatabase.GetBuiltinExtraResource<Sprite>(kInputFieldBackgroundPath);
+                s_StandardResources.knob = AssetDatabase.GetBuiltinExtraResource<Sprite>(kKnobPath);
+                s_StandardResources.checkmark = AssetDatabase.GetBuiltinExtraResource<Sprite>(kCheckmarkPath);
+                s_StandardResources.dropdown = AssetDatabase.GetBuiltinExtraResource<Sprite>(kDropdownArrowPath);
+                s_StandardResources.mask = AssetDatabase.GetBuiltinExtraResource<Sprite>(kMaskPath);
+            }
+            return s_StandardResources;
+        }
+
+        private static void SetPositionVisibleinSceneView(RectTransform canvasRTransform, RectTransform itemTransform)
+        {
+            // Find the best scene view
+            SceneView sceneView = SceneView.lastActiveSceneView;
+            if (sceneView == null && SceneView.sceneViews.Count > 0)
+                sceneView = SceneView.sceneViews[0] as SceneView;
+
+            // Couldn't find a SceneView. Don't set position.
+            if (sceneView == null || sceneView.camera == null)
+                return;
+
+            // Create world space Plane from canvas position.
+            Vector2 localPlanePosition;
+            Camera camera = sceneView.camera;
+            Vector3 position = Vector3.zero;
+            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasRTransform, new Vector2(camera.pixelWidth / 2, camera.pixelHeight / 2), camera, out localPlanePosition))
+            {
+                // Adjust for canvas pivot
+                localPlanePosition.x = localPlanePosition.x + canvasRTransform.sizeDelta.x * canvasRTransform.pivot.x;
+                localPlanePosition.y = localPlanePosition.y + canvasRTransform.sizeDelta.y * canvasRTransform.pivot.y;
+
+                localPlanePosition.x = Mathf.Clamp(localPlanePosition.x, 0, canvasRTransform.sizeDelta.x);
+                localPlanePosition.y = Mathf.Clamp(localPlanePosition.y, 0, canvasRTransform.sizeDelta.y);
+
+                // Adjust for anchoring
+                position.x = localPlanePosition.x - canvasRTransform.sizeDelta.x * itemTransform.anchorMin.x;
+                position.y = localPlanePosition.y - canvasRTransform.sizeDelta.y * itemTransform.anchorMin.y;
+
+                Vector3 minLocalPosition;
+                minLocalPosition.x = canvasRTransform.sizeDelta.x * (0 - canvasRTransform.pivot.x) + itemTransform.sizeDelta.x * itemTransform.pivot.x;
+                minLocalPosition.y = canvasRTransform.sizeDelta.y * (0 - canvasRTransform.pivot.y) + itemTransform.sizeDelta.y * itemTransform.pivot.y;
+
+                Vector3 maxLocalPosition;
+                maxLocalPosition.x = canvasRTransform.sizeDelta.x * (1 - canvasRTransform.pivot.x) - itemTransform.sizeDelta.x * itemTransform.pivot.x;
+                maxLocalPosition.y = canvasRTransform.sizeDelta.y * (1 - canvasRTransform.pivot.y) - itemTransform.sizeDelta.y * itemTransform.pivot.y;
+
+                position.x = Mathf.Clamp(position.x, minLocalPosition.x, maxLocalPosition.x);
+                position.y = Mathf.Clamp(position.y, minLocalPosition.y, maxLocalPosition.y);
+            }
+
+            itemTransform.anchoredPosition = position;
+            itemTransform.localRotation = Quaternion.identity;
+            itemTransform.localScale = Vector3.one;
+        }
+
+        private static void PlaceUIElementRoot(GameObject element, MenuCommand menuCommand)
+        {
+            GameObject parent = menuCommand.context as GameObject;
+            if (parent == null || parent.GetComponentInParent<Canvas>() == null)
+            {
+                parent = GetOrCreateCanvasGameObject();
+            }
+
+            string uniqueName = GameObjectUtility.GetUniqueNameForSibling(parent.transform, element.name);
+            element.name = uniqueName;
+            Undo.RegisterCreatedObjectUndo(element, "Create " + element.name);
+            Undo.SetTransformParent(element.transform, parent.transform, "Parent " + element.name);
+            GameObjectUtility.SetParentAndAlign(element, parent);
+            if (parent != menuCommand.context) // not a context click, so center in sceneview
+                SetPositionVisibleinSceneView(parent.GetComponent<RectTransform>(), element.GetComponent<RectTransform>());
+
+            Selection.activeGameObject = element;
+        }
+
+        static public GameObject CreateNewUI()
+        {
+            // Root for the UI
+            var root = new GameObject("Canvas");
+            root.layer = LayerMask.NameToLayer(kUILayerName);
+            Canvas canvas = root.AddComponent<Canvas>();
+            canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+            root.AddComponent<CanvasScaler>();
+            root.AddComponent<GraphicRaycaster>();
+            Undo.RegisterCreatedObjectUndo(root, "Create " + root.name);
+
+            // if there is no event system add one...
+            // CreateEventSystem(false);
+            return root;
+        }
+
+        // Helper function that returns a Canvas GameObject; preferably a parent of the selection, or other existing Canvas.
+        static public GameObject GetOrCreateCanvasGameObject()
+        {
+            GameObject selectedGo = Selection.activeGameObject;
+
+            // Try to find a gameobject that is the selected GO or one if its parents.
+            Canvas canvas = (selectedGo != null) ? selectedGo.GetComponentInParent<Canvas>() : null;
+            if (canvas != null && canvas.gameObject.activeInHierarchy)
+                return canvas.gameObject;
+
+            // No canvas in selection or its parents? Then use just any canvas..
+            canvas = Object.FindObjectOfType(typeof(Canvas)) as Canvas;
+            if (canvas != null && canvas.gameObject.activeInHierarchy)
+                return canvas.gameObject;
+
+            // No canvas in the scene at all? Then create a new one.
+            return SGMenuOptions.CreateNewUI();
+        }
+        #endregion
+        
+        [MenuItem("GameObject/UI/Loop Horizontal Scroll Rect", false, 2151)]
+        static public void AddLoopHorizontalScrollRect(MenuCommand menuCommand)
+        {
+            GameObject go = SGDefaultControls.CreateLoopHorizontalScrollRect(GetStandardResources());
+            PlaceUIElementRoot(go, menuCommand);
+        }
+
+        [MenuItem("GameObject/UI/Loop Vertical Scroll Rect", false, 2152)]
+        static public void AddLoopVerticalScrollRect(MenuCommand menuCommand)
+        {
+            GameObject go = SGDefaultControls.CreateLoopVerticalScrollRect(GetStandardResources());
+            PlaceUIElementRoot(go, menuCommand);
+        }
+    }
+}

UnityGame/Assets/Scripts/ThirdParty/LoopList/Editor/SGMenuOptions.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c4b63bf28f5af0e42a464ac316fef603
+timeCreated: 1476279563
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: