< Summary

Class:GridContainerComponentView
Assembly:UIComponents
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/UIComponents/Scripts/Components/GridContainer/GridContainerComponentView.cs
Covered lines:165
Uncovered lines:26
Coverable lines:191
Total lines:500
Line coverage:86.3% (165 of 191)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
GridContainerComponentView()0%110100%
Awake()0%110100%
Configure(...)0%110100%
RefreshControl()0%3.13077.78%
OnScreenSizeChanged()0%110100%
Dispose()0%110100%
SetConstraint(...)0%2.032080%
SetConstraintCount(...)0%2.032080%
SetItemSizeToContainerAdaptation(...)0%110100%
SetItemSize(...)0%12.0712092%
CalculateAutoSize(...)0%8.348082.61%
CalculateHorizontalSizeForFixedColumnConstraint(...)0%220100%
CalculateHorizontalSizeForFixedRowConstraint(...)0%110100%
CalculateHorizontalSizeForFlexibleConstraint(...)0%10.935038.1%
SetSpaceBetweenItems(...)0%2.032080%
SetMinWidthForFlexibleItems(...)0%110100%
SetItems(...)0%220100%
SetItems(...)0%220100%
AddItemWithResize(...)0%110100%
SetItemSizeForModel()0%110100%
AddItem(...)0%110100%
RemoveItem(...)0%220100%
GetItems()0%2100%
ExtractItems()0%330100%
RemoveItems()0%330100%
CreateItem(...)0%2.012087.5%
ResizeGridContainer()0%660100%
RegisterCurrentInstantiatedItems()0%4.014090.91%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/UIComponents/Scripts/Components/GridContainer/GridContainerComponentView.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Linq;
 4using UnityEngine;
 5using UnityEngine.UI;
 6using static UnityEngine.UI.GridLayoutGroup;
 7
 8public interface IGridContainerComponentView
 9{
 10    /// <summary>
 11    /// Number of items per row that fit with the current grid configuration.
 12    /// </summary>
 13    int currentItemsPerRow { get; }
 14
 15    /// <summary>
 16    /// Set the type of constraint of the grid.
 17    /// </summary>
 18    /// <param name="newConstraint">Type of constraint.</param>
 19    void SetConstraint(Constraint newConstraint);
 20
 21    /// <summary>
 22    /// Set the number of columns/rows of the grid depending on the type of constraint set.
 23    /// </summary>
 24    /// <param name="newConstraintCount">Number of columns or rows.</param>
 25    void SetConstraintCount(int newConstraintCount);
 26
 27    /// <summary>
 28    /// Set the item size adaptation to the container.
 29    /// </summary>
 30    /// <param name="adaptItemSizeToContainer">True for activate the size adaptation.</param>
 31    void SetItemSizeToContainerAdaptation(bool adaptItemSizeToContainer);
 32
 33    /// <summary>
 34    /// Set the size of each child item.
 35    /// </summary>
 36    /// <param name="newItemSize">Size of each child.</param>
 37    void SetItemSize(Vector2 newItemSize);
 38
 39    /// <summary>
 40    /// Set item size and resize grid container with respect to the current model.
 41    /// </summary>
 42    void SetItemSizeForModel();
 43
 44    /// <summary>
 45    /// Set the space between child items.
 46    /// </summary>
 47    /// <param name="newSpace">Space between children.</param>
 48    void SetSpaceBetweenItems(Vector2 newSpace);
 49
 50    /// <summary>
 51    /// Set the minimum width for the items when constraint is set to flexible.
 52    /// </summary>
 53    /// <param name="minWidthForFlexibleItems">Min item width.</param>
 54    void SetMinWidthForFlexibleItems(float minWidthForFlexibleItems);
 55
 56    /// <summary>
 57    /// Creates the items of the grid from the prefab. All previously existing items will be removed.
 58    /// </summary>
 59    /// <param name="prefab">Prefab to create items</param>
 60    /// <param name="amountOfItems">Amounts of items to be created</param>
 61    void SetItems(BaseComponentView prefab, int amountOfItems);
 62
 63    /// <summary>
 64    /// Set the items of the grid. All previously existing items will be removed.
 65    /// </summary>
 66    /// <param name="items">List of UI components.</param>
 67    void SetItems(List<BaseComponentView> items);
 68
 69    /// <summary>
 70    /// Adds a new item in the grid.
 71    /// </summary>
 72    /// <param name="item">An UI component.</param>
 73    void AddItem(BaseComponentView item);
 74
 75    /// <summary>
 76    /// Adds a new item in the grid and resize the grid.
 77    /// </summary>
 78    /// <param name="item">An UI component.</param>
 79    void AddItemWithResize(BaseComponentView item);
 80
 81    /// <summary>
 82    /// Remove an item from the grid.
 83    /// </summary>
 84    /// <param name="item">An UI component</param>
 85    void RemoveItem(BaseComponentView item);
 86
 87    /// <summary>
 88    /// Get all the items of the grid.
 89    /// </summary>
 90    /// <returns>List of items.</returns>
 91    List<BaseComponentView> GetItems();
 92
 93    /// <summary>
 94    /// Extract all items out of the grid.
 95    /// </summary>
 96    /// <returns>The list of extracted items.</returns>
 97    List<BaseComponentView> ExtractItems();
 98
 99    /// <summary>
 100    /// Remove all existing items from the grid.
 101    /// </summary>
 102    void RemoveItems();
 103}
 104
 105public class GridContainerComponentView : BaseComponentView, IGridContainerComponentView, IComponentModelConfig<GridCont
 106{
 107    [Header("Prefab References")]
 108    [SerializeField] internal GridLayoutGroup gridLayoutGroup;
 109    [SerializeField] internal RectTransform externalParentToAdaptSize;
 110
 111    [Header("Configuration")]
 112    [SerializeField] internal GridContainerComponentModel model;
 113
 1134114    internal List<BaseComponentView> instantiatedItems = new List<BaseComponentView>();
 115
 0116    public int currentItemsPerRow { get; internal set; }
 117
 118    public override void Awake()
 119    {
 898120        base.Awake();
 121
 898122        RegisterCurrentInstantiatedItems();
 898123    }
 124
 125    public void Configure(GridContainerComponentModel newModel)
 126    {
 7127        model = newModel;
 7128        RefreshControl();
 7129    }
 130
 131    public override void RefreshControl()
 132    {
 9133        if (model == null)
 0134            return;
 135
 136        //We only do this if we are from editor, this is done because the editor doesn't call awake method
 9137        if (!Application.isPlaying)
 0138            RegisterCurrentInstantiatedItems();
 139
 9140        SetConstraint(model.constraint);
 9141        SetItemSize(model.itemSize);
 9142        SetConstraintCount(model.constraintCount);
 9143        SetSpaceBetweenItems(model.spaceBetweenItems);
 9144    }
 145
 146    public override void OnScreenSizeChanged()
 147    {
 55148        base.OnScreenSizeChanged();
 149
 55150        SetItemSize(model.itemSize);
 55151        SetConstraintCount(model.constraintCount);
 55152    }
 153
 154    public override void Dispose()
 155    {
 2149156        base.Dispose();
 157
 2149158        RemoveItems();
 2149159    }
 160
 161    public void SetConstraint(Constraint newConstraint)
 162    {
 14163        model.constraint = newConstraint;
 164
 14165        if (gridLayoutGroup == null)
 0166            return;
 167
 14168        gridLayoutGroup.constraint = newConstraint;
 14169    }
 170
 171    public void SetConstraintCount(int newConstraintCount)
 172    {
 963173        model.constraintCount = newConstraintCount;
 174
 963175        if (gridLayoutGroup == null)
 0176            return;
 177
 963178        gridLayoutGroup.constraintCount = newConstraintCount;
 963179    }
 180
 181    public void SetItemSizeToContainerAdaptation(bool adaptItemSizeToContainer)
 182    {
 1183        model.adaptHorizontallyItemSizeToContainer = adaptItemSizeToContainer;
 1184        SetItemSize(model.itemSize);
 1185    }
 186
 187    public void SetItemSize(Vector2 newItemSize)
 188    {
 8938189        Vector2 newSizeToApply = newItemSize;
 190
 8938191        if (instantiatedItems.Count > 0)
 192        {
 1845193            if (model.adaptVerticallyItemSizeToContainer && model.adaptHorizontallyItemSizeToContainer)
 194            {
 15195                CalculateAutoSize(out newSizeToApply);
 15196            }
 1830197            else if (model.adaptVerticallyItemSizeToContainer)
 198            {
 199                //TODO: We need to implement this functionality. Nobody is using it
 200                //      Please implement it if needed
 0201                throw new Exception("Not implemented yet! Please implement the functionality");
 202            }
 1830203            else if (model.adaptHorizontallyItemSizeToContainer)
 204            {
 796205                switch (model.constraint)
 206                {
 207                    case Constraint.FixedColumnCount:
 792208                        CalculateHorizontalSizeForFixedColumnConstraint(out newSizeToApply);
 792209                        break;
 210                    case Constraint.FixedRowCount:
 2211                        CalculateHorizontalSizeForFixedRowConstraint(out newSizeToApply);
 2212                        break;
 213                    case Constraint.Flexible:
 2214                        CalculateHorizontalSizeForFlexibleConstraint(out newSizeToApply, newItemSize);
 2215                        break;
 216                }
 217            }
 218            else
 219            {
 1034220                switch (model.constraint)
 221                {
 222                    case Constraint.FixedColumnCount:
 223                    case Constraint.Flexible:
 1026224                        currentItemsPerRow = model.constraintCount;
 1026225                        break;
 226                    case Constraint.FixedRowCount:
 8227                        currentItemsPerRow = (int)Mathf.Ceil((float)instantiatedItems.Count / model.constraintCount);
 228                        break;
 229                }
 230            }
 231        }
 232
 8938233        model.itemSize = newSizeToApply;
 234
 8938235        if (gridLayoutGroup == null)
 0236            return;
 237
 8938238        gridLayoutGroup.cellSize = newSizeToApply;
 239
 8938240        ResizeGridContainer();
 8938241    }
 242
 243    private void CalculateAutoSize(out Vector2 newSizeToApply)
 244    {
 15245        float height = externalParentToAdaptSize != null ? externalParentToAdaptSize.rect.height : ((RectTransform)trans
 15246        float width = externalParentToAdaptSize != null ? externalParentToAdaptSize.rect.width : ((RectTransform)transfo
 247
 15248        int amountsOfHorizontalItemsPerRow =  instantiatedItems.Count / model.constraintCount;
 15249        int amountsOfVerticalItemsPerColumn =  instantiatedItems.Count / amountsOfHorizontalItemsPerRow;
 250
 15251        float extraSpaceToRemoveX = model.spaceBetweenItems.x * (amountsOfHorizontalItemsPerRow - 1);
 15252        float extraSpaceToRemoveY = model.spaceBetweenItems.y * (amountsOfVerticalItemsPerColumn - 1);
 253
 15254        float itemWidth = model.recommendedWidthForFlexibleItems;
 15255        float itemHeight = model.recommendedHeightForFlexibleItems;
 256
 15257        if (itemWidth * amountsOfHorizontalItemsPerRow + extraSpaceToRemoveX >= width)
 0258            itemWidth = (width - extraSpaceToRemoveX) / amountsOfHorizontalItemsPerRow;
 259
 15260        if (itemWidth < model.minWidthForFlexibleItems)
 0261            itemWidth = model.minWidthForFlexibleItems;
 262
 15263        if (itemHeight * amountsOfVerticalItemsPerColumn + extraSpaceToRemoveY >= height)
 0264            itemHeight = (height - extraSpaceToRemoveY) / amountsOfVerticalItemsPerColumn;
 265
 15266        if (itemHeight < model.minHeightForFlexibleItems)
 0267            itemHeight = model.minHeightForFlexibleItems;
 268
 15269        if (model.sameHeightAndWidhtFlexibleItem)
 270        {
 15271            float minValue = Mathf.Min(itemHeight, itemWidth);
 15272            itemHeight = minValue;
 15273            itemWidth = minValue;
 274        }
 275
 15276        newSizeToApply = new Vector2(
 277            itemWidth,
 278            itemHeight);
 279
 15280        currentItemsPerRow = model.constraintCount;
 15281    }
 282
 283    private void CalculateHorizontalSizeForFixedColumnConstraint(out Vector2 newSizeToApply)
 284    {
 792285        float width = externalParentToAdaptSize != null ? externalParentToAdaptSize.rect.width : ((RectTransform)transfo
 792286        float extraSpaceToRemove = (model.spaceBetweenItems.x * (model.constraintCount - 1)) / model.constraintCount;
 287
 792288        newSizeToApply = new Vector2(
 289            (width / model.constraintCount) - extraSpaceToRemove,
 290            model.itemSize.y);
 291
 792292        currentItemsPerRow = model.constraintCount;
 792293    }
 294
 295    private void CalculateHorizontalSizeForFixedRowConstraint(out Vector2 newSizeToApply)
 296    {
 2297        float height = ((RectTransform)transform).rect.height;
 2298        float extraSpaceToRemove = (model.spaceBetweenItems.y / (model.constraintCount / 2f));
 299
 2300        newSizeToApply = new Vector2(
 301            model.itemSize.x,
 302            (height / model.constraintCount) - extraSpaceToRemove);
 303
 2304        currentItemsPerRow = (int)Mathf.Ceil((float)instantiatedItems.Count / model.constraintCount);
 2305    }
 306
 307    private void CalculateHorizontalSizeForFlexibleConstraint(out Vector2 newSizeToApply, Vector2 newItemSize)
 308    {
 2309        newSizeToApply = newItemSize;
 310
 2311        float width = externalParentToAdaptSize != null ? externalParentToAdaptSize.rect.width : ((RectTransform)transfo
 2312        int numberOfPossibleItems = (int)(width / model.minWidthForFlexibleItems);
 313
 2314        SetConstraint(Constraint.FixedColumnCount);
 315
 2316        if (numberOfPossibleItems > 0)
 317        {
 0318            for (int numColumnsToTry = 1; numColumnsToTry <= numberOfPossibleItems; numColumnsToTry++)
 319            {
 0320                SetConstraintCount(numColumnsToTry);
 0321                SetItemSize(model.itemSize);
 0322                currentItemsPerRow = numColumnsToTry;
 323
 0324                if (model.itemSize.x < model.minWidthForFlexibleItems)
 325                {
 0326                    SetConstraintCount(numColumnsToTry - 1);
 0327                    SetItemSize(model.itemSize);
 0328                    currentItemsPerRow = numColumnsToTry - 1;
 0329                    break;
 330                }
 331
 0332                newSizeToApply = model.itemSize;
 333            }
 0334        }
 335        else
 336        {
 2337            newSizeToApply = new Vector2(model.minWidthForFlexibleItems, newSizeToApply.y);
 338        }
 339
 2340        SetConstraint(Constraint.Flexible);
 2341    }
 342
 343    public void SetSpaceBetweenItems(Vector2 newSpace)
 344    {
 2282345        model.spaceBetweenItems = newSpace;
 346
 2282347        if (gridLayoutGroup == null)
 0348            return;
 349
 2282350        gridLayoutGroup.spacing = newSpace;
 2282351    }
 352
 353    public void SetMinWidthForFlexibleItems(float minWidthForFlexibleItems)
 354    {
 1355        model.minWidthForFlexibleItems = minWidthForFlexibleItems;
 1356        SetItemSize(model.itemSize);
 1357    }
 358
 359    public void SetItems(BaseComponentView prefab, int amountOfItems)
 360    {
 2361        RemoveItems();
 362
 20363        for (int i = 0; i < amountOfItems; i++)
 364        {
 8365            BaseComponentView instanciatedItem = Instantiate(prefab);
 8366            CreateItem(instanciatedItem, $"Item{i}");
 367        }
 368
 2369        SetItemSize(model.itemSize);
 2370    }
 371
 372    public void SetItems(List<BaseComponentView> items)
 373    {
 12374        RemoveItems();
 375
 62376        for (int i = 0; i < items.Count; i++)
 377        {
 19378            CreateItem(items[i], $"Item{i}");
 379        }
 380
 12381        SetItemSize(model.itemSize);
 12382    }
 383
 384    public void AddItemWithResize(BaseComponentView item)
 385    {
 1407386        CreateItem(item, $"Item{instantiatedItems.Count}");
 1407387        SetItemSize(model.itemSize);
 1407388    }
 389
 390    public void SetItemSizeForModel() =>
 4391        SetItemSize(model.itemSize);
 392
 393    public void AddItem(BaseComponentView item) =>
 56394        CreateItem(item, $"Item{instantiatedItems.Count}");
 395
 396    public void RemoveItem(BaseComponentView item)
 397    {
 8398        BaseComponentView itemToRemove = instantiatedItems.FirstOrDefault(x => x == item);
 4399        if (itemToRemove != null)
 400        {
 4401            Destroy(itemToRemove.gameObject);
 4402            instantiatedItems.Remove(item);
 403        }
 404
 4405        SetItemSize(model.itemSize);
 4406    }
 407
 0408    public List<BaseComponentView> GetItems() { return instantiatedItems; }
 409
 410    public List<BaseComponentView> ExtractItems()
 411    {
 3386412        List<BaseComponentView> extractedItems = new List<BaseComponentView>();
 11680413        foreach (BaseComponentView item in instantiatedItems)
 414        {
 2454415            if (item != null)
 2449416                item.transform.SetParent(null);
 417
 2454418            extractedItems.Add(item);
 419        }
 420
 3386421        instantiatedItems.Clear();
 422
 3386423        SetItemSize(model.itemSize);
 424
 3386425        return extractedItems;
 426    }
 427
 428    public void RemoveItems()
 429    {
 3153430        List<BaseComponentView> itemsToDestroy = ExtractItems();
 9234431        foreach (BaseComponentView itemToDestroy in itemsToDestroy)
 432        {
 1464433            if (itemToDestroy != null)
 1459434                DestroyImmediate(itemToDestroy.gameObject);
 435        }
 3153436        itemsToDestroy.Clear();
 437
 3153438        instantiatedItems.Clear();
 439
 3153440        SetItemSize(model.itemSize);
 3153441    }
 442
 443    internal void CreateItem(BaseComponentView newItem, string name)
 444    {
 1491445        if (newItem == null)
 0446            return;
 447
 1491448        newItem.transform.SetParent(transform);
 1491449        newItem.transform.localPosition = Vector3.zero;
 1491450        newItem.transform.localScale = Vector3.one;
 1491451        newItem.name = name;
 452
 1491453        instantiatedItems.Add(newItem);
 1491454    }
 455
 456    private void ResizeGridContainer()
 457    {
 8938458        int currentNumberOfItems = transform.childCount;
 459
 8938460        if (currentNumberOfItems == 0)
 461        {
 6666462            ((RectTransform)transform).sizeDelta = Vector2.zero;
 6666463            return;
 464        }
 465
 2272466        if (model.constraint == Constraint.FixedColumnCount)
 467        {
 1303468            int numRows = (int)Mathf.Ceil((float)currentNumberOfItems / model.constraintCount);
 1303469            ((RectTransform)transform).sizeDelta = new Vector2(
 470                model.adaptHorizontallyItemSizeToContainer ? ((RectTransform)transform).sizeDelta.x : (model.constraintC
 471                (numRows * model.itemSize.y) + (model.spaceBetweenItems.y * (numRows - 1)));
 1303472        }
 969473        else if (model.constraint == Constraint.FixedRowCount)
 474        {
 35475            int numCols = (int)Mathf.Ceil((float)currentNumberOfItems / model.constraintCount);
 35476            ((RectTransform)transform).sizeDelta = new Vector2(
 477                (numCols * model.itemSize.x) + (model.spaceBetweenItems.x * (numCols - 1)),
 478                model.adaptHorizontallyItemSizeToContainer ? ((RectTransform)transform).sizeDelta.y : (model.constraintC
 479        }
 480
 2272481        SetSpaceBetweenItems(model.spaceBetweenItems);
 2272482    }
 483
 484    private void RegisterCurrentInstantiatedItems()
 485    {
 898486        instantiatedItems.Clear();
 487
 4204488        foreach (Transform child in transform)
 489        {
 1204490            BaseComponentView existingItem = child.GetComponent<BaseComponentView>();
 1204491            if (existingItem != null)
 1204492                instantiatedItems.Add(existingItem);
 493            else
 0494                DestroyImmediate(child.gameObject);
 495        }
 496
 898497        SetItemSize(model.itemSize);
 898498        SetConstraintCount(model.constraintCount);
 898499    }
 500}
Generated by: ReportGenerator 4.8.9.0
11/09/2022 - 19:59:51
GitHub | www.palmmedia.de

Methods/Properties

GridContainerComponentView()
currentItemsPerRow()
currentItemsPerRow(System.Int32)
Awake()
Configure(GridContainerComponentModel)
RefreshControl()
OnScreenSizeChanged()
Dispose()
SetConstraint(UnityEngine.UI.GridLayoutGroup/Constraint)
SetConstraintCount(System.Int32)
SetItemSizeToContainerAdaptation(System.Boolean)
SetItemSize(UnityEngine.Vector2)
CalculateAutoSize(UnityEngine.Vector2&)
CalculateHorizontalSizeForFixedColumnConstraint(UnityEngine.Vector2&)
CalculateHorizontalSizeForFixedRowConstraint(UnityEngine.Vector2&)
CalculateHorizontalSizeForFlexibleConstraint(UnityEngine.Vector2&, UnityEngine.Vector2)
SetSpaceBetweenItems(UnityEngine.Vector2)
SetMinWidthForFlexibleItems(System.Single)
SetItems(BaseComponentView, System.Int32)
SetItems(System.Collections.Generic.List[BaseComponentView])
AddItemWithResize(BaseComponentView)
SetItemSizeForModel()
AddItem(BaseComponentView)
RemoveItem(BaseComponentView)
GetItems()
ExtractItems()
RemoveItems()
CreateItem(BaseComponentView, System.String)
ResizeGridContainer()
RegisterCurrentInstantiatedItems()