Editor drag & drop operations.

Exemplo n.º 1
0
        internal static Object DoDropField(Rect position, int id, System.Type objType, ObjectFieldValidator validator, bool allowSceneObjects, GUIStyle style)
        {
            if (validator == null)
            {
                validator = ValidateObjectFieldAssignment;
            }
            Event     evt       = Event.current;
            EventType eventType = evt.type;

            // special case test, so we continue to ping/select objects with the object field disabled
            if (!GUI.enabled && GUIClip.enabled && (Event.current.rawType == EventType.MouseDown))
            {
                eventType = Event.current.rawType;
            }

            switch (eventType)
            {
            case EventType.DragExited:
                if (GUI.enabled)
                {
                    HandleUtility.Repaint();
                }
                break;

            case EventType.DragUpdated:
            case EventType.DragPerform:

                if (position.Contains(Event.current.mousePosition) && GUI.enabled)
                {
                    Object[] references      = DragAndDrop.objectReferences;
                    Object   validatedObject = validator(references, objType, null, ObjectFieldValidatorOptions.None);

                    if (validatedObject != null)
                    {
                        // If scene objects are not allowed and object is a scene object then clear
                        if (!allowSceneObjects && !EditorUtility.IsPersistent(validatedObject))
                        {
                            validatedObject = null;
                        }
                    }

                    if (validatedObject != null)
                    {
                        DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
                        if (eventType == EventType.DragPerform)
                        {
                            GUI.changed = true;
                            DragAndDrop.AcceptDrag();
                            DragAndDrop.activeControlID = 0;
                            Event.current.Use();
                            return(validatedObject);
                        }
                        else
                        {
                            DragAndDrop.activeControlID = id;
                            Event.current.Use();
                        }
                    }
                }
                break;

            case EventType.Repaint:
                style.Draw(position, GUIContent.none, id, DragAndDrop.activeControlID == id);
                break;
            }
            return(null);
        }
        void ListArea(Rect rect, PresetLibrary lib, object newPresetObject)
        {
            if (lib == null)
            {
                return;
            }

            Event evt = Event.current;

            if (m_PresetLibraryFileLocation == PresetFileLocation.ProjectFolder && evt.type == EventType.Repaint)
            {
                m_IsOpenForEdit = AssetDatabase.IsOpenForEdit(pathWithExtension, StatusQueryOptions.UseCachedIfPossible);
            }
            else if (m_PresetLibraryFileLocation == PresetFileLocation.PreferencesFolder)
            {
                m_IsOpenForEdit = true;
            }

            if (!m_IsOpenForEdit)
            {
                Rect versionControlRect = new Rect(rect.x, rect.yMax - versionControlAreaHeight, rect.width, versionControlAreaHeight);
                VersionControlArea(versionControlRect);
                rect.height -= versionControlAreaHeight;
            }

            // To ensure we setup grid to visible rect we need to run once to check if scrollbar is taking up screen estate.
            // To optimize the first width is based on the last frame and we therefore most likely will only run once.
            for (int i = 0; i < 2; i++)
            {
                gridWidth = m_ShowedScrollBarLastFrame ? rect.width - 17 : rect.width;
                SetupGrid(gridWidth, lib.Count());
                bool isShowingScrollBar = m_Grid.height > rect.height;
                if (isShowingScrollBar == m_ShowedScrollBarLastFrame)
                {
                    break;
                }
                else
                {
                    m_ShowedScrollBarLastFrame = isShowingScrollBar;
                }
            }

            // Draw horizontal lines for scrollview content to clip against
            if ((m_ShowedScrollBarLastFrame || alwaysShowScrollAreaHorizontalLines) && Event.current.type == EventType.Repaint)
            {
                Rect scrollEdgeRect = new RectOffset(1, 1, 1, 1).Add(rect);
                scrollEdgeRect.height = 1;
                EditorGUI.DrawRect(scrollEdgeRect, new Color(0, 0, 0, 0.3f));
                scrollEdgeRect.y += rect.height + 1;
                EditorGUI.DrawRect(scrollEdgeRect, new Color(0, 0, 0, 0.3f));
            }

            Rect contentRect = new Rect(0, 0, 1, m_Grid.height);

            m_State.m_ScrollPosition = GUI.BeginScrollView(rect, m_State.m_ScrollPosition, contentRect);
            {
                int   startIndex, endIndex;
                float yOffset                 = 0f;
                int   maxIndex                = m_ShowAddNewPresetItem ? lib.Count() : lib.Count() - 1;
                bool  isGridVisible           = m_Grid.IsVisibleInScrollView(rect.height, m_State.m_ScrollPosition.y, yOffset, maxIndex, out startIndex, out endIndex);
                bool  drawDragInsertionMarker = false;
                if (isGridVisible)
                {
                    // Handle renaming overlay before item handling because its needs mouse input first to end renaming if clicked outside
                    if (GetRenameOverlay().IsRenaming() && !GetRenameOverlay().isWaitingForDelay)
                    {
                        if (!m_State.m_RenameOverlay.OnGUI())
                        {
                            EndRename();
                            evt.Use();
                        }
                        Repaint();
                    }

                    for (int i = startIndex; i <= endIndex; ++i)
                    {
                        int itemControlID = i + 1000000;

                        Rect itemRect    = m_Grid.CalcRect(i, yOffset);
                        Rect previewRect = itemRect;
                        Rect labelRect   = itemRect;
                        switch (m_State.itemViewMode)
                        {
                        case PresetLibraryEditorState.ItemViewMode.List:
                            previewRect.width = m_State.m_PreviewHeight * m_PreviewAspect;
                            labelRect.x      += previewRect.width + 8f;
                            labelRect.width  -= previewRect.width + 10f;
                            labelRect.height  = kGridLabelHeight;
                            labelRect.y       = itemRect.yMin + (itemRect.height - kGridLabelHeight) * 0.5f;
                            break;

                        case PresetLibraryEditorState.ItemViewMode.Grid:
                            // only preview is shown: no label
                            break;
                        }

                        // Add new preset button
                        if (m_ShowAddNewPresetItem && i == lib.Count())
                        {
                            CreateNewPresetButton(previewRect, newPresetObject, lib, m_IsOpenForEdit);
                            continue;
                        }

                        // Rename overlay
                        bool isRenamingThisItem = IsRenaming(i);
                        if (isRenamingThisItem)
                        {
                            Rect renameRect = labelRect;
                            renameRect.y -= 1f; renameRect.x -= 1f; // adjustment to fit perfectly
                            m_State.m_RenameOverlay.editFieldRect = renameRect;
                        }

                        // Handle event
                        switch (evt.type)
                        {
                        case EventType.Repaint:
                            if (m_State.m_HoverIndex == i)
                            {
                                if (itemRect.Contains(evt.mousePosition))
                                {
                                    // TODO: We need a better hover effect so disabling for now...
                                    //if (!GetRenameOverlay().IsRenaming ())
                                    //  DrawHoverEffect (itemRect, false);
                                }
                                else
                                {
                                    m_State.m_HoverIndex = -1;
                                }
                            }

                            if (m_DragState.draggingIndex == i || GUIUtility.hotControl == itemControlID)
                            {
                                DrawHoverEffect(itemRect, false);
                            }

                            lib.Draw(previewRect, i);
                            if (!isRenamingThisItem && drawLabels)
                            {
                                GUI.Label(labelRect, GUIContent.Temp(lib.GetName(i)));
                            }

                            if (m_DragState.dragUponIndex == i && m_DragState.draggingIndex != m_DragState.dragUponIndex)
                            {
                                drawDragInsertionMarker = true;
                            }

                            // We delete presets on alt-click
                            if (GUIUtility.hotControl == 0 && Event.current.alt && m_IsOpenForEdit)
                            {
                                EditorGUIUtility.AddCursorRect(itemRect, MouseCursor.ArrowMinus);
                            }

                            break;

                        case EventType.MouseDown:
                            if (evt.button == 0 && itemRect.Contains(evt.mousePosition))
                            {
                                GUIUtility.hotControl = itemControlID;
                                if (evt.clickCount == 1)
                                {
                                    m_ItemClickedCallback(evt.clickCount, lib.GetPreset(i));
                                    evt.Use();
                                }
                            }
                            break;

                        case EventType.MouseDrag:
                            if (GUIUtility.hotControl == itemControlID && m_IsOpenForEdit)
                            {
                                DragAndDropDelay delay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), itemControlID);
                                if (delay.CanStartDrag())
                                {
                                    // Start drag
                                    DragAndDrop.PrepareStartDrag();
                                    DragAndDrop.SetGenericData("DraggingPreset", i);
                                    DragAndDrop.StartDrag("");
                                    m_DragState.draggingIndex = i;
                                    m_DragState.dragUponIndex = i;
                                    GUIUtility.hotControl     = 0;
                                }
                                evt.Use();
                            }
                            break;

                        case EventType.DragUpdated:
                        case EventType.DragPerform:
                        {
                            Rect dragRect = GetDragRect(itemRect);
                            if (dragRect.Contains(evt.mousePosition))
                            {
                                m_DragState.dragUponIndex = i;
                                m_DragState.dragUponRect  = itemRect;

                                if (m_State.itemViewMode == PresetLibraryEditorState.ItemViewMode.List)
                                {
                                    m_DragState.insertAfterIndex = ((evt.mousePosition.y - dragRect.y) / dragRect.height) > 0.5f;
                                }
                                else
                                {
                                    m_DragState.insertAfterIndex = ((evt.mousePosition.x - dragRect.x) / dragRect.width) > 0.5f;
                                }

                                bool perform = evt.type == EventType.DragPerform;
                                if (perform)
                                {
                                    if (m_DragState.draggingIndex >= 0)
                                    {
                                        MovePreset(m_DragState.draggingIndex, m_DragState.dragUponIndex, m_DragState.insertAfterIndex);
                                        DragAndDrop.AcceptDrag();
                                    }
                                    ClearDragState();
                                }
                                DragAndDrop.visualMode = DragAndDropVisualMode.Move;
                                evt.Use();
                            }
                        }
                        break;

                        case EventType.DragExited:
                            if (m_DragState.IsDragging())
                            {
                                ClearDragState();
                                evt.Use();
                            }
                            break;

                        case EventType.MouseUp:
                            if (GUIUtility.hotControl == itemControlID)
                            {
                                GUIUtility.hotControl = 0;
                                if (evt.button == 0 && itemRect.Contains(evt.mousePosition))
                                {
                                    if (Event.current.alt && m_IsOpenForEdit)
                                    {
                                        DeletePreset(i);
                                        evt.Use();
                                    }
                                }
                            }
                            break;

                        case EventType.ContextClick:
                            if (itemRect.Contains(evt.mousePosition))
                            {
                                PresetContextMenu.Show(m_IsOpenForEdit, i, newPresetObject, this);
                                evt.Use();
                            }
                            break;

                        case EventType.MouseMove:
                            if (itemRect.Contains(evt.mousePosition))
                            {
                                if (m_State.m_HoverIndex != i)
                                {
                                    m_State.m_HoverIndex = i;
                                    Repaint();
                                }
                            }
                            else if (m_State.m_HoverIndex == i)
                            {
                                m_State.m_HoverIndex = -1;
                                Repaint();
                            }

                            break;
                        }
                    } // end foreach item

                    // Draw above all items
                    if (drawDragInsertionMarker)
                    {
                        DrawDragInsertionMarker();
                    }
                }
            } GUI.EndScrollView();
        }
