Ejemplo n.º 1
0
        public void Display(ItemData data, int index)
        {
            try
            {
                if (data == null)
                {
                    Debugging.Message("Data null");
                }

                if (component == null || data?.name == null)
                {
                    return;
                }

                currentData = data;

                component.Unfocus();
                component.name = data.name;
                component.gameObject.GetComponent <TutorialUITag>().tutorialTag = data.name;

                PrefabInfo prefab = data.asset.prefab;
                if (prefab == null)
                {
                    Debugging.Message("Couldn't display item. Prefab is null");
                    return;
                }

                ImageUtils.FixThumbnails(prefab, null, data.asset);

                component.atlas             = prefab.m_Atlas;
                component.verticalAlignment = UIVerticalAlignment.Middle;

                component.normalFgSprite   = prefab.m_Thumbnail;
                component.hoveredFgSprite  = prefab.m_Thumbnail + "Hovered";
                component.pressedFgSprite  = prefab.m_Thumbnail + "Pressed";
                component.disabledFgSprite = prefab.m_Thumbnail + "Disabled";
                component.focusedFgSprite  = null;

                bool rico = false;

                if (FindIt.isRicoEnabled)
                {
                    string name = Asset.GetName(prefab);
                    if (AssetTagList.instance.assets.ContainsKey(name))
                    {
                        rico = AssetTagList.instance.assets[name].assetType == Asset.AssetType.Rico;
                    }
                }

                component.isEnabled      = rico || Settings.unlockAll || ToolsModifierControl.IsUnlocked(prefab.GetUnlockMilestone());
                component.tooltip        = data.tooltip;
                component.tooltipBox     = data.tooltipBox;
                component.objectUserData = data.asset.prefab;
                component.forceZOrder    = index;

                if (component.containsMouse)
                {
                    component.RefreshTooltip();

                    if (m_tooltipBox != null && m_tooltipBox.isVisible && m_tooltipBox != data.tooltipBox)
                    {
                        m_tooltipBox.Hide();
                        data.tooltipBox.Show(true);
                        data.tooltipBox.opacity          = 1f;
                        data.tooltipBox.relativePosition = m_tooltipBox.relativePosition + new Vector3(0, m_tooltipBox.height - data.tooltipBox.height);
                    }

                    m_tooltipBox = data.tooltipBox;

                    RefreshTooltipAltas(component);
                }

                if (m_tagSprite != null)
                {
                    m_tagSprite.atlas = FindIt.atlas;

                    m_tagSprite.isVisible = currentData.asset != null && AssetTagList.instance.assets.ContainsValue(currentData.asset) && (component.containsMouse || currentData.asset.tagsCustom.Count > 0);
                }


                // batch action check box
                if (m_batchCheckBox != null && data.asset != null && UIFilterTag.instance?.batchAssetSet != null)
                {
                    if (UIFilterTag.instance.batchAssetSet.Contains(data.asset))
                    {
                        m_batchCheckBox.isChecked = true;
                    }
                    else
                    {
                        m_batchCheckBox.isChecked = false;
                    }

                    m_batchCheckBox.isVisible = UISearchBox.instance.tagPanel.isBatchActionsEnabled;
                }
                else if (m_batchCheckBox != null)
                {
                    m_batchCheckBox.isVisible = false;
                }

                if (m_instanceCountLabel != null && data.asset?.prefab != null)
                {
                    if (Settings.showInstancesCounter)
                    {
                        m_instanceCountLabel.isVisible = true;

                        uint count = 0;
                        if (AssetTagList.instance.prefabInstanceCountDictionary.ContainsKey(data.asset.prefab))
                        {
                            count = AssetTagList.instance.prefabInstanceCountDictionary[data.asset.prefab];
                        }

                        if (data.asset.prefab is NetInfo)
                        {
                            m_instanceCountLabel.text = (count == 0) ? Translations.Translate("FIF_UIS_UN") : Translations.Translate("FIF_UIS_IN");
                        }
                        else
                        {
                            if (data.asset.prefab is TreeInfo)
                            {
                                m_instanceCountLabel.text = (count == 0) ? Translations.Translate("FIF_UIS_UN") : count.ToString();
                            }
                            else
                            {
                                if (Settings.includePOinstances && FindIt.isPOEnabled)
                                {
                                    uint poCount = 0;
                                    poCount = ProceduralObjectsTool.GetPrefabPOInstanceCount(data.asset.prefab);
                                    m_instanceCountLabel.text = "";
                                    if (count == 0 && poCount == 0)
                                    {
                                        m_instanceCountLabel.text = Translations.Translate("FIF_UIS_UN");
                                    }
                                    if (count != 0)
                                    {
                                        m_instanceCountLabel.text += (count.ToString());
                                        if (poCount != 0)
                                        {
                                            m_instanceCountLabel.text += (" + ");
                                        }
                                    }
                                    if (poCount != 0)
                                    {
                                        m_instanceCountLabel.text += (poCount.ToString() + " PO");
                                    }
                                }
                                else
                                {
                                    m_instanceCountLabel.text = (count == 0) ? Translations.Translate("FIF_UIS_UN") : count.ToString();
                                }
                            }
                        }
                    }
                    else
                    {
                        m_instanceCountLabel.isVisible = false;
                    }
                }

                if (m_dlcSprite != null)
                {
                    m_dlcSprite.tooltip   = null;
                    m_dlcSprite.isVisible = false;
                    m_dlcSprite.opacity   = 0.8f;

                    if (data.asset != null)
                    {
                        if (FindIt.isNext2Enabled && AssetTagList.instance.next2Assets.Contains(data.asset))
                        {
                            m_dlcSprite.isVisible  = true;
                            m_dlcSprite.spriteName = "UIFilterWorkshopItemsFocusedHovered";
                            m_dlcSprite.tooltip    = "Network Extension 2 Mod";
                        }
                        else if (FindIt.isETSTEnabled && AssetTagList.instance.etstAssets.Contains(data.asset))
                        {
                            m_dlcSprite.isVisible  = true;
                            m_dlcSprite.spriteName = "UIFilterWorkshopItemsFocusedHovered";
                            m_dlcSprite.tooltip    = "Extra Train Station Tracks Mod";
                        }
                        else if (FindIt.isOWTTEnabled && AssetTagList.instance.owttAssets.Contains(data.asset))
                        {
                            m_dlcSprite.isVisible  = true;
                            m_dlcSprite.spriteName = "UIFilterWorkshopItemsFocusedHovered";
                            m_dlcSprite.tooltip    = "One-Way Train Tracks Mod";
                        }
                        else if (!data.asset.prefab.m_isCustomContent)
                        {
                            SetDLCSprite(m_dlcSprite, data.asset.prefab.m_dlcRequired);
                        }
                        else
                        {
                            if (!data.asset.author.IsNullOrWhiteSpace() && (data.asset.steamID != 0))
                            {
                                m_dlcSprite.opacity    = 0.45f;
                                m_dlcSprite.isVisible  = true;
                                m_dlcSprite.spriteName = "UIFilterWorkshopItems";
                                m_dlcSprite.tooltip    = "By " + data.asset.author + "\n" + Translations.Translate("FIF_UIS_WS");
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                if (data != null)
                {
                    Debugging.Message("Display failed : " + data.name);
                }
                else
                {
                    Debugging.Message("Display failed");
                }
                Debugging.LogException(e);
            }
        }
Ejemplo n.º 2
0
        public override void Start()
        {
            instance = this;
            UnityEngine.Random.InitState(System.Environment.TickCount);

            // panel for search input box, type filter and building filters
            inputPanel                  = AddUIComponent <UIPanel>();
            inputPanel.atlas            = SamsamTS.UIUtils.GetAtlas("Ingame");
            inputPanel.backgroundSprite = "GenericTab";
            inputPanel.color            = new Color32(196, 200, 206, 255);
            inputPanel.size             = new Vector2(parent.width, 35);
            inputPanel.relativePosition = new Vector2(0, -inputPanel.height - 40);

            // search input box
            input                  = SamsamTS.UIUtils.CreateTextField(inputPanel);
            input.size             = new Vector2(250, 28);
            input.padding.top      = 6;
            input.relativePosition = new Vector3(5, 4);

            string search = null;

            input.eventTextChanged += (c, p) =>
            {
                search = p;
                // store search query individually for each asset type
                Debugging.Message($"store query for index '{this.typeFilter.selectedIndex}' (cast '{(DropDownOptions)this.typeFilter.selectedIndex}'): \"{p}\"");
                this.storedQueries[(DropDownOptions)this.typeFilter.selectedIndex] = p;
                Search();
            };

            input.eventTextCancelled += (c, p) =>
            {
                if (search != null)
                {
                    input.text = search;
                }
            };

            input.eventKeyDown += (component, eventParam) =>
            {
                if (eventParam.keycode != KeyCode.DownArrow && eventParam.keycode != KeyCode.UpArrow)
                {
                    return;
                }
                if (typeFilter != null)
                {
                    typeFilter.selectedIndex = Mathf.Clamp(typeFilter.selectedIndex + (eventParam.keycode == KeyCode.DownArrow ? 1 : -1), 0, typeFilter.items.Length);
                }
            };

            // search icon
            searchIcon                  = inputPanel.AddUIComponent <UISprite>();
            searchIcon.size             = new Vector2(25, 30);
            searchIcon.atlas            = FindIt.atlas;
            searchIcon.spriteName       = "FindItDisabled";
            searchIcon.relativePosition = new Vector3(5, 4);

            // clear search box
            clearButton                  = inputPanel.AddUIComponent <UISprite>();
            clearButton.size             = new Vector2(26, 26);
            clearButton.atlas            = FindIt.atlas;
            clearButton.spriteName       = "Clear";
            clearButton.tooltip          = Translations.Translate("FIF_SE_SEBTP");
            clearButton.opacity          = 0.5f;
            clearButton.relativePosition = new Vector3(input.relativePosition.x + input.width + 3, 4);
            clearButton.eventClicked    += (c, p) =>
            {
                input.text = "";
                //PickerRandomTest();
            };
            clearButton.eventMouseEnter += (c, p) =>
            {
                clearButton.opacity = 0.9f;
            };

            clearButton.eventMouseLeave += (c, p) =>
            {
                clearButton.opacity = 0.5f;
            };

            // asset type filter. Also Manipulated by the Picker mod through reflection.
            // Need to notify Quboid if a new dropdown item is added, or the item order is changed
            typeFilter                  = SamsamTS.UIUtils.CreateDropDown(inputPanel);
            typeFilter.name             = "FindIt_AssetTypeFilter";
            typeFilter.size             = new Vector2(105, 25);
            typeFilter.tooltip          = Translations.Translate("FIF_POP_SCR");
            typeFilter.relativePosition = new Vector3(clearButton.relativePosition.x + clearButton.width + 7, 5);

            if (FindIt.isRicoEnabled)
            {
                string[] items =
                {
                    Translations.Translate("FIF_SE_IA"),  // All
                    Translations.Translate("FIF_SE_IN"),  // Network
                    Translations.Translate("FIF_SE_IP"),  // Ploppable
                    Translations.Translate("FIF_SE_IG"),  // Growable
                    Translations.Translate("FIF_SE_IR"),  // RICO
                    Translations.Translate("FIF_SE_IGR"), // Growable/RICO
                    Translations.Translate("FIF_SE_IPR"), // Prop
                    Translations.Translate("FIF_SE_ID"),  // Decal
                    Translations.Translate("FIF_SE_IT")   // Tree
                };
                typeFilter.items = items;
            }
            else
            {
                string[] items =
                {
                    Translations.Translate("FIF_SE_IA"),  // All
                    Translations.Translate("FIF_SE_IN"),  // Network
                    Translations.Translate("FIF_SE_IP"),  // Ploppable
                    Translations.Translate("FIF_SE_IG"),  // Growable
                    Translations.Translate("FIF_SE_IPR"), // Prop
                    Translations.Translate("FIF_SE_ID"),  // Decal
                    Translations.Translate("FIF_SE_IT")   // Tree
                };
                typeFilter.items = items;
            }
            typeFilter.selectedIndex = 0;

            typeFilter.eventSelectedIndexChanged += (c, p) =>
            {
                UpdateFilterPanels();

                // restore stored search query individually for each asset type
                // or hold SHIFT when switching asset type to share query keyword temporarily
                Event e = Event.current;
                if (Settings.separateSearchKeyword && !e.shift)
                {
                    if (this.storedQueries.TryGetValue((UISearchBox.DropDownOptions)p, out string storedQuery))
                    {
                        // Debugging.Message($"restore stored query for category {p} (cast: '{(UISearchBox.DropDownOptions)p}': \"{storedQuery}\"");
                        this.input.text = storedQuery;
                    }
                    else
                    {
                        this.input.text = "";
                    }
                }
                Search();
            };

            // workshop filter checkbox (custom assets saved in local asset folder are also included)
            workshopFilter                    = SamsamTS.UIUtils.CreateCheckBox(inputPanel);
            workshopFilter.isChecked          = Settings.useWorkshopFilter;
            workshopFilter.width              = 80;
            workshopFilter.label.text         = Translations.Translate("FIF_SE_WF");
            workshopFilter.label.textScale    = 0.8f;
            workshopFilter.relativePosition   = new Vector3(typeFilter.relativePosition.x + typeFilter.width + 12, 10);
            workshopFilter.eventCheckChanged += (c, i) =>
            {
                Settings.useWorkshopFilter = workshopFilter.isChecked;
                XMLUtils.SaveSettings();
                Search();
            };

            // vanilla filter checkbox
            vanillaFilter                    = SamsamTS.UIUtils.CreateCheckBox(inputPanel);
            vanillaFilter.isChecked          = Settings.useVanillaFilter;
            vanillaFilter.width              = 80;
            vanillaFilter.label.text         = Translations.Translate("FIF_SE_VF");
            vanillaFilter.label.textScale    = 0.8f;
            vanillaFilter.relativePosition   = new Vector3(workshopFilter.relativePosition.x + workshopFilter.width, 10);
            vanillaFilter.eventCheckChanged += (c, i) =>
            {
                Settings.useVanillaFilter = vanillaFilter.isChecked;
                XMLUtils.SaveSettings();
                Search();
            };

            // Refresh Display
            refreshDisplayIcon                  = inputPanel.AddUIComponent <UISprite>();
            refreshDisplayIcon.size             = new Vector2(26, 22);
            refreshDisplayIcon.atlas            = FindIt.atlas;
            refreshDisplayIcon.spriteName       = "Refresh";
            refreshDisplayIcon.tooltip          = Translations.Translate("FIF_REF_DIS");
            refreshDisplayIcon.opacity          = 0.45f;
            refreshDisplayIcon.relativePosition = new Vector3(vanillaFilter.relativePosition.x + vanillaFilter.width + 5, 6.5f);
            refreshDisplayIcon.eventClicked    += (c, p) =>
            {
                AssetTagList.instance.UpdatePrefabInstanceCount(DropDownOptions.All);
                if (FindIt.isPOEnabled && Settings.includePOinstances)
                {
                    ProceduralObjectsTool.UpdatePOInfoList();
                }
                UISearchBox.instance.scrollPanel.Refresh();
            };

            refreshDisplayIcon.eventMouseEnter += (c, p) =>
            {
                refreshDisplayIcon.opacity = 0.9f;
            };

            refreshDisplayIcon.eventMouseLeave += (c, p) =>
            {
                refreshDisplayIcon.opacity = 0.45f;
            };

            // Locate Instance
            LocateNextInstanceTool.Initialize();
            locateInstanceIcon                  = inputPanel.AddUIComponent <UISprite>();
            locateInstanceIcon.size             = new Vector2(26, 23);
            locateInstanceIcon.atlas            = FindIt.atlas;
            locateInstanceIcon.spriteName       = "Locate";
            locateInstanceIcon.tooltip          = Translations.Translate("FIF_LOC_TOOL");
            locateInstanceIcon.opacity          = 0.45f;
            locateInstanceIcon.relativePosition = new Vector3(refreshDisplayIcon.relativePosition.x + refreshDisplayIcon.width + 4, 5.5f);
            locateInstanceIcon.eventClicked    += (c, p) =>
            {
                Event e = Event.current;
                if (e.shift)
                {
                    LocateNextInstanceTool.LocateNextInstance(true); // find PO instance
                }
                else
                {
                    LocateNextInstanceTool.LocateNextInstance(false); // find normal asset instance
                }
            };


            locateInstanceIcon.eventMouseEnter += (c, p) =>
            {
                locateInstanceIcon.opacity = 1.0f;
            };

            locateInstanceIcon.eventMouseLeave += (c, p) =>
            {
                locateInstanceIcon.opacity = 0.45f;
            };

            // change custom tag panel visibility
            tagToolIcon                  = inputPanel.AddUIComponent <UISprite>();
            tagToolIcon.size             = new Vector2(26, 21);
            tagToolIcon.atlas            = FindIt.atlas;
            tagToolIcon.spriteName       = "Tag";
            tagToolIcon.tooltip          = Translations.Translate("FIF_SE_SCTP");
            tagToolIcon.opacity          = 0.5f;
            tagToolIcon.relativePosition = new Vector3(locateInstanceIcon.relativePosition.x + locateInstanceIcon.width + 3.5f, 7);
            tagToolIcon.eventClicked    += (c, p) =>
            {
                if (!tagPanel.isVisible)
                {
                    tagToolIcon.opacity = 1.0f;
                    //CreateCustomTagPanel();
                    tagPanel.isVisible = true;
                }
                else
                {
                    tagToolIcon.opacity = 0.5f;
                    //DestroyCustomTagPanel();
                    tagPanel.isVisible = false;
                    tagPanel.tagDropDownCheckBox.isChecked = false;
                    Search();
                }
                UpdateTopPanelsPosition();
            };

            tagToolIcon.eventMouseEnter += (c, p) =>
            {
                tagToolIcon.opacity = 1.0f;
            };

            tagToolIcon.eventMouseLeave += (c, p) =>
            {
                if (tagPanel.isVisible)
                {
                    tagToolIcon.opacity = 1.0f;
                }
                else
                {
                    tagToolIcon.opacity = 0.5f;
                }
            };

            // change extra filters panel visibility
            extraFiltersIcon                  = inputPanel.AddUIComponent <UISprite>();
            extraFiltersIcon.size             = new Vector2(26, 23);
            extraFiltersIcon.atlas            = FindIt.atlas;
            extraFiltersIcon.spriteName       = "ExtraFilters";
            extraFiltersIcon.tooltip          = Translations.Translate("FIF_SE_EFI");
            extraFiltersIcon.opacity          = 0.5f;
            extraFiltersIcon.relativePosition = new Vector3(tagToolIcon.relativePosition.x + tagToolIcon.width + 4, 6);

            extraFiltersIcon.eventClicked += (c, p) =>
            {
                if (!extraFiltersPanel.isVisible)
                {
                    extraFiltersIcon.opacity = 1.0f;
                    //CreateExtraFiltersPanel();
                    extraFiltersPanel.isVisible = true;
                }
                else
                {
                    extraFiltersIcon.opacity = 0.5f;
                    //DestroyExtraFiltersPanel();
                    extraFiltersPanel.isVisible = false;
                    extraFiltersPanel.optionDropDownCheckBox.isChecked = false;
                    Search();
                }
                UpdateTopPanelsPosition();
            };

            extraFiltersIcon.eventMouseEnter += (c, p) =>
            {
                extraFiltersIcon.opacity = 1.0f;
            };

            extraFiltersIcon.eventMouseLeave += (c, p) =>
            {
                if (extraFiltersPanel.isVisible)
                {
                    extraFiltersIcon.opacity = 1.0f;
                }
                else
                {
                    extraFiltersIcon.opacity = 0.5f;
                }
            };

            quickMenuIcon                  = inputPanel.AddUIComponent <UISprite>();
            quickMenuIcon.size             = new Vector2(26, 23);
            quickMenuIcon.atlas            = FindIt.atlas;
            quickMenuIcon.spriteName       = "QuickMenu";
            quickMenuIcon.tooltip          = Translations.Translate("FIF_QM_TIT");
            quickMenuIcon.opacity          = 0.5f;
            quickMenuIcon.relativePosition = new Vector3(extraFiltersIcon.relativePosition.x + extraFiltersIcon.width + 4, 6);
            quickMenuIcon.eventClicked    += (c, p) =>
            {
                UIQuickMenuPopUp.ShowAt(quickMenuIcon);
                quickMenuVisible      = true;
                quickMenuIcon.opacity = 1.0f;
            };
            quickMenuIcon.eventMouseEnter += (c, p) =>
            {
                quickMenuIcon.opacity = 1.0f;
            };

            quickMenuIcon.eventMouseLeave += (c, p) =>
            {
                if (quickMenuVisible)
                {
                    quickMenuIcon.opacity = 1.0f;
                }
                else
                {
                    quickMenuIcon.opacity = 0.5f;
                }
            };

            // building size filter
            sizeFilterX                  = SamsamTS.UIUtils.CreateDropDown(inputPanel);
            sizeFilterX.size             = new Vector2(55, 25);
            sizeFilterX.items            = filterItemsGrowable;
            sizeFilterX.selectedIndex    = 0;
            sizeFilterX.relativePosition = new Vector3(quickMenuIcon.relativePosition.x + quickMenuIcon.width + 9, 5);

            sizeLabel                  = inputPanel.AddUIComponent <UILabel>();
            sizeLabel.textScale        = 0.8f;
            sizeLabel.padding          = new RectOffset(0, 0, 8, 0);
            sizeLabel.text             = "x";
            sizeLabel.tooltip          = Translations.Translate("FIF_SE_SIZEX");
            sizeLabel.relativePosition = new Vector3(sizeFilterX.relativePosition.x + sizeFilterX.width + 3.5f, 5);

            sizeLabel.eventClick += (c, p) =>
            {
                sizeFilterX.selectedIndex = 0;
                sizeFilterY.selectedIndex = 0;
            };

            sizeFilterY                  = SamsamTS.UIUtils.CreateDropDown(inputPanel);
            sizeFilterY.size             = new Vector2(55, 25);
            sizeFilterY.items            = filterItemsGrowable;
            sizeFilterY.selectedIndex    = 0;
            sizeFilterY.relativePosition = new Vector3(sizeLabel.relativePosition.x + sizeLabel.width + 2f, 5);

            sizeFilterX.eventSelectedIndexChanged += (c, i) => Search();
            sizeFilterY.eventSelectedIndexChanged += (c, i) => Search();

            // panel of sort button and filter toggle tabs
            panel       = AddUIComponent <UIPanel>();
            panel.atlas = SamsamTS.UIUtils.GetAtlas("Ingame");
            if (!Settings.useLightBackground)
            {
                panel.backgroundSprite = "GenericTabHovered";
            }
            else
            {
                panel.backgroundSprite = "GenericTab";
            }
            panel.size             = new Vector2(parent.width, 45);
            panel.relativePosition = new Vector3(0, -panel.height + 5);

            // sort button
            sortButton      = SamsamTS.UIUtils.CreateButton(panel);
            sortButton.size = new Vector2(100, 35);
            if (Settings.useRelevanceSort)
            {
                sortButton.text    = Translations.Translate("FIF_SO_RE");
                sortButton.tooltip = Translations.Translate("FIF_SO_RETP");
            }
            else
            {
                sortButton.text    = Translations.Translate("FIF_SO_NE");
                sortButton.tooltip = Translations.Translate("FIF_SO_NETP");
            }
            sortButton.relativePosition = new Vector3(5, 5);

            sortButton.eventClick += (c, p) =>
            {
                if (Settings.useRelevanceSort)
                {
                    Settings.useRelevanceSort = false;
                    XMLUtils.SaveSettings();
                    sortButton.text    = Translations.Translate("FIF_SO_NE");
                    sortButton.tooltip = Translations.Translate("FIF_SO_NETP");
                }
                else
                {
                    Settings.useRelevanceSort = true;
                    XMLUtils.SaveSettings();
                    sortButton.text    = Translations.Translate("FIF_SO_RE");
                    sortButton.tooltip = Translations.Translate("FIF_SO_RETP");
                }
                Search();
            };

            // ploppable filter tabs
            filterPloppable                        = panel.AddUIComponent <UIFilterPloppable>();
            filterPloppable.isVisible              = false;
            filterPloppable.relativePosition       = new Vector3(sortButton.relativePosition.x + sortButton.width, 0);
            filterPloppable.eventFilteringChanged += (c, p) => Search();

            // growable filter tabs
            filterGrowable                        = panel.AddUIComponent <UIFilterGrowable>();
            filterGrowable.isVisible              = false;
            filterGrowable.relativePosition       = new Vector3(sortButton.relativePosition.x + sortButton.width, 0);
            filterGrowable.eventFilteringChanged += (c, p) => Search();

            // prop filter tabs
            filterProp                        = panel.AddUIComponent <UIFilterProp>();
            filterProp.isVisible              = false;
            filterProp.relativePosition       = new Vector3(sortButton.relativePosition.x + sortButton.width, 0);
            filterProp.eventFilteringChanged += (c, p) => Search();

            // tree filter tabs
            filterTree                        = panel.AddUIComponent <UIFilterTree>();
            filterTree.isVisible              = false;
            filterTree.relativePosition       = new Vector3(sortButton.relativePosition.x + sortButton.width, 0);
            filterTree.eventFilteringChanged += (c, p) => Search();

            // network filter tabs
            filterNetwork                        = panel.AddUIComponent <UIFilterNetwork>();
            filterNetwork.isVisible              = false;
            filterNetwork.relativePosition       = new Vector3(sortButton.relativePosition.x + sortButton.width, 0);
            filterNetwork.eventFilteringChanged += (c, p) => Search();

            // decal filter tabs
            filterDecal                  = panel.AddUIComponent <UIFilterDecal>();
            filterDecal.isVisible        = false;
            filterDecal.relativePosition = new Vector3(sortButton.relativePosition.x + sortButton.width, 0);

            UpdateFilterPanels();
            CreateAssetTypePanel();
            if (Settings.showAssetTypePanel)
            {
                assetTypePanel.isVisible = true;
            }
            CreateCustomTagPanel();
            CreateExtraFiltersPanel();

            size = Vector2.zero;
        }