Класс LayoutHolder

Граф наследования:LayoutHolder:

Защищенные члены
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)
Container	GetFocusedContainer ()
Container	GetContainer (int index)
void	SetFocusedContainer (Container cont)
SlotsIcon	GetFocusedSlotsIcon ()
int	GetActiveIndex ()
void	SetActiveIndex (int index)
ScrollWidget	GetScrollWidget ()
void	UpdateRadialIcon ()
void	SetSlotIcon (SlotsIcon icon)
void	SetDefaultFocus (bool while_micromanagment_mode=false)
void	SetLastFocus ()
void	Unfocus ()
void	MoveGridCursor (int direction)
void	ScrollToActiveContainer ()
void	CheckScrollbarVisibility ()
void	Open ()
void	Close ()
bool	IsOpened ()
void	SetOpenForSlotIcon (bool open, SlotsIcon icon=null)
void	Toggle ()
float	GetFocusedContainerHeight (bool contents=false)
float	GetFocusedContainerYPos (bool contents=false)
float	GetFocusedContainerYScreenPos (bool contents=false)
int	Count ()
bool	SelectItem ()
bool	Select ()
bool	OnSelectButton ()
bool	Combine ()
bool	TransferItemToVicinity ()
bool	TransferItem ()
bool	InspectItem ()
bool	SplitItem ()
bool	EquipItem ()
bool	CanOpenCloseContainer ()
bool	CanOpenCloseContainerEx (EntityAI focusedEntity)
bool	CanSplit ()
bool	CanSplitEx (EntityAI focusedEntity)
bool	CanDrop ()
bool	CanDropEx (EntityAI focusedEntity)
bool	CanSwapOrTakeToHands ()
bool	CanSwapOrTakeToHandsEx (EntityAI focusedEntity)
bool	CanEquip ()
bool	CanEquipEx (EntityAI focusedEntity)
bool	CanTakeToInventory ()
bool	CanTakeToInventoryEx (EntityAI focusedEntity)
bool	CanCombine ()
bool	CanCombineEx (EntityAI focusedEntity)
bool	CanCombineAmmo ()
bool	CanAddToQuickbarEx (EntityAI focusedEntity)
bool	AddItemToQuickbarRadial (EntityAI itemToAssign)
bool	IsEmpty ()
bool	IsItemActive ()
bool	IsItemWithQuantityActive ()
EntityAI	GetFocusedItem ()
EntityAI	GetFocusedContainerEntity ()
int	GetColumnCount ()
void	SetColumnCount (int count)
int	GetFocusedColumn ()
void	SetFocusedColumn (int column)
override void	UpdateInterval ()
override void	SetLastActive ()
override void	SetFirstActive ()
override void	SetActive (bool active)
void	UnfocusAll ()
void	UnfocusGrid ()
bool	IsLastIndex ()
bool	IsFirstIndex ()
bool	IsFirstContainerFocused ()
bool	IsLastContainerFocused ()
void	ResetFocusedContainer ()
void	SetNextActive ()
void	SetPreviousActive (bool force=false)
void	SetNextRightActive ()
void	SetNextLeftActive ()
void	SetSameLevelNextActive ()
void	SetSameLevelPreviousActive ()
void	RecomputeOpenedContainers ()
override void	SetLayoutName ()
void	Insert (LayoutHolder container, int pos=-1, bool immedUpdate=true)
void	Remove (LayoutHolder container)
LayoutHolder	Get (int x)
override void	Refresh ()
void	UpdateBodySpacers ()
void	HideContent (bool force_hide=false)
void	ShowContent (bool force_show=false)
void	SetForceShow (bool value)
override void	UpdateSelectionIcons ()
void	ExpandCollapseContainer ()

Защищенные данные
ref array< ref LayoutHolder >	m_Body
ref array< LayoutHolder >	m_OpenedContainers
int	m_ActiveIndex = 0
bool	m_LastIndex
bool	m_Closed
Container	m_FocusedContainer
float	m_PrevAlpha
const int	ITEMS_IN_ROW = 8
int	m_ColumnCount
int	m_FocusedColumn = 0
bool	m_ForcedHide
bool	m_ForcedShow
SlotsIcon	m_SlotIcon
EntityAI	m_Entity
const int	SORT_ATTACHMENTS_OWN = 1
const int	SORT_CARGO_OWN = 2
const int	SORT_ATTACHMENTS_NEXT_OFFSET = 2
const int	SORT_CARGO_NEXT_OFFSET = 3

