SetGenericData() public static method

Set data associated with current drag and drop operation.

public static SetGenericData ( string type, object data ) : void
type string
data object
return void
Exemplo n.º 1
0
 public override void StartDrag(TreeViewItem draggedNode, List <int> draggedNodes)
 {
     if (!EditorApplication.isPlaying)
     {
         List <AudioMixerItem> audioMixerItemsFromIDs = this.GetAudioMixerItemsFromIDs(draggedNodes);
         DragAndDrop.PrepareStartDrag();
         DragAndDrop.SetGenericData("AudioMixerDragging", new AudioMixerTreeViewDragging.DragData(audioMixerItemsFromIDs));
         DragAndDrop.objectReferences = new UnityEngine.Object[0];
         string title = draggedNodes.Count + " AudioMixer" + ((draggedNodes.Count <= 1) ? "" : "s");
         DragAndDrop.StartDrag(title);
     }
 }
        public override void StartDrag(TreeViewItem draggedNode, List <int> draggedNodes)
        {
            if (EditorApplication.isPlaying)
            {
                return;
            }
            List <AudioMixerItem> mixerItemsFromIds = this.GetAudioMixerItemsFromIDs(draggedNodes);

            DragAndDrop.PrepareStartDrag();
            DragAndDrop.SetGenericData("AudioMixerDragging", (object)new AudioMixerTreeViewDragging.DragData(mixerItemsFromIds));
            DragAndDrop.objectReferences = new UnityEngine.Object[0];
            DragAndDrop.StartDrag(draggedNodes.Count.ToString() + " AudioMixer" + (draggedNodes.Count <= 1 ? (object)string.Empty : (object)"s"));
        }
        public override void StartDrag(TreeViewItem draggedNode, List<int> draggedItemIDs)
        {
            DragAndDrop.PrepareStartDrag();
            var tvItems = SelectionManager.SelectedTrackGUI().Cast<TreeViewItem>().ToList();
            DragAndDrop.SetGenericData(k_GenericDragId, new TimelineDragData(tvItems));
            DragAndDrop.objectReferences = new UnityObject[] {};  // this IS required for dragging to work

            string title = draggedItemIDs.Count + (draggedItemIDs.Count > 1 ? "s" : ""); // title is only shown on OSX (at the cursor)

            TimelineGroupGUI groupGui = draggedNode as TimelineGroupGUI;
            if (groupGui != null)
            {
                title = groupGui.displayName;
            }
            DragAndDrop.StartDrag(title);
        }
Exemplo n.º 4
0
        public override void StartDrag(TreeViewItem draggedNode, List <int> draggedItemIDs)
        {
            DragAndDrop.PrepareStartDrag();
            List <TreeViewItem> draggedItems = SelectionManager.SelectedTrackGUI().Cast <TreeViewItem>().ToList <TreeViewItem>();

            DragAndDrop.SetGenericData("TimelineDragging", new TimelineDragging.TimelineDragData(draggedItems));
            DragAndDrop.set_objectReferences(new Object[0]);
            string           text             = draggedItemIDs.Count + ((draggedItemIDs.Count <= 1) ? "" : "s");
            TimelineGroupGUI timelineGroupGUI = draggedNode as TimelineGroupGUI;

            if (timelineGroupGUI != null)
            {
                text = timelineGroupGUI.get_displayName();
            }
            DragAndDrop.StartDrag(text);
        }
        public override void StartDrag(TreeViewItem draggedNode, List <int> draggedNodes)
        {
            // We do not allow changing routing in playmode for now
            if (EditorApplication.isPlaying)
            {
                return;
            }

            List <AudioMixerItem> draggedItems = GetAudioMixerItemsFromIDs(draggedNodes);

            DragAndDrop.PrepareStartDrag();
            DragAndDrop.SetGenericData(k_AudioMixerDraggingID, new DragData(draggedItems));
            string title = draggedNodes.Count + " AudioMixer" + (draggedNodes.Count > 1 ? "s" : ""); // title is only shown on OSX (at the cursor)

            DragAndDrop.StartDrag(title);
        }
        internal static void StartDrag(int draggedInstanceID, List <int> selectedInstanceIDs)
        {
            if (draggedInstanceID == ProjectBrowser.kPackagesFolderInstanceId)
            {
                return;
            }

            DragAndDrop.PrepareStartDrag();

            string title = "";

            if (IsFavoritesItem(draggedInstanceID))
            {
                DragAndDrop.SetGenericData(k_DraggingFavoriteGenericData, draggedInstanceID);
            }
            else
            {
                // Normal assets dragging
                bool isFolder = IsFolder(draggedInstanceID);
                DragAndDrop.objectReferences = GetDragAndDropObjects(draggedInstanceID, selectedInstanceIDs);
                DragAndDrop.SetGenericData(k_IsFolderGenericData, isFolder ? "isFolder" : "");
                string[] paths = GetDragAndDropPaths(draggedInstanceID, selectedInstanceIDs);
                if (paths.Length > 0)
                {
                    DragAndDrop.paths = paths;
                }

                if (DragAndDrop.objectReferences.Length > 1)
                {
                    title = "<Multiple>";
                }
                else
                {
                    title = ObjectNames.GetDragAndDropTitle(InternalEditorUtility.GetObjectFromInstanceID(draggedInstanceID));
                }
            }

            DragAndDrop.StartDrag(title);
        }
Exemplo n.º 7
0
        private static void DoDragAndDrop(ListViewState listView, ListViewElement element, List <ColumnViewElement> columnViewElements, ColumnView.ObjectColumnGetDataFunction getDataForDraggingFunction)
        {
            if (GUIUtility.hotControl == listView.ID && Event.current.type == EventType.MouseDown && (element.position.Contains(Event.current.mousePosition) && Event.current.button == 0))
            {
                ((DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), listView.ID)).mouseDownPosition = Event.current.mousePosition;
            }
            if (GUIUtility.hotControl != listView.ID || Event.current.type != EventType.MouseDrag || (!GUIClip.visibleRect.Contains(Event.current.mousePosition) || !((DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), listView.ID)).CanStartDrag()))
            {
                return;
            }
            object data = getDataForDraggingFunction != null?getDataForDraggingFunction(columnViewElements[listView.row].value) : (object)null;

            if (data == null)
            {
                return;
            }
            DragAndDrop.PrepareStartDrag();
            DragAndDrop.objectReferences = new Object[0];
            DragAndDrop.paths            = (string[])null;
            DragAndDrop.SetGenericData("CustomDragData", data);
            DragAndDrop.StartDrag(columnViewElements[listView.row].name);
            Event.current.Use();
        }
Exemplo n.º 8
0
        private static void DoDragAndDrop(ListViewState listView, ListViewElement element, List <ColumnViewElement> columnViewElements, ObjectColumnGetDataFunction getDataForDraggingFunction)
        {
            if (GUIUtility.hotControl == listView.ID && Event.current.type == EventType.MouseDown &&
                element.position.Contains(Event.current.mousePosition) &&
                Event.current.button == 0)
            {
                var delay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), listView.ID);
                delay.mouseDownPosition = Event.current.mousePosition;
            }

            if (GUIUtility.hotControl == listView.ID &&
                Event.current.type == EventType.MouseDrag &&
                GUIClip.visibleRect.Contains(Event.current.mousePosition))
            {
                var delay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), listView.ID);

                if (delay.CanStartDrag())
                {
                    var data = getDataForDraggingFunction == null ? null :
                               getDataForDraggingFunction(columnViewElements[listView.row].value);

                    if (data == null)
                    {
                        return;
                    }

                    DragAndDrop.PrepareStartDrag();

                    DragAndDrop.paths = null;

                    DragAndDrop.SetGenericData("CustomDragData", data);
                    DragAndDrop.StartDrag(columnViewElements[listView.row].name);

                    Event.current.Use();
                }
            }
        }
Exemplo n.º 9
0
        internal static void StartDrag(int draggedInstanceID, List <int> selectedInstanceIDs)
        {
            DragAndDrop.PrepareStartDrag();
            string title = string.Empty;

            if (ProjectWindowUtil.IsFavoritesItem(draggedInstanceID))
            {
                DragAndDrop.SetGenericData(ProjectWindowUtil.k_DraggingFavoriteGenericData, (object)draggedInstanceID);
                DragAndDrop.objectReferences = new UnityEngine.Object[0];
            }
            else
            {
                bool flag = ProjectWindowUtil.IsFolder(draggedInstanceID);
                DragAndDrop.objectReferences = ProjectWindowUtil.GetDragAndDropObjects(draggedInstanceID, selectedInstanceIDs);
                DragAndDrop.SetGenericData(ProjectWindowUtil.k_IsFolderGenericData, !flag ? (object)string.Empty : (object)"isFolder");
                string[] dragAndDropPaths = ProjectWindowUtil.GetDragAndDropPaths(draggedInstanceID, selectedInstanceIDs);
                if (dragAndDropPaths.Length > 0)
                {
                    DragAndDrop.paths = dragAndDropPaths;
                }
                title = DragAndDrop.objectReferences.Length <= 1 ? ObjectNames.GetDragAndDropTitle(InternalEditorUtility.GetObjectFromInstanceID(draggedInstanceID)) : "<Multiple>";
            }
            DragAndDrop.StartDrag(title);
        }
