private void UpdatePositionField(Rect rect)
 {
     m_PositionFieldX.SetValueWithoutNotify((long)selectedSpriteRect.x);
     m_PositionFieldY.SetValueWithoutNotify((long)selectedSpriteRect.y);
     m_PositionFieldW.SetValueWithoutNotify((long)selectedSpriteRect.width);
     m_PositionFieldH.SetValueWithoutNotify((long)selectedSpriteRect.height);
 }
        protected void PopulateSpriteFrameInspectorField()
        {
            m_SelectedFrameInspector.visible = hasSelected;
            if (!hasSelected)
            {
                return;
            }
            m_NameElement.SetEnabled(containsMultipleSprites);
            m_NameField.SetValueWithoutNotify(selectedSpriteName);
            m_PositionElement.SetEnabled(containsMultipleSprites);
            var spriteRect = selectedSpriteRect;

            m_PositionFieldX.SetValueWithoutNotify(Mathf.RoundToInt(spriteRect.x));
            m_PositionFieldY.SetValueWithoutNotify(Mathf.RoundToInt(spriteRect.y));
            m_PositionFieldW.SetValueWithoutNotify(Mathf.RoundToInt(spriteRect.width));
            m_PositionFieldH.SetValueWithoutNotify(Mathf.RoundToInt(spriteRect.height));
            var spriteBorder = selectedSpriteBorder;

            m_BorderFieldL.SetValueWithoutNotify(Mathf.RoundToInt(spriteBorder.x));
            m_BorderFieldT.SetValueWithoutNotify(Mathf.RoundToInt(spriteBorder.w));
            m_BorderFieldR.SetValueWithoutNotify(Mathf.RoundToInt(spriteBorder.z));
            m_BorderFieldB.SetValueWithoutNotify(Mathf.RoundToInt(spriteBorder.y));
            m_PivotField.SetValueWithoutNotify(selectedSpriteAlignment);
            m_PivotUnitModeField.SetValueWithoutNotify(m_PivotUnitMode);
            Vector2 pivot = selectedSpritePivotInCurUnitMode;

            m_CustomPivotFieldX.SetValueWithoutNotify(pivot.x);
            m_CustomPivotFieldY.SetValueWithoutNotify(pivot.y);

            m_CustomPivotElement.SetEnabled(hasSelected && selectedSpriteAlignment == SpriteAlignment.Custom);
        }
        private void AddMainUI(VisualElement mainView)
        {
            var visualTree = EditorGUIUtility.Load("UXML/SpriteEditor/SpriteFrameModuleInspector.uxml") as VisualTreeAsset;

            m_SelectedFrameInspector = visualTree.CloneTree(null).Q("spriteFrameModuleInspector");

            m_NameElement = m_SelectedFrameInspector.Q("name");
            m_NameField   = m_SelectedFrameInspector.Q <PropertyControl <string> >("spriteName");
            m_NameField.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    selectedSpriteName = evt.newValue;
                }
            });

            m_NameField.RegisterCallback <FocusOutEvent>((focus) =>
            {
                if (hasSelected)
                {
                    m_NameField.SetValueWithoutNotify(selectedSpriteName);
                }
            });


            m_PositionElement = m_SelectedFrameInspector.Q("position");
            m_PositionFieldX  = m_PositionElement.Q <PropertyControl <long> >("positionX");
            m_PositionFieldX.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    var rect           = selectedSpriteRect;
                    rect.x             = evt.newValue;
                    selectedSpriteRect = rect;
                    UpdatePositionField(selectedSpriteRect);
                }
            });

            m_PositionFieldY = m_PositionElement.Q <PropertyControl <long> >("positionY");
            m_PositionFieldY.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    var rect           = selectedSpriteRect;
                    rect.y             = evt.newValue;
                    selectedSpriteRect = rect;
                    UpdatePositionField(selectedSpriteRect);
                }
            });

            m_PositionFieldW = m_PositionElement.Q <PropertyControl <long> >("positionW");
            m_PositionFieldW.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    var rect           = selectedSpriteRect;
                    rect.width         = evt.newValue;
                    selectedSpriteRect = rect;
                    UpdatePositionField(selectedSpriteRect);
                }
            });

            m_PositionFieldH = m_PositionElement.Q <PropertyControl <long> >("positionH");
            m_PositionFieldH.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    var rect           = selectedSpriteRect;
                    rect.height        = evt.newValue;
                    selectedSpriteRect = rect;
                    UpdatePositionField(selectedSpriteRect);
                }
            });

            var borderElement = m_SelectedFrameInspector.Q("border");

            m_BorderFieldL = borderElement.Q <PropertyControl <long> >("borderL");
            m_BorderFieldL.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    var border           = selectedSpriteBorder;
                    border.x             = evt.newValue;
                    selectedSpriteBorder = border;
                    m_BorderFieldL.SetValueWithoutNotify((long)selectedSpriteBorder.x);
                }
            });

            m_BorderFieldT = borderElement.Q <PropertyControl <long> >("borderT");
            m_BorderFieldT.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    var border           = selectedSpriteBorder;
                    border.w             = evt.newValue;
                    selectedSpriteBorder = border;
                    m_BorderFieldT.SetValueWithoutNotify((long)selectedSpriteBorder.w);
                    evt.StopPropagation();
                }
            });

            m_BorderFieldR = borderElement.Q <PropertyControl <long> >("borderR");
            m_BorderFieldR.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    var border           = selectedSpriteBorder;
                    border.z             = evt.newValue;
                    selectedSpriteBorder = border;
                    m_BorderFieldR.SetValueWithoutNotify((long)selectedSpriteBorder.z);
                }
            });

            m_BorderFieldB = borderElement.Q <PropertyControl <long> >("borderB");
            m_BorderFieldB.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    var border           = selectedSpriteBorder;
                    border.y             = evt.newValue;
                    selectedSpriteBorder = border;
                    m_BorderFieldB.SetValueWithoutNotify((long)selectedSpriteBorder.y);
                }
            });

            m_PivotField = m_SelectedFrameInspector.Q <EnumField>("pivotField");
            m_PivotField.Init(SpriteAlignment.Center);
            m_PivotField.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    SpriteAlignment alignment = (SpriteAlignment)evt.newValue;
                    SetSpritePivotAndAlignment(selectedSpritePivot, alignment);
                    m_CustomPivotElement.SetEnabled(selectedSpriteAlignment == SpriteAlignment.Custom);
                    Vector2 pivot = selectedSpritePivotInCurUnitMode;
                    m_CustomPivotFieldX.SetValueWithoutNotify(pivot.x);
                    m_CustomPivotFieldY.SetValueWithoutNotify(pivot.y);
                }
            });


            m_PivotUnitModeField = m_SelectedFrameInspector.Q <EnumField>("pivotUnitModeField");
            m_PivotUnitModeField.Init(PivotUnitMode.Normalized);
            m_PivotUnitModeField.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    m_PivotUnitMode = (PivotUnitMode)evt.newValue;

                    Vector2 pivot = selectedSpritePivotInCurUnitMode;
                    m_CustomPivotFieldX.SetValueWithoutNotify(pivot.x);
                    m_CustomPivotFieldY.SetValueWithoutNotify(pivot.y);
                }
            });


            m_CustomPivotElement = m_SelectedFrameInspector.Q("customPivot");
            m_CustomPivotFieldX  = m_CustomPivotElement.Q <PropertyControl <double> >("customPivotX");
            m_CustomPivotFieldX.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    float newValue = (float)evt.newValue;
                    float pivotX   = m_PivotUnitMode == PivotUnitMode.Pixels
                        ? ConvertFromRectToNormalizedSpace(new Vector2(newValue, 0.0f), selectedSpriteRect).x
                        : newValue;

                    var pivot = selectedSpritePivot;
                    pivot.x   = pivotX;
                    SetSpritePivotAndAlignment(pivot, selectedSpriteAlignment);
                }
            });

            m_CustomPivotFieldY = m_CustomPivotElement.Q <PropertyControl <double> >("customPivotY");
            m_CustomPivotFieldY.OnValueChanged((evt) =>
            {
                if (hasSelected)
                {
                    float newValue = (float)evt.newValue;
                    float pivotY   = m_PivotUnitMode == PivotUnitMode.Pixels
                        ? ConvertFromRectToNormalizedSpace(new Vector2(0.0f, newValue), selectedSpriteRect).y
                        : newValue;

                    var pivot = selectedSpritePivot;
                    pivot.y   = pivotY;
                    SetSpritePivotAndAlignment(pivot, selectedSpriteAlignment);
                }
            });

            //// Force an update of all the fields.
            PopulateSpriteFrameInspectorField();

            mainView.RegisterCallback <SpriteSelectionChangeEvent>(SelectionChange);

            // Stop mouse events from reaching the main view.
            m_SelectedFrameInspector.pickingMode = PickingMode.Ignore;
            m_SelectedFrameInspector.RegisterCallback <MouseDownEvent>((e) => { e.StopPropagation(); });
            m_SelectedFrameInspector.RegisterCallback <MouseUpEvent>((e) => { e.StopPropagation(); });
            m_SelectedFrameInspector.AddToClassList("moduleWindow");
            m_SelectedFrameInspector.AddToClassList("bottomRightFloating");
            mainView.Add(m_SelectedFrameInspector);
        }