using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace Rainbow.UI
{
    /// <summary>
    /// 根据Context的bounds，自动判断ScrollRect 是否可以滑动！当检测的几何框大小发生变化的时候会重新计算
    /// 以Vertical为例当高度小于ScrollRect的高度，锁定垂直方向上的滑动
    /// *要点1、必须挂在需要检测RectTransform变化的GameObject上 Content上
    /// *要点2、设置 scrollRect
    /// *要点3、设置 dragDir
    /// </summary>
    [RequireComponent(typeof(RectTransform))]
    public class UIScrollDragAdapter : UIBehaviour
    {
        public ScrollRect scrollRect;
        public DragDir dragDir;
        RectTransform rectTransform;
        RectTransform scrollRectTransform;

        public enum DragDir
        {
            Vertical,
            Horizontal,
        }

        protected override void Start()
        {
            rectTransform = GetComponent<RectTransform>();
            if (scrollRect != null)
            {
                scrollRectTransform = scrollRect.GetComponent<RectTransform>();
            }
            OnRectTransformDimensionsChange();
        }
        protected override void OnRectTransformDimensionsChange()
        {
            if (rectTransform == null || scrollRectTransform == null)
            {
                return;
            }
            Bounds bounds = RectTransformUtility.CalculateRelativeRectTransformBounds(scrollRectTransform, rectTransform);

            if (dragDir == DragDir.Vertical)
            {
                bool dragv = bounds.size.y > scrollRectTransform.sizeDelta.y;
                scrollRect.vertical = dragv;
            }

            if (dragDir == DragDir.Horizontal)
            {
                bool dragh = bounds.size.x > scrollRectTransform.sizeDelta.x;
                scrollRect.horizontal = dragh;
            }
        }

    }
}

protected enum SelectionState
{
    Normal,         // 默认状态
    Highlighted,    //鼠标悬浮
    Pressed,        //点击
    Selected,       //选中
    Disabled        //禁用
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using DG.Tweening;
using Unity.VisualScripting;

namespace Rainbow.UI
{
    public class UIScaleButton : Button
    {
        [SerializeField]
        public float m_ScaleUp = 1f;
        [SerializeField]
        public float m_ScaleDown = 0.95f;
        [SerializeField]
        Transform m_Target;

        private float transScale = 1f;

        Tween tween;

        protected override void DoStateTransition(SelectionState state, bool instant)
        {
            base.DoStateTransition(state, instant);
            switch (state)
            {
                case SelectionState.Normal:
                    transScale = m_ScaleUp;
                    break;
                case SelectionState.Pressed:
                    transScale = m_ScaleDown;
                    break;
                default:
                    transScale = m_ScaleUp;
                    break;
            }
            DoScale();

        }

        void DoScale()
        {
            Transform tweenTrans = m_Target ? m_Target : transform;
            tween = tweenTrans.DOScale(Vector3.one * transScale, 0.3f).SetEase(Ease.OutBack);
        }

        protected override void OnDestroy()
        {
            base.OnDestroy();
            tween.Kill();
        }

    }
}

using UnityEditor;
using UnityEditor.UI;
using UnityEngine;

namespace Rainbow.UI
{
    [CustomEditor(typeof(UIScaleButton))]
    [DisallowMultipleComponent]
    public class UIScaleButtonEditor : ButtonEditor
    {
        SerializedProperty m_ScaleUpProperty;
        SerializedProperty m_ScaleDownProperty;
        SerializedProperty m_TargetProperty;
        protected override void OnEnable()
        {
            base.OnEnable();
            m_ScaleUpProperty = serializedObject.FindProperty("m_ScaleUp");
            m_ScaleDownProperty = serializedObject.FindProperty("m_ScaleDown");
            m_TargetProperty = serializedObject.FindProperty("m_Target");
        }

        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();
            serializedObject.Update();
            EditorGUILayout.PropertyField(m_ScaleUpProperty);
            EditorGUILayout.PropertyField(m_ScaleDownProperty);
            EditorGUILayout.PropertyField(m_TargetProperty);
            serializedObject.ApplyModifiedProperties();
        }
    }
}

using TMPro.EditorUtilities;
using UnityEditor;
using UnityEngine;
using UnityEngine.UI;
namespace Rainbow.UI
{
    public static class UGUIExt_CreateObjectMenu 
    {
        [MenuItem("GameObject/UI/ScaleButton - TextMeshPro", false, 2031)]
        public static void AddButton(MenuCommand menuCommand)
        {
            TMPro_CreateObjectMenu.AddButton(menuCommand);
           
            for (int i = 0; i < Selection.gameObjects.Length; i++)
            {
                 string selectName = Selection.gameObjects[i].name;
                 if(selectName == "Button")
                 { 
                    GameObject tg = Selection.gameObjects[i];
                    tg.name = "UIScaleButton";
                    GameObject.DestroyImmediate(tg.GetComponent<Button>());
                    tg.AddComponent<UIScaleButton>();
                 }
            }
        }

    }
}

