Inheritance: UIRectEditor
    /// <summary>
    /// Handles & interaction.
    /// </summary>

    public void OnSceneGUI()
    {
        //Tools.current = Tool.View;

        Event e = Event.current;

        switch (e.type)
        {
        case EventType.MouseUp:
        {
            UIPanel panel = target as UIPanel;
            BetterList <UIWidget> widgets = UIWidgetInspector.SceneViewRaycast(panel, e.mousePosition);
            if (widgets.size > 0)
            {
                Selection.activeGameObject = widgets[0].gameObject;
            }
        }
        break;

        case EventType.KeyDown:
        {
            if (e.keyCode == KeyCode.Escape)
            {
                Tools.current = Tool.Move;
                Selection.activeGameObject = null;
                e.Use();
            }
        }
        break;
        }
    }
Exemple #2
0
    /// <summary>
    /// Draw the widget's color.
    /// </summary>

    static public void DrawColor(SerializedObject so, UIWidget w, UIWidgetInspector widgetInspector)
    {
        GUILayout.BeginHorizontal();
        SerializedProperty colorSp = NGUIEditorTools.DrawProperty("Color Tint", so, "mColor", GUILayout.MinWidth(20f));

        GUI.SetNextControlName("Encoded Color");
        widgetInspector.mEncodedColor = EditorGUILayout.TextField("", widgetInspector.mEncodedColor, GUILayout.Width(50f));
        GUILayout.EndHorizontal();

        if (colorSp != null)
        {
            if (GUI.GetNameOfFocusedControl() == "Encoded Color")
            {
                if (Event.current.keyCode == KeyCode.Return && Event.current.type == EventType.Used)
                {
                    int length = widgetInspector.mEncodedColor.Length;
                    for (int index = length; index < 6; ++index)
                    {
                        widgetInspector.mEncodedColor += "0";
                    }
                    Color color = NGUIText.ParseColor24(widgetInspector.mEncodedColor, 0);
                    color.a            = w.color.a;
                    colorSp.colorValue = color;
                }
            }
            else
            {
                widgetInspector.mEncodedColor = NGUIText.EncodeColor24(colorSp.colorValue);
            }
        }
    }
