Container.c

Go to the documentation of this file.

class Container extends LayoutHolder
{
  protected ref array<ref LayoutHolder> m_Body;
  protected ref array<LayoutHolder> m_OpenedContainers;
  protected int m_ActiveIndex = 0;
  protected bool m_LastIndex; //deprecated
  protected bool m_Closed;
  protected Container m_FocusedContainer;
  protected float m_PrevAlpha;
  const int ITEMS_IN_ROW = 8;
 
  //protected int             m_RowCount;
  protected int m_ColumnCount;
 
  protected int m_FocusedColumn = 0;
  protected bool m_ForcedHide;
  protected bool m_ForcedShow; //used to override displayability condition, but 'm_ForcedHide' takes preference
 
  protected SlotsIcon m_SlotIcon;
  protected EntityAI m_Entity;
 
  const int SORT_ATTACHMENTS_OWN = 1; //direct attachments of the parent item
  const int SORT_CARGO_OWN = 2; //cargo of the parent item
  const int SORT_ATTACHMENTS_NEXT_OFFSET = 2;
  const int SORT_CARGO_NEXT_OFFSET = 3;
 
  void OnDropReceivedFromHeader(Widget w, int x, int y, Widget receiver);
  void DraggingOver(Widget w, int x, int y, Widget receiver);
  void DraggingOverHeader(Widget w, int x, int y, Widget receiver);
  void UpdateSpacer();
  Header GetHeader();
  void SetHeader(Header header);
  void CheckHeaderDragability();
 
  void Container(LayoutHolder parent)
  {
    m_Body = new array<ref LayoutHolder>;
    m_OpenedContainers = new array<LayoutHolder>;
    m_PrevAlpha = m_RootWidget.GetAlpha();
    m_SlotIcon = null;
    m_ForcedHide = false;
    m_ForcedShow = false;
 
    m_ActiveIndex = 0;
    m_IsActive = false;
  }
 
  Container GetFocusedContainer()
  {
    if (m_ActiveIndex < m_OpenedContainers.Count())
      return Container.Cast(m_OpenedContainers[m_ActiveIndex]);
    return null;
  }
 
  Container GetContainer(int index)
  {
    if (index < m_Body.Count())
      return Container.Cast(m_Body[index]);
    return null;
  }
 
 
  void SetFocusedContainer(Container cont)
  {
    m_FocusedContainer = cont;
  }
 
  SlotsIcon GetFocusedSlotsIcon()
  {
    Container c = GetFocusedContainer();
    if (c)
      return c.GetFocusedSlotsIcon();
    return null;
  }
 
  int GetActiveIndex()
  {
    return m_ActiveIndex;
  }
 
  void SetActiveIndex(int index)
  {
    m_ActiveIndex = index;
  }
 
  ScrollWidget GetScrollWidget()
  {
    return null;
  }
 
  void UpdateRadialIcon()
  {
    if (m_SlotIcon)
      m_SlotIcon.GetRadialIconPanel().Show(false);
  }
 
  void SetSlotIcon(SlotsIcon icon)
  {
    m_SlotIcon = icon;
  }
 
  void SetDefaultFocus(bool while_micromanagment_mode = false)
  {
    m_ActiveIndex = 0;
  }
 
  void SetLastFocus()
  {
    m_ActiveIndex = 0;
    m_FocusedColumn = 0;
    if (m_OpenedContainers.Count() > 0)
      m_ActiveIndex = m_OpenedContainers.Count() - 1;
  }
 
  void Unfocus()
  {
  }
 
  void MoveGridCursor(int direction)
  {
    if (direction == Direction.UP)
      SetPreviousActive();
    else if (direction == Direction.DOWN)
      SetNextActive();
    else if (direction == Direction.RIGHT)
      SetNextRightActive();
    else if (direction == Direction.LEFT)
      SetNextLeftActive();
 
    UpdateSelectionIcons();
 
    Inventory.GetInstance().UpdateConsoleToolbar();
  }
 