Exemplo n.º 3
0
        private DragAndDropVisualMode DoDragScenes(GameObjectTreeViewItem parentItem, GameObjectTreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
        {
            List <Scene> genericData = DragAndDrop.GetGenericData("SceneHeaderList") as List <Scene>;
            bool         flag        = genericData != null;
            bool         flag2       = false;

            if (!flag && (DragAndDrop.objectReferences.Length > 0))
            {
                int num = 0;
                foreach (Object obj2 in DragAndDrop.objectReferences)
                {
                    if (obj2 is SceneAsset)
                    {
                        num++;
                    }
                }
                flag2 = num == DragAndDrop.objectReferences.Length;
            }
            if (!flag && !flag2)
            {
                return(DragAndDropVisualMode.None);
            }
            if (perform)
            {
                List <Scene> list2 = null;
                if (flag2)
                {
                    List <Scene> source = new List <Scene>();
                    foreach (Object obj3 in DragAndDrop.objectReferences)
                    {
                        string assetPath   = AssetDatabase.GetAssetPath(obj3);
                        Scene  sceneByPath = SceneManager.GetSceneByPath(assetPath);
                        if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(sceneByPath))
                        {
                            base.m_TreeView.Frame(sceneByPath.handle, true, true);
                        }
                        else
                        {
                            if (Event.current.alt)
                            {
                                sceneByPath = EditorSceneManager.OpenScene(assetPath, OpenSceneMode.AdditiveWithoutLoading);
                            }
                            else
                            {
                                sceneByPath = EditorSceneManager.OpenScene(assetPath, OpenSceneMode.Additive);
                            }
                            if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(sceneByPath))
                            {
                                source.Add(sceneByPath);
                            }
                        }
                    }
                    if (targetItem != null)
                    {
                        list2 = source;
                    }
                    if ((SceneManager.sceneCount - source.Count) == 1)
                    {
                        Scene sceneAt = SceneManager.GetSceneAt(0);
                        ((TreeViewDataSource)base.m_TreeView.data).SetExpanded(sceneAt.handle, true);
                    }
                    if (source.Count > 0)
                    {
                        if (< > f__am$cache1 == null)
                        {
Exemplo n.º 4
0
        static Object DoObjectField(Rect position, Rect dropRect, int id, Object obj, Object objBeingEdited, System.Type objType, System.Type additionalType, SerializedProperty property, ObjectFieldValidator validator, bool allowSceneObjects, GUIStyle style, GUIStyle buttonStyle)
        {
            if (validator == null)
            {
                validator = ValidateObjectFieldAssignment;
            }
            if (property != null)
            {
                obj = property.objectReferenceValue;
            }
            Event     evt       = Event.current;
            EventType eventType = evt.type;

            // special case test, so we continue to ping/select objects with the object field disabled
            if (!GUI.enabled && GUIClip.enabled && (Event.current.rawType == EventType.MouseDown))
            {
                eventType = Event.current.rawType;
            }

            bool hasThumbnail = EditorGUIUtility.HasObjectThumbnail(objType);

            // Determine visual type
            ObjectFieldVisualType visualType = ObjectFieldVisualType.IconAndText;

            if (hasThumbnail && position.height <= kObjectFieldMiniThumbnailHeight && position.width <= kObjectFieldMiniThumbnailWidth)
            {
                visualType = ObjectFieldVisualType.MiniPreview;
            }
            else if (hasThumbnail && position.height > kSingleLineHeight)
            {
                visualType = ObjectFieldVisualType.LargePreview;
            }

            Vector2 oldIconSize = EditorGUIUtility.GetIconSize();

            if (visualType == ObjectFieldVisualType.IconAndText)
            {
                EditorGUIUtility.SetIconSize(new Vector2(12, 12));  // Have to be this small to fit inside a single line height ObjectField
            }
            else if (visualType == ObjectFieldVisualType.LargePreview)
            {
                EditorGUIUtility.SetIconSize(new Vector2(64, 64));
            }

            if ((eventType == EventType.MouseDown && Event.current.button == 1 ||
                 (eventType == EventType.ContextClick && visualType == ObjectFieldVisualType.IconAndText)) &&
                position.Contains(Event.current.mousePosition))
            {
                var actualObject = property != null ? property.objectReferenceValue : obj;
                var contextMenu  = new GenericMenu();

                if (FillPropertyContextMenu(property, null, contextMenu) != null)
                {
                    contextMenu.AddSeparator("");
                }
                contextMenu.AddItem(GUIContent.Temp("Properties..."), false, () => PropertyEditor.OpenPropertyEditor(actualObject));
                contextMenu.DropDown(position);
                Event.current.Use();
            }

            switch (eventType)
            {
            case EventType.DragExited:
                if (GUI.enabled)
                {
                    HandleUtility.Repaint();
                }

                break;

            case EventType.DragUpdated:
            case EventType.DragPerform:

                if (eventType == EventType.DragPerform)
                {
                    string errorString;
                    if (!ValidDroppedObject(DragAndDrop.objectReferences, objType, out errorString))
                    {
                        Object reference = DragAndDrop.objectReferences[0];
                        EditorUtility.DisplayDialog("Can't assign script", errorString, "OK");
                        break;
                    }
                }

                if (dropRect.Contains(Event.current.mousePosition) && GUI.enabled)
                {
                    Object[] references      = DragAndDrop.objectReferences;
                    Object   validatedObject = validator(references, objType, property, ObjectFieldValidatorOptions.None);

                    if (validatedObject != null)
                    {
                        // If scene objects are not allowed and object is a scene object then clear
                        if (!allowSceneObjects && !EditorUtility.IsPersistent(validatedObject))
                        {
                            validatedObject = null;
                        }
                    }

                    if (validatedObject != null)
                    {
                        DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
                        if (eventType == EventType.DragPerform)
                        {
                            if (property != null)
                            {
                                property.objectReferenceValue = validatedObject;
                            }
                            else
                            {
                                obj = validatedObject;
                            }

                            GUI.changed = true;
                            DragAndDrop.AcceptDrag();
                            DragAndDrop.activeControlID = 0;
                        }
                        else
                        {
                            DragAndDrop.activeControlID = id;
                        }
                        Event.current.Use();
                    }
                }
                break;

            case EventType.MouseDown:
                if (position.Contains(Event.current.mousePosition) && Event.current.button == 0)
                {
                    // Get button rect for Object Selector
                    Rect buttonRect = GetButtonRect(visualType, position);

                    EditorGUIUtility.editingTextField = false;

                    if (buttonRect.Contains(Event.current.mousePosition))
                    {
                        if (GUI.enabled)
                        {
                            GUIUtility.keyboardControl = id;
                            var types = additionalType == null ? new Type[] { objType } : new Type[] { objType, additionalType };
                            if (property != null)
                            {
                                ObjectSelector.get.Show(types, property, allowSceneObjects);
                            }
                            else
                            {
                                ObjectSelector.get.Show(obj, types, objBeingEdited, allowSceneObjects);
                            }
                            ObjectSelector.get.objectSelectorID = id;

                            evt.Use();
                            GUIUtility.ExitGUI();
                        }
                    }
                    else
                    {
                        Object    actualTargetObject = property != null ? property.objectReferenceValue : obj;
                        Component com = actualTargetObject as Component;
                        if (com)
                        {
                            actualTargetObject = com.gameObject;
                        }
                        if (showMixedValue)
                        {
                            actualTargetObject = null;
                        }

                        // One click shows where the referenced object is, or pops up a preview
                        if (Event.current.clickCount == 1)
                        {
                            GUIUtility.keyboardControl = id;

                            PingObjectOrShowPreviewOnClick(actualTargetObject, position);
                            var selectedMaterial = actualTargetObject as Material;
                            if (selectedMaterial != null)
                            {
                                PingObjectInSceneViewOnClick(selectedMaterial);
                            }
                            evt.Use();
                        }
                        // Double click opens the asset in external app or changes selection to referenced object
                        else if (Event.current.clickCount == 2)
                        {
                            if (actualTargetObject)
                            {
                                AssetDatabase.OpenAsset(actualTargetObject);
                                evt.Use();
                                GUIUtility.ExitGUI();
                            }
                        }
                    }
                }
                break;

            case EventType.ExecuteCommand:
                string commandName = evt.commandName;
                if (commandName == ObjectSelector.ObjectSelectorUpdatedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && (property == null || !property.isScript))
                {
                    return(AssignSelectedObject(property, validator, objType, evt));
                }
                else if (commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && property != null && property.isScript)
                {
                    if (ObjectSelector.get.GetInstanceID() == 0)
                    {
                        // User canceled object selection; don't apply
                        evt.Use();
                        break;
                    }
                    return(AssignSelectedObject(property, validator, objType, evt));
                }
                else if ((evt.commandName == EventCommandNames.Delete || evt.commandName == EventCommandNames.SoftDelete) && GUIUtility.keyboardControl == id)
                {
                    if (property != null)
                    {
                        property.objectReferenceValue = null;
                    }
                    else
                    {
                        obj = null;
                    }

                    GUI.changed = true;
                    evt.Use();
                }
                break;

            case EventType.ValidateCommand:
                if ((evt.commandName == EventCommandNames.Delete || evt.commandName == EventCommandNames.SoftDelete) && GUIUtility.keyboardControl == id)
                {
                    evt.Use();
                }
                break;

            case EventType.KeyDown:
                if (GUIUtility.keyboardControl == id)
                {
                    if (evt.keyCode == KeyCode.Backspace || (evt.keyCode == KeyCode.Delete && (evt.modifiers & EventModifiers.Shift) == 0))
                    {
                        if (property != null)
                        {
                            if (property.propertyPath.EndsWith("]"))
                            {
                                var  parentArrayPropertyPath = property.propertyPath.Substring(0, property.propertyPath.LastIndexOf(".Array.data[", StringComparison.Ordinal));
                                var  parentArrayProperty     = property.serializedObject.FindProperty(parentArrayPropertyPath);
                                bool isReorderableList       = PropertyHandler.s_reorderableLists.ContainsKey(ReorderableListWrapper.GetPropertyIdentifier(parentArrayProperty));

                                // If it's an element of an non-orderable array and it is displayed inside a list, remove that element from the array (cases 1379541 & 1335322)
                                if (!isReorderableList && GUI.isInsideList && GetInsideListDepth() == parentArrayProperty.depth)
                                {
                                    TargetChoiceHandler.DeleteArrayElement(property);
                                }
                                else
                                {
                                    property.objectReferenceValue = null;
                                }
                            }
                            else
                            {
                                property.objectReferenceValue = null;
                            }
                        }
                        else
                        {
                            obj = null;
                        }

                        GUI.changed = true;
                        evt.Use();
                    }

                    // Apparently we have to check for the character being space instead of the keyCode,
                    // otherwise the Inspector will maximize upon pressing space.
                    if (evt.MainActionKeyForControl(id))
                    {
                        var types = additionalType == null ? new Type[] { objType } : new Type[] { objType, additionalType };
                        if (property != null)
                        {
                            ObjectSelector.get.Show(types, property, allowSceneObjects);
                        }
                        else
                        {
                            ObjectSelector.get.Show(obj, types, objBeingEdited, allowSceneObjects);
                        }
                        ObjectSelector.get.objectSelectorID = id;
                        evt.Use();
                        GUIUtility.ExitGUI();
                    }
                }
                break;

            case EventType.Repaint:
                GUIContent temp;
                if (showMixedValue)
                {
                    temp = s_MixedValueContent;
                }
                else
                {
                    // If obj or objType are both null, we have to rely on
                    // property.objectReferenceStringValue to display None/Missing and the
                    // correct type. But if not, EditorGUIUtility.ObjectContent is more reliable.
                    // It can take a more specific object type specified as argument into account,
                    // and it gets the icon at the same time.
                    if (obj == null && objType == null && property != null)
                    {
                        temp = EditorGUIUtility.TempContent(property.objectReferenceStringValue);
                    }
                    else
                    {
                        // In order for ObjectContext to be able to distinguish between None/Missing,
                        // we need to supply an instanceID. For some reason, getting the instanceID
                        // from property.objectReferenceValue is not reliable, so we have to
                        // explicitly check property.objectReferenceInstanceIDValue if a property exists.
                        if (property != null)
                        {
                            temp = EditorGUIUtility.ObjectContent(obj, objType, property.objectReferenceInstanceIDValue);
                        }
                        else
                        {
                            temp = EditorGUIUtility.ObjectContent(obj, objType);
                        }
                    }

                    if (property != null)
                    {
                        if (obj != null)
                        {
                            Object[] references = { obj };
                            if (EditorSceneManager.preventCrossSceneReferences && CheckForCrossSceneReferencing(obj, property.serializedObject.targetObject))
                            {
                                if (!EditorApplication.isPlaying)
                                {
                                    temp = s_SceneMismatch;
                                }
                                else
                                {
                                    temp.text = temp.text + string.Format(" ({0})", GetGameObjectFromObject(obj).scene.name);
                                }
                            }
                            else if (validator(references, objType, property, ObjectFieldValidatorOptions.ExactObjectTypeValidation) == null)
                            {
                                temp = s_TypeMismatch;
                            }
                        }
                    }
                }

                switch (visualType)
                {
                case ObjectFieldVisualType.IconAndText:
                    BeginHandleMixedValueContentColor();
                    style.Draw(position, temp, id, DragAndDrop.activeControlID == id, position.Contains(Event.current.mousePosition));

                    Rect buttonRect = buttonStyle.margin.Remove(GetButtonRect(visualType, position));
                    buttonStyle.Draw(buttonRect, GUIContent.none, id, DragAndDrop.activeControlID == id, buttonRect.Contains(Event.current.mousePosition));
                    EndHandleMixedValueContentColor();
                    break;

                case ObjectFieldVisualType.LargePreview:
                    DrawObjectFieldLargeThumb(position, id, obj, temp);
                    break;

                case ObjectFieldVisualType.MiniPreview:
                    DrawObjectFieldMiniThumb(position, id, obj, temp);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                break;
            }

            EditorGUIUtility.SetIconSize(oldIconSize);

            return(obj);
        }
Exemplo n.º 5
0
        private DragAndDropVisualMode DoDragScenes(GameObjectTreeViewItem parentItem, GameObjectTreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
        {
            List <Scene> list  = DragAndDrop.GetGenericData("SceneHeaderList") as List <Scene>;
            bool         flag  = list != null;
            bool         flag2 = false;

            if (!flag && DragAndDrop.objectReferences.Length > 0)
            {
                int num = 0;
                UnityEngine.Object[] objectReferences = DragAndDrop.objectReferences;
                for (int i = 0; i < objectReferences.Length; i++)
                {
                    UnityEngine.Object @object = objectReferences[i];
                    if (@object is SceneAsset)
                    {
                        num++;
                    }
                }
                flag2 = (num == DragAndDrop.objectReferences.Length);
            }
            DragAndDropVisualMode result;

            if (!flag && !flag2)
            {
                result = DragAndDropVisualMode.None;
            }
            else
            {
                if (perform)
                {
                    List <Scene> list2 = null;
                    if (flag2)
                    {
                        List <Scene>         list3             = new List <Scene>();
                        UnityEngine.Object[] objectReferences2 = DragAndDrop.objectReferences;
                        for (int j = 0; j < objectReferences2.Length; j++)
                        {
                            UnityEngine.Object assetObject = objectReferences2[j];
                            string             assetPath   = AssetDatabase.GetAssetPath(assetObject);
                            Scene scene = SceneManager.GetSceneByPath(assetPath);
                            if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene))
                            {
                                this.m_TreeView.Frame(scene.handle, true, true);
                            }
                            else
                            {
                                bool alt = Event.current.alt;
                                if (alt)
                                {
                                    scene = EditorSceneManager.OpenScene(assetPath, OpenSceneMode.AdditiveWithoutLoading);
                                }
                                else
                                {
                                    scene = EditorSceneManager.OpenScene(assetPath, OpenSceneMode.Additive);
                                }
                                if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene))
                                {
                                    list3.Add(scene);
                                }
                            }
                        }
                        if (targetItem != null)
                        {
                            list2 = list3;
                        }
                        if (list3.Count > 0)
                        {
                            Selection.instanceIDs = (from x in list3
                                                     select x.handle).ToArray <int>();
                            this.m_TreeView.Frame(list3.Last <Scene>().handle, true, false);
                        }
                    }
                    else
                    {
                        list2 = list;
                    }
                    if (list2 != null)
                    {
                        if (targetItem != null)
                        {
                            Scene scene2 = targetItem.scene;
                            if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene2))
                            {
                                if (!targetItem.isSceneHeader || dropPos == TreeViewDragging.DropPosition.Upon)
                                {
                                    dropPos = TreeViewDragging.DropPosition.Below;
                                }
                                if (dropPos == TreeViewDragging.DropPosition.Above)
                                {
                                    for (int k = 0; k < list2.Count; k++)
                                    {
                                        EditorSceneManager.MoveSceneBefore(list2[k], scene2);
                                    }
                                }
                                else if (dropPos == TreeViewDragging.DropPosition.Below)
                                {
                                    for (int l = list2.Count - 1; l >= 0; l--)
                                    {
                                        EditorSceneManager.MoveSceneAfter(list2[l], scene2);
                                    }
                                }
                            }
                        }
                        else
                        {
                            Scene sceneAt = SceneManager.GetSceneAt(SceneManager.sceneCount - 1);
                            for (int m = list2.Count - 1; m >= 0; m--)
                            {
                                EditorSceneManager.MoveSceneAfter(list2[m], sceneAt);
                            }
                        }
                    }
                }
                result = DragAndDropVisualMode.Move;
            }
            return(result);
        }
        private static void OnProjectWindowItemOnGUI(string guid, Rect selectionRect)
        {
            // Break - key modifier doen't pressed
            var activated = Event.current.alt;

            if (activated == false)
            {
                return;
            }

            // Break - OnGUI() call not for mouse target
            var within = selectionRect.Contains(Event.current.mousePosition);

            if (within == false)
            {
                return;
            }

            // Break - destination match one of sources
            var target          = AssetDatabase.GUIDToAssetPath(guid);
            var targetInSources = Array.IndexOf(DragAndDrop.paths, target) != -1;

            if (targetInSources)
            {
                return;
            }

            // Break - unity default moving
            var targetIsFolder = AssetDatabase.IsValidFolder(target);

            if (targetIsFolder)
            {
                foreach (var asset in DragAndDrop.objectReferences)
                {
                    if (AssetDatabase.IsMainAsset(asset))
                    {
                        return;
                    }
                }
            }

            // Break - there is Unity restriction to use GameObjects as SubAssets
            foreach (var obj in DragAndDrop.objectReferences)
            {
                if (obj is GameObject)
                {
                    return;
                }
            }

            if (Event.current.type == EventType.DragUpdated)
            {
                DragAndDrop.visualMode = DragAndDropVisualMode.Move;
                Event.current.Use();
            }
            else if (Event.current.type == EventType.DragPerform)
            {
                Move(DragAndDrop.objectReferences, target);
                DragAndDrop.AcceptDrag();
                Event.current.Use();
            }
        }
