targetScript = EditorGUILayout.ObjectField(m_targetScript, typeof(MonoScript), false) as MonoScript;

/*
class SomeMono<TData> : MonoBehaviour
doesnt work on this case, the result will be null     
*/
Type targetType = m_targetScript.GetClass();

// we can also set the folderPath to save our time :D 

var paths = AssetDatabase.FindAssets($"t: prefab", new[] { folderPath });
GameObject[] toCheck = new GameObject[paths.Length];
for (int i = 0; i < paths.Length; i++)
    toCheck[i] = AssetDatabase.LoadAssetAtPath<GameObject>(AssetDatabase.GUIDToAssetPath(paths[i]));

Type targetType;
GameObject prefab;
var components = prefab.GetComponents(targetType);
// if components is not empty, then you get your stuff :D

[InitializeOnLoad]
public static class RectTransformExtendedEditor
{
    struct EditContext
    {
        public RectTransform Transform;
    }

    private static EditContext m_context;
    private static bool m_showTool;

    static RectTransformExtendedEditor()
    {
        Selection.selectionChanged += OnSelectionChanged;
    }

    private static void OnSelectionChanged()
    {
        SceneView.duringSceneGui -= OnSceneGUI;
        if (Selection.activeTransform is RectTransform rectTransform)
        {
            m_context = new EditContext()
            {
                Transform = rectTransform
            };

            SceneView.duringSceneGui += OnSceneGUI;
        }
    }

    private static void OnSceneGUI(SceneView sceneView)
    {
        Handles.BeginGUI();
        if (GUI.Button(new Rect(0, 0, 20, 20), "T"))
        {
            m_showTool = !m_showTool;
        }
        if (m_showTool)
        {
            GUILayout.BeginArea(new Rect(0, 20, 120, 320));
            if (GUILayout.Button("Set Anchors"))
            {
                RectTransform rectTransform = m_context.Transform;
                RectTransform parent = rectTransform.parent as RectTransform;

                Undo.RecordObject(rectTransform, "Set Anchors");

                if (parent != null)
                {
                    Vector2 anchorMin = new Vector2(
                        rectTransform.anchorMin.x + rectTransform.offsetMin.x / parent.rect.width,
                        rectTransform.anchorMin.y + rectTransform.offsetMin.y / parent.rect.height);

                    Vector2 anchorMax = new Vector2(
                        rectTransform.anchorMax.x + rectTransform.offsetMax.x / parent.rect.width,
                        rectTransform.anchorMax.y + rectTransform.offsetMax.y / parent.rect.height);

                    rectTransform.anchorMin = anchorMin;
                    rectTransform.anchorMax = anchorMax;
                    rectTransform.offsetMin = rectTransform.offsetMax = Vector2.zero;
                }
            }
            GUILayout.EndArea();
        }

        Handles.EndGUI();
    }
}

[Serializable]
public struct LocalizationStringParmPack
{
    [CustomValueDrawer("DrawPreviewText")]
    public LocalizedString TextLoc;
    public LocalizationParamsManager.ParamValue[] ParmsArray;
    public override string ToString()
    {
        return this.GetRawEnglishString();
    }

#if UNITY_EDITOR

    static GUIStyle m_previewStyle;
    static GUIStyle PreviewStyle
    {
        get
        {
            if (m_previewStyle == null)
            {
                m_previewStyle = new GUIStyle(EditorStyles.textArea);
                m_previewStyle.wordWrap = true;
            }
            return m_previewStyle;
        }
    }