  void ScrollToActiveContainer()
  {
    ScrollWidget sw = GetScrollWidget();
    if (sw)
    {
      float x, y, y_s;
 
      sw.GetScreenPos(x, y);
      sw.GetScreenSize(x, y_s);
      float f_y, f_h;
      float amount;
      f_y = GetFocusedContainerYScreenPos(true);
      f_h = GetFocusedContainerHeight(true);
 
      float next_pos = f_y + f_h;
 
      if (next_pos > (y + y_s))
      {
        amount = sw.GetVScrollPos() + next_pos - (y + y_s) + 2;
        sw.VScrollToPos(amount);
      }
      else if (f_y < y)
      {
        amount = sw.GetVScrollPos() + f_y - y - 2;
        sw.VScrollToPos(amount);
      }
 
      //CheckScrollbarVisibility();
    }
  }
 
  void CheckScrollbarVisibility()
  {
    ScrollWidget sw = GetScrollWidget();
    if (sw)
    {
      if (!sw.IsScrollbarVisible())
        sw.VScrollToPos01(0.0);
      else if (sw.GetVScrollPos01() > 1.0)
        sw.VScrollToPos01(1.0);
    }
  }
 
  void Open()
  {
    m_Closed = false;
    UpdateSelectionIcons();
  }
 
  void Close()
  {
    m_Closed = true;
    UpdateSelectionIcons();
  }
 
  bool IsOpened()
  {
    return !m_Closed;
  }
 
  void SetOpenForSlotIcon(bool open, SlotsIcon icon = null/*m_SlotIcon*/)
  {
    if (!icon)
      icon = m_SlotIcon;
 
    if (icon)
    {
      icon.GetRadialIcon().Show(open);
      icon.GetRadialIconClosed().Show(!open);
    }
    /*else
      {
      ErrorEx("Dbg No Icon");
      }*/
  }
 
  void Toggle()
  {
    if (IsOpened())
      Close();
    else
      Open();
    SetOpenForSlotIcon(IsOpened());
  }
 
  float GetFocusedContainerHeight(bool contents = false)
  {
    float x, y, result;
    if (GetFocusedContainer())
      y = GetFocusedContainer().GetFocusedContainerHeight(contents);
    else if (GetRootWidget())
      GetRootWidget().GetScreenSize(x, y);
 
    result = y;
 
    if (m_ActiveIndex == 0)
    {
      if (GetHeader())
      {
        GetHeader().GetRootWidget().GetScreenSize(x, y);
        result += y;
      }
    }
    return result;
  }
 
  float GetFocusedContainerYPos(bool contents = false)
  {
    float x, y;
    if (GetFocusedContainer())
      y = GetFocusedContainer().GetFocusedContainerYPos(contents);
    else if (GetRootWidget())
      GetRootWidget().GetPos(x, y);
 
    return y;
  }
 
  float GetFocusedContainerYScreenPos(bool contents = false)
  {
    float x, y, result;
    if (GetFocusedContainer())
      y = GetFocusedContainer().GetFocusedContainerYScreenPos(contents);
    else if (GetRootWidget())
      GetRootWidget().GetScreenPos(x, y);
 
 
    result = y;
 
    if (m_ActiveIndex == 0)
    {
      if (GetHeader())
      {
        GetHeader().GetRootWidget().GetScreenPos(x, y);
        result = y;
      }
    }
    return result;
  }
 
  int Count()
  {
    return m_Body.Count();
  }
 