Exemplo n.º 7
0
        public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos)
        {
            if (targetItem == null)
            {
                return(DragAndDropVisualMode.None);
            }

            object savedFilterData = DragAndDrop.GetGenericData(ProjectWindowUtil.k_DraggingFavoriteGenericData);

            // Dragging saved filter
            if (savedFilterData != null)
            {
                int instanceID = (int)savedFilterData;
                if (targetItem is SearchFilterTreeItem && parentItem is SearchFilterTreeItem)// && targetItem.id != draggedInstanceID && parentItem.id != draggedInstanceID)
                {
                    bool validMove = SavedSearchFilters.CanMoveSavedFilter(instanceID, parentItem.id, targetItem.id, dropPos == DropPosition.Below);
                    if (validMove && perform)
                    {
                        SavedSearchFilters.MoveSavedFilter(instanceID, parentItem.id, targetItem.id, dropPos == DropPosition.Below);
                        m_TreeView.SetSelection(new[] { instanceID }, false);
                        m_TreeView.NotifyListenersThatSelectionChanged();
                    }
                    return(validMove ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.None);
                }
                return(DragAndDropVisualMode.None);
            }
            // Dragging of folders into filters
            else
            {
                // Check if we are dragging a single folder
                if (targetItem is SearchFilterTreeItem && parentItem is SearchFilterTreeItem)
                {
                    string genericData = DragAndDrop.GetGenericData(ProjectWindowUtil.k_IsFolderGenericData) as string;
                    if (genericData == "isFolder")
                    {
                        if (perform)
                        {
                            Object[] objs = DragAndDrop.objectReferences;
                            if (objs.Length > 0)
                            {
                                string path = AssetDatabase.GetAssetPath(objs[0].GetInstanceID());
                                if (!string.IsNullOrEmpty(path))
                                {
                                    // TODO: Fix with new AssetDatabase API when it is ready (GetName)
                                    string       folderName   = new DirectoryInfo(path).Name;
                                    SearchFilter searchFilter = new SearchFilter();
                                    searchFilter.folders = new[] { path };
                                    bool addAsChild = targetItem == parentItem;

                                    float previewSize = ProjectBrowserColumnOneTreeViewGUI.GetListAreaGridSize();
                                    int   instanceID  = SavedSearchFilters.AddSavedFilterAfterInstanceID(folderName, searchFilter, previewSize, targetItem.id, addAsChild);
                                    m_TreeView.SetSelection(new[] { instanceID }, false);
                                    m_TreeView.NotifyListenersThatSelectionChanged();
                                }
                                else
                                {
                                    Debug.Log("Could not get asset path from id " + objs[0].GetInstanceID());
                                }
                            }
                        }
                        return(DragAndDropVisualMode.Copy); // Allow dragging folders to filters
                    }
                    return(DragAndDropVisualMode.None);     // Assets that are not folders are not allowed to be dragged to filters
                }
            }
            //  Assets are handled by base
            return(base.DoDrag(parentItem, targetItem, perform, dropPos));
        }
        public DragAndDropVisualMode HandleTrackDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos)
        {
            ((TimelineTreeView)m_Window.treeView.gui).showInsertionMarker = false;
            var  trackDragData = (TimelineDragData)DragAndDrop.GetGenericData(k_GenericDragId);
            bool validDrag     = ValidDrag(targetItem, trackDragData.draggedItems);

            if (!validDrag)
            {
                return(DragAndDropVisualMode.None);
            }


            var draggedTracks = trackDragData.draggedItems.OfType <TimelineGroupGUI>().Select(x => x.track).ToList();

            if (draggedTracks.Count == 0)
            {
                return(DragAndDropVisualMode.None);
            }

            if (parentItem != null)
            {
                var parentActor = parentItem as TimelineGroupGUI;
                if (parentActor != null && parentActor.track != null)
                {
                    if (parentActor.track.lockedInHierarchy)
                    {
                        return(DragAndDropVisualMode.Rejected);
                    }

                    if (draggedTracks.Any(x => !TimelineCreateUtilities.ValidateParentTrack(parentActor.track, x.GetType())))
                    {
                        return(DragAndDropVisualMode.Rejected);
                    }
                }
            }

            var insertAfterItem = targetItem as TimelineGroupGUI;

            if (insertAfterItem != null && insertAfterItem.track != null)
            {
                ((TimelineTreeView)m_Window.treeView.gui).showInsertionMarker = true;
            }

            if (dropPos == DropPosition.Upon)
            {
                var groupGUI = targetItem as TimelineGroupGUI;
                if (groupGUI != null)
                {
                    groupGUI.isDropTarget = true;
                }
            }

            if (perform)
            {
                PlayableAsset targetParent = m_Timeline;
                var           parentActor  = parentItem as TimelineGroupGUI;

                if (parentActor != null && parentActor.track != null)
                {
                    targetParent = parentActor.track;
                }

                TrackAsset siblingTrack = insertAfterItem != null ? insertAfterItem.track : null;

                // where the user drops after the last track, make sure to place it after all the tracks
                if (targetParent == m_Timeline && dropPos == DropPosition.Below && siblingTrack == null)
                {
                    siblingTrack = m_Timeline.GetRootTracks().LastOrDefault(x => !draggedTracks.Contains(x));
                }

                if (TrackExtensions.ReparentTracks(TrackExtensions.FilterTracks(draggedTracks).ToList(), targetParent, siblingTrack, dropPos == DropPosition.Above))
                {
                    m_Window.state.Refresh();
                }
            }

            return(DragAndDropVisualMode.Move);
        }