Exemple #3
0
    /// <summary>
    /// Make it possible to easily drag the transform around.
    /// </summary>

    public void OnSceneGUI()
    {
        //NGUIEditorTools.HideMoveTool(true);
        if (!UIWidget.showHandles)
        {
            return;
        }

        var mb = target as MonoBehaviour;

        if (mb.GetComponent <UIWidget>() != null)
        {
            return;
        }
        if (mb.GetComponent <UIPanel>() != null)
        {
            return;
        }

        var t       = mb.transform;
        var widgets = t.GetComponentsInChildren <UIWidget>();

        var e            = Event.current;
        var id           = GUIUtility.GetControlID(mHash, FocusType.Passive);
        var type         = e.GetTypeForControl(id);
        var isWithinRect = false;

        Vector3[] corners = null;
        Vector3[] handles = null;

        if (widgets.Length > 0)
        {
            var worldToLocal = t.worldToLocalMatrix;
            var localToWorld = t.localToWorldMatrix;
            var bounds       = new Bounds();

            // Calculate the local bounds
            for (var i = 0; i < widgets.Length; ++i)
            {
                var wcs = widgets[i].worldCorners;

                for (var b = 0; b < 4; ++b)
                {
                    wcs[b] = worldToLocal.MultiplyPoint3x4(wcs[b]);
                    if (i == 0 && b == 0)
                    {
                        bounds = new Bounds(wcs[b], Vector3.zero);
                    }
                    else
                    {
                        bounds.Encapsulate(wcs[b]);
                    }
                }
            }

            // Calculate the 4 local corners
            var v0 = bounds.min;
            var v1 = bounds.max;

            var z = Mathf.Min(v0.z, v1.z);
            corners    = new Vector3[4];
            corners[0] = new Vector3(v0.x, v0.y, z);
            corners[1] = new Vector3(v0.x, v1.y, z);
            corners[2] = new Vector3(v1.x, v1.y, z);
            corners[3] = new Vector3(v1.x, v0.y, z);

            // Transform the 4 corners into world space
            for (var i = 0; i < 4; ++i)
            {
                corners[i] = localToWorld.MultiplyPoint3x4(corners[i]);
            }

            handles = new Vector3[8];

            handles[0] = corners[0];
            handles[1] = corners[1];
            handles[2] = corners[2];
            handles[3] = corners[3];

            handles[4] = (corners[0] + corners[1]) * 0.5f;
            handles[5] = (corners[1] + corners[2]) * 0.5f;
            handles[6] = (corners[2] + corners[3]) * 0.5f;
            handles[7] = (corners[0] + corners[3]) * 0.5f;

            var handlesColor = UIWidgetInspector.handlesColor;
            NGUIHandles.DrawShadowedLine(handles, handles[0], handles[1], handlesColor);
            NGUIHandles.DrawShadowedLine(handles, handles[1], handles[2], handlesColor);
            NGUIHandles.DrawShadowedLine(handles, handles[2], handles[3], handlesColor);
            NGUIHandles.DrawShadowedLine(handles, handles[0], handles[3], handlesColor);

            isWithinRect = mIsDragging || (e.modifiers == 0 &&
                                           NGUIEditorTools.SceneViewDistanceToRectangle(corners, e.mousePosition) == 0f);
#if !UNITY_3_5
            // Change the mouse cursor to a more appropriate one
            var screenPos = new Vector2[8];
            for (var i = 0; i < 8; ++i)
            {
                screenPos[i] = HandleUtility.WorldToGUIPoint(handles[i]);
            }

            bounds = new Bounds(screenPos[0], Vector3.zero);
            for (var i = 1; i < 8; ++i)
            {
                bounds.Encapsulate(screenPos[i]);
            }

            // Change the cursor to a move arrow when it's within the screen rectangle
            Vector2 min  = bounds.min;
            Vector2 max  = bounds.max;
            var     rect = new Rect(min.x, min.y, max.x - min.x, max.y - min.y);
            UIWidgetInspector.SetCursorRect(rect, isWithinRect ? MouseCursor.MoveArrow : MouseCursor.Arrow);
#endif
        }

        switch (type)
        {
        case EventType.Repaint:
        {
            if (handles != null)
            {
                Vector3 v0 = HandleUtility.WorldToGUIPoint(handles[0]);
                Vector3 v2 = HandleUtility.WorldToGUIPoint(handles[2]);

                if ((v2 - v0).magnitude > 60f)
                {
                    Vector3 v1 = HandleUtility.WorldToGUIPoint(handles[1]);
                    Vector3 v3 = HandleUtility.WorldToGUIPoint(handles[3]);

                    Handles.BeginGUI();
                    {
                        for (var i = 0; i < 4; ++i)
                        {
                            UIWidgetInspector.DrawKnob(handles[i], false, false, id);
                        }

                        if (Mathf.Abs(v1.y - v0.y) > 80f)
                        {
                            UIWidgetInspector.DrawKnob(handles[4], false, false, id);
                            UIWidgetInspector.DrawKnob(handles[6], false, false, id);
                        }

                        if (Mathf.Abs(v3.x - v0.x) > 80f)
                        {
                            UIWidgetInspector.DrawKnob(handles[5], false, false, id);
                            UIWidgetInspector.DrawKnob(handles[7], false, false, id);
                        }
                    }
                    Handles.EndGUI();
                }
            }
        }
        break;

        case EventType.MouseDown:
        {
            mAllowSelection = true;
            mStartMouse     = e.mousePosition;

            if (e.button == 1 && isWithinRect)
            {
                GUIUtility.hotControl = GUIUtility.keyboardControl = id;
                e.Use();
            }
            else if (e.button == 0 && isWithinRect && corners != null && UIWidgetInspector.Raycast(corners, out mStartDrag))
            {
                mCanDrag              = true;
                mStartPos             = t.position;
                GUIUtility.hotControl = GUIUtility.keyboardControl = id;
                e.Use();
            }
        }
        break;

        case EventType.MouseDrag:
        {
            // Prevent selection once the drag operation begins
            var dragStarted = (e.mousePosition - mStartMouse).magnitude > 3f;
            if (dragStarted)
            {
                mAllowSelection = false;
            }

            if (GUIUtility.hotControl == id)
            {
                e.Use();

                if (mCanDrag)
                {
                    Vector3 pos;

                    if (corners != null & UIWidgetInspector.Raycast(corners, out pos))
                    {
                        // Wait until the mouse moves by more than a few pixels
                        if (!mIsDragging && dragStarted)
                        {
                            NGUIEditorTools.RegisterUndo("Move " + t.name, t);
                            mStartPos   = t.position;
                            mIsDragging = true;
                        }

                        if (mIsDragging)
                        {
                            t.position      = mStartPos + (pos - mStartDrag);
                            pos             = t.localPosition;
                            pos.x           = Mathf.Round(pos.x);
                            pos.y           = Mathf.Round(pos.y);
                            pos.z           = Mathf.Round(pos.z);
                            t.localPosition = pos;
                        }
                    }
                }
            }
        }
        break;

        case EventType.MouseUp:
        {
            if (GUIUtility.hotControl == id)
            {
                GUIUtility.hotControl      = 0;
                GUIUtility.keyboardControl = 0;

                if (e.button == 0)
                {
                    if (mIsDragging)
                    {
                        mIsDragging = false;
                        var pos = t.localPosition;
                        pos.x           = Mathf.Round(pos.x);
                        pos.y           = Mathf.Round(pos.y);
                        pos.z           = Mathf.Round(pos.z);
                        t.localPosition = pos;
                    }
                    else if (mAllowSelection)
                    {
                        // Left-click: Select the topmost widget
                        NGUIEditorTools.SelectWidget(e.mousePosition);
                        e.Use();
                    }
                    e.Use();
                }
                else
                {
                    // Right-click: Open a context menu listing all widgets underneath
                    NGUIEditorTools.ShowSpriteSelectionMenu(e.mousePosition);
                    e.Use();
                }
                mCanDrag = false;
            }
        }
        break;

        case EventType.KeyDown:
        {
            if (e.keyCode == KeyCode.UpArrow)
            {
                var pos = t.localPosition;
                pos.y          += 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.DownArrow)
            {
                var pos = t.localPosition;
                pos.y          -= 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.LeftArrow)
            {
                var pos = t.localPosition;
                pos.x          -= 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.RightArrow)
            {
                var pos = t.localPosition;
                pos.x          += 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.Escape)
            {
                if (GUIUtility.hotControl == id)
                {
                    if (mIsDragging)
                    {
                        mIsDragging = false;
                        t.position  = mStartPos;
                    }

                    GUIUtility.hotControl      = 0;
                    GUIUtility.keyboardControl = 0;
                    e.Use();
                }
                else
                {
                    Selection.activeGameObject = null;
                }
            }
        }
        break;
        }
    }
