Exemplo n.º 1
0
        public override void OnGUI()
        {
            GUILayout.BeginHorizontal();

            GUILayout.BeginVertical();

            sidebarScrollPos = EditorGUILayout.BeginScrollView(sidebarScrollPos);

            for (int i = 0; i < selectionLabels.Length; i++)
            {
                if (GUILayout.Toggle(i == selection, selectionLabels[i], EditorStyles.toolbarButton, GUILayout.Width(sidebarWidth)))
                {
                    selection = i;
                }
            }

            EditorGUILayout.EndScrollView();

            GUILayout.EndVertical();

            EditorGUILayoutUtil.DrawLine(false, 2);

            GUILayout.BeginVertical();

            if (selection == 0)
            {
                Editor editor = Editor.CreateEditor(TenaciousEditorSettings.GetOrCreateSettings());
                editor.DrawHeader();
                editor.OnInspectorGUI();
            }

            GUILayout.EndVertical();

            GUILayout.EndHorizontal();
        }
Exemplo n.º 2
0
 public override void OnInspectorGUI()
 {
     GUI.enabled = true;
     EditorGUILayout.BeginHorizontal();
     if (EditorGUILayoutUtil.ObjectField <UIRoot>("Root", ref root, true))
     {
         Classify(ref root);
     }
     if (GUILayout.Button("Refresh", GUILayout.ExpandWidth(false)) || root == null)
     {
         Classify(ref root);
     }
     GUI.enabled = root != null;
     if (GUILayout.Button("Rename", GUILayout.ExpandWidth(false)))
     {
         Rename();
     }
     GUI.enabled = true;
     EditorGUILayout.EndHorizontal();
     scroll = EditorGUILayout.BeginScrollView(scroll);
     VisualizeGroup();
     EditorGUILayoutUtil.DrawSeparator();
     VisualizeDups();
     EditorGUILayout.EndScrollView();
 }
Exemplo n.º 3
0
        private bool DrawRowHeader()
        {
            bool changed = false;

            EditorGUILayout.BeginVertical();
            changed |= EditorGUILayoutUtil.ObjectField <UITableCell>(ref table.defaultPrefab, true, W_Option, H_Option);
            EditorGUILayout.LabelField("Align", EditorStyles.boldLabel, H_Option);
            EditorGUILayout.LabelField("Size", EditorStyles.boldLabel, H_Option);
            EditorGUILayout.LabelField("Index", EditorStyles.boldLabel, H_Option);
            int row = table.isVertical? table.GetMaxPerLine(): table.rowCount;

            table.InitArray();
            for (int r = 0; r < row; r++)
            {
                EditorGUILayout.BeginHorizontal();
                changed |= EditorGUILayoutUtil.ObjectField <UITableCell>(ref table.rowPrefab[r], true, GUILayout.Width(WIDTH - 20), H_Option);
                changed |= EditorGUILayoutUtil.Popup <UITableLayout.VAlign>(ref table.valigns[r], EnumUtil.Values <UITableLayout.VAlign>(), GUILayout.Width(40), H_Option);
                changed |= EditorGUILayoutUtil.IntField(null, ref table.rowHeight[r], GUILayout.Width(WIDTH - 30), H_Option);
                EditorGUILayout.LabelField((r + 1).ToString(), EditorStyles.boldLabel, GUILayout.Width(20), H_Option);
                EditorGUILayout.EndHorizontal();
            }
            if (!IsHorizontal())
            {
                EditorGUILayout.LabelField("", W_Option);
                EditorGUILayout.LabelField("", W_Option);
                EditorGUILayout.LabelField("", W_Option);
            }
            EditorGUILayout.EndVertical();
            if (changed)
            {
                table.InitArray();
            }
            return(changed);
        }
Exemplo n.º 4
0
        private bool DrawTextMod()
        {
            bool changed = false;
            int  row     = grid.rowCount;
            int  col     = grid.columnCount;

            mod = EditorGUILayout.Foldout(mod, "Text Mod");
            if (mod)
            {
                EditorGUI.indentLevel += 2;
                for (int r = 0; r < row; r++)
                {
                    EditorGUILayout.BeginHorizontal();
                    for (int c = 0; c < col; c++)
                    {
                        UITableCell cell = grid.GetCell(r, c);
                        UILabel     l    = cell != null?cell.GetComponentInChildren <UILabel>() : null;

                        string s = l != null? l.text: "";
                        if (EditorGUILayoutUtil.TextField(null, ref s, GUILayout.Width(70)) && l != null)
                        {
                            l.SetText(s);
                            changed = true;
                        }
                    }
                    EditorGUILayout.EndHorizontal();
                }
                EditorGUI.indentLevel -= 2;
            }
            return(changed);
        }
        private bool DrawTableStructure()
        {
            bool changed = false;

            if (NGUIEditorTools.DrawHeader("Table Structure"))
            {
                NGUIEditorTools.BeginContents();
                EditorGUILayout.HelpBox("Modifying structure values may occur unintented result", MessageType.Warning);
                changed = EditorGUILayoutUtil.PopupEnum <UITableLayout.Arrangement>("Orientation", ref grid.arrangement, GUILayout.ExpandWidth(false));
                string rowCol = grid.isHorizontal? "Column Size": "Row Size";
                if (EditorGUILayoutUtil.IntField(rowCol, ref grid.maxPerLine, GUILayout.ExpandWidth(false)))
                {
                    if (grid.maxPerLine <= 0)
                    {
                        grid.maxPerLine = 1;
                    }
                    changed = true;
                }
                changed |= EditorGUILayoutUtil.IntField("Row Header", ref grid.rowHeader, GUILayout.ExpandWidth(false));
                changed |= EditorGUILayoutUtil.IntField("Column Header", ref grid.columnHeader, GUILayout.ExpandWidth(false));
                changed |= EditorGUILayoutUtil.Toggle("Reuse Cell", ref grid.reuseCell, GUILayout.ExpandWidth(false));
                NGUIEditorTools.EndContents();
            }
            if (changed)
            {
                grid.InitArray();
            }
            return(changed);
        }