Exemplo n.º 10
0
        internal static void StartDrag(int draggedInstanceID, List <int> selectedInstanceIDs)
        {
            DragAndDrop.PrepareStartDrag();
            string title = string.Empty;

            if (ProjectWindowUtil.IsFavoritesItem(draggedInstanceID))
            {
                DragAndDrop.SetGenericData(ProjectWindowUtil.k_DraggingFavoriteGenericData, draggedInstanceID);
                DragAndDrop.objectReferences = new UnityEngine.Object[0];
            }
            else
            {
                bool flag = false;
                HierarchyProperty hierarchyProperty = new HierarchyProperty(HierarchyType.Assets);
                if (hierarchyProperty.Find(draggedInstanceID, null))
                {
                    flag = hierarchyProperty.isFolder;
                }
                DragAndDrop.objectReferences = ProjectWindowUtil.GetDragAndDropObjects(draggedInstanceID, selectedInstanceIDs);
                DragAndDrop.SetGenericData(ProjectWindowUtil.k_IsFolderGenericData, (!flag) ? string.Empty : "isFolder");
                string[] dragAndDropPaths = ProjectWindowUtil.GetDragAndDropPaths(draggedInstanceID, selectedInstanceIDs);
                if (dragAndDropPaths.Length > 0)
                {
                    DragAndDrop.paths = dragAndDropPaths;
                }
                if (DragAndDrop.objectReferences.Length > 1)
                {
                    title = "<Multiple>";
                }
                else
                {
                    title = ObjectNames.GetDragAndDropTitle(InternalEditorUtility.GetObjectFromInstanceID(draggedInstanceID));
                }
            }
            DragAndDrop.StartDrag(title);
        }
Exemplo n.º 11
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 && m_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)
                {
                    var draggingMode = DragAndDrop.GetGenericData(k_DraggingModeKey) as DraggingMode ? ;
                    if (!draggingMode.HasValue || draggingMode.Value == DraggingMode.NotApplicable)
                    {
                        m_TargetIndex = -1;
                        return;
                    }

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

                    var targetComponents = editors[m_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(targetComponent.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))
                            {
                                // Revert added components if move operation fails (e.g. user aborts when asked to break prefab instance)
                                Undo.RevertAllDownToGroup(undoGroup);
                            }
                        }
                    }
                    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);
                    }

                    m_TargetIndex = -1;
                    DragAndDrop.AcceptDrag();
                    evt.Use();
                    EditorGUIUtility.ExitGUI();
                }
                break;

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

            case EventType.Repaint:
                if (m_TargetIndex != -1 && targetRect.Contains(evt.mousePosition))
                {
                    Styles.insertionMarker.Draw(GetMarkerRect(targetRect, markerY, m_TargetAbove), false, false, false, false);
                }
                break;
            }
        }
Exemplo n.º 12
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 (DragAndDrop.visualMode != DragAndDropVisualMode.None && DragAndDrop.visualMode != DragAndDropVisualMode.Rejected &&
                    (targetRect.Contains(evt.mousePosition) ||
                     editorIndex == m_BottomAreaDropIndex &&
                     m_BottomArea.Contains(GUIClip.UnclipToWindow(evt.mousePosition)) &&
                     m_BottomAreaDropIndex == editors.Length - 1))
                {
                    Styles.insertionMarker.Draw(GetMarkerRect(targetRect), false, false, false, false);
                }
                break;
            }
        }
 public override void DragCleanup(bool revertExpanded)
 {
     DragAndDrop.SetGenericData("SceneHeaderList", null);
     base.DragCleanup(revertExpanded);
 }
Exemplo n.º 14
0
        public override void StartDrag(TreeViewItem draggedItem, List <int> draggedItemIDs)
        {
            DragAndDrop.PrepareStartDrag();
            draggedItemIDs = this.m_TreeView.SortIDsInVisiblityOrder(draggedItemIDs);
            if (!draggedItemIDs.Contains(draggedItem.id))
            {
                draggedItemIDs = new List <int>()
                {
                    draggedItem.id
                }
            }
            ;
            UnityEngine.Object[] dragAndDropObjects = ProjectWindowUtil.GetDragAndDropObjects(draggedItem.id, draggedItemIDs);
            DragAndDrop.objectReferences = dragAndDropObjects;
            List <Scene> draggedScenes = this.GetDraggedScenes(draggedItemIDs);

            if (draggedScenes != null)
            {
                DragAndDrop.SetGenericData("SceneHeaderList", (object)draggedScenes);
                List <string> stringList = new List <string>();
                using (List <Scene> .Enumerator enumerator = draggedScenes.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        Scene current = enumerator.Current;
                        if (current.path.Length > 0)
                        {
                            stringList.Add(current.path);
                        }
                    }
                }
                DragAndDrop.paths = stringList.ToArray();
            }
            else
            {
                DragAndDrop.paths = new string[0];
            }
            string title;

            if (draggedItemIDs.Count > 1)
            {
                title = "<Multiple>";
            }
            else if (dragAndDropObjects.Length == 1)
            {
                title = ObjectNames.GetDragAndDropTitle(dragAndDropObjects[0]);
            }
            else if (draggedScenes != null && draggedScenes.Count == 1)
            {
                title = draggedScenes[0].path;
            }
            else
            {
                title = "Unhandled dragged item";
                Debug.LogError((object)"Unhandled dragged item");
            }
            DragAndDrop.StartDrag(title);
            if (!(this.m_TreeView.data is GameObjectTreeViewDataSource))
            {
                return;
            }
            ((GameObjectTreeViewDataSource)this.m_TreeView.data).SetupChildParentReferencesIfNeeded();
        }
        public override void StartDrag(TreeViewItem draggedItem, List <int> draggedItemIDs)
        {
            DragAndDrop.PrepareStartDrag();

            if (Event.current.control || Event.current.command)
            {
                draggedItemIDs.Add(draggedItem.id);
            }

            // Ensure correct order for hierarchy items (to preserve visible order when dropping at new location)
            draggedItemIDs = m_TreeView.SortIDsInVisiblityOrder(draggedItemIDs);

            if (!draggedItemIDs.Contains(draggedItem.id))
            {
                draggedItemIDs = new List <int> {
                    draggedItem.id
                }
            }
            ;

            Object[] draggedObjReferences = ProjectWindowUtil.GetDragAndDropObjects(draggedItem.id, draggedItemIDs);
            DragAndDrop.objectReferences = draggedObjReferences;

            // After introducing multi-scene, UnityEngine.Scene can be selected in HierarchyWindow.
            // UnityEngine.Scene is not a UnityEngine.Object.
            // So DragAndDrop.objectReferences can't cover this case.
            List <Scene> draggedScenes = GetDraggedScenes(draggedItemIDs);

            if (draggedScenes != null)
            {
                DragAndDrop.SetGenericData(kSceneHeaderDragString, draggedScenes);

                List <string> paths = new List <string>();
                foreach (Scene scene in draggedScenes)
                {
                    if (scene.path.Length > 0)
                    {
                        paths.Add(scene.path);
                    }
                }
                DragAndDrop.paths = paths.ToArray();
            }
            else
            {
                DragAndDrop.paths = new string[0];
            }

            string title;

            if (draggedItemIDs.Count > 1)
            {
                title = "<Multiple>";
            }
            else
            {
                if (draggedObjReferences.Length == 1)
                {
                    title = ObjectNames.GetDragAndDropTitle(draggedObjReferences[0]);
                }
                else if (draggedScenes != null && draggedScenes.Count == 1)
                {
                    title = draggedScenes[0].path;
                }
                else
                {
                    title = "Unhandled dragged item";
                    Debug.LogError("Unhandled dragged item");
                }
            }
            DragAndDrop.StartDrag(title);

            dataSource.SetupChildParentReferencesIfNeeded();
        }

        GameObjectTreeViewDataSource dataSource {
            get { return((GameObjectTreeViewDataSource)m_TreeView.data); }
        }