Подробное описание

Методы

AddItemToQuickbarRadial()

bool AddItemToQuickbarRadial ( EntityAI itemToAssign )

inlineprotected

    {
        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;
    }

Перекрестные ссылки GetGame(), GetPlayer(), MENU_INVENTORY и MENU_RADIAL_QUICKBAR.

CanAddToQuickbarEx()

bool CanAddToQuickbarEx ( EntityAI focusedEntity )

inlineprotected

    {
        if ( ItemManager.GetInstance().IsMicromanagmentMode() )
            return false;
        
        if (focusedEntity)
        {
            PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
            if (focusedEntity.GetHierarchyRootPlayer() == player)
            {
                return true;
            }
        }
        
        return false;
    }

Перекрестные ссылки GetGame(), ItemManager::GetInstance() и GetPlayer().

CanCombine()

bool CanCombine ( )

inlineprotected

    {
        EntityAI focusedEntity = GetFocusedItem();
        if (focusedEntity)
        {
            if (GetFocusedContainer())
                return GetFocusedContainer().CanCombineEx(focusedEntity);
        
            return CanCombineEx(focusedEntity);
        }
 
        return false;
    }

Перекрестные ссылки Container::GetFocusedItem().

CanCombineAmmo()

bool CanCombineAmmo ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().CanCombineAmmo();
        return false;
    }

CanCombineEx()

bool CanCombineEx ( EntityAI focusedEntity )

inlineprotected

    {
        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;
    }

Перекрестные ссылки ItemManager::GetCombinationFlags(), GetGame(), ItemManager::GetInstance() и GetPlayer().

CanDrop()

bool CanDrop ( )

inlineprotected

    {
        EntityAI focusedEntity = GetFocusedItem();
        if (focusedEntity)
        {
            if (GetFocusedContainer())
                return GetFocusedContainer().CanDropEx(focusedEntity);
        
            return CanDropEx(focusedEntity);
        
        }
 
        return false;
    }

Перекрестные ссылки Container::GetFocusedItem().

CanDropEx()

bool CanDropEx ( EntityAI focusedEntity )

inlineprotected

    {
        if ( ItemManager.GetInstance().IsMicromanagmentMode() )
            return false;
        
        if (focusedEntity)
        {
            PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        
            if (player)
            {
                return player.CanDropEntity(focusedEntity);
            }
        }
        return false;
    }

Перекрестные ссылки GetGame(), ItemManager::GetInstance() и GetPlayer().

CanEquip()

bool CanEquip ( )

inlineprotected

    {   
        EntityAI focusedEntity = GetFocusedItem();
        if (focusedEntity)
        {
            if (GetFocusedContainer())
                return GetFocusedContainer().CanEquipEx(focusedEntity);
        
            return CanEquipEx(focusedEntity);
        }
 
        return false;   
    }

Перекрестные ссылки Container::GetFocusedItem().

CanEquipEx()

bool CanEquipEx ( EntityAI focusedEntity )

inlineprotected

    {
        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;
    }

Перекрестные ссылки GetGame(), ItemManager::GetInstance() и GetPlayer().

CanOpenCloseContainer()

bool CanOpenCloseContainer ( )

inlineprotected

    {
        if ( ItemManager.GetInstance().IsMicromanagmentMode() )
            return false;
        
        EntityAI focusedEntity = GetFocusedItem();
        if (focusedEntity)
        {
            if (GetFocusedContainer())
                return GetFocusedContainer().CanOpenCloseContainerEx(focusedEntity);
        
            return CanOpenCloseContainerEx(focusedEntity);
        }
 
        return false;       
    }

Перекрестные ссылки Container::GetFocusedItem() и ItemManager::GetInstance().

CanOpenCloseContainerEx()

bool CanOpenCloseContainerEx ( EntityAI focusedEntity )

inlineprotected

    {
        return false;
    }

CanSplit()

bool CanSplit ( )

inlineprotected

    {
        EntityAI focusedEntity = GetFocusedItem();
        if (focusedEntity)
        {
            if (GetFocusedContainer())
                return GetFocusedContainer().CanSplitEx(focusedEntity);
        
            return CanSplitEx(focusedEntity);
        }
 
        return false;       
    }

Перекрестные ссылки Container::GetFocusedItem().

CanSplitEx()

bool CanSplitEx ( EntityAI focusedEntity )

