// Token: 0x060011F6 RID: 4598 RVA: 0x0007446C File Offset: 0x0007286C
        protected void handleTokenFieldSubmitted(Sleek2Field field, string value)
        {
            TranslationReference translationReference = (TranslationReference)base.inspectable.value;

            translationReference.token = value;
            base.inspectable.value     = translationReference;
        }
コード例 #2
0
 protected virtual void handleKeySubmitted(Sleek2Field field, string value)
 {
     if (this.leaf != null)
     {
         this.leaf.branch.key          = value;
         this.leaf.translation.isDirty = true;
     }
 }
コード例 #3
0
 protected virtual void handleTextSubmitted(Sleek2Field field, string value)
 {
     if (this.leaf != null)
     {
         DevkitTransactionManager.beginTransaction(new TranslatedText(new TranslationReference("#SDG::Devkit.Transactions.Translation")));
         DevkitTransactionUtility.recordObjectDelta(this.leaf);
         DevkitTransactionUtility.recordObjectDelta(this.leaf.translation);
         this.leaf.text = value;
         this.leaf.version++;
         this.leaf.translation.isDirty = true;
         DevkitTransactionManager.endTransaction();
     }
 }
コード例 #4
0
 // Token: 0x06001345 RID: 4933 RVA: 0x0007AD93 File Offset: 0x00079193
 protected virtual void handleKeySubmitted(Sleek2Field field, string value)
 {
     this.branch.key = value;
 }
コード例 #5
0
        protected virtual void handleSplatmapSearchFieldTyped(Sleek2Field field, string value)
        {
            if (this.searchLength == -1 || value.Length < this.searchLength)
            {
                this.searchResults.Clear();
                Assets.find <LandscapeMaterialAsset>(this.searchResults);
            }
            this.searchLength = value.Length;
            this.splatmapMaterialsPanel.clearElements();
            this.splatmapMaterialsPanel.transform.offsetMin = new Vector2(0f, 0f);
            this.splatmapMaterialsPanel.transform.offsetMax = new Vector2(0f, 0f);
            if (value.Length > 0)
            {
                string[] array = value.Split(new char[]
                {
                    ' '
                });
                for (int i = this.searchResults.Count - 1; i >= 0; i--)
                {
                    LandscapeMaterialAsset landscapeMaterialAsset = this.searchResults[i];
                    bool flag = true;
                    switch (landscapeMaterialAsset.assetOrigin)
                    {
                    case EAssetOrigin.OFFICIAL:
                        flag &= LandscapeToolWindow.showOfficialAssets;
                        break;

                    case EAssetOrigin.CURATED:
                        flag &= LandscapeToolWindow.showCuratedAssets;
                        break;

                    case EAssetOrigin.WORKSHOP:
                        flag &= LandscapeToolWindow.showWorkshopAssets;
                        break;

                    case EAssetOrigin.MISC:
                        flag &= LandscapeToolWindow.showMiscAssets;
                        break;
                    }
                    if (flag)
                    {
                        foreach (string value2 in array)
                        {
                            if (landscapeMaterialAsset.name.IndexOf(value2, StringComparison.InvariantCultureIgnoreCase) == -1)
                            {
                                flag = false;
                                break;
                            }
                        }
                    }
                    if (!flag)
                    {
                        this.searchResults.RemoveAtFast(i);
                    }
                }
                if (this.searchResults.Count <= 64)
                {
                    this.searchResults.Sort(new LandscapeToolWindow.LandscapeToolAssetComparer());
                    foreach (LandscapeMaterialAsset newAsset in this.searchResults)
                    {
                        LandscapeToolMaterialAssetButton landscapeToolMaterialAssetButton = new LandscapeToolMaterialAssetButton(newAsset);
                        landscapeToolMaterialAssetButton.clicked += this.handleMaterialAssetButtonClicked;
                        this.splatmapMaterialsPanel.addElement(landscapeToolMaterialAssetButton);
                    }
                }
            }
        }