    // use hacky stuff to get selected new lockey
    static string s_wtfKey = string.Empty;
    static bool s_hasChanged = false;
    LocalizedString DrawPreviewText(LocalizedString value, GUIContent label)
    {
        using (new EditorGUILayout.VerticalScope(UnityEditor.EditorStyles.helpBox))
        {
            // draw lockey
            using (new EditorGUILayout.HorizontalScope())
            {
                if (label != null)
                {
                    EditorGUILayout.LabelField(label, GUILayout.Width(EditorGUIUtility.labelWidth));
                }

                // weird stuff happin in dropdown
                if (EditorGUILayout.DropdownButton(new GUIContent(value.mTerm), FocusType.Keyboard))
                {
                    var terms = LocalizationManager.GetTermsList();
                    var selector = new GenericSelector<string>("Select Term", terms);
                    selector.EnableSingleClickToSelect();
                    selector.SelectionConfirmed += s =>
                    {
                        if (s.Any())
                        {
                            s_wtfKey = s.First();
                            // WEIRD STUFF HERE
                            /* if I do  
                            LocalizedString next = new LocalizedString(s.First());
                            and return 'next' and the end of method, it just doesnt work!!!

                            cuz the GenericSelector is actually a editor window, and
                            */
                            s_hasChanged = true;
                        }
                    };
                    selector.ShowInPopup();
                }

                int mask = (value.mRTL_IgnoreArabicFix ? 0 : 1) +
                           (value.mRTL_ConvertNumbers ? 0 : 2) +
                           (value.m_DontLocalizeParameters ? 0 : 4);

                using (var changed = new EditorGUI.ChangeCheckScope())
                {
                    int newMask = EditorGUILayout.MaskField(mask, new string[] { "Arabic Fix", "Ignore Numbers in RTL", "Localize Parameters" }, GUILayout.Width(30));
                    if (newMask != mask)
                    {
                        value.mRTL_IgnoreArabicFix = (newMask & 1) == 0;
                        value.mRTL_ConvertNumbers = (newMask & 2) == 0;
                        value.m_DontLocalizeParameters = (newMask & 4) == 0;
                    }
                }

                if (GUILayout.Button($"Clear"))
                {
                    /* this will also work
                    LocalizedString next = new LocalizedString("[NULL]");
                    */
                    s_wtfKey = "[NULL]";
                }

            }

            LocalizedString next = s_hasChanged ? new LocalizedString(s_wtfKey) : value;
            s_hasChanged = false;
            /*
            draw preview
            draw preview
            draw preview
            */
            return next;
        }
    }

    string GetParamValue(string key)
    {
        for (int i = 0; i < ParmsArray.Length; i++)
        {
            if (ParmsArray[i].Name == key)
            {
                return string.IsNullOrEmpty(ParmsArray[i].Value) ? key : ParmsArray[i].Value;
            }
        }
        return key;
    }

#endif
}

public static class InputBindSaveHelper
{
    static readonly string s_keyMappingPreferKey = "KeyMapping";

    public static void SaveActionMapRebinding(InputActionMap actionMap)
    {
        Dictionary<Guid, string> overridedActionPathDict = new Dictionary<Guid, string>();
        UnityEngine.InputSystem.Utilities.ReadOnlyArray<InputAction> actions = actionMap.actions;
        for (int i = 0; i < actions.Count; i++)
        {
            InputAction action = actions[i];
            UnityEngine.InputSystem.Utilities.ReadOnlyArray<InputBinding> actionBindings = action.bindings;
            for (int j = 0; j < actionBindings.Count; j++)
            {
                InputBinding actionBinding = actionBindings[j];
                if (string.IsNullOrEmpty(actionBinding.overridePath))
                    continue;
                overridedActionPathDict.Add(actionBinding.id, actionBinding.overridePath);
            }
        }

        BinaryFormatter binFormatter = new BinaryFormatter();
        MemoryStream mStream = new MemoryStream();
        binFormatter.Serialize(mStream, overridedActionPathDict);

        byte[] byteArr = mStream.ToArray();
        // idk why [Encoding.UTF8.GetString()] just doesnt work
        string encodingString = Convert.ToBase64String(byteArr, Base64FormattingOptions.InsertLineBreaks);
        PlayerPrefs.SetString(s_keyMappingPreferKey, encodingString);
    }