Exemplo n.º 6
0
        public bool OnInspectorGUI()
        {
            Animation anim    = script.GetComponent <Animation>();
            bool      changed = false;

            EditorGUI.indentLevel++;
            foreach (string varName in clipVars)
            {
                AnimationClip val = script.GetFieldValue <AnimationClip>(varName);
                if (anim != null)
                {
                    if (EditorGUILayoutUtil.PopupNullable(varName, ref val, anim.GetAllClips().ToArray()))
                    {
                        script.SetFieldValue(varName, val);
                        changed = true;
                    }
                }
                else
                {
                    if (val != null)
                    {
                        script.SetFieldValue <AnimationClip>(varName, null);
                        changed = true;
                    }
                }
            }
            EditorGUI.indentLevel--;
            if (changed)
            {
                EditorUtil.SetDirty(script);
            }
            return(changed);
        }
 public void OnInspectorGUI()
 {
     if (EditorGUILayoutUtil.ObjectField <GameObject>("Empty Obj", ref grid.emptyObj, true))
     {
         EditorUtil.SetDirty(grid.emptyObj);
     }
     OnGridGUI();
 }
        protected override bool OnInspectorGUI(RenderQueueElement info, int i)
        {
            float width   = GetWidth();
            bool  changed = false;

            changed |= EditorGUILayoutUtil.TextField(null, ref info.name, GUILayout.MinWidth(width * 0.5F));
            changed |= EditorGUILayoutUtil.IntField(null, ref info.value, GUILayout.MinWidth(width * 0.3F));
            return(changed);
        }
Exemplo n.º 9
0
Arquivo: DiMenu.cs Projeto: mulova/di
        public static void PreferenceMenu()
        {
            bool di = DiService.enableDi;

            if (EditorGUILayoutUtil.Toggle("enable DI", ref di))
            {
                DiService.enableDi = di;
                Save();
            }
        }
Exemplo n.º 10
0
 private void DrawFindLexiconGUI()
 {
     EditorGUILayout.BeginHorizontal();
     EditorGUILayoutUtil.TextField("Lexicon Keys", ref lexiconKeys);
     if (GUILayout.Button("Find") && !lexiconKeys.IsEmpty())
     {
         Debug.Log(UIBuildScript.FindTextKey(lexiconKeys));
     }
     EditorGUILayout.EndHorizontal();
 }
Exemplo n.º 11
0
        private bool DrawColumn()
        {
            bool changed     = false;
            int  columnSize  = table.isHorizontal? table.GetMaxPerLine(): table.columnCount;
            int  contentSize = table.columnCount;

            for (int c = 0; c < columnSize; c++)
            {
                EditorGUILayout.BeginVertical();
                changed |= EditorGUILayoutUtil.ObjectField <UITableCell>(ref table.columnPrefab[c], true, GUILayout.ExpandWidth(false), H_Option);
                changed |= EditorGUILayoutUtil.Popup <UITableLayout.HAlign>(ref table.haligns[c], EnumUtil.Values <UITableLayout.HAlign>(), GUILayout.Width(WIDTH - 20), H_Option);
                changed |= EditorGUILayoutUtil.IntField(null, ref table.columnWidth[c], GUILayout.Width(WIDTH - 20), H_Option);
                EditorGUILayout.LabelField(c.ToString(), EditorStyles.boldLabel, W_Option, H_Option);
                int row = table.rowCount;
                if (c < contentSize)
                {
                    for (int r = 0; r < row; r++)
                    {
                        changed |= DrawCell(r, c);
                    }

                    // Draw Column +/- buttons
                    EditorGUILayout.BeginHorizontal();
                    if (GUILayout.Button(new GUIContent("A", "Add Selected"), GUILayout.ExpandWidth(false), H_Option))
                    {
                        AddSelected(c, UITableLayout.Arrangement.Vertical);
                        changed = true;
                    }
                    if (GUILayout.Button("+", GUILayout.ExpandWidth(false), H_Option))
                    {
                        #pragma warning disable 0618
                        table.AddColumn(c + 1, new UITableCell[table.rowCount]);
                        #pragma warning restore 0618
                        changed = true;
                    }
                    GUI.enabled = c >= table.columnHeader;
                    if (GUILayout.Button("-", GUILayout.ExpandWidth(false), H_Option))
                    {
                        if (EditorUtility.DisplayDialog("Confirm", "Delete column " + (c + 1), "OK", "Cancel"))
                        {
                            #pragma warning disable 0618
                            table.RemoveColumn(c);
                            #pragma warning restore 0618
                            table.Reposition();
                            changed = true;
                        }
                    }
                    GUI.enabled = true;
                    EditorGUILayout.EndHorizontal();
                }

                EditorGUILayout.EndVertical();
            }
            return(changed);
        }
Exemplo n.º 12
0
        private bool DrawCell(int r, int c)
        {
            bool        changed = false;
            UITableCell cell    = table.GetCell(r, c);

            if (EditorGUILayoutUtil.ObjectField <UITableCell>(ref cell, true, W_Option, GUILayout.Height(HEIGHT - 1)))
            {
                table.SetCell(r, c, cell);
                changed = true;
            }
            return(changed);
        }
Exemplo n.º 13
0
 public override void OnHeaderGUI(List <Object> found)
 {
     EditorGUILayoutUtil.TextArea("Exclude", ref exclude);
     EditorGUILayoutUtil.Toggle("Exclude TexLoader", ref excludeTexLoader);
     EditorGUILayout.BeginHorizontal();
     EditorGUILayoutUtil.TextField(null, ref filter);
     if (GUILayout.Button("Search"))
     {
         SetExclude(exclude);
         Search();
     }
     EditorGUILayout.EndHorizontal();
 }
Exemplo n.º 14
0
        public override void OnHeaderGUI()
        {
            bool changed = EditorGUILayoutUtil.ObjectField <GameObject>("Scene Root", ref sceneRoot, true);

            changed |= EditorGUILayoutUtil.ObjectField <UIAtlas>("From", ref atlasFrom, false);
            changed |= EditorGUILayoutUtil.ObjectField <UIAtlas>("To", ref atlasTo, false);
            NGUIEditorTools.DrawSeparator();

            if (changed && atlasFrom != null && atlasTo != null)
            {
                duplicateSprites = FindDuplicate(atlasFrom, atlasTo);
            }
        }