Exemplo n.º 16
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)GUIUtility.GetStateObject(typeof(DragAndDropDelay), this.ilvState.state.ID)).mouseDownPosition = Event.current.mousePosition;
                            this.ilvState.dragItem       = this.yPos;
                            ListViewShared.dragControlID = this.ilvState.state.ID;
                        }
                    }
                    if ((this.ilvState.wantsReordering || this.ilvState.wantsToStartCustomDrag) && (GUIUtility.hotControl == this.ilvState.state.ID && Event.current.type == EventType.MouseDrag) && GUIClip.visibleRect.Contains(Event.current.mousePosition))
                    {
                        if (((DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), this.ilvState.state.ID)).CanStartDrag())
                        {
                            DragAndDrop.PrepareStartDrag();
                            DragAndDrop.objectReferences = new UnityEngine.Object[0];
                            DragAndDrop.paths            = (string[])null;
                            if (this.ilvState.wantsReordering)
                            {
                                this.ilvState.state.dropHereRect = new Rect(this.ilvState.rect.x, 0.0f, this.ilvState.rect.width, (float)(this.ilvState.state.rowHeight * 2));
                                DragAndDrop.StartDrag(this.dragTitle);
                            }
                            else if (this.ilvState.wantsToStartCustomDrag)
                            {
                                DragAndDrop.SetGenericData("CustomDragID", (object)this.ilvState.state.ID);
                                DragAndDrop.StartDrag(this.dragTitle);
                            }
                        }
                        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.height;
                    }
                }
                else
                {
                    if (this.xPos >= 1)
                    {
                        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 && 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 insertion = (GUIStyle)ListViewShared.Constants.insertion;
                        insertion.Draw(insertion.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;
                        switch (Event.current.type)
                        {
                        case EventType.DragUpdated:
                            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 ((double)state.dropHereRect.y >= (double)(state.rowHeight * state.totalRows))
                                {
                                    state.dropHereRect.y = (float)(state.rowHeight * (state.totalRows - 1));
                                }
                                state.drawDropHere = true;
                                break;
                            }
                            break;

                        case EventType.DragPerform:
                            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;
                                }
                                this.ilvState.state.row = this.ilvState.state.draggedTo <= this.ilvState.state.draggedFrom ? this.ilvState.state.draggedTo : this.ilvState.state.draggedTo - 1;
                                this.ilvState.state.selectionChanged = true;
                                DragAndDrop.AcceptDrag();
                                Event.current.Use();
                                this.ilvState.wantsReordering    = false;
                                this.ilvState.state.drawDropHere = false;
                            }
                            GUIUtility.hotControl = 0;
                            break;

                        case EventType.DragExited:
                            this.ilvState.wantsReordering    = false;
                            this.ilvState.state.drawDropHere = false;
                            GUIUtility.hotControl            = 0;
                            break;
                        }
                    }
                    else if (this.ilvState.wantsExternalFiles)
                    {
                        switch (Event.current.type)
                        {
                        case EventType.DragUpdated:
                            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 ((double)this.ilvState.state.dropHereRect.y >= (double)(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;
                                    break;
                                }
                                break;
                            }
                            break;

                        case EventType.DragPerform:
                            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;
                            break;

                        case EventType.DragExited:
                            this.ilvState.wantsExternalFiles = false;
                            this.ilvState.state.drawDropHere = false;
                            GUIUtility.hotControl            = 0;
                            break;
                        }
                    }
                    else if (this.ilvState.wantsToAcceptCustomDrag && ListViewShared.dragControlID != this.ilvState.state.ID)
                    {
                        switch (Event.current.type)
                        {
                        case EventType.DragUpdated:
                            if (GUIClip.visibleRect.Contains(Event.current.mousePosition) && DragAndDrop.GetGenericData("CustomDragID") != null)
                            {
                                DragAndDrop.visualMode = !this.ilvState.rect.Contains(Event.current.mousePosition) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Move;
                                Event.current.Use();
                                break;
                            }
                            break;

                        case EventType.DragPerform:
                            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;
                            break;

                        case EventType.DragExited:
                            GUIUtility.hotControl = 0;
                            break;
                        }
                    }
                    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);
            }
        public override void StartDrag(TreeViewItem draggedItem, List <int> draggedItemIDs)
        {
            DragAndDrop.PrepareStartDrag();
            if (Event.current.control || Event.current.command)
            {
                draggedItemIDs.Add(draggedItem.id);
            }
            draggedItemIDs = this.m_TreeView.SortIDsInVisiblityOrder(draggedItemIDs);
            if (!draggedItemIDs.Contains(draggedItem.id))
            {
                draggedItemIDs = new List <int>
                {
                    draggedItem.id
                };
            }
            UnityEngine.Object[] dragAndDropObjects = ProjectWindowUtil.GetDragAndDropObjects(draggedItem.id, draggedItemIDs);
            DragAndDrop.objectReferences = dragAndDropObjects;
            List <Scene> draggedScenes = this.GetDraggedScenes(draggedItemIDs);

            if (draggedScenes != null)
            {
                DragAndDrop.SetGenericData("SceneHeaderList", draggedScenes);
                List <string> list = new List <string>();
                foreach (Scene current in draggedScenes)
                {
                    if (current.path.Length > 0)
                    {
                        list.Add(current.path);
                    }
                }
                DragAndDrop.paths = list.ToArray();
            }
            else
            {
                DragAndDrop.paths = new string[0];
            }
            string title;

            if (draggedItemIDs.Count > 1)
            {
                title = "<Multiple>";
            }
            else if (dragAndDropObjects.Length == 1)
            {
                title = ObjectNames.GetDragAndDropTitle(dragAndDropObjects[0]);
            }
            else if (draggedScenes != null && draggedScenes.Count == 1)
            {
                title = draggedScenes[0].path;
            }
            else
            {
                title = "Unhandled dragged item";
                Debug.LogError("Unhandled dragged item");
            }
            DragAndDrop.StartDrag(title);
            if (this.m_TreeView.data is GameObjectTreeViewDataSource)
            {
                ((GameObjectTreeViewDataSource)this.m_TreeView.data).SetupChildParentReferencesIfNeeded();
            }
        }