Exemple #4
0
    /// <summary>
    /// Cache the reference.
    /// </summary>

    protected override void OnEnable()
    {
        base.OnEnable();
        instance = this;
        mWidget  = target as UIWidget;
    }
Exemple #5
0
 protected override void OnDisable()
 {
     base.OnDisable();
     NGUIEditorTools.HideMoveTool(false);
     instance = null;
 }
	/// <summary>
	/// Cache the reference.
	/// </summary>

	protected override void OnEnable ()
	{
		base.OnEnable();
		instance = this;
		mWidget = target as UIWidget;
	}
	void OnDisable ()
	{
		NGUIEditorTools.HideMoveTool(false);
		instance = null;
	}
    /// <summary>
    /// Handles & interaction.
    /// </summary>

    public void OnSceneGUI()
    {
        NGUIEditorTools.HideMoveTool(true);
        if (!UIWidget.showHandles)
        {
            return;
        }

        Event     e    = Event.current;
        int       id   = GUIUtility.GetControlID(s_Hash, FocusType.Passive);
        EventType type = e.GetTypeForControl(id);
        Transform t    = mPanel.cachedTransform;

        Vector3[] handles = UIWidgetInspector.GetHandles(mPanel.worldCorners);

        // Time to figure out what kind of action is underneath the mouse
        UIWidgetInspector.Action actionUnderMouse = mAction;

        Color handlesColor = new Color(0.5f, 0f, 0.5f);

        NGUIHandles.DrawShadowedLine(handles, handles[0], handles[1], handlesColor);
        NGUIHandles.DrawShadowedLine(handles, handles[1], handles[2], handlesColor);
        NGUIHandles.DrawShadowedLine(handles, handles[2], handles[3], handlesColor);
        NGUIHandles.DrawShadowedLine(handles, handles[0], handles[3], handlesColor);

        if (mPanel.isAnchored)
        {
            UIWidgetInspector.DrawAnchorHandle(mPanel.leftAnchor, mPanel.cachedTransform, handles, 0, id);
            UIWidgetInspector.DrawAnchorHandle(mPanel.topAnchor, mPanel.cachedTransform, handles, 1, id);
            UIWidgetInspector.DrawAnchorHandle(mPanel.rightAnchor, mPanel.cachedTransform, handles, 2, id);
            UIWidgetInspector.DrawAnchorHandle(mPanel.bottomAnchor, mPanel.cachedTransform, handles, 3, id);
        }

        if (type == EventType.Repaint)
        {
            bool showDetails = (mAction == UIWidgetInspector.Action.Scale) || NGUISettings.drawGuides;
            if (mAction == UIWidgetInspector.Action.None && e.modifiers == EventModifiers.Control)
            {
                showDetails = true;
            }
            if (NGUITools.GetActive(mPanel) && mPanel.parent == null)
            {
                showDetails = true;
            }
            if (showDetails)
            {
                NGUIHandles.DrawSize(handles, Mathf.RoundToInt(mPanel.width), Mathf.RoundToInt(mPanel.height));
            }
        }

        bool canResize = (mPanel.clipping != UIDrawCall.Clipping.None);

        // NOTE: Remove this part when it's possible to neatly resize rotated anchored panels.
        if (canResize && mPanel.isAnchored)
        {
            Quaternion rot = mPanel.cachedTransform.localRotation;
            if (Quaternion.Angle(rot, Quaternion.identity) > 0.01f)
            {
                canResize = false;
            }
        }

        bool[] resizable = new bool[8];

        resizable[4] = canResize;                    // left
        resizable[5] = canResize;                    // top
        resizable[6] = canResize;                    // right
        resizable[7] = canResize;                    // bottom

        resizable[0] = resizable[7] && resizable[4]; // bottom-left
        resizable[1] = resizable[5] && resizable[4]; // top-left
        resizable[2] = resizable[5] && resizable[6]; // top-right
        resizable[3] = resizable[7] && resizable[6]; // bottom-right

        UIWidget.Pivot pivotUnderMouse = UIWidgetInspector.GetPivotUnderMouse(handles, e, resizable, true, ref actionUnderMouse);

        switch (type)
        {
        case EventType.Repaint:
        {
            Vector3 v0 = HandleUtility.WorldToGUIPoint(handles[0]);
            Vector3 v2 = HandleUtility.WorldToGUIPoint(handles[2]);

            if ((v2 - v0).magnitude > 60f)
            {
                Vector3 v1 = HandleUtility.WorldToGUIPoint(handles[1]);
                Vector3 v3 = HandleUtility.WorldToGUIPoint(handles[3]);

                Handles.BeginGUI();
                {
                    for (int i = 0; i < 4; ++i)
                    {
                        DrawKnob(handles[i], id, resizable[i]);
                    }

                    if (Mathf.Abs(v1.y - v0.y) > 80f)
                    {
                        if (mPanel.leftAnchor.target == null || mPanel.leftAnchor.absolute != 0)
                        {
                            DrawKnob(handles[4], id, resizable[4]);
                        }

                        if (mPanel.rightAnchor.target == null || mPanel.rightAnchor.absolute != 0)
                        {
                            DrawKnob(handles[6], id, resizable[6]);
                        }
                    }

                    if (Mathf.Abs(v3.x - v0.x) > 80f)
                    {
                        if (mPanel.topAnchor.target == null || mPanel.topAnchor.absolute != 0)
                        {
                            DrawKnob(handles[5], id, resizable[5]);
                        }

                        if (mPanel.bottomAnchor.target == null || mPanel.bottomAnchor.absolute != 0)
                        {
                            DrawKnob(handles[7], id, resizable[7]);
                        }
                    }
                }
                Handles.EndGUI();
            }
        }
        break;

        case EventType.MouseDown:
        {
            if (actionUnderMouse != UIWidgetInspector.Action.None)
            {
                mStartMouse     = e.mousePosition;
                mAllowSelection = true;

                if (e.button == 1)
                {
                    if (e.modifiers == 0)
                    {
                        GUIUtility.hotControl = GUIUtility.keyboardControl = id;
                        e.Use();
                    }
                }
                else if (e.button == 0 && actionUnderMouse != UIWidgetInspector.Action.None &&
                         UIWidgetInspector.Raycast(handles, out mStartDrag))
                {
                    mWorldPos             = t.position;
                    mLocalPos             = t.localPosition;
                    mStartRot             = t.localRotation.eulerAngles;
                    mStartDir             = mStartDrag - t.position;
                    mStartCR              = mPanel.baseClipRegion;
                    mDragPivot            = pivotUnderMouse;
                    mActionUnderMouse     = actionUnderMouse;
                    GUIUtility.hotControl = GUIUtility.keyboardControl = id;
                    e.Use();
                }
            }
        }
        break;

        case EventType.MouseUp:
        {
            if (GUIUtility.hotControl == id)
            {
                GUIUtility.hotControl      = 0;
                GUIUtility.keyboardControl = 0;

                if (e.button < 2)
                {
                    bool handled = false;

                    if (e.button == 1)
                    {
                        // Right-click: Open a context menu listing all widgets underneath
                        NGUIEditorTools.ShowSpriteSelectionMenu(e.mousePosition);
                        handled = true;
                    }
                    else if (mAction == UIWidgetInspector.Action.None)
                    {
                        if (mAllowSelection)
                        {
                            // Left-click: Select the topmost widget
                            NGUIEditorTools.SelectWidget(e.mousePosition);
                            handled = true;
                        }
                    }
                    else
                    {
                        // Finished dragging something
                        Vector3 pos = t.localPosition;
                        pos.x           = Mathf.Round(pos.x);
                        pos.y           = Mathf.Round(pos.y);
                        pos.z           = Mathf.Round(pos.z);
                        t.localPosition = pos;
                        handled         = true;
                    }

                    if (handled)
                    {
                        e.Use();
                    }
                }

                // Clear the actions
                mActionUnderMouse = UIWidgetInspector.Action.None;
                mAction           = UIWidgetInspector.Action.None;
            }
            else if (mAllowSelection)
            {
                BetterList <UIWidget> widgets = NGUIEditorTools.SceneViewRaycast(e.mousePosition);
                if (widgets.size > 0)
                {
                    Selection.activeGameObject = widgets[0].gameObject;
                }
            }
            mAllowSelection = true;
        }
        break;

        case EventType.MouseDrag:
        {
            // Prevent selection once the drag operation begins
            bool dragStarted = (e.mousePosition - mStartMouse).magnitude > 3f;
            if (dragStarted)
            {
                mAllowSelection = false;
            }

            if (GUIUtility.hotControl == id)
            {
                e.Use();

                if (mAction != UIWidgetInspector.Action.None || mActionUnderMouse != UIWidgetInspector.Action.None)
                {
                    Vector3 pos;

                    if (UIWidgetInspector.Raycast(handles, out pos))
                    {
                        if (mAction == UIWidgetInspector.Action.None && mActionUnderMouse != UIWidgetInspector.Action.None)
                        {
                            // Wait until the mouse moves by more than a few pixels
                            if (dragStarted)
                            {
                                if (mActionUnderMouse == UIWidgetInspector.Action.Move)
                                {
                                    NGUISnap.Recalculate(mPanel);
                                }
                                else if (mActionUnderMouse == UIWidgetInspector.Action.Rotate)
                                {
                                    mStartRot = t.localRotation.eulerAngles;
                                    mStartDir = mStartDrag - t.position;
                                }
                                else if (mActionUnderMouse == UIWidgetInspector.Action.Scale)
                                {
                                    mStartCR   = mPanel.baseClipRegion;
                                    mDragPivot = pivotUnderMouse;
                                }
                                mAction = actionUnderMouse;
                            }
                        }

                        if (mAction != UIWidgetInspector.Action.None)
                        {
                            NGUIEditorTools.RegisterUndo("Change Rect", t);
                            NGUIEditorTools.RegisterUndo("Change Rect", mPanel);

                            if (mAction == UIWidgetInspector.Action.Move)
                            {
                                Vector3 before      = t.position;
                                Vector3 beforeLocal = t.localPosition;
                                t.position = mWorldPos + (pos - mStartDrag);
                                pos        = NGUISnap.Snap(t.localPosition, mPanel.localCorners,
                                                           e.modifiers != EventModifiers.Control) - beforeLocal;
                                t.position = before;

                                NGUIMath.MoveRect(mPanel, pos.x, pos.y);
                            }
                            else if (mAction == UIWidgetInspector.Action.Rotate)
                            {
                                Vector3 dir   = pos - t.position;
                                float   angle = Vector3.Angle(mStartDir, dir);

                                if (angle > 0f)
                                {
                                    float dot = Vector3.Dot(Vector3.Cross(mStartDir, dir), t.forward);
                                    if (dot < 0f)
                                    {
                                        angle = -angle;
                                    }
                                    angle = mStartRot.z + angle;
                                    angle = (NGUISnap.allow && e.modifiers != EventModifiers.Control) ?
                                            Mathf.Round(angle / 15f) * 15f : Mathf.Round(angle);
                                    t.localRotation = Quaternion.Euler(mStartRot.x, mStartRot.y, angle);
                                }
                            }
                            else if (mAction == UIWidgetInspector.Action.Scale)
                            {
                                // World-space delta since the drag started
                                Vector3 delta = pos - mStartDrag;

                                // Adjust the widget's position and scale based on the delta, restricted by the pivot
                                AdjustClipping(mPanel, mLocalPos, mStartCR, delta, mDragPivot);
                            }
                        }
                    }
                }
            }
        }
        break;

        case EventType.KeyDown:
        {
            if (e.keyCode == KeyCode.UpArrow)
            {
                NGUIEditorTools.RegisterUndo("Nudge Rect", t);
                NGUIEditorTools.RegisterUndo("Nudge Rect", mPanel);
                NGUIMath.MoveRect(mPanel, 0f, 1f);
                e.Use();
            }
            else if (e.keyCode == KeyCode.DownArrow)
            {
                NGUIEditorTools.RegisterUndo("Nudge Rect", t);
                NGUIEditorTools.RegisterUndo("Nudge Rect", mPanel);
                NGUIMath.MoveRect(mPanel, 0f, -1f);
                e.Use();
            }
            else if (e.keyCode == KeyCode.LeftArrow)
            {
                NGUIEditorTools.RegisterUndo("Nudge Rect", t);
                NGUIEditorTools.RegisterUndo("Nudge Rect", mPanel);
                NGUIMath.MoveRect(mPanel, -1f, 0f);
                e.Use();
            }
            else if (e.keyCode == KeyCode.RightArrow)
            {
                NGUIEditorTools.RegisterUndo("Nudge Rect", t);
                NGUIEditorTools.RegisterUndo("Nudge Rect", mPanel);
                NGUIMath.MoveRect(mPanel, 1f, 0f);
                e.Use();
            }
            else if (e.keyCode == KeyCode.Escape)
            {
                if (GUIUtility.hotControl == id)
                {
                    if (mAction != UIWidgetInspector.Action.None)
                    {
                        Undo.PerformUndo();
                    }

                    GUIUtility.hotControl      = 0;
                    GUIUtility.keyboardControl = 0;

                    mActionUnderMouse = UIWidgetInspector.Action.None;
                    mAction           = UIWidgetInspector.Action.None;
                    e.Use();
                }
                else
                {
                    Selection.activeGameObject = null;
                }
            }
        }
        break;
        }
    }