Exemplo n.º 15
0
        private bool DrawAddColumn()
        {
            showAddColumn = EditorGUILayout.Foldout(showAddColumn, "Add Column");
            if (showAddColumn)
            {
                if (!grid.isHorizontal)
                {
                    EditorGUILayout.HelpBox("Currently only Horizontal grid type is supported", MessageType.Warning);
                    return(false);
                }
                EditorGUILayoutUtil.ObjectField <UILabel>("Title Label(Prefab)", ref titleLabelPrefab, true, GUILayout.ExpandWidth(false));
                if (EditorGUILayoutUtil.PopupNullable <GridStyle>(null, ref currentStyle, gridStyles))
                {
                    selectedColumn = null;
                    return(true);
                }
                if (GUILayout.Button("Apply"))
                {
                    grid.totalWidth = currentStyle.width;
                    Vector2 minSize = grid.cellMinSize;
                    minSize.y        = currentStyle.rowHeight;
                    grid.cellMinSize = minSize;
                }
                if (currentStyle != null)
                {
                    EditorGUILayoutUtil.PopupNullable <ColumnWidth>(null, ref selectedColumn, currentStyle.columnWidth);
                    GUI.enabled = titleLabelPrefab != null && selectedColumn != null;
                    if (GUILayout.Button("Add"))
                    {
                        int lastCol = GetLastColumn();

                        for (int r = 1, max = grid.rowHeader; r < max; r++)
                        {
                            UITableCell cell = null;
                            #pragma warning disable 0618
                            grid.Insert((lastCol + 1) * r - 1, cell);
                            #pragma warning restore 0618
                        }
                        grid.maxPerLine = Math.Max(lastCol + 1, grid.maxPerLine);
                        grid.InitArray();
                        grid.columnWidth[lastCol] = selectedColumn.width;
                        grid.SetCell(grid.rowHeader - 1, lastCol, CreateLabel(selectedColumn.name, lastCol + 1));
                        return(true);
                    }
                }
            }
            return(false);
        }
Exemplo n.º 16
0
 public override void OnHeaderGUI()
 {
     EditorGUILayoutUtil.ObjectField <GameObject>("Scene Root", ref sceneRoot, true);
     GUI.enabled = sceneRoot != null;
     ComponentSelector.Draw("Select", NGUISettings.atlas, OnSelectAtlas, true);
     EditorGUILayoutUtil.TextField("Filter", ref filter);
     if (EditorGUILayoutUtil.Toggle("Expand", ref expand))
     {
         foreach (string s in spriteMap.Keys)
         {
             foldMap[s] = expand;
         }
     }
     GUI.enabled = true;
     NGUIEditorTools.DrawSeparator();
 }
        private void OnGUI()
        {
            DrawLocalizationSelect();

            EditorGUILayout.Space();
            EditorGUILayoutUtil.DrawUILine(Color.white, width: position.size.x);
            EditorGUILayout.Space();

            _drawCheckHelper();

            EditorGUILayout.Space();
            EditorGUILayoutUtil.DrawUILine(Color.white, width: position.size.x);
            EditorGUILayout.Space();

            _drawToggle(ToRectKey);
            _drawToggle(IncludeInactive);
        }
        private bool DrawSize()
        {
            bool changed = false;

            if (NGUIEditorTools.DrawHeader("Size"))
            {
                NGUIEditorTools.BeginContents();
                if (EditorGUILayoutUtil.PopupEnum <UITableLayout.HAlign>("Horizontal Align", ref grid.halign, GUILayout.ExpandWidth(false)))
                {
                    for (int i = 0; i < grid.haligns.Length; ++i)
                    {
                        grid.haligns[i] = grid.halign;
                    }
                    changed = true;
                }
                if (EditorGUILayoutUtil.PopupEnum <UITableLayout.VAlign>("Vertical Align", ref grid.valign, GUILayout.ExpandWidth(false)))
                {
                    for (int i = 0; i < grid.valigns.Length; ++i)
                    {
                        grid.valigns[i] = grid.valign;
                    }
                    changed = true;
                }
                changed |= EditorGUILayoutUtil.Vector2Field("Padding", ref grid.padding);
                if (grid.cellMinSize.x == 0 && grid.cellMinSize.y == 0)
                {
                    changed |= EditorGUILayoutUtil.Vector2Field("Cell Size", ref grid.cellSize);
                }
                if (grid.cellSize.x == 0 && grid.cellSize.y == 0)
                {
                    changed |= EditorGUILayoutUtil.Vector2Field("Cell Min Size", ref grid.cellMinSize);
                }
                changed |= EditorGUILayoutUtil.IntField("Total Width", ref grid.totalWidth);
                changed |= EditorGUILayoutUtil.Toggle("Resize Collider", ref grid.resizeCollider, GUILayout.ExpandWidth(false));
                if (grid.resizeCollider && grid.padding != Vector2.zero)
                {
                    EditorGUI.indentLevel += 1;
                    changed |= EditorGUILayoutUtil.Toggle("Expand Collider To Padding", ref grid.expandColliderToPadding, GUILayout.ExpandWidth(false));
                    EditorGUI.indentLevel -= 1;
                }
                NGUIEditorTools.EndContents();
            }
            return(changed);
        }
        private bool DrawTableHeader()
        {
            bool changed = false;

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Size", GUILayout.Width(WIDTH + 10));
            int col = grid.columnCount;

            for (int c = 0; c < col; c++)
            {
                EditorGUILayout.LabelField(c.ToString(), EditorStyles.boldLabel, GUILayout.Width(30));
                changed |= EditorGUILayoutUtil.IntField(null, ref grid.columnWidth[c], GUILayout.Width(WIDTH - 30));
            }
            if (grid.isHorizontal)
            {
                EditorGUILayout.LabelField("", GUILayout.Width(42));
            }
            EditorGUILayout.EndHorizontal();
            return(changed);
        }
Exemplo n.º 20
0
 public override void OnHeaderGUI()
 {
     EditorGUILayoutUtil.ObjectField <LexiconRegistry>("Lexicon Registry", ref lexReg, false);
     if (lexReg == null)
     {
         return;
     }
     EditorGUILayoutUtil.PopupEnum <SystemLanguage>("Mother language", ref motherLang);
     EditorGUILayoutUtil.PopupEnum <SystemLanguage>("Language", ref lang);
     fold = EditorGUILayout.Foldout(fold, "Translate All");
     if (fold)
     {
         if (GUILayout.Button("Convert all Scene and prefab") && EditorUtility.DisplayDialog("Confirm", "Convert All?", "OK", "Cancel"))
         {
             Lexicon.SetMotherLanguage(motherLang);
             Lexicon.SetLanguage(lang);
             TranslateLanguage();
         }
     }
     EditorGUILayoutUtil.Toggle("Lock", ref locked);
     if (EditorGUILayoutUtil.Toggle("Visible Only", ref visibleOnly))
     {
         roots = null;
     }
     EditorGUILayout.BeginHorizontal();
     if (GUILayout.Button("Reload Table", GUILayout.Height(30)))
     {
         ReloadTable();
         ApplyTableToText();
     }
     if (GUILayout.Button("Apply table to text", GUILayout.Height(30)))
     {
         ApplyTableToText();
     }
     if (GUILayout.Button("Revert", GUILayout.Height(30)))
     {
         Clear();
     }
     EditorGUILayout.EndHorizontal();
     DrawFindLexiconGUI();
 }