Exemplo n.º 18
0
        private void ListArea(Rect rect, PresetLibrary lib, object newPresetObject)
        {
            if (lib == null)
            {
                return;
            }
            Event current = Event.current;

            if (this.m_PresetLibraryFileLocation == PresetFileLocation.ProjectFolder && current.type == EventType.Repaint)
            {
                this.m_IsOpenForEdit = AssetDatabase.IsOpenForEdit(this.pathWithExtension);
            }
            else
            {
                if (this.m_PresetLibraryFileLocation == PresetFileLocation.PreferencesFolder)
                {
                    this.m_IsOpenForEdit = true;
                }
            }
            if (!this.m_IsOpenForEdit)
            {
                Rect rect2 = new Rect(rect.x, rect.yMax - this.versionControlAreaHeight, rect.width, this.versionControlAreaHeight);
                this.VersionControlArea(rect2);
                rect.height -= this.versionControlAreaHeight;
            }
            for (int i = 0; i < 2; i++)
            {
                this.gridWidth = ((!this.m_ShowedScrollBarLastFrame) ? rect.width : (rect.width - 17f));
                this.SetupGrid(this.gridWidth, lib.Count());
                bool flag = this.m_Grid.height > rect.height;
                if (flag == this.m_ShowedScrollBarLastFrame)
                {
                    break;
                }
                this.m_ShowedScrollBarLastFrame = flag;
            }
            if ((this.m_ShowedScrollBarLastFrame || this.alwaysShowScrollAreaHorizontalLines) && Event.current.type == EventType.Repaint)
            {
                Rect rect3 = new RectOffset(1, 1, 1, 1).Add(rect);
                rect3.height = 1f;
                EditorGUI.DrawRect(rect3, new Color(0f, 0f, 0f, 0.3f));
                rect3.y += rect.height + 1f;
                EditorGUI.DrawRect(rect3, new Color(0f, 0f, 0f, 0.3f));
            }
            Rect viewRect = new Rect(0f, 0f, 1f, this.m_Grid.height);

            this.m_State.m_ScrollPosition = GUI.BeginScrollView(rect, this.m_State.m_ScrollPosition, viewRect);
            float num      = 0f;
            int   maxIndex = (!this.m_ShowAddNewPresetItem) ? (lib.Count() - 1) : lib.Count();
            int   num2;
            int   num3;
            bool  flag2 = this.m_Grid.IsVisibleInScrollView(rect.height, this.m_State.m_ScrollPosition.y, num, maxIndex, out num2, out num3);
            bool  flag3 = false;

            if (flag2)
            {
                if (this.GetRenameOverlay().IsRenaming() && !this.GetRenameOverlay().isWaitingForDelay)
                {
                    if (!this.m_State.m_RenameOverlay.OnGUI())
                    {
                        this.EndRename();
                        current.Use();
                    }
                    this.Repaint();
                }
                for (int j = num2; j <= num3; j++)
                {
                    int  num4  = j + 1000000;
                    Rect rect4 = this.m_Grid.CalcRect(j, num);
                    Rect rect5 = rect4;
                    Rect rect6 = rect4;
                    PresetLibraryEditorState.ItemViewMode itemViewMode = this.m_State.itemViewMode;
                    if (itemViewMode != PresetLibraryEditorState.ItemViewMode.Grid)
                    {
                        if (itemViewMode == PresetLibraryEditorState.ItemViewMode.List)
                        {
                            rect5.width  = this.m_State.m_PreviewHeight * this.m_PreviewAspect;
                            rect6.x     += rect5.width + 8f;
                            rect6.width -= rect5.width + 10f;
                            rect6.height = 16f;
                            rect6.y      = rect4.yMin + (rect4.height - 16f) * 0.5f;
                        }
                    }
                    if (this.m_ShowAddNewPresetItem && j == lib.Count())
                    {
                        this.CreateNewPresetButton(rect5, newPresetObject, lib, this.m_IsOpenForEdit);
                    }
                    else
                    {
                        bool flag4 = this.IsRenaming(j);
                        if (flag4)
                        {
                            Rect editFieldRect = rect6;
                            editFieldRect.y -= 1f;
                            editFieldRect.x -= 1f;
                            this.m_State.m_RenameOverlay.editFieldRect = editFieldRect;
                        }
                        switch (current.type)
                        {
                        case EventType.MouseDown:
                            if (current.button == 0 && rect4.Contains(current.mousePosition))
                            {
                                GUIUtility.hotControl = num4;
                                if (current.clickCount == 1)
                                {
                                    this.m_ItemClickedCallback(current.clickCount, lib.GetPreset(j));
                                    current.Use();
                                }
                            }
                            break;

                        case EventType.MouseUp:
                            if (GUIUtility.hotControl == num4)
                            {
                                GUIUtility.hotControl = 0;
                                if (current.button == 0 && rect4.Contains(current.mousePosition) && Event.current.alt && this.m_IsOpenForEdit)
                                {
                                    this.DeletePreset(j);
                                    current.Use();
                                }
                            }
                            break;

                        case EventType.MouseMove:
                            if (rect4.Contains(current.mousePosition))
                            {
                                if (this.m_State.m_HoverIndex != j)
                                {
                                    this.m_State.m_HoverIndex = j;
                                    this.Repaint();
                                }
                            }
                            else
                            {
                                if (this.m_State.m_HoverIndex == j)
                                {
                                    this.m_State.m_HoverIndex = -1;
                                    this.Repaint();
                                }
                            }
                            break;

                        case EventType.MouseDrag:
                            if (GUIUtility.hotControl == num4 && this.m_IsOpenForEdit)
                            {
                                DragAndDropDelay dragAndDropDelay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), num4);
                                if (dragAndDropDelay.CanStartDrag())
                                {
                                    DragAndDrop.PrepareStartDrag();
                                    DragAndDrop.SetGenericData("DraggingPreset", j);
                                    DragAndDrop.objectReferences = new UnityEngine.Object[0];
                                    DragAndDrop.StartDrag(string.Empty);
                                    this.m_DragState.draggingIndex = j;
                                    this.m_DragState.dragUponIndex = j;
                                    GUIUtility.hotControl          = 0;
                                }
                                current.Use();
                            }
                            break;

                        case EventType.Repaint:
                            if (this.m_State.m_HoverIndex == j)
                            {
                                if (!rect4.Contains(current.mousePosition))
                                {
                                    this.m_State.m_HoverIndex = -1;
                                }
                            }
                            if (this.m_DragState.draggingIndex == j || GUIUtility.hotControl == num4)
                            {
                                this.DrawHoverEffect(rect4, false);
                            }
                            lib.Draw(rect5, j);
                            if (!flag4 && this.drawLabels)
                            {
                                GUI.Label(rect6, GUIContent.Temp(lib.GetName(j)));
                            }
                            if (this.m_DragState.dragUponIndex == j && this.m_DragState.draggingIndex != this.m_DragState.dragUponIndex)
                            {
                                flag3 = true;
                            }
                            if (GUIUtility.hotControl == 0 && Event.current.alt && this.m_IsOpenForEdit)
                            {
                                EditorGUIUtility.AddCursorRect(rect4, MouseCursor.ArrowMinus);
                            }
                            break;

                        case EventType.DragUpdated:
                        case EventType.DragPerform:
                        {
                            Rect dragRect = this.GetDragRect(rect4);
                            if (dragRect.Contains(current.mousePosition))
                            {
                                this.m_DragState.dragUponIndex = j;
                                this.m_DragState.dragUponRect  = rect4;
                                if (this.m_State.itemViewMode == PresetLibraryEditorState.ItemViewMode.List)
                                {
                                    this.m_DragState.insertAfterIndex = ((current.mousePosition.y - dragRect.y) / dragRect.height > 0.5f);
                                }
                                else
                                {
                                    this.m_DragState.insertAfterIndex = ((current.mousePosition.x - dragRect.x) / dragRect.width > 0.5f);
                                }
                                bool flag5 = current.type == EventType.DragPerform;
                                if (flag5)
                                {
                                    if (this.m_DragState.draggingIndex >= 0)
                                    {
                                        this.MovePreset(this.m_DragState.draggingIndex, this.m_DragState.dragUponIndex, this.m_DragState.insertAfterIndex);
                                        DragAndDrop.AcceptDrag();
                                    }
                                    this.ClearDragState();
                                }
                                DragAndDrop.visualMode = DragAndDropVisualMode.Move;
                                current.Use();
                            }
                            break;
                        }

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

                        case EventType.ContextClick:
                            if (rect4.Contains(current.mousePosition))
                            {
                                PresetLibraryEditor <T> .PresetContextMenu.Show(this.m_IsOpenForEdit, j, newPresetObject, this);

                                current.Use();
                            }
                            break;
                        }
                    }
                }
                if (flag3)
                {
                    this.DrawDragInsertionMarker();
                }
            }
            GUI.EndScrollView();
        }