inlineprotected

    {
        if ( ItemManager.GetInstance().IsMicromanagmentMode() )
            return false;
        
        if (focusedEntity)
        {
            return focusedEntity.CanBeSplit();
        }
        return false;
    }

Перекрестные ссылки ItemManager::GetInstance().

CanSwapOrTakeToHands()

bool CanSwapOrTakeToHands ( )

inlineprotected

    {
        EntityAI focusedEntity = GetFocusedItem();
        if (focusedEntity)
        {
            if (GetFocusedContainer())
                return GetFocusedContainer().CanSwapOrTakeToHandsEx(focusedEntity);
        
            return CanSwapOrTakeToHandsEx(focusedEntity);
        }
 
        return false;   
    }

Перекрестные ссылки Container::GetFocusedItem().

CanSwapOrTakeToHandsEx()

bool CanSwapOrTakeToHandsEx ( EntityAI focusedEntity )

inlineprotected

    {
        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;   
    }

Перекрестные ссылки GameInventory::CanForceSwapEntitiesEx(), GameInventory::CanSwapEntitiesEx(), GetGame(), ItemManager::GetInstance() и GetPlayer().

CanTakeToInventory()

bool CanTakeToInventory ( )

inlineprotected

    {
        EntityAI focusedEntity = GetFocusedItem();
        if (focusedEntity)
        {
            if (GetFocusedContainer())
                return GetFocusedContainer().CanTakeToInventoryEx(focusedEntity);
        
            return CanTakeToInventoryEx(focusedEntity);
        }
 
        return false;
    }

Перекрестные ссылки Container::GetFocusedItem().

CanTakeToInventoryEx()

bool CanTakeToInventoryEx ( EntityAI focusedEntity )

inlineprotected

    {
        if ( ItemManager.GetInstance().IsMicromanagmentMode() )
            return false;
        
        if (focusedEntity)
        {
            PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
            return player.GetInventory().CanAddEntityToInventory(focusedEntity,FindInventoryLocationType.CARGO);
        }
        return false;
    }

Перекрестные ссылки GetGame(), ItemManager::GetInstance() и GetPlayer().

CheckHeaderDragability()

void CheckHeaderDragability ( )

protected

CheckScrollbarVisibility()

void CheckScrollbarVisibility ( )

inlineprotected

    {
        ScrollWidget sw = GetScrollWidget();
        if (sw)
        {
            if (!sw.IsScrollbarVisible())
            {
                sw.VScrollToPos01(0.0);
            }
            else if (sw.GetVScrollPos01() > 1.0)
            {
                sw.VScrollToPos01(1.0);
            }
        }
    }

Close()

void Close ( )

inlineprotected

    {
        m_Closed = true;
        UpdateSelectionIcons();
    }

Combine()

bool Combine ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().Combine();
        return true;
    }

Container()

void Container ( LayoutHolder parent )

inlineprotected

    {
        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;
    }

Перекрестные ссылки m_IsActive и m_RootWidget.

Count()

int Count ( )

inlineprotected

    {
        return m_Body.Count();
    }

Используется в PluginBase::Broadcast(), PluginBase::BroadcastFloat(), PluginBase::BroadcastInt(), PluginBase::BroadcastParam(), PluginBase::BroadcastString() и Container::Get().

DraggingOver()

void DraggingOver ( Widget w, int x, int y, Widget receiver )

protected

DraggingOverHeader()

void DraggingOverHeader ( Widget w, int x, int y, Widget receiver )

protected

EquipItem()

bool EquipItem ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().EquipItem();
        return false;
    }

ExpandCollapseContainer()

void ExpandCollapseContainer ( )

inlineprotected

{}

Get()

LayoutHolder Get ( int x )

inlineprotected

    {
        return m_Body.Get( x );
    }

Перекрестные ссылки x.

Используется в PluginBase::Broadcast(), PluginBase::BroadcastFloat(), PluginBase::BroadcastInt(), PluginBase::BroadcastParam() и PluginBase::BroadcastString().

GetActiveIndex()

int GetActiveIndex ( )

inlineprotected

    {
        return m_ActiveIndex;
    }

GetColumnCount()

int GetColumnCount ( )

inlineprotected

    {
        return m_ColumnCount;
    }

GetContainer()

Container GetContainer ( int index )

inlineprotected

    {
        if (index < m_Body.Count())
        {
            return Container.Cast( m_Body[index] );
        }
        return null;
    }

GetFocusedColumn()