[MenuItem("GameObject/UI/Image", false, 2001)]
static public void AddImage(MenuCommand menuCommand)
{
    GameObject go = DefaultControls.CreateImage(GetStandardResources());
    PlaceUIElementRoot(go, menuCommand);
}

private static void PlaceUIElementRoot(GameObject element, MenuCommand menuCommand)
{
    GameObject parent = menuCommand.context as GameObject;
    bool explicitParentChoice = true;
    if (parent == null)
    {
        parent = GetOrCreateCanvasGameObject();
        explicitParentChoice = false;

        // If in Prefab Mode, Canvas has to be part of Prefab contents,
        // otherwise use Prefab root instead.
        PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
        if (prefabStage != null && !prefabStage.IsPartOfPrefabContents(parent))
            parent = prefabStage.prefabContentsRoot;
    }
    if (parent.GetComponentsInParent<Canvas>(true).Length == 0)
    {
        // Create canvas under context GameObject,
        // and make that be the parent which UI element is added under.
        GameObject canvas = MenuOptions.CreateNewUI();
        canvas.transform.SetParent(parent.transform, false);
        parent = canvas;
    }

    // Setting the element to be a child of an element already in the scene should
    // be sufficient to also move the element to that scene.
    // However, it seems the element needs to be already in its destination scene when the
    // RegisterCreatedObjectUndo is performed; otherwise the scene it was created in is dirtied.
    SceneManager.MoveGameObjectToScene(element, parent.scene);

    Undo.RegisterCreatedObjectUndo(element, "Create " + element.name);

    if (element.transform.parent == null)
    {
        Undo.SetTransformParent(element.transform, parent.transform, "Parent " + element.name);
    }

    GameObjectUtility.EnsureUniqueNameForSibling(element);

    // We have to fix up the undo name since the name of the object was only known after reparenting it.
    Undo.SetCurrentGroupName("Create " + element.name);

    GameObjectUtility.SetParentAndAlign(element, parent);
    if (!explicitParentChoice) // not a context click, so center in sceneview
        SetPositionVisibleinSceneView(parent.GetComponent<RectTransform>(), element.GetComponent<RectTransform>());

    Selection.activeGameObject = element;
}

//创建canvas
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>();

    // Works for all stages.
    StageUtility.PlaceGameObjectInCurrentStage(root);
    bool customScene = false;
    PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
    if (prefabStage != null)
    {
        root.transform.SetParent(prefabStage.prefabContentsRoot.transform, false);
        customScene = true;
    }

    Undo.RegisterCreatedObjectUndo(root, "Create " + root.name);

    // If there is no event system add one...
    // No need to place event system in custom scene as these are temporary anyway.
    // It can be argued for or against placing it in the user scenes,
    // but let's not modify scene user is not currently looking at.
    if (!customScene)
        CreateEventSystem(false);
    return root;
}


private static void CreateEventSystem(bool select)
{
    CreateEventSystem(select, null);
}

//创建事件系统
private static void CreateEventSystem(bool select, GameObject parent)
{
    StageHandle stage = parent == null ? StageUtility.GetCurrentStageHandle() : StageUtility.GetStageHandle(parent);
    var esys = stage.FindComponentOfType<EventSystem>();
    if (esys == null)
    {
        var eventSystem = new GameObject("EventSystem");
        if (parent == null)
            StageUtility.PlaceGameObjectInCurrentStage(eventSystem);
        else
            GameObjectUtility.SetParentAndAlign(eventSystem, parent);
        esys = eventSystem.AddComponent<EventSystem>();
        eventSystem.AddComponent<StandaloneInputModule>();

        Undo.RegisterCreatedObjectUndo(eventSystem, "Create " + eventSystem.name);
    }

    if (select && esys != null)
    {
        Selection.activeGameObject = esys.gameObject;
    }
}

public void Rebuild(CanvasUpdate executing)
{
    switch (executing)
    {
        case CanvasUpdate.Layout:
            // It's unfortunate that we'll perform the same GetComponents querys for the tree 2 times,
            // but each tree have to be fully iterated before going to the next action,
            // so reusing the results would entail storing results in a Dictionary or similar,
            // which is probably a bigger overhead than performing GetComponents multiple times.
            PerformLayoutCalculation(m_ToRebuild, e => (e as ILayoutElement).CalculateLayoutInputHorizontal());
            PerformLayoutControl(m_ToRebuild, e => (e as ILayoutController).SetLayoutHorizontal());
            PerformLayoutCalculation(m_ToRebuild, e => (e as ILayoutElement).CalculateLayoutInputVertical());
            PerformLayoutControl(m_ToRebuild, e => (e as ILayoutController).SetLayoutVertical());
            break;
    }
}