Exemplo n.º 19
0
        private void HandleEditorDragging(int editorIndex, Rect targetRect, float markerY, bool bottomTarget, ActiveEditorTracker tracker)
        {
            Event     current = Event.current;
            EventType type    = current.type;

            switch (type)
            {
            case EventType.Repaint:
                if (this.m_TargetIndex != -1 && targetRect.Contains(current.mousePosition))
                {
                    Rect position = new Rect(targetRect.x, markerY, targetRect.width, 3f);
                    if (!this.m_TargetAbove)
                    {
                        position.y += 2f;
                    }
                    EditorDragging.Styles.insertionMarker.Draw(position, false, false, false, false);
                }
                return;

            case EventType.Layout:
IL_26:
                if (type != EventType.DragExited)
                {
                    return;
                }
                this.m_TargetIndex = -1;
                return;

            case EventType.DragUpdated:
                if (targetRect.Contains(current.mousePosition))
                {
                    EditorDragging.DraggingMode?draggingMode = DragAndDrop.GetGenericData("InspectorEditorDraggingMode") as EditorDragging.DraggingMode?;
                    if (!draggingMode.HasValue)
                    {
                        UnityEngine.Object[] objectReferences = DragAndDrop.objectReferences;
                        if (objectReferences.Length == 0)
                        {
                            draggingMode = new EditorDragging.DraggingMode?(EditorDragging.DraggingMode.NotApplicable);
                        }
                        else if (objectReferences.All((UnityEngine.Object o) => o is Component && !(o is Transform)))
                        {
                            draggingMode = new EditorDragging.DraggingMode?(EditorDragging.DraggingMode.Component);
                        }
                        else if (objectReferences.All((UnityEngine.Object o) => o is MonoScript))
                        {
                            draggingMode = new EditorDragging.DraggingMode?(EditorDragging.DraggingMode.Script);
                        }
                        else
                        {
                            draggingMode = new EditorDragging.DraggingMode?(EditorDragging.DraggingMode.NotApplicable);
                        }
                        DragAndDrop.SetGenericData("InspectorEditorDraggingMode", draggingMode);
                    }
                    if (draggingMode.Value != EditorDragging.DraggingMode.NotApplicable)
                    {
                        Editor[]             activeEditors     = tracker.activeEditors;
                        UnityEngine.Object[] objectReferences2 = DragAndDrop.objectReferences;
                        if (bottomTarget)
                        {
                            this.m_TargetAbove = false;
                            this.m_TargetIndex = this.m_LastIndex;
                        }
                        else
                        {
                            this.m_TargetAbove = (current.mousePosition.y < targetRect.y + targetRect.height / 2f);
                            this.m_TargetIndex = editorIndex;
                            if (this.m_TargetAbove)
                            {
                                this.m_TargetIndex++;
                                while (this.m_TargetIndex < activeEditors.Length && this.m_InspectorWindow.ShouldCullEditor(activeEditors, this.m_TargetIndex))
                                {
                                    this.m_TargetIndex++;
                                }
                                if (this.m_TargetIndex == activeEditors.Length)
                                {
                                    this.m_TargetIndex = -1;
                                    return;
                                }
                            }
                        }
                        if (this.m_TargetAbove && this.m_InspectorWindow.EditorHasLargeHeader(this.m_TargetIndex, activeEditors))
                        {
                            this.m_TargetIndex--;
                            while (this.m_TargetIndex >= 0 && this.m_InspectorWindow.ShouldCullEditor(activeEditors, this.m_TargetIndex))
                            {
                                this.m_TargetIndex--;
                            }
                            if (this.m_TargetIndex == -1)
                            {
                                return;
                            }
                            this.m_TargetAbove = false;
                        }
                        if (draggingMode.Value == EditorDragging.DraggingMode.Script)
                        {
                            DragAndDrop.visualMode = DragAndDropVisualMode.Link;
                        }
                        else
                        {
                            bool flag = false;
                            if (activeEditors[this.m_TargetIndex].targets.All((UnityEngine.Object t) => t is Component))
                            {
                                Component[] targetComponents = activeEditors[this.m_TargetIndex].targets.Cast <Component>().ToArray <Component>();
                                Component[] sourceComponents = DragAndDrop.objectReferences.Cast <Component>().ToArray <Component>();
                                flag = this.MoveOrCopyComponents(sourceComponents, targetComponents, EditorUtility.EventHasDragCopyModifierPressed(current), true);
                            }
                            if (!flag)
                            {
                                DragAndDrop.visualMode = DragAndDropVisualMode.None;
                                this.m_TargetIndex     = -1;
                                return;
                            }
                            DragAndDrop.visualMode = ((!EditorUtility.EventHasDragCopyModifierPressed(current)) ? DragAndDropVisualMode.Move : DragAndDropVisualMode.Copy);
                        }
                        current.Use();
                    }
                }
                else
                {
                    this.m_TargetIndex = -1;
                }
                return;

            case EventType.DragPerform:
                if (this.m_TargetIndex != -1)
                {
                    EditorDragging.DraggingMode?draggingMode2 = DragAndDrop.GetGenericData("InspectorEditorDraggingMode") as EditorDragging.DraggingMode?;
                    if (!draggingMode2.HasValue || draggingMode2.Value == EditorDragging.DraggingMode.NotApplicable)
                    {
                        this.m_TargetIndex = -1;
                    }
                    else
                    {
                        Editor[] activeEditors2 = tracker.activeEditors;
                        if (activeEditors2[this.m_TargetIndex].targets.All((UnityEngine.Object t) => t is Component))
                        {
                            Component[] array = activeEditors2[this.m_TargetIndex].targets.Cast <Component>().ToArray <Component>();
                            if (draggingMode2.Value == EditorDragging.DraggingMode.Script)
                            {
                                IEnumerable <MonoScript> enumerable = DragAndDrop.objectReferences.Cast <MonoScript>();
                                bool        flag2  = true;
                                Component[] array2 = array;
                                for (int i = 0; i < array2.Length; i++)
                                {
                                    Component  targetComponent = array2[i];
                                    GameObject gameObject      = targetComponent.gameObject;
                                    if (enumerable.Any((MonoScript s) => !ComponentUtility.WarnCanAddScriptComponent(targetComponent.gameObject, s)))
                                    {
                                        flag2 = false;
                                        break;
                                    }
                                }
                                if (flag2)
                                {
                                    Undo.IncrementCurrentGroup();
                                    int         currentGroup = Undo.GetCurrentGroup();
                                    int         num          = 0;
                                    Component[] array3       = new Component[array.Length * enumerable.Count <MonoScript>()];
                                    Component[] array4       = array;
                                    for (int j = 0; j < array4.Length; j++)
                                    {
                                        Component  component   = array4[j];
                                        GameObject gameObject2 = component.gameObject;
                                        foreach (MonoScript current2 in enumerable)
                                        {
                                            array3[num++] = Undo.AddComponent(gameObject2, current2.GetClass());
                                        }
                                    }
                                    if (!ComponentUtility.MoveComponentsRelativeToComponents(array3, array, this.m_TargetAbove))
                                    {
                                        Undo.RevertAllDownToGroup(currentGroup);
                                    }
                                }
                            }
                            else
                            {
                                Component[] array5 = DragAndDrop.objectReferences.Cast <Component>().ToArray <Component>();
                                if (array5.Length == 0 || array.Length == 0)
                                {
                                    return;
                                }
                                this.MoveOrCopyComponents(array5, array, EditorUtility.EventHasDragCopyModifierPressed(current), false);
                            }
                            this.m_TargetIndex = -1;
                            DragAndDrop.AcceptDrag();
                            current.Use();
                            GUIUtility.ExitGUI();
                        }
                    }
                }
                return;
            }
            goto IL_26;
        }
