GetName() public abstract method

public abstract GetName ( int index ) : string
index int
return string
        private void DrawPresets(string libraryPath)
        {
            if (GUIClip.visibleRect.width > 0)
            {
                m_LastRepaintedWidth = GUIClip.visibleRect.width;
            }

            if (m_LastRepaintedWidth < 0)
            {
                GUILayoutUtility.GetRect(1, 1); // Ensure consistent call
                HandleUtility.Repaint();        // Wait until we have a proper width
                return;
            }

            PresetLibrary lib = PresetLibraryManager.instance.GetLibrary(m_SaveLoadHelper, libraryPath) as PresetLibrary;

            if (lib == null)
            {
                Debug.Log("Could not load preset library '" + libraryPath + "'");
                return;
            }

            SetupGrid(m_LastRepaintedWidth, lib.Count(), itemViewMode);


            int   showNumPresets   = Mathf.Min(lib.Count(), maxShowNumPresets);
            int   hiddenNumPresets = lib.Count() - showNumPresets;
            float contentHeight    = m_Grid.CalcRect(showNumPresets - 1, 0f).yMax + (hiddenNumPresets > 0 ? 20f : 0f);

            Rect reservedRect = GUILayoutUtility.GetRect(1, contentHeight);

            float spaceBetweenPresetAndText = presetSize.x + 6f;

            for (int index = 0; index < showNumPresets; ++index)
            {
                Rect r          = m_Grid.CalcRect(index, reservedRect.y);
                Rect presetRect = new Rect(r.x, r.y, presetSize.x, presetSize.y);
                lib.Draw(presetRect, index);
                if (itemViewMode == PresetLibraryEditorState.ItemViewMode.List)
                {
                    Rect   nameRect = new Rect(r.x + spaceBetweenPresetAndText, r.y, r.width - spaceBetweenPresetAndText, r.height);
                    string name     = lib.GetName(index);
                    GUI.Label(nameRect, name);
                }
            }
            if (hiddenNumPresets > 0)
            {
                Rect textRect = new Rect(m_Grid.CalcRect(0, 0).x, reservedRect.y + contentHeight - 20f, reservedRect.width, 20f);
                GUI.Label(textRect, string.Format("+ {0} more...", hiddenNumPresets));
            }
        }
Ejemplo n.º 2
0
        private void DrawPresets(string libraryPath)
        {
            if (GUIClip.visibleRect.width > 0f)
            {
                this.m_LastRepaintedWidth = GUIClip.visibleRect.width;
            }
            if (this.m_LastRepaintedWidth < 0f)
            {
                GUILayoutUtility.GetRect(1f, 1f);
                HandleUtility.Repaint();
            }
            else
            {
                PresetLibrary presetLibrary = ScriptableSingleton <PresetLibraryManager> .instance.GetLibrary <T>(this.m_SaveLoadHelper, libraryPath) as PresetLibrary;

                if (presetLibrary == null)
                {
                    Debug.Log("Could not load preset library '" + libraryPath + "'");
                }
                else
                {
                    this.SetupGrid(this.m_LastRepaintedWidth, presetLibrary.Count(), this.itemViewMode);
                    int   num  = Mathf.Min(presetLibrary.Count(), this.maxShowNumPresets);
                    int   num2 = presetLibrary.Count() - num;
                    float num3 = this.m_Grid.CalcRect(num - 1, 0f).yMax + ((num2 <= 0) ? 0f : 20f);
                    Rect  rect = GUILayoutUtility.GetRect(1f, num3);
                    float num4 = this.presetSize.x + 6f;
                    for (int i = 0; i < num; i++)
                    {
                        Rect rect2 = this.m_Grid.CalcRect(i, rect.y);
                        Rect rect3 = new Rect(rect2.x, rect2.y, this.presetSize.x, this.presetSize.y);
                        presetLibrary.Draw(rect3, i);
                        if (this.itemViewMode == PresetLibraryEditorState.ItemViewMode.List)
                        {
                            Rect   position = new Rect(rect2.x + num4, rect2.y, rect2.width - num4, rect2.height);
                            string name     = presetLibrary.GetName(i);
                            GUI.Label(position, name);
                        }
                    }
                    if (num2 > 0)
                    {
                        Rect position2 = new Rect(this.m_Grid.CalcRect(0, 0f).x, rect.y + num3 - 20f, rect.width, 20f);
                        GUI.Label(position2, string.Format("+ {0} more...", num2));
                    }
                }
            }
        }
Ejemplo n.º 3
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();
        }
Ejemplo n.º 4
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();
            }
        }
Ejemplo n.º 5
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();
        }
Ejemplo n.º 6
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();
        }
Ejemplo n.º 7
0
        private void DrawPresets(string libraryPath)
        {
            if ((double)GUIClip.visibleRect.width > 0.0)
            {
                this.m_LastRepaintedWidth = GUIClip.visibleRect.width;
            }
            if ((double)this.m_LastRepaintedWidth < 0.0)
            {
                GUILayoutUtility.GetRect(1f, 1f);
                HandleUtility.Repaint();
            }
            else
            {
                PresetLibrary library = (object)ScriptableSingleton <PresetLibraryManager> .instance.GetLibrary <T>(this.m_SaveLoadHelper, libraryPath) as PresetLibrary;

                if ((UnityEngine.Object)library == (UnityEngine.Object)null)
                {
                    Debug.Log((object)("Could not load preset library '" + libraryPath + "'"));
                }
                else
                {
                    this.SetupGrid(this.m_LastRepaintedWidth, library.Count(), this.itemViewMode);
                    int   num1   = Mathf.Min(library.Count(), this.maxShowNumPresets);
                    int   num2   = library.Count() - num1;
                    float height = this.m_Grid.CalcRect(num1 - 1, 0.0f).yMax + (num2 <= 0 ? 0.0f : 20f);
                    Rect  rect1  = GUILayoutUtility.GetRect(1f, height);
                    float num3   = this.presetSize.x + 6f;
                    for (int index = 0; index < num1; ++index)
                    {
                        Rect rect2 = this.m_Grid.CalcRect(index, rect1.y);
                        Rect rect3 = new Rect(rect2.x, rect2.y, this.presetSize.x, this.presetSize.y);
                        library.Draw(rect3, index);
                        if (this.itemViewMode == PresetLibraryEditorState.ItemViewMode.List)
                        {
                            GUI.Label(new Rect(rect2.x + num3, rect2.y, rect2.width - num3, rect2.height), library.GetName(index));
                        }
                    }
                    if (num2 <= 0)
                    {
                        return;
                    }
                    GUI.Label(new Rect(this.m_Grid.CalcRect(0, 0.0f).x, (float)((double)rect1.y + (double)height - 20.0), rect1.width, 20f), string.Format("+ {0} more...", (object)num2));
                }
            }
        }