Exemplo n.º 21
0
        public override void OnInspectorGUI()
        {
            if (inspector.OnInspectorGUI())
            {
                rq.Optimize();
            }
            showZ = EditorGUILayout.BeginToggleGroup("Z Transform", showZ);
            if (showZ)
            {
                EditorGUI.indentLevel += 2;
                EditorGUILayoutUtil.FloatField("Z Base", ref rq.zBase);
                EditorGUILayoutUtil.FloatField("Z Scale", ref rq.zScale);
                EditorGUI.indentLevel -= 2;
            }
            EditorGUILayout.EndToggleGroup();
            Dictionary <string, bool> nameSet = new Dictionary <string, bool>();
            Dictionary <int, bool>    rqSet   = new Dictionary <int, bool>();

            foreach (RenderQueueElement e in rq.row)
            {
                if (string.IsNullOrEmpty(e.name))
                {
                    continue;
                }
                if (nameSet.ContainsKey(e.name))
                {
                    EditorGUILayout.HelpBox("Duplicate " + e.name, MessageType.Error);
                    break;
                }
                else if (rqSet.ContainsKey(e.value))
                {
                    EditorGUILayout.HelpBox("Duplicate " + e.value, MessageType.Error);
                    break;
                }
                nameSet.Add(e.name, true);
                rqSet.Add(e.value, true);
            }
        }
        protected override bool OnInspectorGUI(UITab tab, int i)
        {
            bool changed = base.OnInspectorGUI(tab, i);

            if (tab != null && selectTab)
            {
                bool visible = tab.IsVisible();
                if (EditorGUILayoutUtil.Toggle(null, ref visible, GUILayout.Width(30)))
                {
                    changed = true;
                    for (int j = 0; j < Length; ++j)
                    {
                        UITab t = this[j] as UITab;
                        if (tab != t)
                        {
                            t.uiRoot.SetActive(false);
                        }
                        EditorUtil.SetDirty(t.gameObject);
                    }
                    tab.uiRoot.SetActive(true);
                }
            }
            return(changed);
        }
Exemplo n.º 23
0
 public override void OnFooterGUI()
 {
     if (atlasFrom != null && atlasTo != null)
     {
         if (duplicateSprites.Count > 0)
         {
             if (GUILayout.Button(atlasFrom.name + " -> " + atlasTo.name))
             {
                 SwitchAtlas();
             }
         }
         NGUIEditorTools.DrawSeparator();
         EditorGUILayout.BeginHorizontal();
         EditorGUILayout.BeginVertical();
         EditorGUILayoutUtil.Popup <string>("Sprite From", ref spriteName1, atlasFrom.GetListOfSprites().ToArray());
         EditorGUILayoutUtil.Popup <string>("Sprite To", ref spriteName2, atlasTo.GetListOfSprites().ToArray());
         EditorGUILayout.EndVertical();
         if (GUILayout.Button("Replace", GUILayout.ExpandWidth(false), GUILayout.Height(30)))
         {
             SwitchSprite(spriteName1, spriteName2);
         }
         EditorGUILayout.EndHorizontal();
     }
 }
        private void DrawNodeInspector(Node node, NodeViewData nodeViewData)
        {
            nodeViewData.name = EditorGUILayout.TextField(nodeViewData.name);

            // Node Delegate Button + Fields
            EditorGUILayout.BeginVertical((GUIStyle)"InspectorBigBox");
            EditorGUILayout.LabelField("Node Delegates:");
            foreach (INodeDelegate nodeDelegate in node.GetNodeDelegates())
            {
                Type nodeDelegateType = nodeDelegate.GetType();
                EditorGUILayout.BeginVertical((GUIStyle)"InspectorBox");
                EditorGUILayout.LabelField(nodeDelegateType.Name, EditorStyles.boldLabel);

                FieldInfo[] fields = TypeUtil.GetInspectorFields(nodeDelegateType);
                foreach (FieldInfo field in fields)
                {
                    EditorGUILayoutUtil.DynamicField(field, nodeDelegate);
                }
                EditorGUILayout.EndVertical();
                EditorGUILayout.Space();
            }

            if (GUILayout.Button("", (GUIStyle)"AddButton", GUILayout.Width(20.0f), GUILayout.Height(20.0f)))
            {
                GenericMenu nodeDelegateMenu = new GenericMenu();
                foreach (Type nodeDelegateType in INodeDelegateUtil.ImplementationTypes)
                {
                    nodeDelegateMenu.AddItem(new GUIContent(nodeDelegateType.Name), false, this.AddNodeDelegateToNode, Tuple.Create(node, nodeDelegateType));
                }
                nodeDelegateMenu.ShowAsContext();
            }
            EditorGUILayout.EndVertical();

            EditorGUILayout.Space();

            // Node Transitions
            EditorGUILayout.BeginVertical((GUIStyle)"InspectorBigBox");
            EditorGUILayout.LabelField("Transitions:");
            IList <NodeTransition> nodeTransitions = this.TargetGraph.GetOutgoingTransitionsForNode(node);

            foreach (NodeTransition nodeTransition in nodeTransitions)
            {
                GUIStyle transitionStyle = this.IsNodeTransitionSelected(nodeTransition) ? (GUIStyle)"SelectedInspectorBox" : (GUIStyle)"InspectorBox";
                Rect     transitionRect  = EditorGUILayout.BeginVertical(transitionStyle, GUILayout.MinHeight(30.0f));
                string   targetText      = "";
                targetText += (nodeTransition.targets.Length > 1) ? "Targets: " : "Target: ";
                targetText += StringUtil.Join(", ", nodeTransition.targets.Select(id => this.GetViewDataForNode(this.TargetGraph.LoadNodeById(id)).name));

                EditorGUILayout.LabelField(targetText, GUILayout.Height(30.0f));

                Rect editButtonRect = new Rect(new Vector2(transitionRect.x + transitionRect.width - 25.0f,
                                                           transitionRect.y + 5.0f),
                                               new Vector2(20.0f, 20.0f));
                if (GUI.Button(editButtonRect, "", (GUIStyle)"EditButton"))
                {
                    this.StartEditingNodeTransition(node, nodeTransition);
                }

                Rect removeButtonRect = new Rect(new Vector2(transitionRect.x + transitionRect.width - 50.0f,
                                                             transitionRect.y + 5.0f),
                                                 new Vector2(20.0f, 20.0f));
                if (GUI.Button(removeButtonRect, "", (GUIStyle)"RemoveButton"))
                {
                    this.AddPendingNodeTransitionRemoval(node, nodeTransition);
                }

                EditorGUILayout.LabelField("Conditions: ");
                Transition transition = nodeTransition.transition;
                transition.WaitForManualExit = EditorGUILayout.Toggle("WaitForManualExit: ", transition.WaitForManualExit);
                foreach (ITransitionCondition transitionCondition in transition.GetTransitionConditions())
                {
                    EditorGUILayout.BeginVertical(transitionStyle);
                    Type transitionConditionType = transitionCondition.GetType();
                    EditorGUILayout.LabelField(transitionConditionType.Name, EditorStyles.boldLabel);

                    FieldInfo[] fields = TypeUtil.GetInspectorFields(transitionConditionType);
                    foreach (FieldInfo field in fields)
                    {
                        EditorGUILayoutUtil.DynamicField(field, transitionCondition);
                    }
                    EditorGUILayout.EndVertical();
                    EditorGUILayout.Space();
                }

                if (GUILayout.Button("", (GUIStyle)"AddButton", GUILayout.Width(20.0f), GUILayout.Height(20.0f)))
                {
                    GenericMenu nodeDelegateMenu = new GenericMenu();
                    foreach (Type transitionConditionType in TypeUtil <ITransitionCondition> .ImplementationTypes)
                    {
                        nodeDelegateMenu.AddItem(new GUIContent(transitionConditionType.Name), false, this.AddTransitionCondition, Tuple.Create(nodeTransition, transitionConditionType));
                    }
                    nodeDelegateMenu.ShowAsContext();
                }
                EditorGUILayout.EndVertical();
                EditorGUILayout.Space();
            }

            if (GUILayout.Button("", (GUIStyle)"AddButton", GUILayout.Width(20.0f), GUILayout.Height(20.0f)))
            {
                this.MakeTransition(node);
            }
            EditorGUILayout.EndVertical();
            EditorGUILayout.Space();
        }