Exemplo n.º 9
0
        internal static Object DoObjectField(Rect position, Rect dropRect, int id, Object obj, System.Type objType, SerializedProperty property, ObjectFieldValidator validator, bool allowSceneObjects, GUIStyle style)
        {
            if (validator == null)
            {
                validator = ValidateObjectFieldAssignment;
            }
            Event     evt       = Event.current;
            EventType eventType = evt.type;

            // special case test, so we continue to ping/select objects with the object field disabled
            if (!GUI.enabled && GUIClip.enabled && (Event.current.rawType == EventType.MouseDown))
            {
                eventType = Event.current.rawType;
            }

            bool hasThumbnail = EditorGUIUtility.HasObjectThumbnail(objType);

            // Determine visual type
            ObjectFieldVisualType visualType = ObjectFieldVisualType.IconAndText;

            if (hasThumbnail && position.height <= kObjectFieldMiniThumbnailHeight && position.width <= kObjectFieldMiniThumbnailWidth)
            {
                visualType = ObjectFieldVisualType.MiniPreview;
            }
            else if (hasThumbnail && position.height > kSingleLineHeight)
            {
                visualType = ObjectFieldVisualType.LargePreview;
            }

            Vector2 oldIconSize = EditorGUIUtility.GetIconSize();

            if (visualType == ObjectFieldVisualType.IconAndText)
            {
                EditorGUIUtility.SetIconSize(new Vector2(12, 12));  // Have to be this small to fit inside a single line height ObjectField
            }
            else if (visualType == ObjectFieldVisualType.LargePreview)
            {
                EditorGUIUtility.SetIconSize(new Vector2(64, 64));
            }

            switch (eventType)
            {
            case EventType.DragExited:
                if (GUI.enabled)
                {
                    HandleUtility.Repaint();
                }

                break;

            case EventType.DragUpdated:
            case EventType.DragPerform:

                if (dropRect.Contains(Event.current.mousePosition) && GUI.enabled)
                {
                    Object[] references      = DragAndDrop.objectReferences;
                    Object   validatedObject = validator(references, objType, property, ObjectFieldValidatorOptions.None);

                    if (validatedObject != null)
                    {
                        // If scene objects are not allowed and object is a scene object then clear
                        if (!allowSceneObjects && !EditorUtility.IsPersistent(validatedObject))
                        {
                            validatedObject = null;
                        }
                    }

                    if (validatedObject != null)
                    {
                        DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
                        if (eventType == EventType.DragPerform)
                        {
                            if (property != null)
                            {
                                property.objectReferenceValue = validatedObject;
                            }
                            else
                            {
                                obj = validatedObject;
                            }

                            GUI.changed = true;
                            DragAndDrop.AcceptDrag();
                            DragAndDrop.activeControlID = 0;
                        }
                        else
                        {
                            DragAndDrop.activeControlID = id;
                        }
                        Event.current.Use();
                    }
                }
                break;

            case EventType.MouseDown:
                // Ignore right clicks
                if (Event.current.button != 0)
                {
                    break;
                }
                if (position.Contains(Event.current.mousePosition))
                {
                    // Get button rect for Object Selector
                    Rect buttonRect;
                    switch (visualType)
                    {
                    case ObjectFieldVisualType.IconAndText:
                    case ObjectFieldVisualType.MiniPreview:
                        buttonRect = new Rect(position.xMax - 15, position.y, 15, position.height);
                        break;

                    case ObjectFieldVisualType.LargePreview:
                        buttonRect = new Rect(position.xMax - 36, position.yMax - 14, 36, 14);
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }

                    EditorGUIUtility.editingTextField = false;

                    if (buttonRect.Contains(Event.current.mousePosition))
                    {
                        if (GUI.enabled)
                        {
                            GUIUtility.keyboardControl = id;
                            ObjectSelector.get.Show(obj, objType, property, allowSceneObjects);
                            ObjectSelector.get.objectSelectorID = id;

                            evt.Use();
                            GUIUtility.ExitGUI();
                        }
                    }
                    else
                    {
                        Object    actualTargetObject = property != null ? property.objectReferenceValue : obj;
                        Component com = actualTargetObject as Component;
                        if (com)
                        {
                            actualTargetObject = com.gameObject;
                        }
                        if (showMixedValue)
                        {
                            actualTargetObject = null;
                        }

                        // One click shows where the referenced object is, or pops up a preview
                        if (Event.current.clickCount == 1)
                        {
                            GUIUtility.keyboardControl = id;

                            PingObjectOrShowPreviewOnClick(actualTargetObject, position);
                            evt.Use();
                        }
                        // Double click opens the asset in external app or changes selection to referenced object
                        else if (Event.current.clickCount == 2)
                        {
                            if (actualTargetObject)
                            {
                                AssetDatabase.OpenAsset(actualTargetObject);
                                GUIUtility.ExitGUI();
                            }
                            evt.Use();
                        }
                    }
                }
                break;

            case EventType.ExecuteCommand:
                string commandName = evt.commandName;
                if (commandName == ObjectSelector.ObjectSelectorUpdatedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && (property == null || !property.isScript))
                {
                    return(AssignSelectedObject(property, validator, objType, evt));
                }
                else if (commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && property != null && property.isScript)
                {
                    if (ObjectSelector.get.GetInstanceID() == 0)
                    {
                        // User canceled object selection; don't apply
                        evt.Use();
                        break;
                    }
                    return(AssignSelectedObject(property, validator, objType, evt));
                }
                break;

            case EventType.KeyDown:
                if (GUIUtility.keyboardControl == id)
                {
                    if (evt.keyCode == KeyCode.Backspace || evt.keyCode == KeyCode.Delete)
                    {
                        if (property != null)
                        {
                            property.objectReferenceValue = null;
                        }
                        else
                        {
                            obj = null;
                        }

                        GUI.changed = true;
                        evt.Use();
                    }

                    // Apparently we have to check for the character being space instead of the keyCode,
                    // otherwise the Inspector will maximize upon pressing space.
                    if (evt.MainActionKeyForControl(id))
                    {
                        ObjectSelector.get.Show(obj, objType, property, allowSceneObjects);
                        ObjectSelector.get.objectSelectorID = id;
                        evt.Use();
                        GUIUtility.ExitGUI();
                    }
                }
                break;

            case EventType.Repaint:
                GUIContent temp;
                if (showMixedValue)
                {
                    temp = s_MixedValueContent;
                }
                else if (property != null)
                {
                    temp = EditorGUIUtility.TempContent(property.objectReferenceStringValue, AssetPreview.GetMiniThumbnail(property.objectReferenceValue));
                    obj  = property.objectReferenceValue;
                    if (obj != null)
                    {
                        Object[] references = { obj };
                        if (EditorSceneManager.preventCrossSceneReferences && CheckForCrossSceneReferencing(obj, property.serializedObject.targetObject))
                        {
                            if (!EditorApplication.isPlaying)
                            {
                                temp = s_SceneMismatch;
                            }
                            else
                            {
                                temp.text = temp.text + string.Format(" ({0})", GetGameObjectFromObject(obj).scene.name);
                            }
                        }
                        else if (validator(references, objType, property, ObjectFieldValidatorOptions.ExactObjectTypeValidation) == null)
                        {
                            temp = s_TypeMismatch;
                        }
                    }
                }
                else
                {
                    temp = EditorGUIUtility.ObjectContent(obj, objType);
                }

                switch (visualType)
                {
                case ObjectFieldVisualType.IconAndText:
                    BeginHandleMixedValueContentColor();
                    style.Draw(position, temp, id, DragAndDrop.activeControlID == id, position.Contains(Event.current.mousePosition));
                    EndHandleMixedValueContentColor();
                    break;

                case ObjectFieldVisualType.LargePreview:
                    DrawObjectFieldLargeThumb(position, id, obj, temp);
                    break;

                case ObjectFieldVisualType.MiniPreview:
                    DrawObjectFieldMiniThumb(position, id, obj, temp);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                break;
            }

            EditorGUIUtility.SetIconSize(oldIconSize);

            return(obj);
        }
        private void HandleMouseInput()
        {
            List <CubemapInfo> hdriList = this.m_LookDevView.envLibrary.hdriList;
            Vector2            pos      = new Vector2(Event.current.mousePosition.x, Event.current.mousePosition.y + this.m_ScrollPosition.y);
            Event     current           = Event.current;
            EventType typeForControl    = current.GetTypeForControl(this.m_LookDevView.hotControl);

            switch (typeForControl)
            {
            case EventType.MouseUp:
                if (this.m_SelectedCubemap != null)
                {
                    Rect gUIRect = this.m_GUIRect;
                    gUIRect.yMax += 16f;
                    if (!gUIRect.Contains(Event.current.mousePosition))
                    {
                        break;
                    }
                    int insertionIndex = this.IsPositionInInsertionArea(pos);
                    if (insertionIndex == -1)
                    {
                        int num2 = this.IsPositionInThumbnailArea(pos);
                        if ((num2 != -1) && this.m_LookDevView.config.enableShadowCubemap)
                        {
                            Undo.RecordObject(this.m_LookDevView.envLibrary, "Update shadow cubemap");
                            CubemapInfo info2 = this.m_LookDevView.envLibrary.hdriList[num2];
                            if (info2 != this.m_SelectedCubemapInfo)
                            {
                                info2.SetCubemapShadowInfo(this.m_SelectedCubemapInfo);
                            }
                            this.m_LookDevView.envLibrary.dirty = true;
                        }
                    }
                    else
                    {
                        this.ResetShadowCubemap();
                        this.m_LookDevView.envLibrary.InsertHDRI(this.m_SelectedCubemap, insertionIndex);
                    }
                    this.CancelSelection();
                }
                break;

            case EventType.MouseDrag:
                if (this.m_SelectedCubeMapOffsetIndex != -1)
                {
                    Undo.RecordObject(this.m_LookDevView.envLibrary, "");
                    CubemapInfo info = hdriList[this.m_SelectedCubeMapOffsetIndex];
                    info.angleOffset = this.ComputeAngleOffsetFromMouseCoord(pos) + this.m_SelectedCubeMapOffsetValue;
                    this.m_LookDevView.envLibrary.dirty = true;
                    Event.current.Use();
                }
                if (this.m_SelectedCubemapInfo != null)
                {
                    if (this.IsPositionInInsertionArea(pos) == -1)
                    {
                        this.m_HoveringCubeMapIndex = this.IsPositionInThumbnailArea(pos);
                    }
                    else
                    {
                        this.m_HoveringCubeMapIndex = -1;
                    }
                }
                this.m_LookDevView.Repaint();
                return;

            case EventType.KeyDown:
                if (Event.current.keyCode == KeyCode.Escape)
                {
                    this.CancelSelection();
                    this.m_LookDevView.Repaint();
                }
                return;

            case EventType.Repaint:
                if (this.m_SelectedCubeMapOffsetIndex != -1)
                {
                    EditorGUIUtility.AddCursorRect(this.m_displayRect, MouseCursor.SlideArrow);
                }
                return;

            case EventType.DragUpdated:
            {
                bool flag = false;
                foreach (UnityEngine.Object obj3 in DragAndDrop.objectReferences)
                {
                    Cubemap cubemap2 = obj3 as Cubemap;
                    if (cubemap2 != null)
                    {
                        flag = true;
                    }
                }
                DragAndDrop.visualMode = !flag ? DragAndDropVisualMode.Rejected : DragAndDropVisualMode.Link;
                if (flag)
                {
                    this.m_DragBeingPerformed = true;
                }
                current.Use();
                return;
            }

            case EventType.DragPerform:
            {
                int num3 = this.IsPositionInInsertionArea(pos);
                foreach (UnityEngine.Object obj2 in DragAndDrop.objectReferences)
                {
                    Cubemap cubemap = obj2 as Cubemap;
                    if (cubemap != null)
                    {
                        this.m_LookDevView.envLibrary.InsertHDRI(cubemap, num3);
                    }
                }
                DragAndDrop.AcceptDrag();
                this.m_DragBeingPerformed = false;
                current.Use();
                return;
            }

            default:
                if (typeForControl == EventType.DragExited)
                {
                }
                return;
            }
            this.m_LookDevView.Repaint();
            if ((this.m_SelectedCubeMapOffsetIndex != -1) && (Mathf.Abs(hdriList[this.m_SelectedCubeMapOffsetIndex].angleOffset) <= 10f))
            {
                Undo.RecordObject(this.m_LookDevView.envLibrary, "");
                hdriList[this.m_SelectedCubeMapOffsetIndex].angleOffset = 0f;
                this.m_LookDevView.envLibrary.dirty = true;
            }
            this.m_SelectedCubemapInfo            = null;
            this.m_SelectedShadowCubemapOwnerInfo = null;
            this.m_SelectedLightIconIndex         = -1;
            this.m_SelectedShadowInfo             = null;
            this.m_SelectedCubeMapOffsetIndex     = -1;
            this.m_HoveringCubeMapIndex           = -1;
            this.m_SelectedCubeMapOffsetValue     = 0f;
            GUIUtility.hotControl = 0;
        }
Exemplo n.º 11
0
 public bool MoveNext()
 {
     if (this.xPos > -1)
     {
         if (ListViewShared.HasMouseDown(this.ilvState, this.rect))
         {
             this.ilvState.state.selectionChanged = true;
             this.ilvState.state.row       = this.yPos;
             this.ilvState.state.column    = this.xPos;
             this.ilvState.state.scrollPos = ListViewShared.ListViewScrollToRow(this.ilvState, this.yPos);
             if ((this.ilvState.wantsReordering || this.ilvState.wantsToStartCustomDrag) && GUIUtility.hotControl == this.ilvState.state.ID)
             {
                 DragAndDropDelay dragAndDropDelay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), this.ilvState.state.ID);
                 dragAndDropDelay.mouseDownPosition = Event.current.mousePosition;
                 this.ilvState.dragItem             = this.yPos;
                 ListViewShared.dragControlID       = this.ilvState.state.ID;
             }
         }
         if (!ListViewShared.isDragging && (this.ilvState.wantsReordering || this.ilvState.wantsToStartCustomDrag) && GUIUtility.hotControl == this.ilvState.state.ID && Event.current.type == EventType.MouseDrag && GUIClip.visibleRect.Contains(Event.current.mousePosition))
         {
             DragAndDropDelay dragAndDropDelay2 = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), this.ilvState.state.ID);
             if (dragAndDropDelay2.CanStartDrag())
             {
                 DragAndDrop.PrepareStartDrag();
                 DragAndDrop.objectReferences = new UnityEngine.Object[0];
                 DragAndDrop.paths            = null;
                 if (this.ilvState.wantsReordering)
                 {
                     this.ilvState.state.dropHereRect = new Rect(this.ilvState.rect.x, 0f, this.ilvState.rect.width, (float)(this.ilvState.state.rowHeight * 2));
                     DragAndDrop.StartDrag(this.dragTitle);
                 }
                 else if (this.ilvState.wantsToStartCustomDrag)
                 {
                     DragAndDrop.SetGenericData("CustomDragID", this.ilvState.state.ID);
                     DragAndDrop.StartDrag(this.dragTitle);
                 }
                 ListViewShared.isDragging = true;
             }
             Event.current.Use();
         }
     }
     this.xPos++;
     if (this.xPos > this.xTo)
     {
         this.xPos = 0;
         this.yPos++;
         this.rect.x     = this.firstRect.x;
         this.rect.width = (float)this.colWidths[0];
         if (this.yPos > this.yTo)
         {
             this.quiting = true;
         }
         else
         {
             this.rect.y = this.rect.y + this.rect.height;
         }
     }
     else
     {
         if (this.xPos >= 1)
         {
             this.rect.x = this.rect.x + (float)this.colWidths[this.xPos - 1];
         }
         this.rect.width = (float)this.colWidths[this.xPos];
     }
     this.element.row      = this.yPos;
     this.element.column   = this.xPos;
     this.element.position = this.rect;
     if (this.element.row >= this.ilvState.state.totalRows)
     {
         this.quiting = true;
     }
     if (this.isLayouted && Event.current.type == EventType.Layout)
     {
         if (this.yFrom + 1 == this.yPos)
         {
             this.quiting = true;
         }
     }
     if (this.isLayouted && this.yPos != this.yFrom)
     {
         GUILayout.EndHorizontal();
     }
     if (this.quiting)
     {
         if (this.ilvState.state.drawDropHere && Event.current.GetTypeForControl(this.ilvState.state.ID) == EventType.Repaint)
         {
             GUIStyle gUIStyle = ListViewShared.Constants.insertion;
             gUIStyle.Draw(gUIStyle.margin.Remove(this.ilvState.state.dropHereRect), false, false, false, false);
         }
         if (ListViewShared.ListViewKeyboard(this.ilvState, this.colWidths.Length))
         {
             this.ilvState.state.selectionChanged = true;
         }
         if (Event.current.GetTypeForControl(this.ilvState.state.ID) == EventType.MouseUp)
         {
             GUIUtility.hotControl = 0;
         }
         if (this.ilvState.wantsReordering && GUIUtility.hotControl == this.ilvState.state.ID)
         {
             ListViewState state = this.ilvState.state;
             EventType     type  = Event.current.type;
             if (type != EventType.DragUpdated)
             {
                 if (type != EventType.DragPerform)
                 {
                     if (type == EventType.DragExited)
                     {
                         this.ilvState.wantsReordering    = false;
                         this.ilvState.state.drawDropHere = false;
                         GUIUtility.hotControl            = 0;
                     }
                 }
                 else
                 {
                     if (GUIClip.visibleRect.Contains(Event.current.mousePosition))
                     {
                         this.ilvState.state.draggedFrom = this.ilvState.dragItem;
                         this.ilvState.state.draggedTo   = Mathf.RoundToInt(Event.current.mousePosition.y / (float)state.rowHeight);
                         if (this.ilvState.state.draggedTo > this.ilvState.state.totalRows)
                         {
                             this.ilvState.state.draggedTo = this.ilvState.state.totalRows;
                         }
                         if (this.ilvState.state.draggedTo > this.ilvState.state.draggedFrom)
                         {
                             this.ilvState.state.row = this.ilvState.state.draggedTo - 1;
                         }
                         else
                         {
                             this.ilvState.state.row = this.ilvState.state.draggedTo;
                         }
                         this.ilvState.state.selectionChanged = true;
                         DragAndDrop.AcceptDrag();
                         Event.current.Use();
                         this.ilvState.wantsReordering    = false;
                         this.ilvState.state.drawDropHere = false;
                     }
                     GUIUtility.hotControl = 0;
                 }
             }
             else
             {
                 DragAndDrop.visualMode = ((!this.ilvState.rect.Contains(Event.current.mousePosition)) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Move);
                 Event.current.Use();
                 if (DragAndDrop.visualMode != DragAndDropVisualMode.None)
                 {
                     state.dropHereRect.y = (float)((Mathf.RoundToInt(Event.current.mousePosition.y / (float)state.rowHeight) - 1) * state.rowHeight);
                     if (state.dropHereRect.y >= (float)(state.rowHeight * state.totalRows))
                     {
                         state.dropHereRect.y = (float)(state.rowHeight * (state.totalRows - 1));
                     }
                     state.drawDropHere = true;
                 }
             }
         }
         else if (this.ilvState.wantsExternalFiles)
         {
             EventType type2 = Event.current.type;
             if (type2 != EventType.DragUpdated)
             {
                 if (type2 != EventType.DragPerform)
                 {
                     if (type2 == EventType.DragExited)
                     {
                         this.ilvState.wantsExternalFiles = false;
                         this.ilvState.state.drawDropHere = false;
                         GUIUtility.hotControl            = 0;
                     }
                 }
                 else
                 {
                     if (GUIClip.visibleRect.Contains(Event.current.mousePosition))
                     {
                         this.ilvState.state.fileNames = DragAndDrop.paths;
                         DragAndDrop.AcceptDrag();
                         Event.current.Use();
                         this.ilvState.wantsExternalFiles = false;
                         this.ilvState.state.drawDropHere = false;
                         this.ilvState.state.draggedTo    = Mathf.RoundToInt(Event.current.mousePosition.y / (float)this.ilvState.state.rowHeight);
                         if (this.ilvState.state.draggedTo > this.ilvState.state.totalRows)
                         {
                             this.ilvState.state.draggedTo = this.ilvState.state.totalRows;
                         }
                         this.ilvState.state.row = this.ilvState.state.draggedTo;
                     }
                     GUIUtility.hotControl = 0;
                 }
             }
             else if (GUIClip.visibleRect.Contains(Event.current.mousePosition) && DragAndDrop.paths != null && DragAndDrop.paths.Length != 0)
             {
                 DragAndDrop.visualMode = ((!this.ilvState.rect.Contains(Event.current.mousePosition)) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Copy);
                 Event.current.Use();
                 if (DragAndDrop.visualMode != DragAndDropVisualMode.None)
                 {
                     this.ilvState.state.dropHereRect = new Rect(this.ilvState.rect.x, (float)((Mathf.RoundToInt(Event.current.mousePosition.y / (float)this.ilvState.state.rowHeight) - 1) * this.ilvState.state.rowHeight), this.ilvState.rect.width, (float)this.ilvState.state.rowHeight);
                     if (this.ilvState.state.dropHereRect.y >= (float)(this.ilvState.state.rowHeight * this.ilvState.state.totalRows))
                     {
                         this.ilvState.state.dropHereRect.y = (float)(this.ilvState.state.rowHeight * (this.ilvState.state.totalRows - 1));
                     }
                     this.ilvState.state.drawDropHere = true;
                 }
             }
         }
         else if (this.ilvState.wantsToAcceptCustomDrag && ListViewShared.dragControlID != this.ilvState.state.ID)
         {
             EventType type3 = Event.current.type;
             if (type3 != EventType.DragUpdated)
             {
                 if (type3 != EventType.DragPerform)
                 {
                     if (type3 == EventType.DragExited)
                     {
                         GUIUtility.hotControl = 0;
                     }
                 }
                 else
                 {
                     object genericData = DragAndDrop.GetGenericData("CustomDragID");
                     if (GUIClip.visibleRect.Contains(Event.current.mousePosition) && genericData != null)
                     {
                         this.ilvState.state.customDraggedFromID = (int)genericData;
                         DragAndDrop.AcceptDrag();
                         Event.current.Use();
                     }
                     GUIUtility.hotControl = 0;
                 }
             }
             else
             {
                 object genericData2 = DragAndDrop.GetGenericData("CustomDragID");
                 if (GUIClip.visibleRect.Contains(Event.current.mousePosition) && genericData2 != null)
                 {
                     DragAndDrop.visualMode = ((!this.ilvState.rect.Contains(Event.current.mousePosition)) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Move);
                     Event.current.Use();
                 }
             }
         }
         if (this.ilvState.beganHorizontal)
         {
             EditorGUILayout.EndScrollView();
             GUILayout.EndHorizontal();
             this.ilvState.beganHorizontal = false;
         }
         if (this.isLayouted)
         {
             GUILayoutUtility.EndLayoutGroup();
             EditorGUILayout.EndScrollView();
         }
         this.ilvState.wantsReordering    = false;
         this.ilvState.wantsExternalFiles = false;
     }
     else if (this.isLayouted)
     {
         if (this.yPos != this.yFrom)
         {
             this.ilvStateL.group.ResetCursor();
             this.ilvStateL.group.AddY();
         }
         else
         {
             this.ilvStateL.group.AddY((float)(this.ilvState.invisibleRows * this.ilvState.state.rowHeight));
         }
     }
     if (this.isLayouted)
     {
         if (!this.quiting)
         {
             GUILayout.BeginHorizontal(GUIStyle.none, new GUILayoutOption[0]);
         }
         else
         {
             GUILayout.EndHorizontal();
         }
     }
     return(!this.quiting);
 }