Exemplo n.º 20
0
            public bool MoveNext()
            {
                if (xPos > -1)
                {
                    if (ListViewShared.HasMouseDown(ilvState, rect))
                    {
                        var previousRow = ilvState.state.row;
                        ilvState.state.selectionChanged = true;
                        ilvState.state.row       = yPos;
                        ilvState.state.column    = xPos;
                        ilvState.state.scrollPos = ListViewShared.ListViewScrollToRow(ilvState, yPos); // this is about clicking on a row that is partially visible

                        if (ilvState.wantsRowMultiSelection)
                        {
                            MultiSelection(ilvState, previousRow);
                        }

                        if ((ilvState.wantsReordering || ilvState.wantsToStartCustomDrag) && (GUIUtility.hotControl == ilvState.state.ID))
                        {
                            DragAndDropDelay delay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), ilvState.state.ID);
                            delay.mouseDownPosition = Event.current.mousePosition;
                            ilvState.dragItem       = yPos;
                            dragControlID           = ilvState.state.ID;
                        }
                    }
                    // On Mouse drag, start drag & drop
                    if (!ListViewShared.isDragging &&
                        (ilvState.wantsReordering || ilvState.wantsToStartCustomDrag) &&
                        GUIUtility.hotControl == ilvState.state.ID &&
                        Event.current.type == EventType.MouseDrag &&
                        GUIClip.visibleRect.Contains(Event.current.mousePosition))
                    {
                        DragAndDropDelay delay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), ilvState.state.ID);

                        if (delay.CanStartDrag())
                        {
                            DragAndDrop.PrepareStartDrag();

                            DragAndDrop.objectReferences = new UnityEngine.Object[] {};  // this IS required for dragging to work
                            DragAndDrop.paths            = null;

                            if (ilvState.wantsReordering)
                            {
                                ilvState.state.dropHereRect = new Rect(ilvState.rect.x, 0, ilvState.rect.width, ilvState.state.rowHeight * 2);
                                DragAndDrop.StartDrag(dragTitle);
                            }
                            else if (ilvState.wantsToStartCustomDrag)
                            {
                                DragAndDrop.SetGenericData("CustomDragID", ilvState.state.ID);
                                DragAndDrop.StartDrag(dragTitle);
                            }

                            ListViewShared.isDragging = true;
                        }

                        Event.current.Use();
                    }
                }

                xPos++;

                if (xPos > xTo)
                {
                    xPos = 0;
                    yPos++;

                    rect.x     = firstRect.x;
                    rect.width = colWidths[0];

                    if (yPos > yTo)
                    {
                        quiting = true;
                    }
                    else // move vertically
                    {
                        rect.y += rect.height;
                    }
                }
                else // move horizontally
                {
                    if (xPos >= 1)
                    {
                        rect.x += colWidths[xPos - 1];
                    }

                    rect.width = colWidths[xPos];
                }

                element.row      = yPos;
                element.column   = xPos;
                element.position = rect;

                if (element.row >= ilvState.state.totalRows)
                {
                    quiting = true;
                }

                if (isLayouted && Event.current.type == EventType.Layout)
                {
                    // this is just "on layout event enumerate just first row" (so we get height of single row)
                    if (yFrom + 1 == yPos)
                    {
                        quiting = true;
                    }
                }

                if (isLayouted && yPos != yFrom)
                {
                    GUILayout.EndHorizontal();
                }

                if (quiting)
                {
                    if (ilvState.state.drawDropHere && Event.current.GetTypeForControl(ilvState.state.ID) == EventType.Repaint)
                    {
                        GUIStyle insertion = Constants.insertion;
                        insertion.Draw(insertion.margin.Remove(ilvState.state.dropHereRect), false, false, false, false);
                    }

                    if (ListViewShared.ListViewKeyboard(ilvState, colWidths.Length))
                    {
                        ilvState.state.selectionChanged = true;
                    }

                    if (Event.current.GetTypeForControl(ilvState.state.ID) == EventType.MouseUp)
                    {
                        GUIUtility.hotControl = 0;
                    }

                    if (ilvState.wantsReordering && (GUIUtility.hotControl == ilvState.state.ID))
                    {
                        ListViewState lv = ilvState.state;

                        switch (Event.current.type)
                        {
                        case EventType.DragUpdated:
                        {
                            DragAndDrop.visualMode = ilvState.rect.Contains(Event.current.mousePosition) ?
                                                     DragAndDropVisualMode.Move : DragAndDropVisualMode.None;

                            Event.current.Use();

                            if (DragAndDrop.visualMode != DragAndDropVisualMode.None)
                            {
                                lv.dropHereRect.y = (Mathf.RoundToInt(Event.current.mousePosition.y / lv.rowHeight) - 1) * lv.rowHeight;

                                if (lv.dropHereRect.y >= lv.rowHeight * lv.totalRows)
                                {
                                    lv.dropHereRect.y = lv.rowHeight * (lv.totalRows - 1);
                                }

                                lv.drawDropHere = true;
                            }

                            break;
                        }

                        case EventType.DragPerform:
                        {
                            if (GUIClip.visibleRect.Contains(Event.current.mousePosition))
                            {
                                ilvState.state.draggedFrom = ilvState.dragItem;
                                ilvState.state.draggedTo   = Mathf.RoundToInt(Event.current.mousePosition.y / lv.rowHeight);

                                if (ilvState.state.draggedTo > ilvState.state.totalRows)
                                {
                                    ilvState.state.draggedTo = ilvState.state.totalRows;
                                }

                                // the guy handling this would better actually rearrange items...
                                if (ilvState.state.draggedTo > ilvState.state.draggedFrom)
                                {
                                    ilvState.state.row = ilvState.state.draggedTo - 1;
                                }
                                else
                                {
                                    ilvState.state.row = ilvState.state.draggedTo;
                                }

                                ilvState.state.selectionChanged = true;

                                DragAndDrop.AcceptDrag();
                                Event.current.Use();
                                ilvState.wantsReordering    = false;
                                ilvState.state.drawDropHere = false;
                            }

                            GUIUtility.hotControl = 0;
                            break;
                        }

                        case EventType.DragExited:
                        {
                            ilvState.wantsReordering    = false;
                            ilvState.state.drawDropHere = false;

                            GUIUtility.hotControl = 0;
                            break;
                        }
                        }
                    }
                    else if (ilvState.wantsExternalFiles)
                    {
                        switch (Event.current.type)
                        {
                        case EventType.DragUpdated:
                        {
                            if ((GUIClip.visibleRect.Contains(Event.current.mousePosition)) &&
                                (DragAndDrop.paths != null) && (DragAndDrop.paths.Length != 0))             // dragging files from somewhere
                            {
                                DragAndDrop.visualMode = ilvState.rect.Contains(Event.current.mousePosition) ?
                                                         DragAndDropVisualMode.Copy : DragAndDropVisualMode.None;

                                Event.current.Use();

                                if (DragAndDrop.visualMode != DragAndDropVisualMode.None)
                                {
                                    ilvState.state.dropHereRect = new Rect(ilvState.rect.x,
                                                                           (Mathf.RoundToInt(Event.current.mousePosition.y / ilvState.state.rowHeight) - 1) * ilvState.state.rowHeight,
                                                                           ilvState.rect.width, ilvState.state.rowHeight);

                                    if (ilvState.state.dropHereRect.y >= ilvState.state.rowHeight * ilvState.state.totalRows)
                                    {
                                        ilvState.state.dropHereRect.y = ilvState.state.rowHeight * (ilvState.state.totalRows - 1);
                                    }

                                    ilvState.state.drawDropHere = true;
                                }
                            }
                            break;
                        }

                        case EventType.DragPerform:
                        {
                            if (GUIClip.visibleRect.Contains(Event.current.mousePosition))
                            {
                                ilvState.state.fileNames = DragAndDrop.paths;
                                DragAndDrop.AcceptDrag();
                                Event.current.Use();
                                ilvState.wantsExternalFiles = false;
                                ilvState.state.drawDropHere = false;
                                ilvState.state.draggedTo    = Mathf.RoundToInt(Event.current.mousePosition.y / ilvState.state.rowHeight);
                                if (ilvState.state.draggedTo > ilvState.state.totalRows)
                                {
                                    ilvState.state.draggedTo = ilvState.state.totalRows;
                                }
                                ilvState.state.row = ilvState.state.draggedTo;
                            }

                            GUIUtility.hotControl = 0;

                            break;
                        }

                        case EventType.DragExited:
                        {
                            ilvState.wantsExternalFiles = false;
                            ilvState.state.drawDropHere = false;

                            GUIUtility.hotControl = 0;
                            break;
                        }
                        }
                    }
                    else if (ilvState.wantsToAcceptCustomDrag && (dragControlID != ilvState.state.ID))
                    {
                        switch (Event.current.type)
                        {
                        case EventType.DragUpdated:
                        {
                            object data = DragAndDrop.GetGenericData("CustomDragID");

                            if (GUIClip.visibleRect.Contains(Event.current.mousePosition) && data != null)
                            {
                                DragAndDrop.visualMode = ilvState.rect.Contains(Event.current.mousePosition) ?
                                                         DragAndDropVisualMode.Move : DragAndDropVisualMode.None;

                                Event.current.Use();
                            }
                            break;
                        }

                        case EventType.DragPerform:
                        {
                            object data = DragAndDrop.GetGenericData("CustomDragID");

                            if (GUIClip.visibleRect.Contains(Event.current.mousePosition) && data != null)
                            {
                                ilvState.state.customDraggedFromID = (int)data;
                                DragAndDrop.AcceptDrag();
                                Event.current.Use();
                            }

                            GUIUtility.hotControl = 0;
                            break;
                        }

                        case EventType.DragExited:
                        {
                            GUIUtility.hotControl = 0;
                            break;
                        }
                        }
                    }

                    if (ilvState.beganHorizontal)
                    {
                        EditorGUILayout.EndScrollView();
                        GUILayout.EndHorizontal();
                        ilvState.beganHorizontal = false;
                    }

                    if (isLayouted)
                    {
                        GUILayoutUtility.EndLayoutGroup();
                        EditorGUILayout.EndScrollView();
                    }

                    ilvState.wantsReordering    = false;
                    ilvState.wantsExternalFiles = false;
                }
                else if (isLayouted)
                {
                    if (yPos != yFrom)
                    {
                        ilvStateL.group.ResetCursor();
                        ilvStateL.group.AddY();
                    }
                    else
                    {
                        ilvStateL.group.AddY(ilvState.invisibleRows * ilvState.state.rowHeight);
                    }
                }

                if (isLayouted)
                {
                    if (!quiting)
                    {
                        GUILayout.BeginHorizontal(GUIStyle.none); // for each row
                    }
                    else
                    {
                        GUILayout.EndHorizontal(); // the one used for drawing LVs background
                    }
                }

                return(!quiting);
            }
Exemplo n.º 21
0
        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.º 22