Exemplo n.º 25
0
        public override void OnInspectorGUI()
        {
            if (EditorUI.DrawHeader("Sprite -> Texture"))
            {
                EditorUI.BeginContents();
                EditorGUILayout.BeginHorizontal();
                EditorGUILayoutUtil.ObjectField <Object>("Folder", ref texFolder, false);
                if (GUILayout.Button("Sprite -> Texture") && EditorUtility.DisplayDialog("Warning", "BackUp?", "OK", "Cancel"))
                {
                    ConvertToTexture(texFolder);
                }
                EditorGUILayout.EndHorizontal();
                var drawer = new ListDrawer <UITexture>(texList, new ObjListItemDrawer <UITexture>());
                drawer.Draw();
                EditorUI.EndContents();
            }
            if (EditorUI.DrawHeader("Texture -> Sprite"))
            {
                EditorUI.BeginContents();
                EditorGUILayout.BeginHorizontal();
                ComponentSelector.Draw <NGUIAtlas>("Atlas", atlasToAdd, OnSelectAtlas, true, GUILayout.MinWidth(80f));
                if (GUILayout.Button("Add Selected"))
                {
                    foreach (Object o in Selection.objects)
                    {
                        if (o is GameObject)
                        {
                            OnSelectAtlas((o as GameObject).GetComponent <NGUIAtlas>());
                        }
                    }
                }
                EditorGUILayout.EndHorizontal();
                EditorGUILayoutUtil.TextField("Search sprite", ref searchSpriteName);
                if (!searchSpriteName.IsEmpty())
                {
                    List <NGUIAtlas> filtered = new List <NGUIAtlas>();
                    foreach (NGUIAtlas a in atlasRefs)
                    {
                        if (a.GetSprite(searchSpriteName) != null)
                        {
                            filtered.Add(a);
                        }
                    }
                    var drawer = new ListDrawer <NGUIAtlas>(filtered, new ObjListItemDrawer <NGUIAtlas>());
                    drawer.Draw();
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayoutUtil.Popup("Change to", ref changeAtlas, filtered);
                    if (GUILayout.Button("Apply"))
                    {
                        EditorTraversal.ForEachAsset <GameObject>(FileType.Prefab, (path, prefab) => {
                            ChangeAtlas(prefab, filtered, changeAtlas);
                        });
                        EditorTraversal.ForEachScene(s => {
                            foreach (var r in s.GetRootGameObjects())
                            {
                                ChangeAtlas(r.gameObject, filtered, changeAtlas);
                            }
                            return(null);
                        });
                    }
                    EditorGUILayout.EndHorizontal();
                    var spriteDrawer = new ListDrawer <UISprite>(spriteList, new ObjListItemDrawer <UISprite>());
                    spriteDrawer.Draw();
                }
                else
                {
                    var drawer = new ListDrawer <NGUIAtlas>(atlasRefs, new ObjListItemDrawer <NGUIAtlas>());
                    if (drawer.Draw())
                    {
                        SaveAtlasRefs();
                    }
                }
                if (!dupSprites.IsEmpty())
                {
                    if (EditorUI.DrawHeader("Duplicate sprites"))
                    {
                        EditorUI.BeginContents();
                        float cellWidth = 200f;
                        float width     = GetWidth();
                        int   column    = Mathf.Max((int)(width / cellWidth), 1);
                        int   i         = 0;
                        foreach (string d in dupSprites)
                        {
                            if (i == 0)
                            {
                                EditorGUILayout.BeginHorizontal();
                            }
                            if (GUILayout.Button(d, GUILayout.Width(200)))
                            {
                                searchSpriteName = d;
                            }
                            i = i + 1;
                            if (i == column)
                            {
                                EditorGUILayout.EndHorizontal();
                                i = 0;
                            }
                        }
                        if (i != 0)
                        {
                            EditorGUILayout.EndHorizontal();
                        }
                        EditorUI.EndContents();
                    }
                }
                EditorGUILayout.BeginHorizontal();
                EditorGUILayoutUtil.ObjectField("Target", ref targetObj, true);
                GUI.enabled = targetObj != null;
                if (GUILayout.Button("Convert to Sprite") && EditorUtility.DisplayDialog("Warning", "BackUp?", "OK"))
                {
                    ConvertToSprite();
                }
                if (GUILayout.Button("Set TexSetter"))
                {
                    foreach (UITexture tex in targetObj.GetComponentsInChildren <UITexture>(true))
                    {
                        TexSetterInspector.SetIfCdn(tex);
                    }
                }
                GUI.enabled = true;
                EditorGUILayout.EndHorizontal();
                // collect atlas
                GUI.enabled = targetObj != null;
                if (EditorUI.DrawHeader("Member Atlases"))
                {
                    EditorUI.BeginContents();
                    if (targetObj != null)
                    {
                        MultiMap <NGUIAtlas, UISprite> collect = new MultiMap <NGUIAtlas, UISprite>();
                        foreach (UISprite s in targetObj.GetComponentsInChildren <UISprite>(true))
                        {
                            collect.Add(s.atlas as NGUIAtlas, s);
                        }
                        foreach (KeyValuePair <NGUIAtlas, List <UISprite> > pair in collect)
                        {
                            if (EditorGUILayout.Foldout(folding.Contains(pair.Key), pair.Key.name()))
                            {
                                folding.Add(pair.Key);
                                EditorGUI.indentLevel++;
                                foreach (UISprite s in pair.Value)
                                {
                                    EditorGUILayout.ObjectField(s.gameObject, typeof(GameObject), true);
                                }
                                EditorGUI.indentLevel--;
                            }
                            else
                            {
                                folding.Remove(pair.Key);
                            }
                        }
                    }
                    EditorUI.EndContents();
                }
                if (EditorUI.DrawHeader("Orphan Texture"))
                {
                    EditorUI.BeginContents();
                    if (targetObj != null)
                    {
                        foreach (UITexture tex in targetObj.GetComponentsInChildren <UITexture>(true))
                        {
                            if (tex.GetComponent <TexLoader>() == null)
                            {
                                EditorGUILayout.BeginHorizontal();
                                EditorGUILayout.ObjectField(tex.gameObject, typeof(GameObject), true);
                                EditorGUILayout.ObjectField(tex.mainTexture, typeof(Texture), false);
                                EditorGUILayout.EndHorizontal();
                            }
                        }
                    }
                    EditorUI.EndContents();
                }
                GUI.enabled = true;

                EditorUI.EndContents();
            }
            if (EditorUI.DrawHeader("Find All Sprites"))
            {
                EditorUI.BeginContents();
                EditorGUILayout.BeginHorizontal();
                ComponentSelector.Draw <NGUIAtlas>("Atlas", atlas4Sprite, OnSelectAtlasForSprite, true, GUILayout.MinWidth(80f));
                if (GUILayout.Button("Find"))
                {
                    var list = Resources.FindObjectsOfTypeAll <UISprite>().ToList(i => i as UISprite);
                    s4a.Clear();
                    foreach (var s in list)
                    {
                        if (s.atlas == atlas4Sprite)
                        {
                            s4a.Add(s);
                        }
                    }
                }
                EditorGUILayout.EndHorizontal();
                EditorUI.EndContents();
            }
            GUI.enabled = true;
        }