Exemplo n.º 12
0
        public void OnSceneDrag(SceneView sceneView)
        {
            GameObject target = this.target as GameObject;

            switch (PrefabUtility.GetPrefabType(target))
            {
            case PrefabType.Prefab:
            case PrefabType.ModelPrefab:
            {
                Event     current = Event.current;
                EventType type    = current.type;
                if (type != EventType.DragUpdated)
                {
                    if (type == EventType.DragPerform)
                    {
                        string uniqueNameForSibling = GameObjectUtility.GetUniqueNameForSibling(null, dragObject.name);
                        dragObject.hideFlags = HideFlags.None;
                        Undo.RegisterCreatedObjectUndo(dragObject, "Place " + dragObject.name);
                        EditorUtility.SetDirty(dragObject);
                        DragAndDrop.AcceptDrag();
                        Selection.activeObject             = dragObject;
                        HandleUtility.ignoreRaySnapObjects = null;
                        EditorWindow.mouseOverWindow.Focus();
                        dragObject.name = uniqueNameForSibling;
                        dragObject      = null;
                        current.Use();
                        return;
                    }
                    if ((type == EventType.DragExited) && (dragObject != null))
                    {
                        Object.DestroyImmediate(dragObject, false);
                        HandleUtility.ignoreRaySnapObjects = null;
                        dragObject = null;
                        current.Use();
                    }
                }
                else
                {
                    if (dragObject == null)
                    {
                        dragObject = (GameObject)PrefabUtility.InstantiatePrefab(PrefabUtility.FindPrefabRoot(target));
                        HandleUtility.ignoreRaySnapObjects = dragObject.GetComponentsInChildren <Transform>();
                        dragObject.hideFlags = HideFlags.HideInHierarchy;
                        dragObject.name      = target.name;
                    }
                    DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
                    object obj3 = HandleUtility.RaySnap(HandleUtility.GUIPointToWorldRay(current.mousePosition));
                    if (obj3 != null)
                    {
                        RaycastHit hit = (RaycastHit)obj3;
                        float      num = 0f;
                        if (Tools.pivotMode == PivotMode.Center)
                        {
                            float num2 = HandleUtility.CalcRayPlaceOffset(HandleUtility.ignoreRaySnapObjects, hit.normal);
                            if (num2 != float.PositiveInfinity)
                            {
                                num = Vector3.Dot(dragObject.transform.position, hit.normal) - num2;
                            }
                        }
                        dragObject.transform.position = Matrix4x4.identity.MultiplyPoint(hit.point + ((Vector3)(hit.normal * num)));
                    }
                    else
                    {
                        dragObject.transform.position = HandleUtility.GUIPointToWorldRay(current.mousePosition).GetPoint(10f);
                    }
                    if (sceneView.in2DMode)
                    {
                        Vector3 position = dragObject.transform.position;
                        position.z = PrefabUtility.FindPrefabRoot(target).transform.position.z;
                        dragObject.transform.position = position;
                    }
                    current.Use();
                }
                break;
            }
            }
        }