    public static void LoadActionMapRebinding(InputActionMap actionMap)
    {
        string encodingString = PlayerPrefs.GetString(s_keyMappingPreferKey);
        byte[] byteArr = Convert.FromBase64String(encodingString);

        BinaryFormatter binFormatter = new BinaryFormatter();
        MemoryStream mStream = new MemoryStream(byteArr);
        Dictionary<Guid, string> rebindSavePairDict = binFormatter.Deserialize(mStream) as Dictionary<Guid, string>;

        if (rebindSavePairDict != null)
        {
            UnityEngine.InputSystem.Utilities.ReadOnlyArray<InputAction> actions = actionMap.actions;
            for (int i = 0; i < actions.Count; i++)
            {
                InputAction action = actions[i];
                UnityEngine.InputSystem.Utilities.ReadOnlyArray<InputBinding> actionBindings = action.bindings;
                for (int j = 0; j < actionBindings.Count; j++)
                {
                    InputBinding actionBinding = actionBindings[j];
                    // override
                    if (rebindSavePairDict.ContainsKey(actionBinding.id))
                    {
                        actionBinding.overridePath = rebindSavePairDict[actionBinding.id];
                        action.ApplyBindingOverride(actionBinding);
                    }
                }
            }

        }
    }
}

public class TempListElementUI : MonoBehaviour
{
    [Header("must have"), Tooltip("should inherit from ISetupable")]
    [SerializeField]
    Component m_dataReceiver;
    [SerializeField, Tooltip("better to manual drag it in")]
    RectTransform m_elementTransform;
    [SerializeField, ReadOnly]
    private int m_index = -1;
    public int ElementIndex => m_index;
    public RectTransform ElementRectTransform
    {
        get
        {
            if (m_elementTransform == null)
                m_elementTransform = GetComponent<RectTransform>();
            return m_elementTransform;
        }
    }
    
    public void Setup<TData>(TData data)
    {
        SomeUtils.ISetup<Component, TData>(m_dataReceiver, data);
    }

    public void Show()
    {
        if (!this.gameObject.activeSelf)
            this.gameObject.SetActive(true);
    }

    public void Hide()
    {
        if (this.gameObject.activeSelf)
            this.gameObject.SetActive(false);
    }

    public void SetIndex(int index)
    {
        m_index = index;
    }

    private void Awake()
    {
        if (m_elementTransform == null)
            m_elementTransform = this.transform as RectTransform;
    }

#if UNITY_EDITOR
    private void Reset()
    {
        m_elementTransform = this.transform as RectTransform;
    }
#endif
}

public class TempListView : MonoBehaviour
{
#if UNITY_EDITOR
#endif
    // check when prefab change
    // [OnValueChanged("OnPrefabChanged")]
    [SerializeField, Header("place holder, the listview should only contains one type of element")]
    TempListElementUI m_elementPrefab;
    RectTransform Container => transform as RectTransform;
    [SerializeField, ReadOnly]
    List<TempListElementUI> m_actualUsedComponents = new List<TempListElementUI>(0);

    public int Count => m_actualUsedComponents.Count;
    public TempListElementUI this[int index] => m_actualUsedComponents[index];
    public IReadOnlyList<TempListElementUI> ElementList => m_actualUsedComponents;

    public TempListElementUI Add()
    {
        TempListElementUI element = InternalAdd();
        m_actualUsedComponents.Add(element);
        element.Show();
        return element;
    }

    public void Clear()
    {
        TempListElementUI element = null;
        while (m_actualUsedComponents.Count > 0)
        {
            element = m_actualUsedComponents[m_actualUsedComponents.Count - 1];
            m_actualUsedComponents.RemoveAt(m_actualUsedComponents.Count - 1);
            InternalRemove(element);
        }
    }

    public void Remove(TempListElementUI instance)
    {
        if (m_actualUsedComponents.Remove(instance))
        {
            instance.Hide();
        }
        else
        {
            Debug.LogError($"listview_{this.gameObject.name} does not contains {instance.ElementRectTransform.name}, remove failed");
        }
    }

    public void RemoveAt(int index)
    {
        if (index < 0 || index >= m_actualUsedComponents.Count)
        {
            Debug.LogError($"{index} is invalid for SimpleListView", this.gameObject);
            return;
        }

        TempListElementUI toRemove = m_actualUsedComponents[index];
        m_actualUsedComponents.RemoveAt(index);
        InternalRemove(toRemove);
    }