Exemplo n.º 26
0
        public override void OnHeaderGUI()
        {
            Validate();
            EditorGUILayout.BeginHorizontal();
            if (EditorGUILayoutUtil.ObjectField <GameObject>("Root", ref root, true))
            {
                Refresh();
            }
            GUI.enabled = root != null;
            if (GUILayout.Button("Refresh", GUILayout.ExpandWidth(false)))
            {
                Refresh();
            }
            GUI.enabled = true;
            EditorGUILayout.EndHorizontal();
            UIPanel[] panels = root != null?root.GetComponentsInChildren <UIPanel>(true) : new UIPanel[0];

            EditorGUILayout.BeginHorizontal();
            if (EditorGUILayoutUtil.PopupNullable("Panel", ref panelSel, panels, ObjToString.DefaultToString))
            {
                Refresh();
                if (panelSel != null)
                {
                    EditorGUIUtility.PingObject(panelSel);
                    Selection.activeGameObject = panelSel.gameObject;
                }
            }
            EditorGUILayoutUtil.Toggle("Show Active Only", ref showActiveOnly);
            EditorGUILayout.EndHorizontal();
            INGUIAtlas[] atlases = GetAtlases(widgets);
            INGUIFont[]  fonts   = GetFonts(widgets);
            if (EditorGUILayoutUtil.PopupNullable("Select Atlas", ref atlasSel, atlases, ObjToString.DefaultToString))
            {
                if (atlasSel != null)
                {
                    fontSel = null;
                }
            }
            if (EditorGUILayoutUtil.PopupNullable("Select Font", ref fontSel, fonts, ObjToString.DefaultToString))
            {
                if (fontSel != null)
                {
                    atlasSel = null;
                }
            }
            EditorGUILayout.BeginHorizontal();
            int index = Array.FindIndex(widgets, w => w.gameObject == Selection.activeGameObject);

            GUI.enabled = index >= 0;
            if (GUI.enabled)
            {
                if (GUILayout.Button("+1 over selection"))
                {
                    for (int i = 0; i <= index; ++i)
                    {
                        widgets[i].depth = widgets[i].depth + 1;
                        EditorUtil.SetDirty(widgets[i]);
                    }
                }
                if (GUILayout.Button("-1 under selection"))
                {
                    for (int i = index; i < widgets.Length; ++i)
                    {
                        widgets[i].depth = widgets[i].depth - 1;
                        EditorUtil.SetDirty(widgets[i]);
                    }
                }
                // TODOM key handling
                var e = Event.current;
                if (e.type == EventType.KeyUp)
                {
                    if (e.keyCode == KeyCode.UpArrow)
                    {
                        index--;
                        if (index >= 0)
                        {
                            Select(widgets[index]);
                        }
                    }
                    else if (e.keyCode == KeyCode.DownArrow)
                    {
                        index++;
                        if (index < widgets.Length)
                        {
                            Select(widgets[index]);
                        }
                    }
                }
            }
            GUI.enabled = true;
            EditorGUILayout.EndHorizontal();
        }