0
        private void ListArea(Rect rect, PresetLibrary lib, object newPresetObject)
        {
            if ((UnityEngine.Object)lib == (UnityEngine.Object)null)
            {
                return;
            }
            Event current = Event.current;

            if (this.m_PresetLibraryFileLocation == PresetFileLocation.ProjectFolder && current.type == EventType.Repaint)
            {
                this.m_IsOpenForEdit = AssetDatabase.IsOpenForEdit(this.pathWithExtension);
            }
            else if (this.m_PresetLibraryFileLocation == PresetFileLocation.PreferencesFolder)
            {
                this.m_IsOpenForEdit = true;
            }
            if (!this.m_IsOpenForEdit)
            {
                this.VersionControlArea(new Rect(rect.x, rect.yMax - this.versionControlAreaHeight, rect.width, this.versionControlAreaHeight));
                rect.height -= this.versionControlAreaHeight;
            }
            for (int index = 0; index < 2; ++index)
            {
                this.gridWidth = !this.m_ShowedScrollBarLastFrame ? rect.width : rect.width - 17f;
                this.SetupGrid(this.gridWidth, lib.Count());
                bool flag = (double)this.m_Grid.height > (double)rect.height;
                if (flag != this.m_ShowedScrollBarLastFrame)
                {
                    this.m_ShowedScrollBarLastFrame = flag;
                }
                else
                {
                    break;
                }
            }
            if ((this.m_ShowedScrollBarLastFrame || this.alwaysShowScrollAreaHorizontalLines) && Event.current.type == EventType.Repaint)
            {
                Rect rect1 = new RectOffset(1, 1, 1, 1).Add(rect);
                rect1.height = 1f;
                EditorGUI.DrawRect(rect1, new Color(0.0f, 0.0f, 0.0f, 0.3f));
                rect1.y += rect.height + 1f;
                EditorGUI.DrawRect(rect1, new Color(0.0f, 0.0f, 0.0f, 0.3f));
            }
            Rect viewRect = new Rect(0.0f, 0.0f, 1f, this.m_Grid.height);

            this.m_State.m_ScrollPosition = GUI.BeginScrollView(rect, this.m_State.m_ScrollPosition, viewRect);
            float num      = 0.0f;
            int   maxIndex = !this.m_ShowAddNewPresetItem ? lib.Count() - 1 : lib.Count();
            int   startIndex;
            int   endIndex;
            bool  flag1 = this.m_Grid.IsVisibleInScrollView(rect.height, this.m_State.m_ScrollPosition.y, num, maxIndex, out startIndex, out endIndex);
            bool  flag2 = false;

            if (flag1)
            {
                if (this.GetRenameOverlay().IsRenaming() && !this.GetRenameOverlay().isWaitingForDelay)
                {
                    if (!this.m_State.m_RenameOverlay.OnGUI())
                    {
                        this.EndRename();
                        current.Use();
                    }
                    this.Repaint();
                }
                for (int index = startIndex; index <= endIndex; ++index)
                {
                    int  controlID = index + 1000000;
                    Rect rect1     = this.m_Grid.CalcRect(index, num);
                    Rect rect2     = rect1;
                    Rect position  = rect1;
                    switch (this.m_State.itemViewMode)
                    {
                    case PresetLibraryEditorState.ItemViewMode.List:
                        rect2.width     = this.m_State.m_PreviewHeight * this.m_PreviewAspect;
                        position.x     += rect2.width + 8f;
                        position.width -= rect2.width + 10f;
                        position.height = 16f;
                        position.y      = rect1.yMin + (float)(((double)rect1.height - 16.0) * 0.5);
                        break;
                    }
                    if (this.m_ShowAddNewPresetItem && index == lib.Count())
                    {
                        this.CreateNewPresetButton(rect2, newPresetObject, lib, this.m_IsOpenForEdit);
                    }
                    else
                    {
                        bool flag3 = this.IsRenaming(index);
                        if (flag3)
                        {
                            Rect rect3 = position;
                            --rect3.y;
                            --rect3.x;
                            this.m_State.m_RenameOverlay.editFieldRect = rect3;
                        }
                        switch (current.type)
                        {
                        case EventType.MouseDown:
                            if (current.button == 0 && rect1.Contains(current.mousePosition))
                            {
                                GUIUtility.hotControl = controlID;
                                if (current.clickCount == 1)
                                {
                                    this.m_ItemClickedCallback(current.clickCount, lib.GetPreset(index));
                                    current.Use();
                                    continue;
                                }
                                continue;
                            }
                            continue;

                        case EventType.MouseUp:
                            if (GUIUtility.hotControl == controlID)
                            {
                                GUIUtility.hotControl = 0;
                                if (current.button == 0 && rect1.Contains(current.mousePosition) && (Event.current.alt && this.m_IsOpenForEdit))
                                {
                                    this.DeletePreset(index);
                                    current.Use();
                                    continue;
                                }
                                continue;
                            }
                            continue;

                        case EventType.MouseMove:
                            if (rect1.Contains(current.mousePosition))
                            {
                                if (this.m_State.m_HoverIndex != index)
                                {
                                    this.m_State.m_HoverIndex = index;
                                    this.Repaint();
                                    continue;
                                }
                                continue;
                            }
                            if (this.m_State.m_HoverIndex == index)
                            {
                                this.m_State.m_HoverIndex = -1;
                                this.Repaint();
                                continue;
                            }
                            continue;

                        case EventType.MouseDrag:
                            if (GUIUtility.hotControl == controlID && this.m_IsOpenForEdit)
                            {
                                if (((DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), controlID)).CanStartDrag())
                                {
                                    DragAndDrop.PrepareStartDrag();
                                    DragAndDrop.SetGenericData("DraggingPreset", (object)index);
                                    DragAndDrop.objectReferences = new UnityEngine.Object[0];
                                    DragAndDrop.StartDrag(string.Empty);
                                    this.m_DragState.draggingIndex = index;
                                    this.m_DragState.dragUponIndex = index;
                                    GUIUtility.hotControl          = 0;
                                }
                                current.Use();
                                continue;
                            }
                            continue;

                        case EventType.Repaint:
                            if (this.m_State.m_HoverIndex == index && !rect1.Contains(current.mousePosition))
                            {
                                this.m_State.m_HoverIndex = -1;
                            }
                            if (this.m_DragState.draggingIndex == index || GUIUtility.hotControl == controlID)
                            {
                                this.DrawHoverEffect(rect1, false);
                            }
                            lib.Draw(rect2, index);
                            if (!flag3 && this.drawLabels)
                            {
                                GUI.Label(position, GUIContent.Temp(lib.GetName(index)));
                            }
                            if (this.m_DragState.dragUponIndex == index && this.m_DragState.draggingIndex != this.m_DragState.dragUponIndex)
                            {
                                flag2 = true;
                            }
                            if (GUIUtility.hotControl == 0 && Event.current.alt && this.m_IsOpenForEdit)
                            {
                                EditorGUIUtility.AddCursorRect(rect1, MouseCursor.ArrowMinus);
                                continue;
                            }
                            continue;

                        case EventType.DragUpdated:
                        case EventType.DragPerform:
                            Rect dragRect = this.GetDragRect(rect1);
                            if (dragRect.Contains(current.mousePosition))
                            {
                                this.m_DragState.dragUponIndex    = index;
                                this.m_DragState.dragUponRect     = rect1;
                                this.m_DragState.insertAfterIndex = this.m_State.itemViewMode != PresetLibraryEditorState.ItemViewMode.List ? ((double)current.mousePosition.x - (double)dragRect.x) / (double)dragRect.width > 0.5 : ((double)current.mousePosition.y - (double)dragRect.y) / (double)dragRect.height > 0.5;
                                if (current.type == EventType.DragPerform)
                                {
                                    if (this.m_DragState.draggingIndex >= 0)
                                    {
                                        this.MovePreset(this.m_DragState.draggingIndex, this.m_DragState.dragUponIndex, this.m_DragState.insertAfterIndex);
                                        DragAndDrop.AcceptDrag();
                                    }
                                    this.ClearDragState();
                                }
                                DragAndDrop.visualMode = DragAndDropVisualMode.Move;
                                current.Use();
                                continue;
                            }
                            continue;

                        case EventType.DragExited:
                            if (this.m_DragState.IsDragging())
                            {
                                this.ClearDragState();
                                current.Use();
                                continue;
                            }
                            continue;

                        case EventType.ContextClick:
                            if (rect1.Contains(current.mousePosition))
                            {
                                PresetLibraryEditor <T> .PresetContextMenu.Show(this.m_IsOpenForEdit, index, newPresetObject, this);

                                current.Use();
                                continue;
                            }
                            continue;

                        default:
                            continue;
                        }
                    }
                }
                if (flag2)
                {
                    this.DrawDragInsertionMarker();
                }
            }
            GUI.EndScrollView();
        }
