Ejemplo n.º 1
0
        private void OnEnable()
        {
            var inst = (target as LayoutTargetComponent);

            for (var i = 0; i < 3; ++i)
            {
                _anchorPresetTypes[i].Type = AnchorPresetInfo.ToAnchorePresetType(inst.LayoutTarget.AnchorMin[i], inst.LayoutTarget.AnchorMax[i]);
            }

            LayoutManagerEditor.UpdateLayoutHierachy(inst);
        }
Ejemplo n.º 2
0
        public override void OnInspectorGUI()
        {
            var inst = target as LayoutTargetComponent;

            if (inst.transform is RectTransform)
            {
                FollowRectTransform = EditorGUILayout.Toggle("Follow RectTransform?", FollowRectTransform);
                if (FollowRectTransform)
                {
                    inst.AutoDetectUpdater();
                    inst.CopyToLayoutTarget();
                }
            }

            if (opModePopUp.Draw(new GUIContent("OpMode")))
            {
                CurrentOpMode = opModePopUp.SelectedOpMode;
            }

            var propSP          = serializedObject.FindProperty("_target");
            var enterChildProps = true;

            while (propSP.NextVisible(enterChildProps))
            {
                if (0 != (PropertyOpModeDict[propSP.name] & CurrentOpMode))
                {
                    EditorGUILayout.PropertyField(propSP);
                }
                enterChildProps = false;
            }

            if (0 != (CurrentOpMode & OpMode.Anchor))
            {
                _foldoutAnchorTypePreset = EditorGUILayout.Foldout(_foldoutAnchorTypePreset, "Anchor Min/Max Preset");
                if (_foldoutAnchorTypePreset)
                {
                    using (var indentScope = new EditorGUI.IndentLevelScope())
                    {
                        foreach (var presetType in _anchorPresetTypes)
                        {
                            using (var scope = new EditorGUILayout.HorizontalScope())
                            {
                                var targetSP    = serializedObject.FindProperty("_target");
                                var anchorMinSP = targetSP.FindPropertyRelative("_anchorMin");
                                var anchorMaxSP = targetSP.FindPropertyRelative("_anchorMax");
                                var localSizeSP = targetSP.FindPropertyRelative("_localSize");

                                var newAnchorType = (AnchorPresetType)EditorGUILayout.EnumPopup(presetType.Name, presetType.Type);
                                if (presetType.Type != newAnchorType)
                                {
                                    presetType.Type = newAnchorType;

                                    var elementMinSP = anchorMinSP.FindPropertyRelative(presetType.Name);
                                    var elementMaxSP = anchorMaxSP.FindPropertyRelative(presetType.Name);
                                    switch (presetType.Type)
                                    {
                                    case AnchorPresetType.Low:
                                        elementMinSP.floatValue = 0f;
                                        elementMaxSP.floatValue = 0f;
                                        break;

                                    case AnchorPresetType.Middle:
                                        elementMinSP.floatValue = 0.5f;
                                        elementMaxSP.floatValue = 0.5f;
                                        break;

                                    case AnchorPresetType.High:
                                        elementMinSP.floatValue = 1f;
                                        elementMaxSP.floatValue = 1f;
                                        break;

                                    case AnchorPresetType.Expand:
                                        elementMinSP.floatValue = 0f;
                                        elementMaxSP.floatValue = 1f;
                                        break;
                                    }
                                }

                                var anchorAreaSize = GetLayoutSize(this.target as LayoutTargetComponent);
                                var doExpand       = MathUtils.AreNearlyEqual(anchorAreaSize[presetType.ElementIndex], localSizeSP.vector3Value[presetType.ElementIndex], LayoutDefines.NUMBER_PRECISION);
                                var newDoExpand    = EditorGUILayout.Toggle("doExpand?", doExpand);
                                if (newDoExpand != doExpand && newDoExpand)
                                {
                                    var layoutSize = GetLayoutSize(this.target as LayoutTargetComponent);
                                    var tmp        = localSizeSP.vector3Value;
                                    tmp[presetType.ElementIndex] = layoutSize[presetType.ElementIndex];
                                    localSizeSP.vector3Value     = tmp;

                                    var offsetMinSP = targetSP.FindPropertyRelative("_anchorOffsetMin");
                                    var offsetMin   = offsetMinSP.vector3Value;
                                    var offsetMaxSP = targetSP.FindPropertyRelative("_anchorOffsetMax");
                                    var offsetMax   = offsetMaxSP.vector3Value;

                                    offsetMin[presetType.ElementIndex] = 0;
                                    offsetMax[presetType.ElementIndex] = 0;

                                    offsetMinSP.vector3Value = offsetMin;
                                    offsetMaxSP.vector3Value = offsetMax;
                                }
                            }
                        }
                    }
                }

                _foldoutAnchorOffset = EditorGUILayout.Foldout(_foldoutAnchorOffset, "Anchor Offset Min/Max");
                if (_foldoutAnchorOffset && false)
                {
                    using (var s = new EditorGUI.IndentLevelScope())
                    {
                        var targetSP    = serializedObject.FindProperty("_target");
                        var anchorMinSP = targetSP.FindPropertyRelative("_anchorMin");
                        var anchorMaxSP = targetSP.FindPropertyRelative("_anchorMax");
                        var localSizeSP = targetSP.FindPropertyRelative("_localSize");
                        var offsetSP    = targetSP.FindPropertyRelative("_offset");

                        var other = new LayoutTargetObject();
                        other.SetParent(GetParentLayoutTarget(inst));
                        other.Pivot = inst.LayoutTarget.Pivot;
                        other.SetAnchor(inst.LayoutTarget.AnchorMin, inst.LayoutTarget.AnchorMax);
                        other.UpdateLocalSize(inst.LayoutTarget.LocalSize, inst.LayoutTarget.Offset);

                        var(offsetMin, offsetMax) = other.AnchorOffsetMinMax();
                        var newOffsetMin = EditorGUILayout.Vector3Field("Offset Min", offsetMin);
                        var newOffsetMax = EditorGUILayout.Vector3Field("Offset Max", offsetMax);

                        if (!offsetMin.AreNearlyEqual(newOffsetMin) ||
                            !offsetMax.AreNearlyEqual(newOffsetMax))
                        {
                            other.SetAnchorOffset(newOffsetMin, newOffsetMax);

                            anchorMinSP.vector3Value = other.AnchorMin;
                            anchorMaxSP.vector3Value = other.AnchorMax;
                            localSizeSP.vector3Value = other.LocalSize;
                            offsetSP.vector3Value    = other.Offset;

                            other.Dispose();
                        }
                    }
                }
            }

            if (serializedObject.ApplyModifiedProperties())
            {
                LayoutManagerEditor.UpdateLayoutHierachy(inst);
            }

            if (GUILayout.Button("Copy From Transform"))
            {
                inst.CopyToLayoutTarget();
            }
        }