Exemplo n.º 27
0
        public override void OnInspectorGUI()
        {
            object current = null;

            Color contentColor = GUI.contentColor;
            Color bgColor      = GUI.backgroundColor;
            Color c1           = BG_COLOR1;
            Color c2           = BG_COLOR1;

            foreach (UIWidget w in widgets)
            {
                if (w.GetType() == typeof(UIWidget) || w.gameObject == null)
                {
                    continue;
                }
                UISprite  s     = w as UISprite;
                UILabel   l     = w as UILabel;
                UITexture t     = w as UITexture;
                int       depth = w.depth;

                #pragma warning disable 0253
                bool toggle = false;
                if (s != null)
                {
                    if (s.atlas == null)
                    {
                        continue;
                    }
                    if (s.atlas != current)
                    {
                        current = s.atlas;
                        toggle  = true;
                    }
                }
                else if (l != null)
                {
                    if (l.bitmapFont != current)
                    {
                        current = l.bitmapFont;
                        toggle  = true;
                    }
                }
                else if (t != null)
                {
                    if (t.mainTexture != current)
                    {
                        current = t.mainTexture;
                        toggle  = true;
                    }
                }
                else
                {
                    toggle  = true;
                    current = null;
                }
                #pragma warning restore 0253
                if (toggle)
                {
                    c2 = c2 != BG_COLOR1? BG_COLOR1: BG_COLOR2;
                }
                c1 = c2;

                if (atlasSel != null)
                {
                    c1 = s != null && s.atlas == atlasSel? SEL_BG_COLOR: BG_COLOR1;
                }
                else if (fontSel != null)
                {
                    c1 = l != null && l.bitmapFont == fontSel? SEL_BG_COLOR: BG_COLOR1;
                }
                if (w.gameObject == Selection.activeGameObject)
                {
                    c1 = SEL_BG_COLOR;
                }
                GUI.backgroundColor = c1;
                if (c1 == BG_COLOR1)
                {
                    GUI.contentColor = TXT_COLOR1;
                }
                else if (c1 == BG_COLOR2)
                {
                    GUI.contentColor = TXT_COLOR2;
                }
                else if (c1 == SEL_BG_COLOR)
                {
                    GUI.contentColor = SEL_TXT_COLOR;
                }

                EditorGUILayout.BeginHorizontal();
                string widgetName = w.name;
                if (s != null)
                {
                    if (s.atlas != null)
                    {
                        widgetName = string.Format("[ATLAS {0}] {2} ({1})", s.atlas.ToString(), s.spriteName, w.name);
                    }
                }
                else if (l != null)
                {
                    if (l.trueTypeFont != null)
                    {
                        widgetName = string.Format("[TTF {0}] {1}", l.trueTypeFont.name, w.name);
                    }
                    else if (l.bitmapFont != null)
                    {
                        widgetName = string.Format("[BMF {0}] {1}", l.bitmapFont.ToString(), w.name);
                    }
                    else
                    {
                        widgetName = string.Format("FNT {0}", w.name);
                    }
                }
                else if (t != null)
                {
                    if (t.mainTexture != null)
                    {
                        widgetName = string.Format("[TEX {0}] {1}", t.mainTexture.name, t.name);
                    }
                    else
                    {
                        widgetName = string.Format("TEX {0}", t.name);
                    }
                }
                bool active = w.gameObject.activeInHierarchy;
                if (active || !showActiveOnly)
                {
                    Color fgColor = Color.white;
                    if (!active)
                    {
                        fgColor = INACTIVE_TXT_COLOR;
                    }
                    GUI.contentColor = fgColor;
                    if (GUILayout.Button(widgetName, EditorStyles.objectField))
                    {
                        Select(w);
                    }
                    if (EditorGUILayoutUtil.IntField(null, ref depth, GUILayout.Width(40)))
                    {
                        w.depth = depth;
                        EditorUtil.SetDirty(w);
                    }
                }
                EditorGUILayout.EndHorizontal();
            }

            GUI.backgroundColor = bgColor;
            GUI.contentColor    = contentColor;
        }
Exemplo n.º 28
0
        private void DrawTextList()
        {
            EditorGUILayoutUtil.DrawSeparator();

            if (!locked && !Selection.gameObjects.IsEmpty() && (roots == null || !Enumerable.SequenceEqual(roots, Selection.gameObjects)))
            {
                Clear();
                // search labels
                roots = Selection.gameObjects;
                foreach (GameObject o in roots)
                {
                    tabs.Clear();
                    foreach (UITabHandler t in o.GetComponentsInChildren <UITabHandler>(true))
                    {
                        tabs.Add(new UITabHandlerInspectorImpl(t));
                    }
                }
                foreach (GameObject o in roots)
                {
                    // remove number labels
                    HashSet <UIText> ignore = new HashSet <UIText>();

                    foreach (DropDown dropdown in o.GetComponentsInChildren <DropDown>(true))
                    {
                        foreach (UIText l in dropdown.GetComponentsInChildren <UIText>(true))
                        {
                            ignore.Add(l);
                        }
                    }

                    foreach (UIText l in o.GetComponentsInChildren <UIText>(true))
                    {
                        if (l.text.IsEmpty())
                        {
                            continue;
                        }
                        if (ignore.Contains(l))
                        {
                            continue;
                        }
                        if (visibleOnly && (!l.gameObject.activeInHierarchy || !l.enabled))
                        {
                            continue;
                        }
                        foreach (char c in l.text)
                        {
                            if (char.IsLetter(c) && !char.IsWhiteSpace(c) && !char.IsPunctuation(c))
                            {
                                labels.Add(l);
                                break;
                            }
                        }
                    }
                }
            }
            foreach (UITabHandlerInspectorImpl inspector in tabs)
            {
                if (inspector.OnInspectorGUI())
                {
                    Save();
                    roots = null;
                }
            }

            // draw trigger list
            EditorGUILayout.BeginVertical();
            foreach (UIText l in labels)
            {
                if (!mod.ContainsKey(l))
                {
                    FindKey(l);
                }
                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.ObjectField(l, typeof(UIText), true);
                Color  oldColor = GUI.backgroundColor;
                string srcKey   = mod.Get(l);
                if (srcKey == null)
                {
                    srcKey = l.textKey;
                }
                if (!Lexicon.ContainsKey(srcKey))
                {
                    GUI.backgroundColor = Color.red;
                }
                string dstKey = EditorGUILayout.TextField(srcKey);
                GUI.backgroundColor = oldColor;
                string text = EditorGUILayout.TextField(l.text);
                if (srcKey != dstKey)
                {
                    mod[l] = dstKey;
                }
                if (text != l.text)
                {
                    l.SetText(text);
                    EditorUtil.SetDirty(l);
                }
                EditorGUILayout.EndHorizontal();
            }
            EditorGUILayout.EndVertical();

            if (GUILayout.Button("Save"))
            {
                Save();
            }
        }
