예제 #1
0
        void Search(string searchText, BuildInfo buildReportToDisplay)
        {
            BuildReportTool.AssetList list = GetAssetListToDisplay(buildReportToDisplay);


            BuildReportTool.FileFilterGroup filter = buildReportToDisplay.FileFilters;

            if (BuildReportTool.Options.ShouldUseConfiguredFileFilters())
            {
                filter = _configuredFileFilterGroup;
            }

            List <BuildReportTool.SizePart> searchResults = new List <BuildReportTool.SizePart>();


            BuildReportTool.SizePart[] assetListToSearchFrom = list.GetListToDisplay(filter);

            for (int n = 0; n < assetListToSearchFrom.Length; ++n)
            {
                if (IsANearStringMatch(assetListToSearchFrom[n].Name, searchText))
                {
                    searchResults.Add(assetListToSearchFrom[n]);
                }
            }

            if (searchResults.Count > 0)
            {
                searchResults.Sort((a, b) => GetFuzzyEqualityScore(searchText, a.Name).CompareTo(GetFuzzyEqualityScore(searchText, b.Name)));
            }

            _searchResults = searchResults.ToArray();
        }
예제 #2
0
        void DrawAssetList(BuildReportTool.AssetList assetList)
        {
            BuildReportTool.SizePart[] assetsToShow = assetList.TopTenLargest;

            if (assetsToShow == null)
            {
                Debug.LogError("no top ten largest");
                return;
            }

            bool useAlt = true;

            GUILayout.BeginHorizontal();

            // 1st column: name
            GUILayout.BeginVertical();
            for (int n = 0; n < assetsToShow.Length; ++n)
            {
                BuildReportTool.SizePart b = assetsToShow[n];

                string styleToUse = useAlt ? BuildReportTool.Window.Settings.LIST_NORMAL_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_NORMAL_STYLE_NAME;

                string  prettyName = " " + (n + 1) + ". " + Path.GetFileName(b.Name);
                Texture icon       = AssetDatabase.GetCachedIcon(b.Name);
                if (GUILayout.Button(new GUIContent(prettyName, icon), styleToUse, GUILayout.MinWidth(100), GUILayout.MaxWidth(400), GUILayout.Height(30)))
                {
                    Utility.PingAssetInProject(b.Name);
                }

                useAlt = !useAlt;
            }
            GUILayout.EndVertical();

            // 2nd column: size
            useAlt = true;
            GUILayout.BeginVertical();
            for (int n = 0; n < assetsToShow.Length; ++n)
            {
                BuildReportTool.SizePart b = assetsToShow[n];

                string styleToUse = useAlt ? BuildReportTool.Window.Settings.LIST_NORMAL_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_NORMAL_STYLE_NAME;

                GUILayout.Label(b.RawSize, styleToUse, GUILayout.MaxWidth(100), GUILayout.Height(30));

                useAlt = !useAlt;
            }
            GUILayout.EndVertical();
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();
        }
예제 #3
0
        void DrawAssetList(BuildReportTool.AssetList assetList, bool usedAssets)
        {
            BuildReportTool.SizePart[] assetsToShow = assetList.TopLargest;

            if (assetsToShow == null)
            {
                //Debug.LogError("no top ten largest");
                return;
            }

            bool useAlt = true;

            GUILayout.BeginHorizontal();

            // 1st column: name
            GUILayout.BeginVertical();
            for (int n = 0; n < assetsToShow.Length; ++n)
            {
                BuildReportTool.SizePart b = assetsToShow[n];

                string styleToUse     = useAlt ? BuildReportTool.Window.Settings.LIST_NORMAL_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_NORMAL_STYLE_NAME;
                string iconStyleToUse = useAlt ? BuildReportTool.Window.Settings.LIST_ICON_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_ICON_STYLE_NAME;

                string  prettyName = " " + (n + 1) + ". " + Path.GetFileName(b.Name);
                Texture icon       = AssetDatabase.GetCachedIcon(b.Name);

                GUILayout.BeginHorizontal();
                if (icon == null)
                {
                    //GUILayout.Space(22);
                    GUILayout.Label(string.Empty, iconStyleToUse, GUILayout.Width(28), GUILayout.Height(30));
                }
                else
                {
                    GUILayout.Button(icon, iconStyleToUse, GUILayout.Width(28), GUILayout.Height(30));
                }
                if (GUILayout.Button(prettyName, styleToUse, GUILayout.MinWidth(100), GUILayout.MaxWidth(400), GUILayout.Height(30)))
                {
                    Utility.PingAssetInProject(b.Name);
                }
                GUILayout.EndHorizontal();

                useAlt = !useAlt;
            }
            GUILayout.EndVertical();

            // 2nd column: size

            var useRawSize = (usedAssets && !BuildReportTool.Options.ShowImportedSizeForUsedAssets) || !usedAssets;

            useAlt = true;
            GUILayout.BeginVertical();
            for (int n = 0; n < assetsToShow.Length; ++n)
            {
                BuildReportTool.SizePart b = assetsToShow[n];

                string styleToUse = useAlt ? BuildReportTool.Window.Settings.LIST_NORMAL_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_NORMAL_STYLE_NAME;

                GUILayout.Label(useRawSize ? b.RawSize : b.ImportedSize, styleToUse, GUILayout.MaxWidth(100), GUILayout.Height(30));

                useAlt = !useAlt;
            }
            GUILayout.EndVertical();
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();
        }