Exemple #9
0
 void OnDisable()
 {
     NGUIEditorTools.HideMoveTool(false);
     instance = null;
 }
 /// <summary>
 /// Cache the reference.
 /// </summary>
 protected virtual void OnEnable()
 {
     instance = this;
     mWidget = target as UIWidget;
 }
	protected override void OnDisable ()
	{
		base.OnDisable();
		NGUIEditorTools.HideMoveTool(false);
		instance = null;
	}
    /// <summary>
    /// Make it possible to easily drag the transform around.
    /// </summary>

    public void OnSceneGUI()
    {
        NGUIEditorTools.HideMoveTool(true);
        if (Tools.current != Tool.Move)
        {
            return;
        }

        MonoBehaviour mb = target as MonoBehaviour;

        if (mb.GetComponent <UIWidget>() != null)
        {
            return;
        }

        Transform t = mb.transform;

        UIWidget[] widgets = t.GetComponentsInChildren <UIWidget>();
        if (widgets.Length == 0)
        {
            return;
        }

        Matrix4x4 worldToLocal = t.worldToLocalMatrix;
        Matrix4x4 localToWorld = t.localToWorldMatrix;
        Bounds    bounds       = new Bounds();

        // Calculate the local bounds
        for (int i = 0; i < widgets.Length; ++i)
        {
            Vector3[] wcs = widgets[i].worldCorners;

            for (int b = 0; b < 4; ++b)
            {
                wcs[b] = worldToLocal.MultiplyPoint3x4(wcs[b]);
                if (i == 0 && b == 0)
                {
                    bounds = new Bounds(wcs[b], Vector3.zero);
                }
                else
                {
                    bounds.Encapsulate(wcs[b]);
                }
            }
        }

        // Calculate the 4 local corners
        Vector3 v0 = bounds.min;
        Vector3 v1 = bounds.max;

        float z = Mathf.Min(v0.z, v1.z);

        Vector3[] corners = new Vector3[4];
        corners[0] = new Vector3(v0.x, v0.y, z);
        corners[1] = new Vector3(v0.x, v1.y, z);
        corners[2] = new Vector3(v1.x, v1.y, z);
        corners[3] = new Vector3(v1.x, v0.y, z);

        // Transform the 4 corners into world space
        for (int i = 0; i < 4; ++i)
        {
            corners[i] = localToWorld.MultiplyPoint3x4(corners[i]);
        }

        Event     e    = Event.current;
        int       id   = GUIUtility.GetControlID(mHash, FocusType.Passive);
        EventType type = e.GetTypeForControl(id);

        Handles.color = UIWidgetInspector.handlesColor;
        Handles.DrawLine(corners[0], corners[1]);
        Handles.DrawLine(corners[1], corners[2]);
        Handles.DrawLine(corners[2], corners[3]);
        Handles.DrawLine(corners[0], corners[3]);

        Vector3[] worldPos = new Vector3[8];

        worldPos[0] = corners[0];
        worldPos[1] = corners[1];
        worldPos[2] = corners[2];
        worldPos[3] = corners[3];

        worldPos[4] = (corners[0] + corners[1]) * 0.5f;
        worldPos[5] = (corners[1] + corners[2]) * 0.5f;
        worldPos[6] = (corners[2] + corners[3]) * 0.5f;
        worldPos[7] = (corners[0] + corners[3]) * 0.5f;

        bool isWithinRect = mIsDragging || (e.modifiers == 0 &&
                                            NGUIEditorTools.SceneViewDistanceToRectangle(corners, e.mousePosition) == 0f);

#if !UNITY_3_5
        // Change the mouse cursor to a more appropriate one
        {
            Vector2[] screenPos = new Vector2[8];
            for (int i = 0; i < 8; ++i)
            {
                screenPos[i] = HandleUtility.WorldToGUIPoint(worldPos[i]);
            }

            Bounds b = new Bounds(screenPos[0], Vector3.zero);
            for (int i = 1; i < 8; ++i)
            {
                b.Encapsulate(screenPos[i]);
            }

            // Change the cursor to a move arrow when it's within the screen rectangle
            Vector2 min  = b.min;
            Vector2 max  = b.max;
            Rect    rect = new Rect(min.x, min.y, max.x - min.x, max.y - min.y);
            UIWidgetInspector.SetCursorRect(rect, isWithinRect ? MouseCursor.MoveArrow : MouseCursor.Arrow);
        }
#endif

        switch (type)
        {
        case EventType.Repaint:
        {
            Handles.BeginGUI();
            {
                for (int i = 0; i < 8; ++i)
                {
                    UIWidgetInspector.DrawKnob(worldPos[i], false, false, id);
                }
            }
            Handles.EndGUI();
        }
        break;

        case EventType.MouseDown:
        {
            mAllowSelection = true;
            mStartMouse     = e.mousePosition;

            if (e.button == 1)
            {
                GUIUtility.hotControl = GUIUtility.keyboardControl = id;
                e.Use();
            }
            else if (e.button == 0 && isWithinRect && UIWidgetInspector.Raycast(corners, out mStartDrag))
            {
                mCanDrag              = true;
                mStartPos             = t.position;
                GUIUtility.hotControl = GUIUtility.keyboardControl = id;
                e.Use();
            }
        }
        break;

        case EventType.MouseDrag:
        {
            // Prevent selection once the drag operation begins
            bool dragStarted = (e.mousePosition - mStartMouse).magnitude > 3f;
            if (dragStarted)
            {
                mAllowSelection = false;
            }

            if (GUIUtility.hotControl == id)
            {
                e.Use();

                if (mCanDrag)
                {
                    Vector3 pos;

                    if (UIWidgetInspector.Raycast(corners, out pos))
                    {
                        // Wait until the mouse moves by more than a few pixels
                        if (!mIsDragging && dragStarted)
                        {
                            NGUIEditorTools.RegisterUndo("Move " + t.name, t);
                            mStartPos   = t.position;
                            mIsDragging = true;
                        }

                        if (mIsDragging)
                        {
                            t.position      = mStartPos + (pos - mStartDrag);
                            pos             = t.localPosition;
                            pos.x           = Mathf.Round(pos.x);
                            pos.y           = Mathf.Round(pos.y);
                            pos.z           = Mathf.Round(pos.z);
                            t.localPosition = pos;
                        }
                    }
                }
            }
        }
        break;

        case EventType.MouseUp:
        {
            if (GUIUtility.hotControl == id)
            {
                GUIUtility.hotControl      = 0;
                GUIUtility.keyboardControl = 0;

                if (e.button == 0)
                {
                    if (mIsDragging)
                    {
                        mIsDragging = false;
                        Vector3 pos = t.localPosition;
                        pos.x           = Mathf.Round(pos.x);
                        pos.y           = Mathf.Round(pos.y);
                        pos.z           = Mathf.Round(pos.z);
                        t.localPosition = pos;
                    }
                    e.Use();
                }
                else if (e.button == 1 && mAllowSelection)
                {
                    if (NGUIEditorTools.SelectWidgetOrContainer(mb.gameObject, e.mousePosition, false))
                    {
                        e.Use();
                    }
                }
                mCanDrag = false;
            }
        }
        break;

        case EventType.KeyDown:
        {
            if (e.keyCode == KeyCode.UpArrow)
            {
                Vector3 pos = t.localPosition;
                pos.y          += 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.DownArrow)
            {
                Vector3 pos = t.localPosition;
                pos.y          -= 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.LeftArrow)
            {
                Vector3 pos = t.localPosition;
                pos.x          -= 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.RightArrow)
            {
                Vector3 pos = t.localPosition;
                pos.x          += 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.Escape)
            {
                if (GUIUtility.hotControl == id)
                {
                    if (mIsDragging)
                    {
                        mIsDragging = false;
                        t.position  = mStartPos;
                    }

                    GUIUtility.hotControl      = 0;
                    GUIUtility.keyboardControl = 0;
                    e.Use();
                }
                else
                {
                    Selection.activeGameObject = null;
                }
            }
        }
        break;
        }
    }
    /// <summary>
    /// Cache the reference.
    /// </summary>

    protected virtual void OnEnable()
    {
        instance = this;
        mWidget  = target as UIWidget;
    }