//深度优先，效果就是先把子类的布局好，再布局自己
private void PerformLayoutControl(RectTransform rect, UnityAction<Component> action)
{
    if (rect == null)
        return;

    var components = ListPool<Component>.Get();
    rect.GetComponents(typeof(ILayoutController), components);
    StripDisabledBehavioursFromList(components);

    // If there are no controllers on this rect we can skip this entire sub-tree
    // We don't need to consider controllers on children deeper in the sub-tree either,
    // since they will be their own roots.
    if (components.Count > 0)
    {
        // Layout control needs to executed top down with parents being done before their children,
        // because the children rely on the sizes of the parents.

        // First call layout controllers that may change their own RectTransform
        for (int i = 0; i < components.Count; i++)
            if (components[i] is ILayoutSelfController)
                action(components[i]);

        // Then call the remaining, such as layout groups that change their children, taking their own RectTransform size into account.
        for (int i = 0; i < components.Count; i++)
            if (!(components[i] is ILayoutSelfController))
                action(components[i]);

        for (int i = 0; i < rect.childCount; i++)
            PerformLayoutControl(rect.GetChild(i) as RectTransform, action);
    }

    ListPool<Component>.Release(components);
}

//深度优先，效果就是先把子类的布局好，再布局自己
private void PerformLayoutCalculation(RectTransform rect, UnityAction<Component> action)
{
    if (rect == null)
        return;

    var components = ListPool<Component>.Get();
    rect.GetComponents(typeof(ILayoutElement), components);
    StripDisabledBehavioursFromList(components);

    // If there are no controllers on this rect we can skip this entire sub-tree
    // We don't need to consider controllers on children deeper in the sub-tree either,
    // since they will be their own roots.
    if (components.Count > 0  || rect.GetComponent(typeof(ILayoutGroup)))
    {
        // Layout calculations needs to executed bottom up with children being done before their parents,
        // because the parent calculated sizes rely on the sizes of the children.

        for (int i = 0; i < rect.childCount; i++)
            PerformLayoutCalculation(rect.GetChild(i) as RectTransform, action);

        for (int i = 0; i < components.Count; i++)
            action(components[i]);
    }

    ListPool<Component>.Release(components);
}

/// <summary>
/// Gets a calculated layout property for the layout element with the given RectTransform.
/// </summary>
/// <param name="rect">The RectTransform of the layout element to get a property for.</param>
/// <param name="property">The property to calculate.</param>
/// <param name="defaultValue">The default value to use if no component on the layout element supplies the given property</param>
/// <param name="source">Optional out parameter to get the component that supplied the calculated value.</param>
/// <returns>The calculated value of the layout property.</returns>
public static float GetLayoutProperty(RectTransform rect, System.Func<ILayoutElement, float> property, float defaultValue, out ILayoutElement source)
{
    source = null;
    if (rect == null)
        return 0;
    float min = defaultValue;
    int maxPriority = System.Int32.MinValue;
    var components = ListPool<Component>.Get();
    rect.GetComponents(typeof(ILayoutElement), components);

    for (int i = 0; i < components.Count; i++)
    {
        var layoutComp = components[i] as ILayoutElement;
        if (layoutComp is Behaviour && !((Behaviour)layoutComp).isActiveAndEnabled)
            continue;

        int priority = layoutComp.layoutPriority;
        // If this layout components has lower priority than a previously used, ignore it.
        if (priority < maxPriority)
            continue;
        float prop = property(layoutComp);
        // If this layout property is set to a negative value, it means it should be ignored.
        if (prop < 0)
            continue;

        // If this layout component has higher priority than all previous ones,
        // overwrite with this one's value.
        if (priority > maxPriority)
        {
            min = prop;
            maxPriority = priority;
            source = layoutComp;
        }
        // If the layout component has the same priority as a previously used,
        // use the largest of the values with the same priority.
        else if (prop > min)
        {
            min = prop;
            source = layoutComp;
        }
    }

    ListPool<Component>.Release(components);
    return min;
}

private void GetChildSizes(RectTransform child, int axis, bool controlSize, bool childForceExpand,
    out float min, out float preferred, out float flexible)
{
    if (!controlSize)
    {
        min = child.sizeDelta[axis];
        preferred = min;
        flexible = 0;
    }
    else
    {
        min = LayoutUtility.GetMinSize(child, axis);
        preferred = LayoutUtility.GetPreferredSize(child, axis);
        flexible = LayoutUtility.GetFlexibleSize(child, axis);
    }

    if (childForceExpand)
        flexible = Mathf.Max(flexible, 1);
}

/// <summary>
/// Calculate and apply the horizontal component of the size to the RectTransform
/// </summary>
public virtual void SetLayoutHorizontal()
{
    m_Tracker.Clear();
    HandleSelfFittingAlongAxis(0);
}

private void HandleSelfFittingAlongAxis(int axis)
{
    FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
    if (fitting == FitMode.Unconstrained)
    {
        // Keep a reference to the tracked transform, but don't control its properties:
        m_Tracker.Add(this, rectTransform, DrivenTransformProperties.None);
        return;
    }

    m_Tracker.Add(this, rectTransform, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY));

    // Set size to min or preferred size
    if (fitting == FitMode.MinSize)
        rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
    else
        rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(m_Rect, axis));
}