Exemplo n.º 23
0
        private void ListArea(Rect rect, PresetLibrary lib, object newPresetObject)
        {
            if (lib != null)
            {
                int   num2;
                int   num3;
                Event current = Event.current;
                if ((this.m_PresetLibraryFileLocation == PresetFileLocation.ProjectFolder) && (current.type == EventType.Repaint))
                {
                    this.m_IsOpenForEdit = AssetDatabase.IsOpenForEdit(this.pathWithExtension);
                }
                else if (this.m_PresetLibraryFileLocation == PresetFileLocation.PreferencesFolder)
                {
                    this.m_IsOpenForEdit = true;
                }
                if (!this.m_IsOpenForEdit)
                {
                    Rect rect2 = new Rect(rect.x, rect.yMax - this.versionControlAreaHeight, rect.width, this.versionControlAreaHeight);
                    this.VersionControlArea(rect2);
                    rect.height -= this.versionControlAreaHeight;
                }
                for (int i = 0; i < 2; i++)
                {
                    this.gridWidth = !this.m_ShowedScrollBarLastFrame ? rect.width : (rect.width - 17f);
                    this.SetupGrid(this.gridWidth, lib.Count());
                    bool flag = this.m_Grid.height > rect.height;
                    if (flag == this.m_ShowedScrollBarLastFrame)
                    {
                        break;
                    }
                    this.m_ShowedScrollBarLastFrame = flag;
                }
                if ((this.m_ShowedScrollBarLastFrame || this.alwaysShowScrollAreaHorizontalLines) && (Event.current.type == EventType.Repaint))
                {
                    Rect rect3 = new RectOffset(1, 1, 1, 1).Add(rect);
                    rect3.height = 1f;
                    EditorGUI.DrawRect(rect3, new Color(0f, 0f, 0f, 0.3f));
                    rect3.y += rect.height + 1f;
                    EditorGUI.DrawRect(rect3, new Color(0f, 0f, 0f, 0.3f));
                }
                Rect viewRect = new Rect(0f, 0f, 1f, this.m_Grid.height);
                this.m_State.m_ScrollPosition = GUI.BeginScrollView(rect, this.m_State.m_ScrollPosition, viewRect);
                float gridStartY = 0f;
                int   maxIndex   = !this.m_ShowAddNewPresetItem ? (lib.Count() - 1) : lib.Count();
                bool  flag2      = this.m_Grid.IsVisibleInScrollView(rect.height, this.m_State.m_ScrollPosition.y, gridStartY, maxIndex, out num2, out num3);
                bool  flag3      = false;
                if (flag2)
                {
                    if (this.GetRenameOverlay().IsRenaming() && !this.GetRenameOverlay().isWaitingForDelay)
                    {
                        if (!this.m_State.m_RenameOverlay.OnGUI())
                        {
                            this.EndRename();
                            current.Use();
                        }
                        this.Repaint();
                    }
                    for (int j = num2; j <= num3; j++)
                    {
                        bool flag4;
                        Rect dragRect;
                        int  controlID  = j + 0xf4240;
                        Rect itemRect   = this.m_Grid.CalcRect(j, gridStartY);
                        Rect buttonRect = itemRect;
                        Rect position   = itemRect;
                        PresetLibraryEditorState.ItemViewMode itemViewMode = this.m_State.itemViewMode;
                        if ((itemViewMode != PresetLibraryEditorState.ItemViewMode.Grid) && (itemViewMode == PresetLibraryEditorState.ItemViewMode.List))
                        {
                            buttonRect.width = this.m_State.m_PreviewHeight * this.m_PreviewAspect;
                            position.x      += buttonRect.width + 8f;
                            position.width  -= buttonRect.width + 10f;
                            position.height  = 16f;
                            position.y       = itemRect.yMin + ((itemRect.height - 16f) * 0.5f);
                        }
                        if (this.m_ShowAddNewPresetItem && (j == lib.Count()))
                        {
                            this.CreateNewPresetButton(buttonRect, newPresetObject, lib, this.m_IsOpenForEdit);
                        }
                        else
                        {
                            flag4 = this.IsRenaming(j);
                            if (flag4)
                            {
                                Rect rect8 = position;
                                rect8.y--;
                                rect8.x--;
                                this.m_State.m_RenameOverlay.editFieldRect = rect8;
                            }
                            switch (current.type)
                            {
                            case EventType.MouseDown:
                                if ((current.button == 0) && itemRect.Contains(current.mousePosition))
                                {
                                    GUIUtility.hotControl = controlID;
                                    if (current.clickCount == 1)
                                    {
                                        this.m_ItemClickedCallback(current.clickCount, lib.GetPreset(j));
                                        current.Use();
                                    }
                                }
                                break;

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

                            case EventType.MouseMove:
                                if (!itemRect.Contains(current.mousePosition))
                                {
                                    goto Label_0812;
                                }
                                if (this.m_State.m_HoverIndex != j)
                                {
                                    this.m_State.m_HoverIndex = j;
                                    this.Repaint();
                                }
                                break;

                            case EventType.MouseDrag:
                                if ((GUIUtility.hotControl == controlID) && this.m_IsOpenForEdit)
                                {
                                    DragAndDropDelay stateObject = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), controlID);
                                    if (stateObject.CanStartDrag())
                                    {
                                        DragAndDrop.PrepareStartDrag();
                                        DragAndDrop.SetGenericData("DraggingPreset", j);
                                        DragAndDrop.objectReferences = new UnityEngine.Object[0];
                                        DragAndDrop.StartDrag(string.Empty);
                                        this.m_DragState.draggingIndex = j;
                                        this.m_DragState.dragUponIndex = j;
                                        GUIUtility.hotControl          = 0;
                                    }
                                    current.Use();
                                }
                                break;

                            case EventType.Repaint:
                                if ((this.m_State.m_HoverIndex == j) && !itemRect.Contains(current.mousePosition))
                                {
                                    goto Label_046D;
                                }
                                goto Label_0479;

                            case EventType.DragUpdated:
                            case EventType.DragPerform:
                                dragRect = this.GetDragRect(itemRect);
                                if (!dragRect.Contains(current.mousePosition))
                                {
                                    break;
                                }
                                this.m_DragState.dragUponIndex = j;
                                this.m_DragState.dragUponRect  = itemRect;
                                if (this.m_State.itemViewMode != PresetLibraryEditorState.ItemViewMode.List)
                                {
                                    goto Label_0694;
                                }
                                this.m_DragState.insertAfterIndex = ((current.mousePosition.y - dragRect.y) / dragRect.height) > 0.5f;
                                goto Label_06C5;

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

                            case EventType.ContextClick:
                                if (itemRect.Contains(current.mousePosition))
                                {
                                    PresetContextMenu <T> .Show(this.m_IsOpenForEdit, j, newPresetObject, (PresetLibraryEditor <T>) this);

                                    current.Use();
                                }
                                break;
                            }
                        }
                        continue;
Label_046D:
                        this.m_State.m_HoverIndex = -1;
Label_0479:
                        if ((this.m_DragState.draggingIndex == j) || (GUIUtility.hotControl == controlID))
                        {
                            this.DrawHoverEffect(itemRect, false);
                        }
                        lib.Draw(buttonRect, j);
                        if (!flag4 && this.drawLabels)
                        {
                            GUI.Label(position, GUIContent.Temp(lib.GetName(j)));
                        }
                        if ((this.m_DragState.dragUponIndex == j) && (this.m_DragState.draggingIndex != this.m_DragState.dragUponIndex))
                        {
                            flag3 = true;
                        }
                        if (((GUIUtility.hotControl == 0) && Event.current.alt) && this.m_IsOpenForEdit)
                        {
                            EditorGUIUtility.AddCursorRect(itemRect, MouseCursor.ArrowMinus);
                        }
                        continue;
Label_0694:
                        this.m_DragState.insertAfterIndex = ((current.mousePosition.x - dragRect.x) / dragRect.width) > 0.5f;
Label_06C5:
                        if (current.type == EventType.DragPerform)
                        {
                            if (this.m_DragState.draggingIndex >= 0)
                            {
                                this.MovePreset(this.m_DragState.draggingIndex, this.m_DragState.dragUponIndex, this.m_DragState.insertAfterIndex);
                                DragAndDrop.AcceptDrag();
                            }
                            this.ClearDragState();
                        }
                        DragAndDrop.visualMode = DragAndDropVisualMode.Move;
                        current.Use();
                        continue;
Label_0812:
                        if (this.m_State.m_HoverIndex == j)
                        {
                            this.m_State.m_HoverIndex = -1;
                            this.Repaint();
                        }
                    }
                    if (flag3)
                    {
                        this.DrawDragInsertionMarker();
                    }
                }
                GUI.EndScrollView();
            }
        }