    public void InnerSwap(int indexA, int indexB)
    {
        if (indexA < 0 || indexA > m_actualUsedComponents.Count - 1 || indexB < 0 || indexB > m_actualUsedComponents.Count - 1)
        {
            return;
        }

        TempListElementUI temp = m_actualUsedComponents[indexA];
        int transformIndexA = temp.ElementRectTransform.GetSiblingIndex();
        int transformIndexB = m_actualUsedComponents[indexB].ElementRectTransform.GetSiblingIndex();
        m_actualUsedComponents[indexA] = m_actualUsedComponents[indexB];
        m_actualUsedComponents[indexB] = temp;
        m_actualUsedComponents[indexA].ElementRectTransform.SetSiblingIndex(transformIndexA);
        m_actualUsedComponents[indexB].ElementRectTransform.SetSiblingIndex(transformIndexB);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <returns>-1 means element is not in the list</returns>
    public int IndexOf(TempListElementUI instance)
    {
        try
        {
            return m_actualUsedComponents.IndexOf(instance);
        }
        catch (ArgumentOutOfRangeException)
        {
            return -1;
        }
    }

    protected virtual TempListElementUI InternalAdd()
    {
        // can apply object pool here
        if (Application.isEditor && !Application.isPlaying)
            return UnityEditor.PrefabUtility.InstantiatePrefab(m_elementPrefab, Container) as TempListElementUI;
        return Instantiate(m_elementPrefab, Container);
    }

    protected virtual void InternalRemove(TempListElementUI element)
    {
        // can apply object pool here
        if (element == null) return;
        element.Hide();
        if (Application.isEditor && !Application.isPlaying)
            GameObject.DestroyImmediate(element.ElementRectTransform.gameObject);
        else
            GameObject.Destroy(element.ElementRectTransform.gameObject);
    }

#if UNITY_EDITOR

    private void OnTransformChildrenChanged()
    {
        if (Application.isEditor && !Application.isPlaying)
            FindPrefabInstances();
    }

    private void OnPrefabChanged()
    {
        // remove pre objects
        int amount = m_actualUsedComponents.Count;
        for (int i = 0; i < m_actualUsedComponents.Count; i++)
        {
            GameObject.DestroyImmediate(m_actualUsedComponents[i].ElementRectTransform.gameObject);
        }

        if (m_elementPrefab != null)
        {
            for (int i = 0; i < amount; i++)
            {
                RectTransform rectTransform = (RectTransform)UnityEditor.PrefabUtility.InstantiatePrefab(m_elementPrefab, Container);
                m_actualUsedComponents[i] = (rectTransform.GetComponent<TempListElementUI>());
            }
        }
        else
        {
            m_actualUsedComponents.Clear();
        }
    }

    /// <summary>
    /// Retrieves prefab instances in the transform
    /// </summary>
    [ContextMenu("find prefab instances")]
    private void FindPrefabInstances()
    {
        bool hasPrefab = !(m_elementPrefab == null);
        TempListElementUI elementPrefab = m_elementPrefab.GetComponent<TempListElementUI>();
        m_actualUsedComponents.Clear();
        List<GameObject> toDeleteObjectList = new List<GameObject>();
        foreach (Transform child in Container)
        {
            TempListElementUI childElement = child.GetComponent<TempListElementUI>();
            if (childElement == null)
            {
                toDeleteObjectList.Add(child.gameObject);
                continue;
            }

            if (hasPrefab)
            {
                GameObject detectPrefabGo = UnityEditor.PrefabUtility.GetCorrespondingObjectFromSource(child.gameObject);
                TempListElementUI detectPrefab = (detectPrefabGo == null) ? null : detectPrefabGo.GetComponent<TempListElementUI>();
                if (elementPrefab == detectPrefab)
                {
                    // same source prefab
                    m_actualUsedComponents.Add(childElement);
                }
                else
                {
                    // different source prefab, delete this one
                    toDeleteObjectList.Add(child.gameObject);
                }
            }
            else if (UnityEditor.PrefabUtility.IsAnyPrefabInstanceRoot(child.gameObject))
            {
                // find the first prefab
                GameObject prefab = UnityEditor.PrefabUtility.GetCorrespondingObjectFromSource(child.gameObject);
                m_elementPrefab = prefab.GetComponent<TempListElementUI>();
                m_actualUsedComponents.Add(childElement);
                hasPrefab = true;
            }
        }

        for (int i = 0; i < toDeleteObjectList.Count; i++)
        {
            if (Application.isPlaying)
                GameObject.Destroy(toDeleteObjectList[i]);
            else
                GameObject.DestroyImmediate(toDeleteObjectList[i]);
        }
    }

    [ContextMenu("editor time add")]
    private void EditorTimeAdd()
    {
        if (Application.isPlaying) return;
        if (m_elementPrefab == null)
        {
            Debug.LogError("listview is missing element prefab");
            return;
        }
        TempListElementUI spawnObject = (TempListElementUI)UnityEditor.PrefabUtility.InstantiatePrefab(m_elementPrefab, Container);
        m_actualUsedComponents.Add(spawnObject);
    }

    [ContextMenu("editor time clear")]
    private void EditorTimeClear()
    {
        if (Application.isPlaying) return;
        // remove pre objects
        TempListElementUI[] preObjects = Container.GetComponentsInChildren<TempListElementUI>();
        for (int i = 0; i < preObjects.Length; i++)
        {
            GameObject.DestroyImmediate(preObjects[i].ElementRectTransform.gameObject);
        }
        m_actualUsedComponents.Clear();
    }

    [ContextMenu("test print elements")]
    private void TestPrintListElements()
    {
        if (m_actualUsedComponents != null)
        {
            StringBuilder printText = new StringBuilder($"temp list view children_{m_actualUsedComponents.Count} :\n");
            for (int i = 0; i < m_actualUsedComponents.Count; i++)
            {
                printText.AppendLine(m_actualUsedComponents[i].ElementRectTransform.name);
            }
            Debug.Log(printText);
        }
    }

#endif
}

public class BoundlessScrollRectController : UIBehaviour
{
    /*
    too much code, I will just show the draw
    */