Exemplo n.º 13
0
        private void HandleMouseInput()
        {
            List <CubemapInfo> cubemapList = m_LookDevView.envLibrary.hdriList;

            Vector2 scrollFixedPosition = new Vector2(Event.current.mousePosition.x, Event.current.mousePosition.y + m_ScrollPosition.y);

            Event evt = Event.current;

            switch (evt.GetTypeForControl(m_LookDevView.hotControl))
            {
            // Update overlay position for next repaint event
            case EventType.MouseDrag:
            {
                if (m_SelectedCubeMapOffsetIndex != -1)
                {
                    Undo.RecordObject(m_LookDevView.envLibrary, "");
                    CubemapInfo info = cubemapList[m_SelectedCubeMapOffsetIndex];
                    info.angleOffset = ComputeAngleOffsetFromMouseCoord(scrollFixedPosition) + m_SelectedCubeMapOffsetValue;
                    m_LookDevView.envLibrary.dirty = true;
                    Event.current.Use();
                }

                if (m_SelectedCubemapInfo != null)
                {
                    if (IsPositionInInsertionArea(scrollFixedPosition) == -1)
                    {
                        m_HoveringCubeMapIndex = IsPositionInThumbnailArea(scrollFixedPosition);
                    }
                    else
                    {
                        m_HoveringCubeMapIndex = -1;
                    }
                }

                m_LookDevView.Repaint();
                break;
            }

            // Handles environment drop
            case EventType.MouseUp:
            {
                if (m_SelectedCubemap != null)
                {
                    // The rect needs to include an extra slot when moving to last position
                    Rect extendedGUIRect = m_GUIRect;
                    extendedGUIRect.yMax += EditorGUI.kSingleLineHeight;

                    if (extendedGUIRect.Contains(Event.current.mousePosition))
                    {
                        int insertionRectIndex = IsPositionInInsertionArea(scrollFixedPosition);
                        if (insertionRectIndex != -1)
                        {
                            // Must be called before we do any modification to HDRI list
                            ResetShadowCubemap();

                            m_LookDevView.envLibrary.InsertHDRI(m_SelectedCubemap, insertionRectIndex);
                        }
                        else
                        {
                            int thumbnailRectIndex = IsPositionInThumbnailArea(scrollFixedPosition);
                            if (thumbnailRectIndex != -1 && m_LookDevView.config.enableShadowCubemap)
                            {
                                Undo.RecordObject(m_LookDevView.envLibrary, "Update shadow cubemap");
                                CubemapInfo cubemapInfo = m_LookDevView.envLibrary.hdriList[thumbnailRectIndex];

                                // We don't want the user to drop a cubemap on itself and reset the shadows (it would happen all the time by mistake)
                                if (cubemapInfo != m_SelectedCubemapInfo)
                                {
                                    cubemapInfo.SetCubemapShadowInfo(m_SelectedCubemapInfo);
                                }
                                m_LookDevView.envLibrary.dirty = true;
                            }
                        }
                        CancelSelection();
                    }
                }

                m_LookDevView.Repaint();

                if (m_SelectedCubeMapOffsetIndex != -1)
                {
                    // Fall back to zero when near the center
                    if (Mathf.Abs(cubemapList[m_SelectedCubeMapOffsetIndex].angleOffset) <= 10.0f)
                    {
                        Undo.RecordObject(m_LookDevView.envLibrary, "");
                        cubemapList[m_SelectedCubeMapOffsetIndex].angleOffset = 0.0f;
                        m_LookDevView.envLibrary.dirty = true;
                    }
                }
                m_SelectedCubemapInfo            = null;
                m_SelectedShadowCubemapOwnerInfo = null;
                m_SelectedLightIconIndex         = -1;
                m_SelectedShadowInfo             = null;
                m_SelectedCubeMapOffsetIndex     = -1;
                m_HoveringCubeMapIndex           = -1;
                m_SelectedCubeMapOffsetValue     = 0.0f;

                GUIUtility.hotControl = 0;

                break;
            }

            // Escape closes the window
            case EventType.KeyDown:
            {
                if (Event.current.keyCode == KeyCode.Escape)
                {
                    CancelSelection();
                    m_LookDevView.Repaint();
                }
                break;
            }

            case EventType.DragPerform:
            {
                int insertionIndex = IsPositionInInsertionArea(scrollFixedPosition);

                foreach (UnityEngine.Object o in DragAndDrop.objectReferences)
                {
                    Cubemap cubemap = o as Cubemap;
                    if (cubemap)
                    {
                        // When insertion outside the list the index is -1 which mean in InsertHDRI that it will be add at the end
                        m_LookDevView.envLibrary.InsertHDRI(cubemap, insertionIndex);
                    }
                }

                DragAndDrop.AcceptDrag();
                m_DragBeingPerformed = false;
                evt.Use();
                break;
            }

            case EventType.DragUpdated:
            {
                bool hasCubemap = false;
                foreach (UnityEngine.Object o in DragAndDrop.objectReferences)
                {
                    Cubemap cubemap = o as Cubemap;
                    if (cubemap)
                    {
                        hasCubemap = true;
                    }
                }
                DragAndDrop.visualMode = hasCubemap ? DragAndDropVisualMode.Link : DragAndDropVisualMode.Rejected;
                if (hasCubemap)
                {
                    m_DragBeingPerformed = true;
                }
                evt.Use();
            }
            break;

            case EventType.DragExited:
                break;

            case EventType.Repaint:

                if (m_SelectedCubeMapOffsetIndex != -1)
                {
                    EditorGUIUtility.AddCursorRect(m_displayRect, MouseCursor.SlideArrow);
                }
                break;
            }
        }
        protected override DragAndDropVisualMode HandleDragAndDrop(DragAndDropArgs args)
        {
            // Check if we can handle the current drag data (could be dragged in from other areas/windows in the editor)
            var draggedRows = DragAndDrop.GetGenericData(k_DragId) as List <int>;

            if (draggedRows == null || args.dragAndDropPosition != DragAndDropPosition.BetweenItems)
            {
                return(DragAndDropVisualMode.None);
            }

            if (args.performDrop)
            {
                if (m_Positions.hasMultipleDifferentValues)
                {
                    if (!EditorUtility.DisplayDialog(L10n.Tr("Moving an array element will copy the complete array to all other selected objects."),
                                                     L10n.Tr("Unique values in the different selected objects will be lost"),
                                                     L10n.Tr("OK"),
                                                     L10n.Tr("Cancel")))
                    {
                        return(DragAndDropVisualMode.Rejected);
                    }
                }

                int arraySize = GetArraySize();
                var newList   = new List <Vector3>(arraySize);
                draggedRows.Sort();

                int nextDragItem = 0;
                for (int i = 0; i < arraySize; ++i)
                {
                    if (i == args.insertAtIndex)
                    {
                        // Insert the items here
                        foreach (var viewItem in draggedRows)
                        {
                            newList.Add(m_Positions.GetArrayElementAtIndex(viewItem).vector3Value);
                        }
                    }

                    if (i == draggedRows[nextDragItem])
                    {
                        // Ignore this item, it is being moved
                        nextDragItem++;
                        if (nextDragItem >= draggedRows.Count)
                        {
                            nextDragItem = 0;
                        }
                    }
                    else
                    {
                        newList.Add(m_Positions.GetArrayElementAtIndex(i).vector3Value);
                    }
                }

                // Add to the end?
                if (args.insertAtIndex == arraySize)
                {
                    foreach (var viewItem in draggedRows)
                    {
                        newList.Add(m_Positions.GetArrayElementAtIndex(viewItem).vector3Value);
                    }
                }

                // Copy the list back
                for (int i = 0; i < arraySize; ++i)
                {
                    m_Positions.GetArrayElementAtIndex(i).vector3Value = newList[i];
                }

                SetSelection(Enumerable.Range(args.insertAtIndex - draggedRows.Count(o => o < args.insertAtIndex), draggedRows.Count).ToList());
            }
            return(DragAndDropVisualMode.Move);
        }