コード例 #6
0
 // Token: 0x06001067 RID: 4199 RVA: 0x0006BEAE File Offset: 0x0006A2AE
 protected virtual void handleFieldSubmitted(Sleek2Field field, string value)
 {
     Assets.rename(this.asset, value);
 }
コード例 #7
0
        // Token: 0x06001126 RID: 4390 RVA: 0x0007084C File Offset: 0x0006EC4C
        protected virtual void handleSearchFieldTyped(Sleek2Field field, string value)
        {
            if (this.searchLength == -1 || value.Length < this.searchLength)
            {
                this.searchInfoAssets.Clear();
                Assets.find <FoliageInfoAsset>(this.searchInfoAssets);
                this.searchCollectionAssets.Clear();
                Assets.find <FoliageInfoCollectionAsset>(this.searchCollectionAssets);
            }
            this.searchLength = value.Length;
            this.foliagePanel.clearElements();
            this.foliagePanel.transform.offsetMin = new Vector2(0f, 0f);
            this.foliagePanel.transform.offsetMax = new Vector2(0f, 0f);
            if (value.Length > 0)
            {
                string[] array = value.Split(new char[]
                {
                    ' '
                });
                for (int i = this.searchInfoAssets.Count - 1; i >= 0; i--)
                {
                    FoliageInfoAsset foliageInfoAsset = this.searchInfoAssets[i];
                    bool             flag             = true;
                    switch (foliageInfoAsset.assetOrigin)
                    {
                    case EAssetOrigin.OFFICIAL:
                        flag &= FoliageToolWindow.showOfficialAssets;
                        break;

                    case EAssetOrigin.CURATED:
                        flag &= FoliageToolWindow.showCuratedAssets;
                        break;

                    case EAssetOrigin.WORKSHOP:
                        flag &= FoliageToolWindow.showWorkshopAssets;
                        break;

                    case EAssetOrigin.MISC:
                        flag &= FoliageToolWindow.showMiscAssets;
                        break;
                    }
                    if (flag)
                    {
                        foreach (string value2 in array)
                        {
                            if (foliageInfoAsset.name.IndexOf(value2, StringComparison.InvariantCultureIgnoreCase) == -1)
                            {
                                flag = false;
                                break;
                            }
                        }
                    }
                    if (!flag)
                    {
                        this.searchInfoAssets.RemoveAtFast(i);
                    }
                }
                for (int k = this.searchCollectionAssets.Count - 1; k >= 0; k--)
                {
                    FoliageInfoCollectionAsset foliageInfoCollectionAsset = this.searchCollectionAssets[k];
                    bool flag2 = true;
                    switch (foliageInfoCollectionAsset.assetOrigin)
                    {
                    case EAssetOrigin.OFFICIAL:
                        flag2 &= FoliageToolWindow.showOfficialAssets;
                        break;

                    case EAssetOrigin.CURATED:
                        flag2 &= FoliageToolWindow.showCuratedAssets;
                        break;

                    case EAssetOrigin.WORKSHOP:
                        flag2 &= FoliageToolWindow.showWorkshopAssets;
                        break;

                    case EAssetOrigin.MISC:
                        flag2 &= FoliageToolWindow.showMiscAssets;
                        break;
                    }
                    if (flag2)
                    {
                        foreach (string value3 in array)
                        {
                            if (foliageInfoCollectionAsset.name.IndexOf(value3, StringComparison.InvariantCultureIgnoreCase) == -1)
                            {
                                flag2 = false;
                                break;
                            }
                        }
                    }
                    if (!flag2)
                    {
                        this.searchCollectionAssets.RemoveAtFast(k);
                    }
                }
                if (this.searchInfoAssets.Count + this.searchCollectionAssets.Count <= 64)
                {
                    this.searchInfoAssets.Sort(new FoliageToolWindow.FoliageToolAssetComparer());
                    this.searchCollectionAssets.Sort(new FoliageToolWindow.FoliageToolAssetComparer());
                    foreach (FoliageInfoAsset newAsset in this.searchInfoAssets)
                    {
                        FoliageToolFoliageAssetButton foliageToolFoliageAssetButton = new FoliageToolFoliageAssetButton(newAsset);
                        foliageToolFoliageAssetButton.clicked += this.handleFoliageAssetButtonClicked;
                        this.foliagePanel.addElement(foliageToolFoliageAssetButton);
                    }
                    foreach (FoliageInfoCollectionAsset newAsset2 in this.searchCollectionAssets)
                    {
                        FoliageToolFoliageCollectionAssetButton foliageToolFoliageCollectionAssetButton = new FoliageToolFoliageCollectionAssetButton(newAsset2);
                        foliageToolFoliageCollectionAssetButton.clicked += this.handleFoliageCollectionAssetButtonClicked;
                        this.foliagePanel.addElement(foliageToolFoliageCollectionAssetButton);
                    }
                }
            }
        }