    private void DrawContentItem()
    {
        IReadOnlyList<TempListElementUI> elementList = ElementList;
        int dataCount = m_simulatedDataCount;
        // TODO @Hiko use a general calculation later
        bool test = m_content.anchorMin != Vector2.up || m_content.anchorMax != Vector2.up || m_content.pivot != Vector2.up;
        if (test)
        {
            m_content.anchorMin = Vector2.up;
            m_content.anchorMax = Vector2.up;
            m_content.pivot = Vector2.up;
        }
        Vector3 dragContentAnchorPostion = m_content.anchoredPosition;
        Vector3 contentMove = dragContentAnchorPostion - SomeUtils.GetOffsetLocalPosition(m_content, SomeUtils.UIOffsetType.TopLeft);
        Vector2 itemSize = m_gridLayoutGroup.CellSize, spacing = m_gridLayoutGroup.Spacing;

        RectOffset padding = null;
        if (null != m_gridLayoutGroup)
            padding = m_gridLayoutGroup.RectPadding;

        // need to know the moving direction, then adjust it to prevent wrong draw
        float xMove = contentMove.x < 0 ? (-contentMove.x - padding.horizontal) : 0;
        xMove = Mathf.Clamp(xMove, 0.0f, Mathf.Abs(xMove));
        float yMove = contentMove.y > 0 ? (contentMove.y - padding.vertical) : 0;
        yMove = Mathf.Clamp(yMove, 0.0f, Mathf.Abs(yMove));

        // the column index of the top left item
        int tempColumnIndex = Mathf.FloorToInt((xMove + spacing.x) / (itemSize.x + spacing.x));
        if (xMove % (itemSize.x + spacing.x) - itemSize.x > spacing.x)
            tempColumnIndex = Mathf.Clamp(tempColumnIndex - 1, 0, tempColumnIndex);

        // the row index of the top left item
        int tempRowIndex = Mathf.FloorToInt((yMove + spacing.y) / (itemSize.y + spacing.y));
        if (yMove % (itemSize.y + spacing.y) - itemSize.y > spacing.y)
            tempRowIndex = Mathf.Clamp(tempRowIndex - 1, 0, tempRowIndex);

        Vector2Int rowTopLeftItemIndex = new Vector2Int(tempRowIndex, tempColumnIndex);

        int rowDataCount = 0, columnDataCount = 0;
        if (BoundlessGridLayoutData.Constraint.FixedColumnCount == m_gridLayoutGroup.constraint)
        {
            rowDataCount = m_gridLayoutGroup.constraintCount;
            columnDataCount = Mathf.CeilToInt((float)dataCount / rowDataCount);
        }
        else
        {
            columnDataCount = m_gridLayoutGroup.constraintCount;
            rowDataCount = Mathf.CeilToInt((float)dataCount / columnDataCount);
        }

        // x -> element amount on horizontal axis
        // y -> element amount on vertical axis
        Vector2Int contentRowColumnSize = new Vector2Int(rowDataCount, columnDataCount);

        // deal with content from left to right (simple case)
        int dataIndex = 0, uiItemIndex = 0;
        Vector3 rowTopLeftPosition = new Vector3(padding.left, -padding.top, 0.0f), itemTopLeftPosition = Vector3.zero;
        for (int columnIndex = 0; columnIndex < m_viewItemCountInColumn; columnIndex++)
        {
            if (columnIndex + rowTopLeftItemIndex.x == columnDataCount)
                break;

            rowTopLeftPosition = new Vector3(padding.left, -padding.top, 0.0f) + Vector3.down * (columnIndex + rowTopLeftItemIndex.x) * (itemSize.y + spacing.y);
            for (int rowIndex = 0; rowIndex < m_viewItemCountInRow; rowIndex++)
            {
                if (rowIndex + rowTopLeftItemIndex.y == rowDataCount)
                    break;

                Vector2Int elementIndex = new Vector2Int(rowIndex + rowTopLeftItemIndex.y, columnIndex + rowTopLeftItemIndex.x);
                dataIndex = CaculateDataIndex(elementIndex, contentRowColumnSize, GridLayoutData.startAxis, GridLayoutData.startCorner);
                itemTopLeftPosition = rowTopLeftPosition + Vector3.right * (rowIndex + rowTopLeftItemIndex.y) * (itemSize.x + spacing.x);

                // TODO @Hiko avoid overdraw
                if (uiItemIndex > 0 && elementList[uiItemIndex - 1].ElementIndex == dataIndex)
                    continue; // over draw case
                if (dataIndex > -1 && dataIndex < dataCount)
                {
                    elementList[uiItemIndex].ElementRectTransform.localPosition = itemTopLeftPosition;
                    elementList[uiItemIndex].SetIndex(dataIndex);
                    elementList[uiItemIndex].Show();
                    uiItemIndex++;
                }
            }
        }

        while (uiItemIndex < elementList.Count)
        {
            elementList[uiItemIndex].SetIndex(-1);
            elementList[uiItemIndex].Hide();
            elementList[uiItemIndex].ElementRectTransform.position = Vector3.zero;
            uiItemIndex++;
        }

        NotifyOnContentItemFinishDrawing();
    }
}

// apply this on the target shows actual data
public interface ISetupable<TData>
{
    void Setup(TData data);
}

/// <summary>
/// target component should inherit from ISetupable
/// </summary>
/// <param name="component"></param>
/// <param name="data"></param>
/// <typeparam name="TData"></typeparam>
public static void ISetup<TComponent, TData>(this Component component, TData data) where TComponent : Component
{
    // I guess this check should be fine  :(
    if (component is ISetupable<TData> target)
    {
        target.Setup(data);
        return;
    }
    UnityEngine.Debug.LogError($"component_{component.name} is not a setupable");
}

public class RaycastTarget : Graphic
{
    // Additionally, If you need a Raycast target that is not a rectangle, you can implement bool Raycast(Vector2 sp, Camera eventCamera) method from Graphic.
    public override void SetMaterialDirty() { return; }
    public override void SetVerticesDirty() { return; }
    /// Probably not necessary since the chain of calls `Rebuild()`->`UpdateGeometry()`->`DoMeshGeneration()`->`OnPopulateMesh()` won't happen; so here really just as a fail-safe.
    protected override void OnPopulateMesh(VertexHelper vh)
    {
        vh.Clear();
        return;
    }

#if UNITY_EDITOR