Exemplo n.º 15
0
        void HandleEditorDragging(Editor[] editors, int editorIndex, Rect targetRect, float markerY, bool bottomTarget)
        {
            var evt = Event.current;

            switch (evt.type)
            {
            case EventType.DragUpdated:
                if (targetRect.Contains(evt.mousePosition))
                {
                    var draggingMode = DragAndDrop.GetGenericData(k_DraggingModeKey) as DraggingMode ? ;
                    if (!draggingMode.HasValue)
                    {
                        var draggedObjects = DragAndDrop.objectReferences;

                        if (draggedObjects.Length == 0)
                        {
                            draggingMode = DraggingMode.NotApplicable;
                        }
                        else if (draggedObjects.All(o => o is Component && !(o is Transform)))
                        {
                            draggingMode = DraggingMode.Component;
                        }
                        else if (draggedObjects.All(o => o is MonoScript))
                        {
                            draggingMode = DraggingMode.Script;
                        }
                        else
                        {
                            draggingMode = DraggingMode.NotApplicable;
                        }

                        DragAndDrop.SetGenericData(k_DraggingModeKey, draggingMode);
                    }


                    if (draggingMode.Value != DraggingMode.NotApplicable)
                    {
                        if (bottomTarget)
                        {
                            m_TargetAbove = false;
                            m_TargetIndex = m_LastIndex;
                        }
                        else
                        {
                            m_TargetAbove = evt.mousePosition.y < targetRect.y + targetRect.height / 2f;
                            m_TargetIndex = editorIndex;

                            if (m_TargetAbove)
                            {
                                m_TargetIndex++;
                                while (m_TargetIndex < editors.Length && m_InspectorWindow.ShouldCullEditor(editors, m_TargetIndex))
                                {
                                    m_TargetIndex++;
                                }

                                if (m_TargetIndex == editors.Length)
                                {
                                    m_TargetIndex = -1;
                                    return;
                                }
                            }
                        }

                        if (m_TargetAbove && InspectorWindow.EditorHasLargeHeader(m_TargetIndex, editors))
                        {
                            m_TargetIndex--;
                            while (m_TargetIndex >= 0 && m_InspectorWindow.ShouldCullEditor(editors, m_TargetIndex))
                            {
                                m_TargetIndex--;
                            }

                            if (m_TargetIndex == -1)
                            {
                                return;
                            }

                            m_TargetAbove = false;
                        }

                        if (draggingMode.Value == DraggingMode.Script)
                        {
                            // Validate dragging scripts
                            // Always allow script dragging, instead fail during DragPerform with a dialog box
                            DragAndDrop.visualMode = DragAndDropVisualMode.Link;
                        }
                        else
                        {
                            // Validate dragging components
                            var valid = false;
                            if (editors[m_TargetIndex].targets.All(t => t is Component))
                            {
                                var targetComponents = editors[m_TargetIndex].targets.Cast <Component>().ToArray();
                                var sourceComponents = DragAndDrop.objectReferences.Cast <Component>().ToArray();
                                valid = MoveOrCopyComponents(sourceComponents, targetComponents, EditorUtility.EventHasDragCopyModifierPressed(evt), true);
                            }

                            if (valid)
                            {
                                DragAndDrop.visualMode = EditorUtility.EventHasDragCopyModifierPressed(evt) ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.Move;
                            }
                            else
                            {
                                DragAndDrop.visualMode = DragAndDropVisualMode.None;
                                m_TargetIndex          = -1;
                                return;
                            }
                        }

                        evt.Use();
                    }
                }
                else
                {
                    m_TargetIndex = -1;
                }

                break;

            case EventType.DragPerform:
                if (m_TargetIndex != -1)
                {
                    HandleDragPerformEvent(editors, evt, ref m_TargetIndex);
                }
                break;

            case EventType.DragExited:
                m_TargetIndex = -1;
                break;

            case EventType.Repaint:
                if (m_TargetIndex != -1 && editorIndex == m_TargetIndex &&
                    (targetRect.Contains(evt.mousePosition) ||
                     m_BottomArea.Contains(GUIClip.UnclipToWindow(evt.mousePosition)) &&
                     m_BottomAreaDropIndex == editors.Length - 1))
                {
                    Styles.insertionMarker.Draw(GetMarkerRect(targetRect, markerY, m_TargetAbove), false, false, false, false);
                }
                break;
            }
        }
        public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos)
        {
            m_Window.isDragging = false;

            var retMode = DragAndDropVisualMode.None;

            var trackDragData = DragAndDrop.GetGenericData(k_GenericDragId) as TimelineDragData;

            if (trackDragData != null)
            {
                retMode = HandleTrackDrop(parentItem, targetItem, perform, dropPos);
                if (retMode == DragAndDropVisualMode.Copy && targetItem != null && Event.current.type == EventType.DragUpdated)
                {
                    var targetActor = targetItem as TimelineGroupGUI;
                    if (targetActor != null)
                    {
                        targetActor.isDropTarget = true;
                    }
                }
            }
            else if (DragAndDrop.objectReferences.Any())
            {
                var objectsBeingDropped = DragAndDrop.objectReferences.OfType <UnityObject>();
                var director            = m_Window.state.editSequence.director;

                if (ShouldUseHierarchyDragAndDrop())
                {
                    // for object drawing
                    var          originalTarget   = targetItem;
                    TreeViewItem insertBeforeItem = null;
                    HandleNestedItemGUI(ref parentItem, ref targetItem, ref insertBeforeItem);
                    var track        = GetTrack(targetItem);
                    var parent       = GetTrack(parentItem);
                    var insertBefore = GetTrack(insertBeforeItem);
                    retMode = HandleHierarchyPaneDragAndDrop(objectsBeingDropped, track, perform, m_Timeline, director, ResolveType, insertBefore);

                    // fallback to old clip behaviour
                    if (retMode == DragAndDropVisualMode.None)
                    {
                        retMode = HandleClipPaneObjectDragAndDrop(objectsBeingDropped, track, perform, m_Timeline, parent, director, m_Window.state.timeAreaShownRange.x, ResolveType, insertBefore);
                    }

                    // if we are rejected, clear any drop markers
                    if (retMode == DragAndDropVisualMode.Rejected && targetItem != null)
                    {
                        ClearInsertionMarkers(originalTarget);
                        ClearInsertionMarkers(targetItem);
                        ClearInsertionMarkers(parentItem);
                        ClearInsertionMarkers(insertBeforeItem);
                    }
                }
                else
                {
                    var candidateTime = TimelineHelpers.GetCandidateTime(Event.current.mousePosition);
                    retMode = HandleClipPaneObjectDragAndDrop(objectsBeingDropped, GetTrack(targetItem), perform, m_Timeline, GetTrack(parentItem), director, candidateTime, ResolveType);
                }
            }

            m_Window.isDragging = false;

            return(retMode);
        }