int GetFocusedColumn ( )

inlineprotected

    {
        return m_FocusedColumn;
    }

GetFocusedContainer()

Container GetFocusedContainer ( )

inlineprotected

    {
        if (m_ActiveIndex < m_OpenedContainers.Count())
        {
            return Container.Cast(m_OpenedContainers[m_ActiveIndex]);
        }
        return null;
    }

GetFocusedContainerEntity()

EntityAI GetFocusedContainerEntity ( )

inlineprotected

    {
        EntityAI item;
        if( GetFocusedContainer() )
            item = GetFocusedContainer().GetFocusedContainerEntity();
        return item;
    }

GetFocusedContainerHeight()

float GetFocusedContainerHeight ( bool contents = false )

inlineprotected

    {
        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;
    }

Перекрестные ссылки GetFocusedContainerHeight(), Container::GetHeader(), x и y.

Используется в Container::GetFocusedContainerHeight() и GetFocusedContainerHeight().

GetFocusedContainerYPos()

float GetFocusedContainerYPos ( bool contents = false )

inlineprotected

    {
        float x, y;
        if( GetFocusedContainer() )
            y = GetFocusedContainer().GetFocusedContainerYPos( contents );
        else if( GetRootWidget() )
            GetRootWidget().GetPos( x, y );
        
        return y;
    }

Перекрестные ссылки GetFocusedContainerYPos(), x и y.

Используется в Container::GetFocusedContainerYPos() и GetFocusedContainerYPos().

GetFocusedContainerYScreenPos()

float GetFocusedContainerYScreenPos ( bool contents = false )

inlineprotected

    {
        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;
    }

Перекрестные ссылки GetFocusedContainerYScreenPos(), Container::GetHeader(), x и y.

Используется в Container::GetFocusedContainerYScreenPos() и GetFocusedContainerYScreenPos().

GetFocusedItem()

EntityAI GetFocusedItem ( )

inlineprotected

    {
        EntityAI item;
        if( GetFocusedContainer() )
            item = GetFocusedContainer().GetFocusedItem();
 
        return item;
    }

GetFocusedSlotsIcon()

SlotsIcon GetFocusedSlotsIcon ( )

inlineprotected

    {
        Container c = GetFocusedContainer();
        if (c)
        {
            return c.GetFocusedSlotsIcon();
        }
        return null;
    }

GetHeader()

Header GetHeader ( )

protected

GetScrollWidget()

ScrollWidget GetScrollWidget ( )

inlineprotected

    {
        return null;
    }

HideContent()

void HideContent ( bool force_hide = false )

inlineprotected

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

Insert()

void Insert ( LayoutHolder container, int pos = -1, bool immedUpdate = true )

inlineprotected

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

Перекрестные ссылки Container::Refresh().

InspectItem()

bool InspectItem ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().InspectItem();
        return false;
    }

Используется в Icon::MouseClick().

IsEmpty()

bool IsEmpty ( )

inlineprotected

    {
        return m_OpenedContainers.Count() == 0;
    }

IsFirstContainerFocused()

bool IsFirstContainerFocused ( )

inlineprotected

    {
        return m_ActiveIndex == 0;
    }

IsFirstIndex()

bool IsFirstIndex ( )

inlineprotected

    {
        return m_ActiveIndex == 0; 
    }

IsItemActive()

bool IsItemActive ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().IsItemActive();
        return false;
    }

IsItemWithQuantityActive()

bool IsItemWithQuantityActive ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().IsItemWithQuantityActive();
        return false;
    }

IsLastContainerFocused()

bool IsLastContainerFocused ( )

inlineprotected

    {
        return m_ActiveIndex >= ( m_OpenedContainers.Count() - 1 );
    }

IsLastIndex()

bool IsLastIndex ( )

inlineprotected

    {
        return m_ActiveIndex == ( m_OpenedContainers.Count() - 1 );
    }

IsOpened()

bool IsOpened ( )

inlineprotected

    {
        return !m_Closed;
    }

MoveGridCursor()

void MoveGridCursor ( int direction )

inlineprotected

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

Перекрестные ссылки Inventory(), Container::SetNextActive(), Container::SetNextLeftActive(), Container::SetNextRightActive() и Container::SetPreviousActive().

OnDropReceivedFromHeader()

void OnDropReceivedFromHeader ( Widget w, int x, int y, Widget receiver )

protected

OnSelectButton()

bool OnSelectButton ( )

