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(){}
}