Exemplo n.º 29
0
        private bool DrawTest()
        {
            showTest = EditorGUILayout.Foldout(showTest, "Test");
            bool changed = false;

            if (showTest)
            {
                EditorGUI.indentLevel += 2;
                EditorGUILayoutUtil.ObjectField <UIFont>("Font", ref testFont, true);
                int row = grid.rowCount;
                int col = grid.columnCount;
                if (EditorGUILayoutUtil.IntField("Font Size", ref fontSize, GUILayout.ExpandWidth(false)))
                {
                    for (int r = 0; r < row; r++)
                    {
                        for (int c = 0; c < col; c++)
                        {
                            UILabel label = grid.GetCell(r, c).GetComponent <UILabel>();
                            if (label != null)
                            {
                                label.transform.localScale = new Vector3(fontSize, fontSize, 1);
                            }
                        }
                    }
                }
                if (EditorGUILayoutUtil.ColorField("Font Color", ref fontColor, GUILayout.ExpandWidth(false)))
                {
                    for (int r = grid.rowHeader; r < row; r++)
                    {
                        for (int c = grid.columnHeader; c < col; c++)
                        {
                            UILabel label = grid.GetCell(r, c).GetComponent <UILabel>();
                            if (label != null)
                            {
                                label.color = fontColor;
                                label.MarkAsChanged();
                            }
                        }
                    }
                }
                Array.Resize(ref testStrings, grid.maxPerLine);
                for (int i = 0; i < grid.maxPerLine; i++)
                {
                    EditorGUILayoutUtil.TextField(i.ToString(), ref testStrings[i], GUILayout.ExpandWidth(false));
                }
                GUI.enabled = testFont != null;
                if (GUILayout.Button("Fill Data"))
                {
                    for (int r = grid.rowHeader; r < row; r++)
                    {
                        for (int c = grid.columnHeader; c < col; c++)
                        {
                            UITableCell cell = grid.GetCell(r, c);
                            if (cell == null)
                            {
                                UILabel label = NGUITools.AddWidget <UILabel>(grid.gameObject);
                                label.bitmapFont = testFont;
                                label.name       = "__TEST__";
                                label.SetText(testStrings[grid.isHorizontal?c:r]);
                                label.transform.localScale = new Vector3(fontSize, fontSize, 1);
                                label.color = fontColor;
                                label.MarkAsChanged();
                                UILabelCell lc = label.gameObject.AddComponent <UILabelCell>();
                                lc.label = label;
                                grid.SetCell(r, c, lc);
                            }
                        }
                    }
                    changed = true;
                }
                GUI.enabled            = true;
                EditorGUI.indentLevel -= 2;
            }
            return(changed);
        }
Exemplo n.º 30
0
        internal void LayoutGUI()
        {
            var centeredStyle = new GUIStyle(GUI.skin.GetStyle("Label"));

            centeredStyle.alignment = TextAnchor.UpperCenter;
            GUILayout.Label(new GUIContent("Bundle Pack Config"), centeredStyle);

            EditorGUILayout.Space();

            EditorGUILayout.BeginVertical();
            {
                m_PackConfig.OutputDirPath = EditorGUILayoutUtil.DrawDiskFolderSelection("Bundle Output", m_PackConfig.OutputDirPath);
                if (string.IsNullOrEmpty(m_PackConfig.OutputDirPath))
                {
                    m_PackConfig.OutputDirPath = GetDefaultOutputDir();
                }
                m_PackConfig.BuildTarget = (ValidBuildTarget)EditorGUILayout.EnumPopup(m_TargetContent, m_PackConfig.BuildTarget);

                m_AdvancedSettings = EditorGUILayout.Foldout(m_AdvancedSettings, "Advanced Settings");
                if (m_AdvancedSettings)
                {
                    EditorGUIUtil.BeginIndent();
                    {
                        m_PackConfig.CleanupBeforeBuild = EditorGUILayout.Toggle(m_CleanBeforeBuildContent, m_PackConfig.CleanupBeforeBuild);
                        m_PackConfig.Compression        = (CompressOptions)EditorGUILayout.IntPopup(m_CompressionContent, (int)m_PackConfig.Compression, m_CompressionContents, m_CompressionValues);

                        EditorGUILayout.Space();

                        EditorGUI.BeginChangeCheck();
                        {
                            m_IsForceRebuild = EditorGUILayout.Toggle(m_ForceRebuildContent, m_IsForceRebuild);
                            m_IsAppendHash   = EditorGUILayout.Toggle(m_AppendHashContent, m_IsAppendHash);
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            if (m_IsForceRebuild)
                            {
                                m_PackConfig.BundleOptions |= BuildAssetBundleOptions.ForceRebuildAssetBundle;
                            }
                            else
                            {
                                m_PackConfig.BundleOptions &= ~BuildAssetBundleOptions.ForceRebuildAssetBundle;
                            }
                            if (m_IsAppendHash)
                            {
                                m_PackConfig.BundleOptions |= BuildAssetBundleOptions.AppendHashToAssetBundleName;
                            }
                            else
                            {
                                m_PackConfig.BundleOptions &= ~BuildAssetBundleOptions.AppendHashToAssetBundleName;
                            }
                        }
                    }
                    EditorGUIUtil.EndIndent();
                }

                EditorGUILayout.Space();
                if (GUILayout.Button("Pack Bundle"))
                {
                    EditorApplication.delayCall += () =>
                    {
                        BundlePackUtil.PackAssetBundle(m_PackConfig);
                    };
                }
            }
            EditorGUILayout.EndVertical();


            if (GUI.changed)
            {
                Util.FileUtil.SaveToBinary <BundlePackConfig>(BundlePackUtil.GetPackConfigPath(), m_PackConfig);
            }
        }