inlineprotected

    {
        if(GetFocusedContainer())
        {
            return GetFocusedContainer().OnSelectButton();
        }
        return false;
    }

Open()

void Open ( )

inlineprotected

    {
        m_Closed = false;
        UpdateSelectionIcons();
    }

RecomputeOpenedContainers()

void RecomputeOpenedContainers ( )

inlineprotected

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

Перекрестные ссылки IsActive().

Refresh()

override void Refresh ( )

inlineprotected

    {
        for ( int i = 0; i < m_Body.Count(); i++ )
        {
            if( m_Body.Get( i ) )
                m_Body.Get( i ).Refresh();
        }
    }

Remove()

void Remove ( LayoutHolder container )

inlineprotected

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

Перекрестные ссылки Container::Refresh() и Container::SetPreviousActive().

ResetFocusedContainer()

void ResetFocusedContainer ( )

inlineprotected

    {
        if ( GetFocusedContainer() )
        {
            GetFocusedContainer().ResetFocusedContainer();
        }
        
        m_ActiveIndex == 0;
    }

ScrollToActiveContainer()

void ScrollToActiveContainer ( )

inlineprotected

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

Перекрестные ссылки Container::GetFocusedContainerHeight(), Container::GetFocusedContainerYScreenPos(), x и y.

Select()

bool Select ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().Select();
        return false;
    }

SelectItem()

bool SelectItem ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().SelectItem();
        return false;
    }

SetActive()

override void SetActive ( bool active )

inlineprotected

    {
        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;
        }
    }

Перекрестные ссылки Container::GetHeader(), m_IsActive, Container::SetDefaultFocus() и Container::Unfocus().

SetActiveIndex()

void SetActiveIndex ( int index )

inlineprotected

    {
        m_ActiveIndex = index;
    }

SetColumnCount()

void SetColumnCount ( int count )

inlineprotected

    {
        m_ColumnCount = count;
    }

SetDefaultFocus()

void SetDefaultFocus ( bool while_micromanagment_mode = false )

inlineprotected

    {
        m_ActiveIndex = 0;
    }

SetFirstActive()

override void SetFirstActive ( )

inlineprotected

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

Перекрестные ссылки IsActive(), m_IsActive, SetActive() и Container::SetDefaultFocus().

SetFocusedColumn()

void SetFocusedColumn ( int column )

inlineprotected

    {
        m_FocusedColumn = column;
    }

SetFocusedContainer()

void SetFocusedContainer ( Container cont )

inlineprotected

    {
        m_FocusedContainer = cont;
    }

SetForceShow()

void SetForceShow ( bool value )

inlineprotected

    {
        m_ForcedShow = value;
    }

SetHeader()

void SetHeader ( Header header )

protected

SetLastActive()

override void SetLastActive ( )

inlineprotected

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

Перекрестные ссылки Container::GetHeader(), IsActive(), m_IsActive и Container::SetLastFocus().

SetLastFocus()

void SetLastFocus ( )

inlineprotected

    {
        m_ActiveIndex = 0;
        m_FocusedColumn = 0;
        if ( m_OpenedContainers.Count() > 0 )
        {
            m_ActiveIndex = m_OpenedContainers.Count() - 1;
        }
    }

SetLayoutName()

override void SetLayoutName ( )

inlineprotected

    {
        m_LayoutName = WidgetLayoutName.Container;
    }

Перекрестные ссылки WidgetLayoutName::Container.

Используется в ScriptedWidgetEventHandler::LayoutHolder().

SetNextActive()

void SetNextActive ( )

inlineprotected

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

Перекрестные ссылки GetParent() и SetActive().

SetNextLeftActive()

void SetNextLeftActive ( )

inlineprotected

    {
        Container active;
        if (m_OpenedContainers.Count())
        {
            active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
        }
        
        if (active)
        {
            active.SetNextLeftActive();
        }
    }

SetNextRightActive()

void SetNextRightActive ( )

inlineprotected

    {
        Container active;
        if (m_OpenedContainers.Count())
        {
            active = Container.Cast(m_OpenedContainers[m_ActiveIndex]);
        }
        
        if (active)
        {
            active.SetNextRightActive();
        }
    }

SetOpenForSlotIcon()

void SetOpenForSlotIcon ( bool open, SlotsIcon icon = null )