예제 #4
0
        void InitiateDeleteSelectedInAssetList(BuildInfo buildReportToDisplay, BuildReportTool.AssetList listToDeleteFrom)
        {
            if (listToDeleteFrom.IsNothingSelected)
            {
                return;
            }


            BuildReportTool.SizePart[] all = listToDeleteFrom.All;

            int numOfFilesRequestedToDelete = listToDeleteFrom.GetSelectedCount();
            int numOfFilesToDelete          = numOfFilesRequestedToDelete;
            int systemDeletionFileCount     = 0;
            int brtFilesSelectedForDelete   = 0;


            // filter out files that shouldn't be deleted
            // and identify unrecoverable files
            for (int n = 0, len = all.Length; n < len; ++n)
            {
                BuildReportTool.SizePart b = all[n];
                bool isThisFileToBeDeleted = listToDeleteFrom.InSumSelection(b);

                if (isThisFileToBeDeleted)
                {
                    if (BuildReportTool.Util.IsFileInBuildReportFolder(b.Name) &&
                        !BuildReportTool.Util.IsUselessFile(b.Name))
                    {
                        //Debug.Log("BRT file? " + b.Name);
                        --numOfFilesToDelete;
                        ++brtFilesSelectedForDelete;
                    }
                    else if (BuildReportTool.Util.HaveToUseSystemForDelete(b.Name))
                    {
                        ++systemDeletionFileCount;
                    }
                }
            }

            if (numOfFilesToDelete <= 0)
            {
                if (brtFilesSelectedForDelete > 0)
                {
                    EditorApplication.Beep();
                    EditorUtility.DisplayDialog("Can't delete!",
                                                "Take note that for safety, Build Report Tool assets themselves will not be included for deletion.",
                                                "OK");
                }

                return;
            }


            // prepare warning message for user

            bool deletingSystemFilesOnly = (systemDeletionFileCount == numOfFilesToDelete);
            bool deleteIsRecoverable     = !deletingSystemFilesOnly;

            string plural = "";

            if (numOfFilesToDelete > 1)
            {
                plural = "s";
            }

            string message;

            if (numOfFilesRequestedToDelete != numOfFilesToDelete)
            {
                message = "Among " + numOfFilesRequestedToDelete + " file" + plural + " requested to be deleted, only " +
                          numOfFilesToDelete + " will be deleted.";
            }
            else
            {
                message = "This will delete " + numOfFilesToDelete + " asset" + plural + " in your project.";
            }

            // add warning about BRT files that are skipped
            if (brtFilesSelectedForDelete > 0)
            {
                message += "\n\nTake note that for safety, " + brtFilesSelectedForDelete + " file" +
                           ((brtFilesSelectedForDelete > 1) ? "s" : "") +
                           " found to be Build Report Tool assets are not included for deletion.";
            }

            // add warning about unrecoverable files
            if (systemDeletionFileCount > 0)
            {
                if (deletingSystemFilesOnly)
                {
                    message += "\n\nThe deleted file" + plural + " will not be recoverable from the " +
                               BuildReportTool.Util.NameOfOSTrashFolder + ", unless you have your own backup.";
                }
                else
                {
                    message += "\n\nAmong the " + numOfFilesToDelete + " file" + plural + " for deletion, " +
                               systemDeletionFileCount + " will not be recoverable from the " +
                               BuildReportTool.Util.NameOfOSTrashFolder + ", unless you have your own backup.";
                }

                message +=
                    "\n\nThis is a limitation in Unity and .NET code. To ensure deleting will move the files to the " +
                    BuildReportTool.Util.NameOfOSTrashFolder +
                    " instead, delete your files the usual way using your project view.";
            }
            else
            {
                message += "\n\nThe deleted file" + plural + " can be recovered from your " +
                           BuildReportTool.Util.NameOfOSTrashFolder + ".";
            }

            message +=
                "\n\nDeleting a large number of files may take a long time as Unity will rebuild the project's Library folder.\n\nProceed with deleting?";

            EditorApplication.Beep();
            if (!EditorUtility.DisplayDialog("Delete?", message, "Yes", "No"))
            {
                return;
            }

            List <BuildReportTool.SizePart> allList  = new List <BuildReportTool.SizePart>(all);
            List <BuildReportTool.SizePart> toRemove = new List <BuildReportTool.SizePart>(all.Length / 4);

            // finally, delete the files
            int deletedCount = 0;

            for (int n = 0, len = allList.Count; n < len; ++n)
            {
                BuildReportTool.SizePart b = allList[n];


                bool okToDelete = BuildReportTool.Util.IsUselessFile(b.Name) ||
                                  !BuildReportTool.Util.IsFileInBuildReportFolder(b.Name);

                if (listToDeleteFrom.InSumSelection(b) && okToDelete)
                {
                    // delete this

                    if (BuildReportTool.Util.ShowFileDeleteProgress(deletedCount, numOfFilesToDelete, b.Name,
                                                                    deleteIsRecoverable))
                    {
                        return;
                    }

                    BuildReportTool.Util.DeleteSizePartFile(b);
                    toRemove.Add(b);
                    ++deletedCount;
                }
            }

            EditorUtility.ClearProgressBar();


            // refresh the asset lists
            allList.RemoveAll(i => toRemove.Contains(i));
            BuildReportTool.SizePart[] allWithRemoved = allList.ToArray();

            // recreate per category list (maybe just remove from existing per category lists instead?)
            BuildReportTool.SizePart[][] perCategoryOfList =
                BuildReportTool.ReportGenerator.SegregateAssetSizesPerCategory(allWithRemoved,
                                                                               buildReportToDisplay.FileFilters);

            listToDeleteFrom.Reinit(allWithRemoved, perCategoryOfList,
                                    IsShowingUsedAssets
                                        ? BuildReportTool.Options.NumberOfTopLargestUsedAssetsToShow
                                        : BuildReportTool.Options.NumberOfTopLargestUnusedAssetsToShow);
            listToDeleteFrom.ClearSelection();


            // print info about the delete operation to console
            string finalMessage = string.Format("{0} file{1} removed from your project.", deletedCount.ToString(), plural);

            if (deleteIsRecoverable)
            {
                finalMessage += " They can be recovered from your " + BuildReportTool.Util.NameOfOSTrashFolder + ".";
            }

            EditorApplication.Beep();
            EditorUtility.DisplayDialog("Delete successful", finalMessage, "OK");

            Debug.LogWarning(finalMessage);
        }
예제 #5
0
        void InitiateDeleteAllUnused(BuildInfo buildReportToDisplay)
        {
            BuildReportTool.AssetList  list = buildReportToDisplay.UnusedAssets;
            BuildReportTool.SizePart[] all  = list.All;

            int filesToDeleteCount = 0;

            for (int n = 0, len = all.Length; n < len; ++n)
            {
                BuildReportTool.SizePart b = all[n];

                bool okToDelete = BuildReportTool.Util.IsFileOkForDeleteAllOperation(b.Name);

                if (okToDelete)
                {
                    //Debug.Log("added " + b.Name + " for deletion");
                    ++filesToDeleteCount;
                }
            }

            if (filesToDeleteCount == 0)
            {
                const string NOTHING_TO_DELETE =
                    "Take note that for safety, Build Report Tool assets, Unity editor assets, version control metadata, and Unix-style hidden files will not be included for deletion.\n\nYou can force deleting them by selecting them (via the checkbox) and using \"Delete selected\", or simply delete them the normal way in your project view.";

                EditorApplication.Beep();
                EditorUtility.DisplayDialog("Nothing to delete!", NOTHING_TO_DELETE, "Ok");
                return;
            }

            string plural = "";

            if (filesToDeleteCount > 1)
            {
                plural = "s";
            }

            EditorApplication.Beep();
            if (!EditorUtility.DisplayDialog("Delete?",
                                             string.Format("Among {0} file{1} in your project, {2} will be deleted.\n\nBuild Report Tool assets themselves, Unity editor assets, version control metadata, and Unix-style hidden files will not be included for deletion. You can force-delete those by selecting them (via the checkbox) and use \"Delete selected\", or simply delete them the normal way in your project view.\n\nDeleting a large number of files may take a long time as Unity will rebuild the project's Library folder.\n\nAre you sure about this?\n\nThe file{1} can be recovered from your {3}.",
                                                           all.Length.ToString(), plural, filesToDeleteCount.ToString(), BuildReportTool.Util.NameOfOSTrashFolder), "Yes", "No"))
            {
                return;
            }

            List <BuildReportTool.SizePart> newAll = new List <BuildReportTool.SizePart>();

            int deletedCount = 0;

            for (int n = 0, len = all.Length; n < len; ++n)
            {
                BuildReportTool.SizePart b = all[n];

                bool okToDelete = BuildReportTool.Util.IsFileOkForDeleteAllOperation(b.Name);

                if (okToDelete)
                {
                    // delete this
                    if (BuildReportTool.Util.ShowFileDeleteProgress(deletedCount, filesToDeleteCount, b.Name, true))
                    {
                        return;
                    }

                    BuildReportTool.Util.DeleteSizePartFile(b);
                    ++deletedCount;
                }
                else
                {
                    //Debug.Log("added " + b.Name + " to new list");
                    newAll.Add(b);
                }
            }

            EditorUtility.ClearProgressBar();

            BuildReportTool.SizePart[] newAllArr = newAll.ToArray();

            BuildReportTool.SizePart[][] perCategoryUnused =
                BuildReportTool.ReportGenerator.SegregateAssetSizesPerCategory(newAllArr, buildReportToDisplay.FileFilters);

            list.Reinit(newAllArr, perCategoryUnused,
                        IsShowingUsedAssets
                                        ? BuildReportTool.Options.NumberOfTopLargestUsedAssetsToShow
                                        : BuildReportTool.Options.NumberOfTopLargestUnusedAssetsToShow);
            list.ClearSelection();


            string finalMessage = string.Format("{0} file{1} removed from your project. They can be recovered from your {2}.",
                                                filesToDeleteCount.ToString(), plural, BuildReportTool.Util.NameOfOSTrashFolder);

            Debug.LogWarning(finalMessage);

            EditorApplication.Beep();
            EditorUtility.DisplayDialog("Delete successful", finalMessage, "OK");
        }