  bool SelectItem()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().SelectItem();
    return false;
  }
 
  bool Select()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().Select();
    return false;
  }
 
  bool OnSelectButton()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().OnSelectButton();
    return false;
  }
 
  bool Combine()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().Combine();
    return true;
  }
 
  bool TransferItemToVicinity()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().TransferItemToVicinity();
    return false;
  }
 
  bool TransferItem()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().TransferItem();
    return false;
  }
 
  bool InspectItem()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().InspectItem();
    return false;
  }
 
  bool SplitItem()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().SplitItem();
    return false;
  }
 
  bool EquipItem()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().EquipItem();
    return false;
  }
 
  bool CanOpenCloseContainer()
  {
    if (ItemManager.GetInstance().IsMicromanagmentMode())
      return false;
 
    EntityAI focusedEntity = GetFocusedItem();
    if (focusedEntity)
    {
      if (GetFocusedContainer())
        return GetFocusedContainer().CanOpenCloseContainerEx(focusedEntity);
 
      return CanOpenCloseContainerEx(focusedEntity);
    }
 
    return false;
  }
 
  bool CanOpenCloseContainerEx(EntityAI focusedEntity)
  {
    return false;
  }
 
  bool CanSplit()
  {
    EntityAI focusedEntity = GetFocusedItem();
    if (focusedEntity)
    {
      if (GetFocusedContainer())
        return GetFocusedContainer().CanSplitEx(focusedEntity);
 
      return CanSplitEx(focusedEntity);
    }
 
    return false;
  }
 
  bool CanSplitEx(EntityAI focusedEntity)
  {
    if (ItemManager.GetInstance().IsMicromanagmentMode())
      return false;
 
    if (focusedEntity)
      return focusedEntity.CanBeSplit();
    return false;
  }
 
  bool CanDrop()
  {
    EntityAI focusedEntity = GetFocusedItem();
    if (focusedEntity)
    {
      if (GetFocusedContainer())
        return GetFocusedContainer().CanDropEx(focusedEntity);
 
      return CanDropEx(focusedEntity);
 
    }
 
    return false;
  }
 
  bool CanDropEx(EntityAI focusedEntity)
  {
    if (ItemManager.GetInstance().IsMicromanagmentMode())
      return false;
 
    if (focusedEntity)
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
      if (player)
        return player.CanDropEntity(focusedEntity);
    }
    return false;
  }
 
  bool CanSwapOrTakeToHands()
  {
    EntityAI focusedEntity = GetFocusedItem();
    if (focusedEntity)
    {
      if (GetFocusedContainer())
        return GetFocusedContainer().CanSwapOrTakeToHandsEx(focusedEntity);
 
      return CanSwapOrTakeToHandsEx(focusedEntity);
    }
 
    return false;
  }
 
  bool CanSwapOrTakeToHandsEx(EntityAI focusedEntity)
  {
    if (ItemManager.GetInstance().IsMicromanagmentMode())
      return false;
 
    if (focusedEntity)
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      EntityAI entityInHands = player.GetItemInHands();
      if (entityInHands)
      {
        InventoryLocation il = new InventoryLocation();
 
        if (!GameInventory.CanSwapEntitiesEx(focusedEntity, entityInHands))
          return GameInventory.CanForceSwapEntitiesEx(focusedEntity, null, entityInHands, il);
        else
          return true;
      }
      else
        return player.GetInventory().CanAddEntityIntoHands(focusedEntity);
    }
    return false;
  }
 
  bool CanEquip()
  {
    EntityAI focusedEntity = GetFocusedItem();
    if (focusedEntity)
    {
      if (GetFocusedContainer())
        return GetFocusedContainer().CanEquipEx(focusedEntity);
 
      return CanEquipEx(focusedEntity);
    }
 
    return false;
  }
 
  bool CanEquipEx(EntityAI focusedEntity)
  {
    if (ItemManager.GetInstance().IsMicromanagmentMode())
      return false;
 
    bool found = false;
    if (focusedEntity)
    {
      InventoryLocation il = new InventoryLocation;
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      found = player.GetInventory().FindFreeLocationFor(focusedEntity, FindInventoryLocationType.ATTACHMENT, il);
 
      if (!found)
      {
        for (int i = 0; i < focusedEntity.GetInventory().GetSlotIdCount(); i++)
        {
          int slot_id = focusedEntity.GetInventory().GetSlotId(i);
          EntityAI slot_item = player.GetInventory().FindAttachment(slot_id);
          if (slot_item && player.GetInventory().CanSwapEntitiesEx(focusedEntity, slot_item))
          {
            found = true;
            break;
          }
 
        }
      }
    }
    return found;
  }
 
  bool CanTakeToInventory()
  {
    EntityAI focusedEntity = GetFocusedItem();
    if (focusedEntity)
    {
      if (GetFocusedContainer())
        return GetFocusedContainer().CanTakeToInventoryEx(focusedEntity);
 
      return CanTakeToInventoryEx(focusedEntity);
    }
 
    return false;
  }
 
  bool CanTakeToInventoryEx(EntityAI focusedEntity)
  {
    if (ItemManager.GetInstance().IsMicromanagmentMode())
      return false;
 
    if (focusedEntity)
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      return player.GetInventory().CanAddEntityToInventory(focusedEntity, FindInventoryLocationType.CARGO);
    }
    return false;
  }
 
  bool CanCombine()
  {
    EntityAI focusedEntity = GetFocusedItem();
    if (focusedEntity)
    {
      if (GetFocusedContainer())
        return GetFocusedContainer().CanCombineEx(focusedEntity);
 
      return CanCombineEx(focusedEntity);
    }
 
    return false;
  }
 
  bool CanCombineEx(EntityAI focusedEntity)
  {
    if (ItemManager.GetInstance().IsMicromanagmentMode())
      return false;
 
    if (focusedEntity)
    {
      EntityAI entityInHands = PlayerBase.Cast(GetGame().GetPlayer()).GetItemInHands();
      if (focusedEntity != entityInHands)
        return (ItemManager.GetCombinationFlags(entityInHands, focusedEntity) != 0);
    }
    return false;
  }
 
  bool CanCombineAmmo()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().CanCombineAmmo();
    return false;
  }
 
  bool CanAddToQuickbarEx(EntityAI focusedEntity)
  {
    if (ItemManager.GetInstance().IsMicromanagmentMode())
      return false;
 
    if (focusedEntity)
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      if (focusedEntity.GetHierarchyRootPlayer() == player)
        return true;
    }
 
    return false;
  }
 
  bool AddItemToQuickbarRadial(EntityAI itemToAssign)
  {
    if (CanAddToQuickbarEx(itemToAssign))
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      DayZPlayerInventory dpi;
      dpi = player.GetDayZPlayerInventory();
 
      if (itemToAssign && dpi && !dpi.IsProcessing())
      {
        RadialQuickbarMenu.SetItemToAssign(itemToAssign);
 
        //open radial quickbar menu
        if (!GetGame().GetUIManager().IsMenuOpen(MENU_RADIAL_QUICKBAR))
          RadialQuickbarMenu.OpenMenu(GetGame().GetUIManager().FindMenu(MENU_INVENTORY));
      }
      return true;
    }
    return false;
  }
 
  bool IsEmpty()
  {
    return m_OpenedContainers.Count() == 0;
  }
 
  bool IsItemActive()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().IsItemActive();
    return false;
  }
 
  bool IsItemWithQuantityActive()
  {
    if (GetFocusedContainer())
      return GetFocusedContainer().IsItemWithQuantityActive();
    return false;
  }
 
  EntityAI GetFocusedItem()
  {
    EntityAI item;
    if (GetFocusedContainer())
      item = GetFocusedContainer().GetFocusedItem();
 
    return item;
  }
 
  EntityAI GetFocusedContainerEntity()
  {
    EntityAI item;
    if (GetFocusedContainer())
      item = GetFocusedContainer().GetFocusedContainerEntity();
    return item;
  }
 
  int GetColumnCount()
  {
    return m_ColumnCount;
  }
 
  void SetColumnCount(int count)
  {
    m_ColumnCount = count;
  }
 
  int GetFocusedColumn()
  {
    return m_FocusedColumn;
  }
 
  void SetFocusedColumn(int column)
  {
    m_FocusedColumn = column;
  }
 
  override void UpdateInterval()
  {
    for (int i = 0; i < m_Body.Count(); i++)
    {
      if (m_Body.Get(i))
        m_Body.Get(i).UpdateInterval();
    }
 
    CheckHeaderDragability();
  }
 
  override void SetLastActive()
  {
    if (m_IsActive)
    {
      m_IsActive = true;
      if (m_OpenedContainers.Count())
      {
        SetLastFocus();
        if (!m_OpenedContainers[m_ActiveIndex].IsActive())
        {
          for (int i = 0; i < m_OpenedContainers.Count() - 1; i++)
          {
            if (m_OpenedContainers[i].IsActive())
              m_OpenedContainers[i].SetActive(false);
          }
          m_OpenedContainers[m_ActiveIndex].SetLastActive();
        }
        else
          m_OpenedContainers[m_ActiveIndex].SetLastActive();
      }
    }
    else
    {
      m_IsActive = true;
      if (GetHeader())
        GetHeader().SetActive(m_IsActive);
      SetLastFocus();
      if (m_OpenedContainers.Count())
      {
        Container c = Container.Cast(m_OpenedContainers.Get(m_ActiveIndex));
        if (c)
          c.SetLastActive();
      }
    }
  }
 
  override void SetFirstActive()
  {
    if (!m_IsActive)
      SetActive(true);
    else
    {
      if (m_OpenedContainers.Count())
      {
        SetDefaultFocus();
        if (!m_OpenedContainers[m_ActiveIndex].IsActive())
        {
          for (int i = 1; i < m_OpenedContainers.Count(); i++)
          {
            if (m_OpenedContainers[i].IsActive())
              m_OpenedContainers[i].SetActive(false);
          }
          m_OpenedContainers[m_ActiveIndex].SetActive(true);
        }
        else
          m_OpenedContainers[m_ActiveIndex].SetFirstActive();
      }
    }
  }
 
  override void SetActive(bool active)
  {
    if (!active)
      HideOwnedTooltip();
 
    if (!active && !m_IsActive)
      return;
 
    super.SetActive(active);
    if (GetHeader())
      GetHeader().SetActive(active);
 
    if (m_MainWidget.FindAnyWidget("SelectedContainer"))
      m_MainWidget.FindAnyWidget("SelectedContainer").Show(active);
 
    Container c;
    if (active)
    {
 
      SetDefaultFocus();
      if (m_OpenedContainers.Count())
      {
        c = Container.Cast(m_OpenedContainers.Get(m_ActiveIndex));
        if (c)
          c.SetActive(active);
      }
    }
    else
    {
      c = GetFocusedContainer();
      if (c)
        GetFocusedContainer().SetActive(false);
      Unfocus();
      m_ActiveIndex = 0;
      m_FocusedColumn = 0;
    }
  }
 
  void UnfocusAll()
  {
    for (int i = 0; i < Count(); i++)
    {
      for (int j = 0; j < ITEMS_IN_ROW; j++)
      {
        SlotsIcon icon;
        if (Get(i) && Get(i).GetMainWidget())
          Get(i).GetMainWidget().GetUserData(icon);
 
        if (icon)
          icon.GetCursorWidget().Show(false);
      }
    }
  }
 
  void UnfocusGrid()
  {
    if (GetFocusedContainer())
    {
      m_FocusedColumn = 0;
      GetFocusedContainer().UnfocusAll();
    }
  }
 
  bool IsLastIndex()
  {
    return m_ActiveIndex == (m_OpenedContainers.Count() - 1);
  }
 
  bool IsFirstIndex()
  {
    return m_ActiveIndex == 0;
  }
 
  bool IsFirstContainerFocused()
  {
    return m_ActiveIndex == 0;
  }
 
  bool IsLastContainerFocused()
  {
    return m_ActiveIndex >= (m_OpenedContainers.Count() - 1);
  }
 
  void ResetFocusedContainer()
  {
    if (GetFocusedContainer())
      GetFocusedContainer().ResetFocusedContainer();
 
    m_ActiveIndex == 0;
  }
 
  void SetNextActive()
  {
    HideOwnedTooltip();
 
    Container active;
    if (m_OpenedContainers.Count())
      active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
 
    if (active && active.IsActive())
      active.SetNextActive();
    if (!active || !active.IsActive())
    {
      Container next;
      if (!IsLastContainerFocused())
      {
        m_ActiveIndex++;
 
        next = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
        next.SetActive(true);
      }
      else if (Container.Cast(GetParent()))
        SetActive(false);
      else
      {
        SetActive(false);
        SetFirstActive();
      }
    }
  }
 
  void SetPreviousActive(bool force = false)
  {
    HideOwnedTooltip();
    Container active;
    if (m_OpenedContainers.Count())
      active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
 
    if (active && active.IsActive())
      active.SetPreviousActive();
 
    if (!active || !active.IsActive())
    {
      Container prev;
      if (!IsFirstContainerFocused())
      {
        m_ActiveIndex--;
 
        prev = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
        prev.SetLastActive();
      }
      else if (Container.Cast(GetParent()))
        SetActive(false);
      else
      {
        SetActive(false);
        SetLastActive();
      }
    }
  }
 
  void SetNextRightActive()
  {
    Container active;
    if (m_OpenedContainers.Count())
      active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
 
    if (active)
      active.SetNextRightActive();
  }
 
  void SetNextLeftActive()
  {
    Container active;
    if (m_OpenedContainers.Count())
      active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
 
    if (active)
      active.SetNextLeftActive();
  }
 
  void SetSameLevelNextActive()
  {
    Container active;
    active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
    active.SetActive(false);
 
    m_ActiveIndex++;
    if (m_ActiveIndex > m_OpenedContainers.Count() - 1)
      m_ActiveIndex = 0;
 
    active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
    active.SetActive(true);
  }
 
  void SetSameLevelPreviousActive()
  {
    Container active;
    active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
    active.SetActive(false);
 
    m_ActiveIndex--;
    if (m_ActiveIndex < 0)
      m_ActiveIndex = m_OpenedContainers.Count() - 1;
 
    active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
    active.SetActive(true);
  }
 
  void RecomputeOpenedContainers()
  {
    m_OpenedContainers.Clear();
    int i;
    bool need_reset_focus = false;
    Container c;
    for (i = 0; i < m_Body.Count(); i++)
    {
      c = Container.Cast(m_Body.Get(i));
      if (c)
      {
        c.RecomputeOpenedContainers();
        if (c.IsDisplayable() && c.IsVisible())
          m_OpenedContainers.Insert(c);
        else if (c.IsActive())
        {
          c.SetActive(false);
          need_reset_focus = true;
        }
 
      }
    }
 
    //In case of removing focused container or change order of containers
    if (IsActive())
    {
      if (!need_reset_focus && (m_ActiveIndex >= m_OpenedContainers.Count() || !m_OpenedContainers[m_ActiveIndex].IsActive()))
      {
        need_reset_focus = true;
        for (i = 0; i < m_OpenedContainers.Count(); i++)
        {
          if (m_OpenedContainers[i].IsActive())
          {
            need_reset_focus = false;
            m_ActiveIndex = i;
          }
        }
      }
 
      if (need_reset_focus)
        SetFirstActive();
    }
  }
 
  override void SetLayoutName()
  {
    m_LayoutName = WidgetLayoutName.Container;
  }
 
  void Insert(LayoutHolder container, int pos = -1, bool immedUpdate = true)
  {
    if (pos > -1 && pos < m_Body.Count())
    {
      if (pos <= m_ActiveIndex)
        m_ActiveIndex++;
      m_Body.InsertAt(container, pos);
    }
    else
      m_Body.Insert(container);
 
    if (immedUpdate)
      Refresh();
  }
 
  void Remove(LayoutHolder container)
  {
    if (m_Body)
    {
      int index = m_Body.Find(container);
      if (index > -1)
      {
        index = m_OpenedContainers.Find(container);
        if (index > -1)
        {
          if (index <= m_ActiveIndex)
          {
            if (GetFocusedContainer() == container)
              SetPreviousActive(true);
            else
              m_ActiveIndex--;
          }
          m_OpenedContainers.RemoveItem(container);
        }
        m_Body.RemoveItem(container);
      }
    }
 
    Refresh();
  }
 
  LayoutHolder Get(int x)
  {
    return m_Body.Get(x);
  }
 
  override void Refresh()
  {
    for (int i = 0; i < m_Body.Count(); i++)
    {
      if (m_Body.Get(i))
        m_Body.Get(i).Refresh();
    }
  }
 
  void UpdateBodySpacers()
  {
    for (int i = 0; i < m_Body.Count(); i++)
    {
      Container c = Container.Cast(m_Body.Get(i));
      if (c && c.IsInherited(Container))
        c.UpdateSpacer();
    }
 
    UpdateSpacer();
  }
 
  void HideContent(bool force_hide = false)
  {
    if (!m_ForcedHide)
      m_ForcedHide = force_hide;
    for (int i = 0; i < m_Body.Count(); i++)
    {
      if (m_Body.Get(i))
        m_Body.Get(i).OnHide();
    }
  }
 
  void ShowContent(bool force_show = false)
  {
    if (force_show)
      m_ForcedHide = false;
 
    if (!m_ForcedHide)
    {
      for (int i = 0; i < m_Body.Count(); i++)
      {
        if (m_Body.Get(i))
          m_Body.Get(i).OnShow();
      }
    }
  }
 
  void SetForceShow(bool value)
  {
    m_ForcedShow = value;
  }
 
  override void UpdateSelectionIcons()
  {
    m_Parent.UpdateSelectionIcons();
  }
 
  void ExpandCollapseContainer() {}
}