コード例 #8
0
 protected void handleFieldSubmitted(Sleek2Field field, string value)
 {
     base.inspectable.value = new Guid(value);
 }
コード例 #9
0
        // Token: 0x060012EA RID: 4842 RVA: 0x00078CB0 File Offset: 0x000770B0
        protected virtual void handleSearchFieldTyped(Sleek2Field field, string value)
        {
            if (this.searchLength == -1 || value.Length < this.searchLength)
            {
                this.searchResults.Clear();
                Assets.find <ObjectAsset>(this.searchResults);
            }
            this.searchLength = value.Length;
            this.itemsPanel.clearElements();
            this.itemsPanel.transform.offsetMin = new Vector2(0f, 0f);
            this.itemsPanel.transform.offsetMax = new Vector2(0f, 0f);
            if (value.Length > 0)
            {
                string[] array = value.Split(new char[]
                {
                    ' '
                });
                for (int i = this.searchResults.Count - 1; i >= 0; i--)
                {
                    ObjectAsset objectAsset = this.searchResults[i];
                    bool        flag        = true;
                    switch (objectAsset.assetOrigin)
                    {
                    case EAssetOrigin.OFFICIAL:
                        flag &= ObjectBrowserWindow.showOfficialObjects;
                        break;

                    case EAssetOrigin.CURATED:
                        flag &= ObjectBrowserWindow.showCuratedObjects;
                        break;

                    case EAssetOrigin.WORKSHOP:
                        flag &= ObjectBrowserWindow.showWorkshopObjects;
                        break;

                    case EAssetOrigin.MISC:
                        flag &= ObjectBrowserWindow.showMiscObjects;
                        break;
                    }
                    if (flag && !objectAsset.canUse)
                    {
                        flag = false;
                    }
                    if (flag)
                    {
                        foreach (string value2 in array)
                        {
                            if (objectAsset.objectName.IndexOf(value2, StringComparison.InvariantCultureIgnoreCase) == -1 && objectAsset.name.IndexOf(value2, StringComparison.InvariantCultureIgnoreCase) == -1)
                            {
                                flag = false;
                                break;
                            }
                        }
                    }
                    if (!flag)
                    {
                        this.searchResults.RemoveAtFast(i);
                    }
                }
                if (this.searchResults.Count <= 64)
                {
                    this.searchResults.Sort(new ObjectBrowserWindow.ObjectBrowserAssetComparer());
                    foreach (ObjectAsset newAsset in this.searchResults)
                    {
                        ObjectBrowserAssetButton objectBrowserAssetButton = new ObjectBrowserAssetButton(newAsset);
                        objectBrowserAssetButton.clicked += this.handleAssetButtonClicked;
                        this.itemsPanel.addElement(objectBrowserAssetButton);
                    }
                }
            }
        }