예제 #6
0
        void InitiateDeleteSelectedUsed(BuildInfo buildReportToDisplay)
        {
            BuildReportTool.AssetList listToDeleteFrom = GetAssetListToDisplay(buildReportToDisplay);

            InitiateDeleteSelectedInAssetList(buildReportToDisplay, listToDeleteFrom);
        }
예제 #7
0
        bool DrawColumn(int sta, int end, BuildReportTool.AssetList.SortType columnType, string columnName, bool allowSort, bool showScrollbar, BuildReportTool.AssetList assetListCollection, BuildReportTool.SizePart[] assetList, ColumnDisplayDelegate dataToDisplay, ref Vector2 scollbarPos)
        {
            bool buttonPressed = false;

            GUILayout.BeginVertical();


            // ----------------------------------------------------------
            // column header
            string sortTypeStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME;

            if (allowSort && assetListCollection.CurrentSortType == columnType)
            {
                if (assetListCollection.CurrentSortOrder == BuildReportTool.AssetList.SortOrder.Descending)
                {
                    sortTypeStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_DESC_STYLE_NAME;
                }
                else
                {
                    sortTypeStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_ASC_STYLE_NAME;
                }
            }
            if (GUILayout.Button(columnName, sortTypeStyleName, GUILayout.Height(LIST_HEIGHT)) && allowSort)
            {
                buttonPressed = true;
            }


            // ----------------------------------------------------------
            // scrollbar
            if (showScrollbar)
            {
                scollbarPos = GUILayout.BeginScrollView(scollbarPos,
                                                        BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME, "verticalscrollbar");
            }
            else
            {
                scollbarPos = GUILayout.BeginScrollView(scollbarPos,
                                                        BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME, BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME);
            }


            // ----------------------------------------------------------
            // actual contents
            bool useAlt = false;

            BuildReportTool.SizePart b;
            for (int n = sta; n < end; ++n)
            {
                b = assetList[n];

                string styleToUse = useAlt ? BuildReportTool.Window.Settings.LIST_SMALL_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_SMALL_STYLE_NAME;
                if (assetListCollection.InSumSelection(b))
                {
                    styleToUse = BuildReportTool.Window.Settings.LIST_SMALL_SELECTED_NAME;
                }

                GUILayout.Label(dataToDisplay(b), styleToUse, GUILayout.MinWidth(90), GUILayout.Height(LIST_HEIGHT));

                useAlt = !useAlt;
            }


            GUILayout.EndScrollView();

            GUILayout.EndVertical();

            return(buttonPressed);
        }