    private void OnDrawGizmos()
    {
        if (!this.enabled)
            return
        RectTransform rectTransform = this.transform as RectTransform;
        Color wireColor = Color.yellow;
        if (this.isActiveAndEnabled)
            wireColor.a *= 0.7f
        // Padding to be applied to the masking
        // X = Left, Y = Bottom, Z = Right, W = Top
        // if you wanna make it bigger, then the all value shouble be negative
        Vector4 padding = this.raycastPadding * -1.0f;
        Matrix4x4 localToWorld = rectTransform.localToWorldMatrix
        Vector3 topLeft = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.TopLeft);
        Vector3 topRight = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.TopRight);
        Vector3 bottomLeft = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.BottomLeft);
        Vector3 bottomRight = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.BottomRight)
        topLeft = localToWorld.MultiplyPoint(topLeft + (Vector3.left * padding.x) + (Vector3.up * padding.w));
        topRight = localToWorld.MultiplyPoint(topRight + (Vector3.right * padding.z) + (Vector3.up * padding.w));
        bottomLeft = localToWorld.MultiplyPoint(bottomLeft + (Vector3.left * padding.x) + (Vector3.down * padding.y));
        bottomRight = localToWorld.MultiplyPoint(bottomRight + (Vector3.right * padding.z) + (Vector3.down * padding.y))
        Color tempColor = Gizmos.color;
        Gizmos.color = wireColor
        Gizmos.DrawLine(topLeft, topRight);
        Gizmos.DrawLine(topLeft, bottomLeft);
        Gizmos.DrawLine(bottomRight, topRight);
        Gizmos.DrawLine(bottomRight, bottomLeft);
        Gizmos.color = tempColor
    }

