Ejemplo n.º 1
0
    // ------------------------------------------------------------------
    // Desc:
    // ------------------------------------------------------------------

    exUIControl RecursivelyGetUIControl(exUIControl _ctrl, Vector2 _worldPos)
    {
        if (_ctrl.gameObject.activeSelf == false || _ctrl.activeSelf == false)
        {
            return(null);
        }

        //
        bool checkChildren = false;

        if (_ctrl.useCollider)
        {
            checkChildren = true;
        }
        else
        {
            Vector2 localPos = new Vector2(_worldPos.x - _ctrl.transform.position.x,
                                           _worldPos.y - _ctrl.transform.position.y);

            Rect boundingRect = _ctrl.GetLocalAABoundingRect();
            checkChildren = boundingRect.Contains(localPos);
        }

        //
        if (checkChildren)
        {
            for (int i = 0; i < _ctrl.children.Count; ++i)
            {
                exUIControl childCtrl  = _ctrl.children[i];
                exUIControl resultCtrl = RecursivelyGetUIControl(childCtrl, _worldPos);
                if (resultCtrl != null)
                {
                    return(resultCtrl);
                }
            }

            if (_ctrl.useCollider == false)
            {
                return(_ctrl);
            }
        }

        return(null);
    }
Ejemplo n.º 2
0
    // ------------------------------------------------------------------
    // Desc:
    // ------------------------------------------------------------------

    protected override void DoInspectorGUI()
    {
        base.DoInspectorGUI();

        // if settingsStyles is null
        if (styles == null)
        {
            styles = new Styles();
        }

        //
        GUILayout.BeginHorizontal();
        GUILayout.FlexibleSpace();
        if (GUILayout.Button("Sync Size", GUILayout.Width(70), GUILayout.Height(20)))
        {
            exPlane targetPlane = target as exPlane;
            if (targetPlane.hasSprite)
            {
                exSpriteBase spriteBase = targetPlane.GetComponent <exSpriteBase>();
                if (targetPlane.width != spriteBase.width)
                {
                    targetPlane.width = spriteBase.width;
                    EditorUtility.SetDirty(targetPlane);
                }

                if (targetPlane.height != spriteBase.height)
                {
                    targetPlane.height = spriteBase.height;
                    EditorUtility.SetDirty(targetPlane);
                }

                if (targetPlane.anchor != spriteBase.anchor)
                {
                    targetPlane.anchor = spriteBase.anchor;
                    EditorUtility.SetDirty(targetPlane);
                }

                if (targetPlane.offset != spriteBase.offset)
                {
                    targetPlane.offset = spriteBase.offset;
                    EditorUtility.SetDirty(targetPlane);
                }
            }
        }
        GUILayout.EndHorizontal();

        //
        EditorGUILayout.Space();
        EditorGUILayout.PropertyField(priorityProp);

        // active
        EditorGUI.BeginChangeCheck();
        EditorGUILayout.PropertyField(activeProp, new GUIContent("Active"));
        if (EditorGUI.EndChangeCheck())
        {
            foreach (Object obj in serializedObject.targetObjects)
            {
                exUIControl ctrl = obj as exUIControl;
                if (ctrl)
                {
                    ctrl.activeSelf = activeProp.boolValue;
                    EditorUtility.SetDirty(ctrl);
                }
            }
        }

        // grabMouseOrTouch
        EditorGUILayout.PropertyField(grabMouseOrTouchProp, new GUIContent("Grab Mouse Or Touch"));

        // use collider
        EditorGUI.BeginChangeCheck();
        EditorGUILayout.PropertyField(useColliderProp, new GUIContent("Use Collider"));
        if (EditorGUI.EndChangeCheck())
        {
            if (useColliderProp.boolValue)
            {
                foreach (Object obj in serializedObject.targetObjects)
                {
                    exUIControl ctrl = obj as exUIControl;
                    if (ctrl)
                    {
                        Collider collider = ctrl.GetComponent <Collider>();
                        if (collider == null)
                        {
                            collider = ctrl.gameObject.AddComponent <BoxCollider>();
                        }

                        BoxCollider boxCollider = collider as BoxCollider;
                        if (boxCollider != null)
                        {
                            Rect localRect = ctrl.GetLocalAABoundingRect();
                            boxCollider.center = new Vector3(localRect.center.x, localRect.center.y, boxCollider.center.z);
                            boxCollider.size   = new Vector3(localRect.width, localRect.height, boxCollider.size.z);
                        }
                    }
                }
            }
            else
            {
                foreach (Object obj in serializedObject.targetObjects)
                {
                    exUIControl ctrl = obj as exUIControl;
                    if (ctrl)
                    {
                        Collider[] colliders = ctrl.GetComponents <Collider>();
                        for (int i = 0; i < colliders.Length; ++i)
                        {
                            Object.DestroyImmediate(colliders[i]);
                        }
                    }
                }
            }
        }

        if (useColliderProp.boolValue)
        {
            EditorGUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            if (GUILayout.Button("Sync Collider", GUILayout.MinWidth(50), GUILayout.Height(20)))
            {
                foreach (Object obj in serializedObject.targetObjects)
                {
                    exUIControl ctrl = obj as exUIControl;
                    if (ctrl)
                    {
                        BoxCollider boxCollider = ctrl.GetComponent <BoxCollider>();
                        Rect        localRect   = ctrl.GetLocalAABoundingRect();
                        boxCollider.center = new Vector3(localRect.center.x, localRect.center.y, boxCollider.center.z);
                        boxCollider.size   = new Vector3(localRect.width, localRect.height, boxCollider.size.z);
                    }
                }
            }
            EditorGUILayout.EndHorizontal();
        }

        if (serializedObject.isEditingMultipleObjects == false)
        {
            exUIControl uiControl = target as exUIControl;

            // event adding selector
            List <string> eventDefNameList = new List <string>();
            eventDefNameList.Add("Event List");
            eventDefNameList.AddRange(uiControl.GetEventNames());

            foreach (exUIControl.EventTrigger eventTrigger in uiControl.events)
            {
                int idx = eventDefNameList.IndexOf(eventTrigger.name);
                if (idx != -1)
                {
                    eventDefNameList.RemoveAt(idx);
                }
            }

            int choice = EditorGUILayout.Popup("Add Event", 0, eventDefNameList.ToArray());
            if (choice != 0)
            {
                exUIControl.EventTrigger newTrigger = new exUIControl.EventTrigger(eventDefNameList[choice]);
                uiControl.events.Add(newTrigger);
                EditorUtility.SetDirty(target);
            }

            // event triggers
            for (int i = 0; i < uiControl.events.Count; ++i)
            {
                EditorGUILayout.Space();

                exUIControl.EventTrigger eventTrigger = uiControl.events[i];
                if (EventField(eventTrigger))
                {
                    uiControl.events.RemoveAt(i);
                    --i;
                    EditorUtility.SetDirty(target);
                }

                EditorGUILayout.Space();
            }
        }

        EditorGUILayout.Space();
    }