Exemple #14
0
    /// <summary>
    /// Handles & interaction.
    /// </summary>

    public void OnSceneGUI()
    {
        Event     e    = Event.current;
        int       id   = GUIUtility.GetControlID(s_Hash, FocusType.Passive);
        EventType type = e.GetTypeForControl(id);
        Transform t    = mPanel.cachedTransform;

        Vector3[] handles = UIWidgetInspector.GetHandles(mPanel.worldCorners);

        // Time to figure out what kind of action is underneath the mouse
        UIWidgetInspector.Action actionUnderMouse = mAction;
        bool canResize = (mPanel.clipping != UIDrawCall.Clipping.None);

        UIWidget.Pivot pivotUnderMouse = UIWidgetInspector.GetPivotUnderMouse(handles, e, canResize, ref actionUnderMouse);

        Handles.color = new Color(0.5f, 0f, 0.5f);
        Handles.DrawLine(handles[0], handles[1]);
        Handles.DrawLine(handles[1], handles[2]);
        Handles.DrawLine(handles[2], handles[3]);
        Handles.DrawLine(handles[0], handles[3]);

        switch (type)
        {
        case EventType.Repaint:
        {
            Vector3 bottomLeft = HandleUtility.WorldToGUIPoint(handles[0]);
            Vector3 topRight   = HandleUtility.WorldToGUIPoint(handles[2]);
            Vector3 diff       = topRight - bottomLeft;
            float   mag        = diff.magnitude;

            if (mag > 140f)
            {
                Handles.BeginGUI();
                for (int i = 0; i < 8; ++i)
                {
                    DrawKnob(handles[i], id);
                }
                Handles.EndGUI();
            }
            else if (mag > 40f)
            {
                Handles.BeginGUI();
                for (int i = 0; i < 4; ++i)
                {
                    DrawKnob(handles[i], id);
                }
                Handles.EndGUI();
            }
        }
        break;

        case EventType.MouseDown:
        {
            mStartMouse     = e.mousePosition;
            mAllowSelection = true;

            if (e.button == 1)
            {
                if (e.modifiers == 0)
                {
                    GUIUtility.hotControl = GUIUtility.keyboardControl = id;
                    e.Use();
                }
            }
            else if (e.button == 0 && actionUnderMouse != UIWidgetInspector.Action.None &&
                     UIWidgetInspector.Raycast(handles, out mStartDrag))
            {
                mStartPos             = t.position;
                mStartRot             = t.localRotation.eulerAngles;
                mStartDir             = mStartDrag - t.position;
                mStartCR              = mPanel.clipRange;
                mDragPivot            = pivotUnderMouse;
                mActionUnderMouse     = actionUnderMouse;
                GUIUtility.hotControl = GUIUtility.keyboardControl = id;
                e.Use();
            }
        }
        break;

        case EventType.MouseUp:
        {
            if (GUIUtility.hotControl == id)
            {
                GUIUtility.hotControl      = 0;
                GUIUtility.keyboardControl = 0;

                if (e.button < 2)
                {
                    bool handled = false;

                    if (e.button == 1)
                    {
                        // Right-click: Open a context menu listing all widgets underneath
                        NGUIEditorTools.ShowSpriteSelectionMenu(e.mousePosition);
                        handled = true;
                    }
                    else if (mAction == UIWidgetInspector.Action.None)
                    {
                        if (mAllowSelection)
                        {
                            // Left-click: Select the topmost widget
                            NGUIEditorTools.SelectWidget(e.mousePosition);
                            handled = true;
                        }
                    }
                    else
                    {
                        // Finished dragging something
                        Vector3 pos = t.localPosition;
                        pos.x           = Mathf.Round(pos.x);
                        pos.y           = Mathf.Round(pos.y);
                        pos.z           = Mathf.Round(pos.z);
                        t.localPosition = pos;
                        handled         = true;
                    }

                    if (handled)
                    {
                        e.Use();
                    }
                }

                // Clear the actions
                mActionUnderMouse = UIWidgetInspector.Action.None;
                mAction           = UIWidgetInspector.Action.None;
            }
            else if (mAllowSelection)
            {
                BetterList <UIWidget> widgets = NGUIEditorTools.SceneViewRaycast(e.mousePosition);
                if (widgets.size > 0)
                {
                    Selection.activeGameObject = widgets[0].gameObject;
                }
            }
            mAllowSelection = true;
        }
        break;

        case EventType.MouseDrag:
        {
            // Prevent selection once the drag operation begins
            bool dragStarted = (e.mousePosition - mStartMouse).magnitude > 3f;
            if (dragStarted)
            {
                mAllowSelection = false;
            }

            if (GUIUtility.hotControl == id)
            {
                e.Use();

                if (mAction != UIWidgetInspector.Action.None || mActionUnderMouse != UIWidgetInspector.Action.None)
                {
                    Vector3 pos;

                    if (UIWidgetInspector.Raycast(handles, out pos))
                    {
                        if (mAction == UIWidgetInspector.Action.None && mActionUnderMouse != UIWidgetInspector.Action.None)
                        {
                            // Wait until the mouse moves by more than a few pixels
                            if (dragStarted)
                            {
                                if (mActionUnderMouse == UIWidgetInspector.Action.Move)
                                {
                                    NGUISnap.Recalculate(mPanel);
                                    mStartPos = t.position;
                                    NGUIEditorTools.RegisterUndo("Move panel", t);
                                }
                                else if (mActionUnderMouse == UIWidgetInspector.Action.Rotate)
                                {
                                    mStartRot = t.localRotation.eulerAngles;
                                    mStartDir = mStartDrag - t.position;
                                    NGUIEditorTools.RegisterUndo("Rotate panel", t);
                                }
                                else if (mActionUnderMouse == UIWidgetInspector.Action.Scale)
                                {
                                    mStartPos  = t.localPosition;
                                    mStartCR   = mPanel.clipRange;
                                    mDragPivot = pivotUnderMouse;
                                    NGUIEditorTools.RegisterUndo("Scale panel", t);
                                    NGUIEditorTools.RegisterUndo("Scale panel", mPanel);
                                }
                                mAction = actionUnderMouse;
                            }
                        }

                        if (mAction != UIWidgetInspector.Action.None)
                        {
                            if (mAction == UIWidgetInspector.Action.Move)
                            {
                                t.position      = mStartPos + (pos - mStartDrag);
                                t.localPosition = NGUISnap.Snap(t.localPosition, mPanel.localCorners,
                                                                e.modifiers != EventModifiers.Control);
                            }
                            else if (mAction == UIWidgetInspector.Action.Rotate)
                            {
                                Vector3 dir   = pos - t.position;
                                float   angle = Vector3.Angle(mStartDir, dir);

                                if (angle > 0f)
                                {
                                    float dot = Vector3.Dot(Vector3.Cross(mStartDir, dir), t.forward);
                                    if (dot < 0f)
                                    {
                                        angle = -angle;
                                    }
                                    angle = mStartRot.z + angle;
                                    angle = (NGUISnap.allow && e.modifiers != EventModifiers.Control) ?
                                            Mathf.Round(angle / 15f) * 15f : Mathf.Round(angle);
                                    t.localRotation = Quaternion.Euler(mStartRot.x, mStartRot.y, angle);
                                }
                            }
                            else if (mAction == UIWidgetInspector.Action.Scale)
                            {
                                // World-space delta since the drag started
                                Vector3 delta = pos - mStartDrag;

                                // Adjust the widget's position and scale based on the delta, restricted by the pivot
                                AdjustClipping(mPanel, mStartPos, mStartCR, delta, mDragPivot);
                            }
                        }
                    }
                }
            }
        }
        break;

        case EventType.KeyDown:
        {
            if (e.keyCode == KeyCode.UpArrow)
            {
                Vector3 pos = t.localPosition;
                pos.y          += 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.DownArrow)
            {
                Vector3 pos = t.localPosition;
                pos.y          -= 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.LeftArrow)
            {
                Vector3 pos = t.localPosition;
                pos.x          -= 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.RightArrow)
            {
                Vector3 pos = t.localPosition;
                pos.x          += 1f;
                t.localPosition = pos;
                e.Use();
            }
            else if (e.keyCode == KeyCode.Escape)
            {
                if (GUIUtility.hotControl == id)
                {
                    if (mAction != UIWidgetInspector.Action.None)
                    {
                        if (mAction == UIWidgetInspector.Action.Move)
                        {
                            t.position = mStartPos;
                        }
                        else if (mAction == UIWidgetInspector.Action.Rotate)
                        {
                            t.localRotation = Quaternion.Euler(mStartRot);
                        }
                        else if (mAction == UIWidgetInspector.Action.Scale)
                        {
                            t.position       = mStartPos;
                            mPanel.clipRange = mStartCR;
                        }
                    }

                    GUIUtility.hotControl      = 0;
                    GUIUtility.keyboardControl = 0;

                    mActionUnderMouse = UIWidgetInspector.Action.None;
                    mAction           = UIWidgetInspector.Action.None;
                    e.Use();
                }
                else
                {
                    Selection.activeGameObject = null;
                }
            }
        }
        break;
        }
    }