Exemplo n.º 17
0
        void HandleDragPerformEvent(Editor[] editors, Event evt, ref int targetIndex)
        {
            if (targetIndex != -1)
            {
                var draggingMode = DragAndDrop.GetGenericData(k_DraggingModeKey) as DraggingMode ? ;
                if (!draggingMode.HasValue || draggingMode.Value == DraggingMode.NotApplicable)
                {
                    targetIndex = -1;
                    return;
                }

                if (!editors[targetIndex].targets.All(t => t is Component))
                {
                    return;
                }

                var targetComponents = editors[targetIndex].targets.Cast <Component>().ToArray();

                if (draggingMode.Value == DraggingMode.Script)
                {
                    var scripts = DragAndDrop.objectReferences.Cast <MonoScript>();

                    // Ensure all script components can be added
                    var valid = true;
                    foreach (var targetComponent in targetComponents)
                    {
                        var gameObject = targetComponent.gameObject;
                        if (scripts.Any(s => !ComponentUtility.WarnCanAddScriptComponent(gameObject, s)))
                        {
                            valid = false;
                            break;
                        }
                    }

                    if (valid)
                    {
                        Undo.IncrementCurrentGroup();
                        var undoGroup = Undo.GetCurrentGroup();

                        // Add script components
                        var index           = 0;
                        var addedComponents = new Component[targetComponents.Length * scripts.Count()];
                        for (int i = 0; i < targetComponents.Length; i++)
                        {
                            var  targetComponent   = targetComponents[i];
                            var  gameObject        = targetComponent.gameObject;
                            bool targetIsTransform = targetComponent is Transform;
                            foreach (var script in scripts)
                            {
                                addedComponents[index++] = ObjectFactory.AddComponent(gameObject, script.GetClass());
                            }

                            // If the target is a Transform, the AddComponent might have replaced it with a RectTransform.
                            // Handle this possibility by updating the target component.
                            if (targetIsTransform)
                            {
                                targetComponents[i] = gameObject.transform;
                            }
                        }

                        // Move added components relative to target components
                        if (!ComponentUtility.MoveComponentsRelativeToComponents(addedComponents, targetComponents, m_TargetAbove))
                        {
                            // Ensure we have the same selection after calling RevertAllDownToGroup below (MoveComponentsRelativeToComponents can have opened a Prefab in Prefab Mode and changed selection to that root)
                            var wantedSelectedGameObject = Selection.activeGameObject;

                            // Revert added components if move operation fails (e.g. user has been shown the dialog with 'prefab instance restructuring is not posssible' or object is not editable)
                            Undo.RevertAllDownToGroup(undoGroup);

                            if (wantedSelectedGameObject != Selection.activeGameObject)
                            {
                                Selection.activeGameObject = wantedSelectedGameObject;
                            }
                        }
                    }
                }
                else
                {
                    // Handle dragging components
                    var sourceComponents = DragAndDrop.objectReferences.Cast <Component>().ToArray();
                    if (sourceComponents.Length == 0 || targetComponents.Length == 0)
                    {
                        return;
                    }

                    MoveOrCopyComponents(sourceComponents, targetComponents, EditorUtility.EventHasDragCopyModifierPressed(evt), false);
                }

                targetIndex = -1;
                DragAndDrop.AcceptDrag();
                evt.Use();
                EditorGUIUtility.ExitGUI();
            }
        }
        public static void HandleBindingDragAndDrop(TrackAsset dropTarget, Type requiredBindingType)
        {
            var objectBeingDragged = DragAndDrop.objectReferences[0];

            var action = BindingUtility.GetBindingAction(requiredBindingType, objectBeingDragged);

            DragAndDrop.visualMode = action == BindingAction.DoNotBind
                ? DragAndDropVisualMode.Rejected
                : DragAndDropVisualMode.Link;

            if (action == BindingAction.DoNotBind || Event.current.type != EventType.DragPerform)
            {
                return;
            }

            var director = TimelineEditor.inspectedDirector;

            switch (action)
            {
            case BindingAction.BindDirectly:
            {
                BindingUtility.Bind(director, dropTarget, objectBeingDragged);
                break;
            }

            case BindingAction.BindToExistingComponent:
            {
                var gameObjectBeingDragged = objectBeingDragged as GameObject;
                Debug.Assert(gameObjectBeingDragged != null, "The object being dragged was detected as being a GameObject");

                BindingUtility.Bind(director, dropTarget, gameObjectBeingDragged.GetComponent(requiredBindingType));
                break;
            }

            case BindingAction.BindToMissingComponent:
            {
                var gameObjectBeingDragged = objectBeingDragged as GameObject;
                Debug.Assert(gameObjectBeingDragged != null, "The object being dragged was detected as being a GameObject");

                var typeNameOfComponent = requiredBindingType.ToString().Split(".".ToCharArray()).Last();
                var bindMenu            = new GenericMenu();

                bindMenu.AddItem(
                    EditorGUIUtility.TextContent("Create " + typeNameOfComponent + " on " + gameObjectBeingDragged.name),
                    false,
                    nullParam => BindingUtility.Bind(director, dropTarget, Undo.AddComponent(gameObjectBeingDragged, requiredBindingType)),
                    null);

                bindMenu.AddSeparator("");
                bindMenu.AddItem(EditorGUIUtility.TrTextContent("Cancel"), false, userData => {}, null);
                bindMenu.ShowAsContext();

                break;
            }

            default:
            {
                //no-op
                return;
            }
            }

            DragAndDrop.AcceptDrag();
        }
Exemplo n.º 19
0
 public override void DragCleanup(bool revertExpanded)
 {
     DragAndDrop.SetGenericData("SceneHeaderList", null);
     base.DragCleanup(revertExpanded);
 }