예제 #8
0
        void DrawAssetList(Rect position, BuildReportTool.AssetList list, BuildReportTool.FileFilterGroup filter, int length)
        {
            if (list != null)
            {
                if (_searchResults != null && _searchResults.Length == 0)
                {
                    DrawCentralMessage(position, "No search results");
                    return;
                }

                BuildReportTool.SizePart[] assetListToUse;

                var hasSearchResults = _searchResults != null;

                if (hasSearchResults && _searchResults.Length > 0)
                {
                    assetListToUse = _searchResults;
                }
                else
                {
                    assetListToUse = list.GetListToDisplay(filter);
                }

                if (assetListToUse != null)
                {
                    if (assetListToUse.Length == 0)
                    {
                        GUILayout.BeginHorizontal();
                        GUILayout.Space(10);
                        GUILayout.Label(Labels.NO_FILES_FOR_THIS_CATEGORY_LABEL, BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
                        GUILayout.EndHorizontal();
                    }
                    else
                    {
                        EditorGUIUtility.SetIconSize(Vector2.one * ICON_DISPLAY_SIZE);
                        bool useAlt = false;

                        int viewOffset = list.GetViewOffsetForDisplayedList(filter);

                        // if somehow view offset was out of bounds of the SizePart[] array
                        // reset it to zero
                        if (viewOffset >= assetListToUse.Length)
                        {
                            list.SetViewOffsetForDisplayedList(filter, 0);
                            viewOffset = 0;
                        }

                        int len = Mathf.Min(viewOffset + length, assetListToUse.Length);



                        GUILayout.BeginHorizontal();


                        // --------------------------------------------------------------------------------------------------------
                        // column: asset path and name
                        GUILayout.BeginVertical();
                        useAlt = false;

                        //GUILayout.Box("", BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME, GUILayout.Height(LIST_HEIGHT), GUILayout.Width(position.width));

                        GUILayout.BeginHorizontal();


                        string sortTypeAssetFullPathStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME;
                        if (!hasSearchResults && list.CurrentSortType == BuildReportTool.AssetList.SortType.AssetFullPath)
                        {
                            if (list.CurrentSortOrder == BuildReportTool.AssetList.SortOrder.Descending)
                            {
                                sortTypeAssetFullPathStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_DESC_STYLE_NAME;
                            }
                            else
                            {
                                sortTypeAssetFullPathStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_ASC_STYLE_NAME;
                            }
                        }
                        if (GUILayout.Button("Asset Path", sortTypeAssetFullPathStyleName, GUILayout.Height(LIST_HEIGHT)) && !hasSearchResults)
                        {
                            list.ToggleSort(BuildReportTool.AssetList.SortType.AssetFullPath);
                        }


                        string sortTypeAssetFilenameStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME;
                        if (!hasSearchResults && list.CurrentSortType == BuildReportTool.AssetList.SortType.AssetFilename)
                        {
                            if (list.CurrentSortOrder == BuildReportTool.AssetList.SortOrder.Descending)
                            {
                                sortTypeAssetFilenameStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_DESC_STYLE_NAME;
                            }
                            else
                            {
                                sortTypeAssetFilenameStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_ASC_STYLE_NAME;
                            }
                        }
                        if (GUILayout.Button("Asset Filename", sortTypeAssetFilenameStyleName, GUILayout.Height(LIST_HEIGHT)) && !hasSearchResults)
                        {
                            list.ToggleSort(BuildReportTool.AssetList.SortType.AssetFilename);
                        }
                        GUILayout.EndHorizontal();


                        // --------------------------------------------------------------------------------------------------------

                        _assetListScrollPos = GUILayout.BeginScrollView(_assetListScrollPos, BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME, BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME);

                        for (int n = viewOffset; n < len; ++n)
                        {
                            BuildReportTool.SizePart b = assetListToUse[n];

                            string styleToUse  = useAlt ? BuildReportTool.Window.Settings.LIST_SMALL_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_SMALL_STYLE_NAME;
                            bool   inSumSelect = list.InSumSelection(b);
                            if (inSumSelect)
                            {
                                styleToUse = BuildReportTool.Window.Settings.LIST_SMALL_SELECTED_NAME;
                            }

                            GUILayout.BeginHorizontal();

                            // checkbox for selecting
                            bool newInSumSelect = GUILayout.Toggle(inSumSelect, "", GUILayout.Width(20));
                            if (inSumSelect != newInSumSelect)
                            {
                                if (newInSumSelect)
                                {
                                    list.AddToSumSelection(b);
                                }
                                else
                                {
                                    list.RemoveFromSumSelection(b);
                                }
                            }


                            // the asset name
                            Texture icon = AssetDatabase.GetCachedIcon(b.Name);

                            string prettyName = string.Empty;

                            prettyName = string.Format(" {0}. <color=#{1}>{2}{3}</color><b>{4}</b>", (n + 1), GetPathColor(inSumSelect), BuildReportTool.Util.GetAssetPath(b.Name), BuildReportTool.Util.GetAssetPathToNameSeparator(b.Name), BuildReportTool.Util.GetAssetFilename(b.Name));



                            GUIStyle styleObjToUse = GUI.skin.GetStyle(styleToUse);
                            Color    temp          = styleObjToUse.normal.textColor;
                            int      origLeft      = styleObjToUse.padding.left;
                            int      origRight     = styleObjToUse.padding.right;

                            styleObjToUse.normal.textColor = styleObjToUse.onNormal.textColor;
                            styleObjToUse.padding.right    = 0;

                            if (icon == null)
                            {
                                //GUILayout.BeginHorizontal(styleObjToUse);
                                GUILayout.Space(15);
                                //GUILayout.EndHorizontal();
                            }

                            styleObjToUse.normal.textColor = temp;
                            styleObjToUse.padding.left     = 2;
                            if (GUILayout.Button(new GUIContent(prettyName, icon), styleObjToUse, GUILayout.Height(LIST_HEIGHT)))
                            {
                                Utility.PingAssetInProject(b.Name);
                            }
                            styleObjToUse.padding.right = origRight;
                            styleObjToUse.padding.left  = origLeft;


                            GUILayout.EndHorizontal();

                            useAlt = !useAlt;
                        }

                        GUILayout.EndScrollView();

                        GUILayout.EndVertical();



                        // --------------------------------------------------------------------------------------------------------
                        // column: raw file size
                        bool pressedRawSizeSortBtn = DrawColumn(viewOffset, len, BuildReportTool.AssetList.SortType.RawSize, (IsShowingUnusedAssets ? "Raw Size" : "Size"), !hasSearchResults, false,
                                                                list, assetListToUse, (b) => { return(b.RawSize); }, ref _assetListScrollPos);


                        bool showScrollbarForImportedSize = IsShowingUnusedAssets;


                        // --------------------------------------------------------------------------------------------------------
                        // column: imported file size

                        bool pressedImpSizeSortBtn = false;

                        if (IsShowingUnusedAssets)
                        {
                            pressedImpSizeSortBtn = DrawColumn(viewOffset, len, BuildReportTool.AssetList.SortType.ImportedSize, "Imported Size   ", !hasSearchResults, showScrollbarForImportedSize,
                                                               list, assetListToUse, (b) => { return(b.ImportedSize); }, ref _assetListScrollPos);
                        }


                        // --------------------------------------------------------------------------------------------------------
                        // column: percentage to total size
                        bool pressedPercentSortBtn = false;

                        if (IsShowingUsedAssets)
                        {
                            pressedPercentSortBtn = DrawColumn(viewOffset, len, BuildReportTool.AssetList.SortType.PercentSize, "Percent   ", !hasSearchResults, true,
                                                               list, assetListToUse, (b) => {
                                string text = b.Percentage + "%";
                                if (b.Percentage < 0)
                                {
                                    text = Labels.NON_APPLICABLE_PERCENTAGE_LABEL;
                                }
                                return(text);
                            }, ref _assetListScrollPos);
                        }

                        // --------------------------------------------------------------------------------------------------------

                        if (!hasSearchResults)
                        {
                            if (pressedRawSizeSortBtn)
                            {
                                list.ToggleSort(BuildReportTool.AssetList.SortType.RawSize);
                            }
                            else if (pressedImpSizeSortBtn)
                            {
                                list.ToggleSort(BuildReportTool.AssetList.SortType.ImportedSize);
                            }
                            else if (pressedPercentSortBtn)
                            {
                                list.ToggleSort(BuildReportTool.AssetList.SortType.PercentSize);
                            }
                        }


                        GUILayout.EndHorizontal();
                    }
                }
            }
        }
예제 #9
0
        public override void DrawGUI(Rect position, BuildInfo buildReportToDisplay)
        {
            if (!buildReportToDisplay.HasUsedAssets)
            {
                return;
            }



            // init variables to use
            // --------------------------------------------------------------------------

            BuildReportTool.FileFilterGroup fileFilterGroupToUse = buildReportToDisplay.FileFilters;

            if (BuildReportTool.Options.ShouldUseConfiguredFileFilters())
            {
                fileFilterGroupToUse = _configuredFileFilterGroup;
            }

            BuildReportTool.AssetList listToDisplay = GetAssetListToDisplay(buildReportToDisplay);

            //BuildReportTool.SizePart[] assetListToUse = listToDisplay.GetListToDisplay(fileFilterGroupToUse);
            //
            //if (assetListToUse == null || assetListToUse.Length == 0)
            //{
            //	fileFilterGroupToUse.ForceSetSelectedFilterIdx(0);
            //}


            if (listToDisplay == null)
            {
                if (IsShowingUsedAssets)
                {
                    Utility.DrawCentralMessage(position, "No \"Used Assets\" included in this build report.");
                }
                else if (IsShowingUnusedAssets)
                {
                    Utility.DrawCentralMessage(position, "No \"Unused Assets\" included in this build report.");
                }
                return;
            }


            // gui
            // --------------------------------------------------------------------------

            GUILayout.Space(1);

            DrawTopBar(position, buildReportToDisplay, fileFilterGroupToUse);

            if (buildReportToDisplay.HasUsedAssets)
            {
                DrawAssetList(position, listToDisplay, fileFilterGroupToUse, BuildReportTool.Options.AssetListPaginationLength);
            }



            // status bar at bottom
            // --------------------------------------------------------------------------

            GUILayout.Space(20);

            string selectedInfoLabel = string.Format("{0}{1}. {2}{3} ({4}%)				Click on an asset's checkbox to include it in size calculation. Click on the filename to highlight it on your Project window.", Labels.SELECTED_QTY_LABEL, listToDisplay.GetSelectedCount().ToString("N0"), Labels.SELECTED_SIZE_LABEL, listToDisplay.GetReadableSizeOfSumSelection(), listToDisplay.GetPercentageOfSumSelection().ToString("N"));

            GUI.Label(new Rect(0, position.height - 20, position.width, 20), selectedInfoLabel, BuildReportTool.Window.Settings.STATUS_BAR_LABEL_STYLE_NAME);
        }
예제 #10
0
        void DrawTopBar(Rect position, BuildInfo buildReportToDisplay, BuildReportTool.FileFilterGroup fileFilterGroupToUse)
        {
            BuildReportTool.AssetList assetListUsed = GetAssetListToDisplay(buildReportToDisplay);

            if (assetListUsed == null)
            {
                return;
            }


            Texture2D prevArrow = GUI.skin.GetStyle(BuildReportTool.Window.Settings.BIG_LEFT_ARROW_ICON_STYLE_NAME).normal.background;
            Texture2D nextArrow = GUI.skin.GetStyle(BuildReportTool.Window.Settings.BIG_RIGHT_ARROW_ICON_STYLE_NAME).normal.background;


            GUILayout.BeginHorizontal(GUILayout.Height(11));

            GUILayout.Label(" ", BuildReportTool.Window.Settings.TOP_BAR_BG_STYLE_NAME);

            // ------------------------------------------------------------------------------------------------------
            // File Filters

            fileFilterGroupToUse.Draw(assetListUsed, position.width - 100);

            // ------------------------------------------------------------------------------------------------------

            GUILayout.Space(20);

            // ------------------------------------------------------------------------------------------------------
            // Unused Assets Batch

            if (IsShowingUnusedAssets)
            {
                int batchNumber = buildReportToDisplay.UnusedAssetsBatchNum + 1;

                if (GUILayout.Button(prevArrow, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME) && (batchNumber - 1 >= 1))
                {
                    // move to previous batch
                    BuildReportTool.ReportGenerator.MoveUnusedAssetsBatchToPrev(buildReportToDisplay, fileFilterGroupToUse);
                }

                string batchLabel = "Batch " + batchNumber;
                GUILayout.Label(batchLabel, BuildReportTool.Window.Settings.TOP_BAR_LABEL_STYLE_NAME);

                if (GUILayout.Button(nextArrow, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME))
                {
                    // move to next batch
                    // (possible to have no new batch anymore. if so, it will just fail silently)
                    BuildReportTool.ReportGenerator.MoveUnusedAssetsBatchToNext(buildReportToDisplay, fileFilterGroupToUse);
                }
            }

            // ------------------------------------------------------------------------------------------------------

            // ------------------------------------------------------------------------------------------------------
            // Paginate Buttons

            BuildReportTool.SizePart[] assetListToUse = assetListUsed.GetListToDisplay(fileFilterGroupToUse);

            int assetListLength = 0;

            if (assetListToUse != null)
            {
                assetListLength = assetListToUse.Length;
            }

            int viewOffset = assetListUsed.GetViewOffsetForDisplayedList(fileFilterGroupToUse);

            int len = Mathf.Min(viewOffset + BuildReportTool.Options.AssetListPaginationLength, assetListLength);
            int offsetNonZeroBased = viewOffset + (len > 0 ? 1 : 0);

            string NUM_STR = "D" + assetListLength.ToString().Length;


            if (GUILayout.Button(prevArrow, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME) && (viewOffset - BuildReportTool.Options.AssetListPaginationLength >= 0))
            {
                assetListUsed.SetViewOffsetForDisplayedList(fileFilterGroupToUse, viewOffset - BuildReportTool.Options.AssetListPaginationLength);
                _assetListScrollPos.y = 0;
            }

            string paginateLabel = "Page " + offsetNonZeroBased.ToString(NUM_STR) + " - " + len.ToString(NUM_STR) + " of " + assetListLength.ToString(NUM_STR);

            GUILayout.Label(paginateLabel, BuildReportTool.Window.Settings.TOP_BAR_LABEL_STYLE_NAME);

            if (GUILayout.Button(nextArrow, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME) && (viewOffset + BuildReportTool.Options.AssetListPaginationLength < assetListLength))
            {
                assetListUsed.SetViewOffsetForDisplayedList(fileFilterGroupToUse, viewOffset + BuildReportTool.Options.AssetListPaginationLength);
                _assetListScrollPos.y = 0;
            }

            // ------------------------------------------------------------------------------------------------------


            GUILayout.FlexibleSpace();

            _searchTextInput = GUILayout.TextField(_searchTextInput, "TextField-Search", GUILayout.MinWidth(200));
            if (GUILayout.Button(string.Empty, "TextField-Search-ClearButton"))
            {
                ClearSearch();
            }

            // ------------------------------------------------------------------------------------------------------
            // Recalculate Imported sizes
            // (makes sense only for unused assets)

            if (_currentListDisplayed != ListToDisplay.UsedAssets && GUILayout.Button(Labels.RECALC_IMPORTED_SIZES, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME))
            {
                assetListUsed.PopulateImportedSizes();
            }

            // ------------------------------------------------------------------------------------------------------



            // ------------------------------------------------------------------------------------------------------
            // Selection buttons

            if (GUILayout.Button(Labels.SELECT_ALL_LABEL, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME))
            {
                assetListUsed.AddAllDisplayedToSumSelection(fileFilterGroupToUse);
            }
            if (GUILayout.Button(Labels.SELECT_NONE_LABEL, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME))
            {
                assetListUsed.ClearSelection();
            }

            // ------------------------------------------------------------------------------------------------------



            // ------------------------------------------------------------------------------------------------------
            // Delete buttons

            if (ShouldShowDeleteButtons(buildReportToDisplay))
            {
                GUI.backgroundColor = Color.red;
                const string delSelectedLabel = "Delete selected";
                if (GUILayout.Button(delSelectedLabel, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME))
                {
                    InitiateDeleteSelectedUsed(buildReportToDisplay);
                }

                const string deleteAllLabel = "Delete all";
                if (GUILayout.Button(deleteAllLabel, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME))
                {
                    InitiateDeleteAllUnused(buildReportToDisplay);
                }

                GUI.backgroundColor = Color.white;
            }

            // ------------------------------------------------------------------------------------------------------

            GUILayout.EndHorizontal();


            GUILayout.Space(5);
        }
예제 #11
0
        void DrawAssetList(Rect position, BuildReportTool.AssetList list, BuildReportTool.FileFilterGroup filter, int length)
        {
            if (list != null)
            {
                if (_searchResults != null && _searchResults.Length == 0)
                {
                    DrawCentralMessage(position, "No search results");
                    return;
                }

                BuildReportTool.SizePart[] assetListToUse;

                var hasSearchResults = _searchResults != null;

                if (hasSearchResults && _searchResults.Length > 0)
                {
                    assetListToUse = _searchResults;
                }
                else
                {
                    assetListToUse = list.GetListToDisplay(filter);
                }

                if (assetListToUse != null)
                {
                    if (assetListToUse.Length == 0)
                    {
                        GUILayout.BeginHorizontal();
                        GUILayout.Space(10);
                        GUILayout.Label(Labels.NO_FILES_FOR_THIS_CATEGORY_LABEL, BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
                        GUILayout.EndHorizontal();
                    }
                    else
                    {
                        EditorGUIUtility.SetIconSize(Vector2.one * ICON_DISPLAY_SIZE);
                        bool useAlt = false;

                        int viewOffset = list.GetViewOffsetForDisplayedList(filter);

                        // if somehow view offset was out of bounds of the SizePart[] array
                        // reset it to zero
                        if (viewOffset >= assetListToUse.Length)
                        {
                            list.SetViewOffsetForDisplayedList(filter, 0);
                            viewOffset = 0;
                        }

                        int len = Mathf.Min(viewOffset + length, assetListToUse.Length);



                        GUILayout.BeginHorizontal();


                        // --------------------------------------------------------------------------------------------------------
                        // column: asset path and name
                        GUILayout.BeginVertical();
                        useAlt = false;

                        //GUILayout.Box("", BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME, GUILayout.Height(LIST_HEIGHT), GUILayout.Width(position.width));

                        GUILayout.BeginHorizontal();


                        string sortTypeAssetFullPathStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME;
                        if (!hasSearchResults && list.CurrentSortType == BuildReportTool.AssetList.SortType.AssetFullPath)
                        {
                            if (list.CurrentSortOrder == BuildReportTool.AssetList.SortOrder.Descending)
                            {
                                sortTypeAssetFullPathStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_DESC_STYLE_NAME;
                            }
                            else
                            {
                                sortTypeAssetFullPathStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_ASC_STYLE_NAME;
                            }
                        }
                        if (GUILayout.Button("Asset Path", sortTypeAssetFullPathStyleName, GUILayout.Height(LIST_HEIGHT)) && !hasSearchResults)
                        {
                            list.ToggleSort(BuildReportTool.AssetList.SortType.AssetFullPath);
                        }


                        string sortTypeAssetFilenameStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME;
                        if (!hasSearchResults && list.CurrentSortType == BuildReportTool.AssetList.SortType.AssetFilename)
                        {
                            if (list.CurrentSortOrder == BuildReportTool.AssetList.SortOrder.Descending)
                            {
                                sortTypeAssetFilenameStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_DESC_STYLE_NAME;
                            }
                            else
                            {
                                sortTypeAssetFilenameStyleName = BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_ASC_STYLE_NAME;
                            }
                        }
                        if (GUILayout.Button("Asset Filename", sortTypeAssetFilenameStyleName, GUILayout.Height(LIST_HEIGHT)) && !hasSearchResults)
                        {
                            list.ToggleSort(BuildReportTool.AssetList.SortType.AssetFilename);
                        }
                        GUILayout.EndHorizontal();


                        // --------------------------------------------------------------------------------------------------------

                        _assetListScrollPos = GUILayout.BeginScrollView(_assetListScrollPos, BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME, BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME);

                        for (int n = viewOffset; n < len; ++n)
                        {
                            BuildReportTool.SizePart b = assetListToUse[n];

                            string styleToUse  = useAlt ? BuildReportTool.Window.Settings.LIST_SMALL_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_SMALL_STYLE_NAME;
                            bool   inSumSelect = list.InSumSelection(b);
                            if (inSumSelect)
                            {
                                styleToUse = BuildReportTool.Window.Settings.LIST_SMALL_SELECTED_NAME;
                            }

                            GUILayout.BeginHorizontal();

                            if (b.Name.StartsWith("Assets/"))
                            {
                                if (GUILayout.Button("Ping", GUILayout.Width(37)))
                                {
                                    Utility.PingAssetInProject(b.Name);
                                }
                            }
                            else
                            {
                                GUILayout.Space(37);
                            }


                            // the asset name
                            Texture icon = AssetDatabase.GetCachedIcon(b.Name);

                            string prettyName = string.Empty;

                            prettyName = string.Format(" {0}. <color=#{1}>{2}{3}</color><b>{4}</b>", (n + 1), GetPathColor(inSumSelect), BuildReportTool.Util.GetAssetPath(b.Name), BuildReportTool.Util.GetAssetPathToNameSeparator(b.Name), BuildReportTool.Util.GetAssetFilename(b.Name));



                            GUIStyle styleObjToUse = GUI.skin.GetStyle(styleToUse);
                            Color    temp          = styleObjToUse.normal.textColor;
                            int      origLeft      = styleObjToUse.padding.left;
                            int      origRight     = styleObjToUse.padding.right;

                            styleObjToUse.normal.textColor = styleObjToUse.onNormal.textColor;
                            styleObjToUse.padding.right    = 0;

                            if (icon == null)
                            {
                                //GUILayout.BeginHorizontal(styleObjToUse);
                                GUILayout.Space(24);
                                //GUILayout.EndHorizontal();
                            }

                            styleObjToUse.normal.textColor = temp;
                            styleObjToUse.padding.left     = 2;
                            if (GUILayout.Button(new GUIContent(prettyName, icon), styleObjToUse, GUILayout.Height(LIST_HEIGHT)))
                            {
                                if (Event.current.control)
                                {
                                    if (!inSumSelect)
                                    {
                                        list.AddToSumSelection(b);
                                        _lastClickedEntryIdx = n;
                                    }
                                    else
                                    {
                                        list.ToggleSumSelection(b);
                                        _lastClickedEntryIdx = -1;
                                    }
                                }
                                else if (Event.current.shift)
                                {
                                    if (_lastClickedEntryIdx != -1)
                                    {
                                        // select all from last clicked to here
                                        if (_lastClickedEntryIdx < n)
                                        {
                                            for (int addToSelectIdx = _lastClickedEntryIdx; addToSelectIdx <= n; ++addToSelectIdx)
                                            {
                                                list.AddToSumSelection(assetListToUse[addToSelectIdx]);
                                            }
                                        }
                                        else if (_lastClickedEntryIdx > n)
                                        {
                                            for (int addToSelectIdx = n; addToSelectIdx <= _lastClickedEntryIdx; ++addToSelectIdx)
                                            {
                                                list.AddToSumSelection(assetListToUse[addToSelectIdx]);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        list.AddToSumSelection(b);
                                    }

                                    _lastClickedEntryIdx = n;
                                }
                                else
                                {
                                    list.ClearSelection();
                                    list.AddToSumSelection(b);
                                    _lastClickedEntryIdx = n;
                                }
                            }
                            styleObjToUse.padding.right = origRight;
                            styleObjToUse.padding.left  = origLeft;


                            GUILayout.EndHorizontal();

                            useAlt = !useAlt;
                        }


                        GUILayout.Space(SCROLLBAR_BOTTOM_PADDING);

                        GUILayout.EndScrollView();

                        GUILayout.EndVertical();



                        bool pressedRawSizeSortBtn = false;
                        bool pressedImpSizeSortBtn = false;

                        bool pressedSizeBeforeBuildSortBtn = false;

                        // --------------------------------------------------------------------------------------------------------
                        // column: raw file size


                        if (IsShowingUsedAssets && (assetListToUse[0].SizeInAssetsFolderBytes != -1))
                        {
                            pressedSizeBeforeBuildSortBtn = DrawColumn(viewOffset, len, BuildReportTool.AssetList.SortType.SizeBeforeBuild, "Size Before Build   ", !hasSearchResults, false,
                                                                       list, assetListToUse, (b) => b.SizeInAssetsFolder, ref _assetListScrollPos);
                        }

                        if (IsShowingUsedAssets && BuildReportTool.Options.ShowImportedSizeForUsedAssets)
                        {
                            pressedRawSizeSortBtn = DrawColumn(viewOffset, len, BuildReportTool.AssetList.SortType.ImportedSizeOrRawSize, "Size In Build", !hasSearchResults, false,
                                                               list, assetListToUse, (b) =>
                            {
                                // assets in the "StreamingAssets" folder do not have an imported size
                                // in those cases, the raw size is the same as the imported size
                                // so just use the raw size
                                if (b.ImportedSize == "N/A")
                                {
                                    return(b.RawSize);
                                }

                                return(b.ImportedSize);
                            }, ref _assetListScrollPos);
                        }

                        if (IsShowingUnusedAssets || (IsShowingUsedAssets && !BuildReportTool.Options.ShowImportedSizeForUsedAssets))
                        {
                            pressedRawSizeSortBtn = DrawColumn(viewOffset, len, BuildReportTool.AssetList.SortType.RawSize, (IsShowingUnusedAssets ? "Raw Size" : "Size In Build"), !hasSearchResults, false,
                                                               list, assetListToUse, (b) => b.RawSize, ref _assetListScrollPos);
                        }


                        bool showScrollbarForImportedSize = IsShowingUnusedAssets;


                        // --------------------------------------------------------------------------------------------------------
                        // column: imported file size


                        if (IsShowingUnusedAssets)
                        {
                            pressedImpSizeSortBtn = DrawColumn(viewOffset, len, BuildReportTool.AssetList.SortType.ImportedSize, "Imported Size   ", !hasSearchResults, showScrollbarForImportedSize,
                                                               list, assetListToUse, (b) => b.ImportedSize, ref _assetListScrollPos);
                        }


                        // --------------------------------------------------------------------------------------------------------
                        // column: percentage to total size

                        bool pressedPercentSortBtn = false;

                        if (IsShowingUsedAssets)
                        {
                            pressedPercentSortBtn = DrawColumn(viewOffset, len, BuildReportTool.AssetList.SortType.PercentSize, "Percent   ", !hasSearchResults, true,
                                                               list, assetListToUse, (b) => {
                                string text = b.Percentage + "%";
                                if (b.Percentage < 0)
                                {
                                    text = Labels.NON_APPLICABLE_PERCENTAGE_LABEL;
                                }
                                return(text);
                            }, ref _assetListScrollPos);
                        }

                        // --------------------------------------------------------------------------------------------------------

                        if (!hasSearchResults)
                        {
                            if (pressedRawSizeSortBtn)
                            {
                                var sortType = BuildReportTool.AssetList.SortType.RawSize;
                                if (IsShowingUsedAssets && BuildReportTool.Options.ShowImportedSizeForUsedAssets)
                                {
                                    sortType = BuildReportTool.AssetList.SortType.ImportedSizeOrRawSize;
                                }
                                list.ToggleSort(sortType);
                            }
                            else if (pressedSizeBeforeBuildSortBtn)
                            {
                                list.ToggleSort(BuildReportTool.AssetList.SortType.SizeBeforeBuild);
                            }
                            else if (pressedImpSizeSortBtn)
                            {
                                list.ToggleSort(BuildReportTool.AssetList.SortType.ImportedSize);
                            }
                            else if (pressedPercentSortBtn)
                            {
                                list.ToggleSort(BuildReportTool.AssetList.SortType.PercentSize);
                            }
                        }


                        GUILayout.EndHorizontal();
                    }
                }
            }
        }
예제 #12
0
        void Search(string searchText, SearchType searchType, bool searchFilenameOnly, bool caseSensitive, BuildInfo buildReportToDisplay)
        {
            if (string.IsNullOrEmpty(searchText))
            {
                _searchResults = null;
                return;
            }

            BuildReportTool.AssetList list = GetAssetListToDisplay(buildReportToDisplay);


            BuildReportTool.FileFilterGroup filter = buildReportToDisplay.FileFilters;

            if (BuildReportTool.Options.ShouldUseConfiguredFileFilters())
            {
                filter = _configuredFileFilterGroup;
            }

            List <BuildReportTool.SizePart> searchResults = new List <BuildReportTool.SizePart>();


            BuildReportTool.SizePart[] assetListToSearchFrom = list.GetListToDisplay(filter);

            var options = caseSensitive ? System.Text.RegularExpressions.RegexOptions.None : System.Text.RegularExpressions.RegexOptions.IgnoreCase;

            for (int n = 0; n < assetListToSearchFrom.Length; ++n)
            {
                string input;
                if (searchFilenameOnly)
                {
                    input = Path.GetFileName(assetListToSearchFrom[n].Name);
                }
                else
                {
                    input = assetListToSearchFrom[n].Name;
                }

                bool assetIsMatch;
                switch (searchType)
                {
                case SearchType.Regex:
                    try
                    {
                        assetIsMatch = System.Text.RegularExpressions.Regex.IsMatch(input, searchText, options);
                    }
                    catch (ArgumentException)
                    {
                        assetIsMatch = false;
                    }
                    break;

                case SearchType.Fuzzy:
                    assetIsMatch = IsANearStringMatch(input, searchText);
                    break;

                default:
                    // default is SearchType.Basic
                    assetIsMatch = System.Text.RegularExpressions.Regex.IsMatch(input, BuildReportTool.Util.WildCardToRegex(searchText), options);
                    break;
                }

                if (assetIsMatch)
                {
                    searchResults.Add(assetListToSearchFrom[n]);
                }
            }

            if (searchResults.Count > 0)
            {
                searchResults.Sort((a, b) =>
                                   GetFuzzyEqualityScore(searchText, a.Name).CompareTo(GetFuzzyEqualityScore(searchText, b.Name)));
            }

            _searchResults = searchResults.ToArray();
        }
예제 #13
0
        void DrawAssetList(BuildReportTool.AssetList assetList, bool usedAssets, BuildInfo buildReportToDisplay,
                           AssetDependencies assetDependencies)
        {
            if (assetList == null || assetList.TopLargest == null)
            {
                //Debug.LogError("no top ten largest");
                return;
            }

            BuildReportTool.SizePart[] assetsToShow = assetList.TopLargest;

            if (assetsToShow == null)
            {
                //Debug.LogError("no top ten largest");
                return;
            }

            bool useAlt = true;

            var newEntryHoveredIdx = -1;

            BuildReportTool.SizePart newEntryHovered = null;
            Rect newEntryHoveredRect = new Rect();
            Rect iconRect            = new Rect();
            var  hoveringOverIcon    = false;

            //var hoveringOverLabel = false;

            GUILayout.BeginHorizontal();

            // 1st column: name
            GUILayout.BeginVertical();
            for (int n = 0; n < assetsToShow.Length; ++n)
            {
                BuildReportTool.SizePart b = assetsToShow[n];

                string styleToUse = useAlt
                                                            ? BuildReportTool.Window.Settings.LIST_NORMAL_ALT_STYLE_NAME
                                                            : BuildReportTool.Window.Settings.LIST_NORMAL_STYLE_NAME;
                string iconStyleToUse = useAlt
                                                                ? BuildReportTool.Window.Settings.LIST_ICON_ALT_STYLE_NAME
                                                                : BuildReportTool.Window.Settings.LIST_ICON_STYLE_NAME;

                Texture icon = AssetDatabase.GetCachedIcon(b.Name);

                GUILayout.BeginHorizontal();
                if (icon == null)
                {
                    // no icon, just add space so it aligns with the other entries
                    GUILayout.Label(string.Empty, iconStyleToUse, GUILayout.Width(28), GUILayout.Height(30));
                }
                else
                {
                    GUILayout.Button(icon, iconStyleToUse, GUILayout.Width(28), GUILayout.Height(30));
                }

                if (Event.current.type == EventType.Repaint)
                {
                    iconRect = GUILayoutUtility.GetLastRect();

                    // if mouse is hovering over asset entry's icon (not the label)
                    // draw a border on the asset icon
                    if (iconRect.Contains(Event.current.mousePosition))
                    {
                        hoveringOverIcon    = true;
                        newEntryHoveredIdx  = n;
                        newEntryHovered     = b;
                        newEntryHoveredRect = iconRect;

                        GUI.Box(iconRect, icon, "IconHovered");
                    }
                }

                string prettyName = string.Format(" {0}. {1}", (n + 1).ToString(), BuildReportTool.Util.GetAssetFilename(b.Name));
                if (GUILayout.Button(prettyName, styleToUse, GUILayout.MinWidth(100), GUILayout.MaxWidth(400),
                                     GUILayout.Height(30)))
                {
                    Utility.PingAssetInProject(b.Name);
                }

                if (newEntryHoveredIdx == -1 && Event.current.type == EventType.Repaint)
                {
                    var labelRect = GUILayoutUtility.GetLastRect();

                    // if mouse is hovering over asset entry's label
                    // draw a border on the asset icon
                    if (labelRect.Contains(Event.current.mousePosition))
                    {
                        //hoveringOverLabel = true;
                        newEntryHoveredIdx  = n;
                        newEntryHovered     = b;
                        newEntryHoveredRect = labelRect;

                        GUI.Box(iconRect, icon, "IconHovered");
                    }
                }

                GUILayout.EndHorizontal();

                useAlt = !useAlt;
            }

            GUILayout.EndVertical();


            if (Event.current.type == EventType.Repaint)
            {
                if (usedAssets)
                {
                    _assetUsedEntryHoveredIdx = newEntryHoveredIdx;
                }
                else
                {
                    _assetUnusedEntryHoveredIdx = newEntryHoveredIdx;
                }

                if (newEntryHoveredIdx != -1)
                {
                    string hoveredAssetPath = newEntryHovered != null ? newEntryHovered.Name : null;

                    // ----------------
                    // update what is considered the hovered asset, for use later on
                    // when the tooltip will be drawn
                    BRT_BuildReportWindow.UpdateHoveredAsset(hoveredAssetPath, newEntryHoveredRect,
                                                             usedAssets, buildReportToDisplay, assetDependencies);

                    // ----------------
                    // if mouse is hovering over the correct area, we signify that
                    // the tooltip thumbnail should be drawn
                    if (BuildReportTool.Options.ShowTooltipThumbnail &&
                        (BuildReportTool.Options.ShowThumbnailOnHoverLabelToo || hoveringOverIcon) &&
                        BRT_BuildReportWindow.GetAssetPreview(hoveredAssetPath) != null)
                    {
                        _shouldShowThumbnailOnHoveredAsset = true;
                    }
                    else
                    {
                        _shouldShowThumbnailOnHoveredAsset = false;
                    }
                }
            }

            // 2nd column: size

            var useRawSize = (usedAssets && !BuildReportTool.Options.ShowImportedSizeForUsedAssets) || !usedAssets;

            useAlt = true;
            GUILayout.BeginVertical();
            for (int n = 0; n < assetsToShow.Length; ++n)
            {
                BuildReportTool.SizePart b = assetsToShow[n];

                string styleToUse = useAlt
                                                            ? BuildReportTool.Window.Settings.LIST_NORMAL_ALT_STYLE_NAME
                                                            : BuildReportTool.Window.Settings.LIST_NORMAL_STYLE_NAME;

                GUILayout.Label(useRawSize ? b.RawSize : b.ImportedSize, styleToUse, GUILayout.MaxWidth(100),
                                GUILayout.Height(30));

                useAlt = !useAlt;
            }

            GUILayout.EndVertical();
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();
        }