inlineprotected

    {
        if (!icon)
        {
            icon = m_SlotIcon;
        }
        
        if (icon)
        {
            icon.GetRadialIcon().Show(open);
            icon.GetRadialIconClosed().Show(!open);
        }
        /*else
        {
            ErrorEx("Dbg No Icon");
        }*/
    }

SetPreviousActive()

void SetPreviousActive ( bool force = false )

inlineprotected

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

Перекрестные ссылки GetParent(), SetActive() и Container::SetLastActive().

SetSameLevelNextActive()

void SetSameLevelNextActive ( )

inlineprotected

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

SetSameLevelPreviousActive()

void SetSameLevelPreviousActive ( )

inlineprotected

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

SetSlotIcon()

void SetSlotIcon ( SlotsIcon icon )

inlineprotected

    {
        m_SlotIcon = icon;
    }

ShowContent()

void ShowContent ( bool force_show = false )

inlineprotected

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

SplitItem()

bool SplitItem ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().SplitItem();
        return false;
    }

Toggle()

void Toggle ( )

inlineprotected

    {
        if (IsOpened())
        {
            Close();
        }
        else
        {
            Open();
        }
        SetOpenForSlotIcon(IsOpened());
    }

Перекрестные ссылки Container::Close(), IsOpened() и Container::Open().

TransferItem()

bool TransferItem ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().TransferItem();
        return false;
    }

TransferItemToVicinity()

bool TransferItemToVicinity ( )

inlineprotected

    {
        if( GetFocusedContainer() )
            return GetFocusedContainer().TransferItemToVicinity();
        return false;
    }

Unfocus()

void Unfocus ( )

inlineprotected

    {
    }

UnfocusAll()

void UnfocusAll ( )

inlineprotected

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

Перекрестные ссылки Count, Get() и ITEMS_IN_ROW.

UnfocusGrid()

void UnfocusGrid ( )

inlineprotected

    {
        if( GetFocusedContainer() )
        {
            m_FocusedColumn = 0;
            GetFocusedContainer().UnfocusAll();
        }
    }

UpdateBodySpacers()

void UpdateBodySpacers ( )

inlineprotected

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

UpdateInterval()

override void UpdateInterval ( )

inlineprotected

    {
        for ( int i = 0; i < m_Body.Count(); i++ )
        {
            if ( m_Body.Get( i ) )
                m_Body.Get( i ).UpdateInterval();
        }
        
        CheckHeaderDragability();
    }

Перекрестные ссылки Container::CheckHeaderDragability().

UpdateRadialIcon()

void UpdateRadialIcon ( )

inlineprotected

    {
        if ( m_SlotIcon )
        {
            m_SlotIcon.GetRadialIconPanel().Show( false );
        }
    }

Перекрестные ссылки SlotsIcon::GetRadialIconPanel().

UpdateSelectionIcons()

override void UpdateSelectionIcons ( )

inlineprotected

    {
        m_Parent.UpdateSelectionIcons();
    }

Перекрестные ссылки m_Parent.

UpdateSpacer()

void UpdateSpacer ( )

protected

Поля

ITEMS_IN_ROW

const int ITEMS_IN_ROW = 8

protected

m_ActiveIndex

int m_ActiveIndex = 0

protected

m_Body

ref array<ref LayoutHolder> m_Body

protected

m_Closed

bool m_Closed

protected

m_ColumnCount

int m_ColumnCount

protected

m_Entity

EntityAI m_Entity

protected

m_FocusedColumn

int m_FocusedColumn = 0

protected

m_FocusedContainer

Container m_FocusedContainer

protected

m_ForcedHide

bool m_ForcedHide

protected

m_ForcedShow

bool m_ForcedShow

protected

m_LastIndex

bool m_LastIndex

protected

m_OpenedContainers

ref array<LayoutHolder> m_OpenedContainers

protected

m_PrevAlpha

float m_PrevAlpha

protected

m_SlotIcon

SlotsIcon m_SlotIcon

protected

SORT_ATTACHMENTS_NEXT_OFFSET

const int SORT_ATTACHMENTS_NEXT_OFFSET = 2

protected

SORT_ATTACHMENTS_OWN

const int SORT_ATTACHMENTS_OWN = 1

protected

SORT_CARGO_NEXT_OFFSET

const int SORT_CARGO_NEXT_OFFSET = 3

protected

SORT_CARGO_OWN

const int SORT_CARGO_OWN = 2

protected

---

Объявления и описания членов класса находятся в файле:

• D:/Ishodniki/scripts/5_Mission/GUI/InventoryNew/Containers/Container.c