Exemple #15
0
    /// <summary>
    /// Draw common widget properties.
    /// </summary>

    static public void DrawInspectorProperties(SerializedObject so, UIWidget w, bool drawColor, UIWidgetInspector widgetInspector)
    {
        if (drawColor)
        {
            if (w.GetType() == typeof(UIWidget))
            {
                DrawAlpha(so, w);
            }
            else
            {
                DrawColor(so, w, widgetInspector);
            }
            GUILayout.Space(3f);
        }

        PrefabType type = PrefabUtility.GetPrefabType(w.gameObject);

        if (NGUIEditorTools.DrawHeader("Widget"))
        {
            NGUIEditorTools.BeginContents();
            if (NGUISettings.minimalisticLook)
            {
                NGUIEditorTools.SetLabelWidth(70f);
            }

            DrawPivot(so, w);
            DrawDepth(so, w, type == PrefabType.Prefab);
            DrawDimensions(so, w, type == PrefabType.Prefab);
            if (NGUISettings.minimalisticLook)
            {
                NGUIEditorTools.SetLabelWidth(70f);
            }

            SerializedProperty ratio  = so.FindProperty("aspectRatio");
            SerializedProperty aspect = so.FindProperty("keepAspectRatio");

            GUILayout.BeginHorizontal();
            {
                if (!aspect.hasMultipleDifferentValues && aspect.intValue == 0)
                {
                    EditorGUI.BeginDisabledGroup(true);
                    NGUIEditorTools.DrawProperty("Aspect", ratio, false, GUILayout.Width(130f));
                    EditorGUI.EndDisabledGroup();
                }
                else
                {
                    NGUIEditorTools.DrawProperty("Aspect", ratio, false, GUILayout.Width(130f));
                }

                NGUIEditorTools.DrawProperty("", aspect, false, GUILayout.MinWidth(20f));
            }
            GUILayout.EndHorizontal();

            if (so.isEditingMultipleObjects || w.hasBoxCollider)
            {
                GUILayout.BeginHorizontal();
                {
                    NGUIEditorTools.DrawProperty("Collider", so, "autoResizeBoxCollider", GUILayout.Width(100f));
                    GUILayout.Label("auto-adjust to match");
                }
                GUILayout.EndHorizontal();
            }
            NGUIEditorTools.EndContents();
        }
    }