AssetBundleGraph.NodeGUI.ShowFilterKeyTypeMenu C# (CSharp) Method

        public static void ShowFilterKeyTypeMenu(string current, Action<string> Selected)
        {
            var menu = new GenericMenu();

            menu.AddDisabledItem(new GUIContent(current));

            menu.AddSeparator(string.Empty);

            for (var i = 0; i < TypeUtility.KeyTypes.Count; i++) {
                var type = TypeUtility.KeyTypes[i];
                if (type == current) continue;

                menu.AddItem(
                    new GUIContent(type),
                    false,
                    () => {
                        Selected(type);
                    }
                );
            }
            menu.ShowAsContext();
        }

        private void DoInspectorFilterGUI(NodeGUI node)
        {
            EditorGUILayout.HelpBox("Filter: Filter incoming assets by keywords and types. You can use regular expressions for keyword field.", MessageType.Info);
            UpdateNodeName(node);

            using (new EditorGUILayout.VerticalScope(GUI.skin.box)) {
                GUILayout.Label("Filter Settings:");
                for (int i = 0; i < node.filterContainsKeywords.Count; i++)
                {
                    Action messageAction = null;

                    using (new GUILayout.HorizontalScope()) {
                        if (GUILayout.Button("-", GUILayout.Width(30)))
                        {
                            node.BeforeSave();
                            node.filterContainsKeywords.RemoveAt(i);
                            node.filterContainsKeytypes.RemoveAt(i);
                            node.DeleteFilterOutputPoint(i);
                        }
                        else
                        {
                            var newContainsKeyword = node.filterContainsKeywords[i];

                            /*
                             *                                      generate keyword + keytype string for compare exists setting vs new modifying setting at once.
                             */
                            var currentKeywordsSource = new List <string>(node.filterContainsKeywords);
                            var currentKeytypesSource = new List <string>(node.filterContainsKeytypes);

                            var currentKeytype = currentKeytypesSource[i];

                            for (var j = 0; j < currentKeywordsSource.Count; j++)
                            {
                                currentKeywordsSource[j] = currentKeywordsSource[j] + currentKeytypesSource[j];
                            }

                            // remove current choosing one from compare target.
                            currentKeywordsSource.RemoveAt(i);
                            var currentKeywords = new List <string>(currentKeywordsSource);

                            GUIStyle s = new GUIStyle((GUIStyle)"TextFieldDropDownText");

                            IntegratedGUIFilter.ValidateFilter(
                                newContainsKeyword + currentKeytype,
                                currentKeywords,
                                () => {
                                s.fontStyle = FontStyle.Bold;
                                s.fontSize  = 12;
                            },
                                () => {
                                s.fontStyle = FontStyle.Bold;
                                s.fontSize  = 12;
                            }
                                );

                            using (new EditorGUILayout.HorizontalScope()) {
                                newContainsKeyword = EditorGUILayout.TextField(node.filterContainsKeywords[i], s, GUILayout.Width(120));
                                var currentIndex = i;
                                if (GUILayout.Button(node.filterContainsKeytypes[i], "Popup"))
                                {
                                    NodeGUI.ShowFilterKeyTypeMenu(
                                        node.filterContainsKeytypes[currentIndex],
                                        (string selectedTypeStr) => {
                                        node.BeforeSave();
                                        node.filterContainsKeytypes[currentIndex] = selectedTypeStr;
                                        node.Save();
                                    }
                                        );
                                }
                            }

                            if (newContainsKeyword != node.filterContainsKeywords[i])
                            {
                                node.BeforeSave();
                                node.filterContainsKeywords[i] = newContainsKeyword;
                                node.RenameFilterOutputPointLabel(i, node.filterContainsKeywords[i]);
                            }
                        }
                    }

                    if (messageAction != null)
                    {
                        using (new GUILayout.HorizontalScope()) {
                            messageAction.Invoke();
                        }
                    }
                }

                // add contains keyword interface.
                if (GUILayout.Button("+"))
                {
                    node.BeforeSave();
                    var addingIndex = node.filterContainsKeywords.Count;
                    var newKeyword  = AssetBundleGraphSettings.DEFAULT_FILTER_KEYWORD;

                    node.filterContainsKeywords.Add(newKeyword);
                    node.filterContainsKeytypes.Add(AssetBundleGraphSettings.DEFAULT_FILTER_KEYTYPE);

                    node.AddFilterOutputPoint(addingIndex, AssetBundleGraphSettings.DEFAULT_FILTER_KEYWORD);
                }
            }
        }