#endif

}

public void OnScrollWheel(InputAction.CallbackContext context)
{
    if (IsActive())
    {
        PointerEventData eventData = GetPointerData();
        eventData.button = PointerEventData.InputButton.Middle;
        eventData.Reset();
        eventData.scrollDelta = context.ReadValue<Vector2>()
        GameObject testScrollObject = ExecuteEventExecuteHierarchy(eventData.pointerCurrentRaycasgameObject, eventData, ExecuteEvents.scrollHandler)
        if (testScrollObject != null)
        {
            // to re-do the reycast cuz we may scroll a recyclscrollrect
            HandlePointerExitAndEnter(eventData, null);
            m_rayCastDelayFrame = SCROLL_RAYCAST_DELAY;
            // SCROLL_RAYCAST_DELAY =3 or 5, depends....
        }
    }
}

// will call in update
public override void Process()
{
    /*
    .....
    */
    CheckAndDoDelayRaycast();
}

void CheckAndDoDelayRaycast()
{
    if (m_rayCastDelayFrame < 0)
    {
        return;
    
    if (--m_rayCastDelayFrame == 0)
    {
        var eventData = GetPointerData();
        eventSystem.RaycastAll(eventData, m_RaycastResultCache);
        var firstRaycast = FindFirstRaycast(m_RaycastResultCache)
        eventData.pointerCurrentRaycast = firstRaycast;
        m_RaycastResultCache.Clear()
        var temp = eventData.pointerCurrentRaycast.gameObject;
        HandlePointerExitAndEnter(eventData, temp);
        m_rayCastDelayFrame = -1;
    }
}