Класс AttachmentCategoriesRow

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

Защищенные члены
void	AttachmentCategoriesRow (LayoutHolder parent, int sort=-1)
string	GetCategoryIdentifier ()
int	GetFocusedSlot ()
override bool	Select ()
override bool	TransferItem ()
override bool	TransferItemToVicinity ()
override bool	Combine ()
override bool	CanSplitEx (EntityAI focusedItem)
override bool	SplitItem ()
override bool	EquipItem ()
override bool	CanCombine ()
override bool	CanCombineAmmo ()
override bool	IsItemActive ()
override bool	IsItemWithQuantityActive ()
override void	OnDropReceivedFromHeader (Widget w, int x, int y, Widget receiver)
override void	UnfocusAll ()
override void	DraggingOverHeader (Widget w, int x, int y, Widget receiver)
bool	DraggingOverGrid (Widget w, int x, int y, Widget reciever, CargoContainer cargo)
void	DropReceived (Widget w, int x, int y, CargoContainer cargo)
EntityAI	GetItemPreviewItem (Widget w)
override void	Refresh ()
void	RefreshAllSlots ()
void	RefreshSlot (int row, int column, int slot_id, string slot_name)
void	DoubleClick (Widget w, int x, int y, int button)
void	MouseClick (Widget w, int x, int y, int button)
void	Init (int attachments_categories_count, int i, string attachment_category, string config_path_attachment_categories, EntityAI entity, int parent_m_Body_count)
override void	UpdateInterval ()

Защищенные данные
string	m_CategoryIdentifier
string	m_RowConfigPath
bool	m_Refreshing
ref AttachmentsGroupContainer	m_AttachmentsContainer
ref map< int, ref ContainerWithCargo >	m_AttachmentCargos

Дополнительные унаследованные члены
Закрытые члены унаследованные от ClosableContainer
void	ContainerWithCargo (Container parent, int sort=-1)
override bool	IsDisplayable ()
override bool	IsEmpty ()
override bool	IsItemActive ()
override bool	CanCombine ()
override bool	CanCombineAmmo ()
override bool	IsItemWithQuantityActive ()
void	LockCargo (bool value)
override void	Open ()
override void	Close ()
override bool	IsOpened ()
override void	UpdateInterval ()
override bool	IsFirstContainerFocused ()
override bool	IsLastContainerFocused ()
override void	SetDefaultFocus (bool while_micromanagment_mode=false)
override void	UnfocusAll ()
override bool	SplitItem ()
override bool	EquipItem ()
override bool	TransferItem ()
override bool	TransferItemToVicinity ()
override bool	InspectItem ()
void	SetEntity (EntityAI entity, int cargo_index=0, bool immedUpdate=true)
EntityAI	GetEntity ()
override EntityAI	GetFocusedContainerEntity ()
EntityAI	GetItemPreviewItem (Widget w)
bool	DraggingOverGrid (Widget w, int x, int y, Widget reciever)
void	DropReceived (Widget w, int x, int y)
void	TakeIntoHands (notnull PlayerBase player, notnull EntityAI item)
override void	DraggingOverHeader (Widget w, int x, int y, Widget receiver)
override void	DraggingOver (Widget w, int x, int y, Widget receiver)
override void	OnDropReceivedFromHeader (Widget w, int x, int y, Widget receiver)
void	ContainerWithCargoAndAttachments (LayoutHolder parent, int sort=-1)
void	~ContainerWithCargoAndAttachments ()
void	RecomputeContainers ()
void	AttachmentAddedEx (EntityAI item, string slot, EntityAI parent, bool immedUpdate=true)
void	AttachmentAdded (EntityAI item, string slot, EntityAI parent)
void	AttachmentRemoved (EntityAI item, string slot, EntityAI parent)
override void	UpdateInterval ()
override EntityAI	GetFocusedContainerEntity ()
override void	UnfocusAll ()
override bool	IsLastIndex ()
override bool	IsFirstContainerFocused ()
override bool	IsLastContainerFocused ()
override void	MoveGridCursor (int direction)
void	SetEntity (EntityAI entity, bool immedUpdate=true)
void	HideCargo ()
void	ShowCargo ()
EntityAI	GetEntity ()
ItemPreviewWidget	GetItemPreviewWidgetDragOrDrop (Widget w)
EntityAI	GetItemPreviewItem (Widget w)
Widget	GetItemPreviewWidget (Widget w)
void	MouseClick2 (Widget w, int x, int y, int button)
void	DropReceived (Widget w, int x, int y, CargoContainer cargo)
	NOTE Used for mouse only.
void	TakeAsAttachment (Widget w, Widget receiver)
override void	OnDropReceivedFromHeader (Widget w, int x, int y, Widget receiver)
void	OnDropReceivedFromHeader2 (Widget w, int x, int y, Widget receiver)
void	DoubleClick (Widget w, int x, int y, int button)
bool	DraggingOverGrid (Widget w, int x, int y, Widget reciever, CargoContainer cargo)
override void	DraggingOver (Widget w, int x, int y, Widget receiver)
override void	DraggingOverHeader (Widget w, int x, int y, Widget receiver)
Закрытые данные унаследованные от ClosableContainer
ref CargoContainer	m_CargoGrid
int	m_CargoIndex = -1
ref Attachments	m_Atts
ref map< EntityAI, ref CargoContainer >	m_AttachmentCargos
ref map< EntityAI, ref AttachmentsWrapper >	m_AttachmentAttachmentsContainers
ref map< EntityAI, ref Attachments >	m_AttachmentAttachments
ref array< int >	m_AttachmentSlotsSorted

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

Конструктор(ы)

AttachmentCategoriesRow()

void AttachmentCategoriesRow ( LayoutHolder parent, int sort = -1 )

inlineprotected

    {
        m_Refreshing = false;
        m_AttachmentCargos      = new map<int, ref ContainerWithCargo>;
        m_AttachmentsContainer  = new AttachmentsGroupContainer(this);
        
        m_Body.Insert(m_AttachmentsContainer);
        
        m_ClosableHeader.GetMainWidget().ClearFlags( WidgetFlags.DRAGGABLE );
        
        RecomputeOpenedContainers();
    }

Перекрестные ссылки m_AttachmentCargos, m_AttachmentsContainer и m_Refreshing.

Методы

CanCombine()

override bool CanCombine ( )

inlineprotected

    {
        Man player = GetGame().GetPlayer();
        ItemBase prev_item = ItemBase.Cast( GetFocusedItem() );
        ItemBase selected_item = ItemBase.Cast( player.GetHumanInventory().GetEntityInHands() );
        SlotsIcon focused_icon = GetFocusedSlotsIcon();
        
        if( selected_item )
        {
            int selected_slot = GetFocusedSlot();
            int stack_max;
            if( selected_item && selected_item.GetInventory().CanRemoveEntity() && (focused_icon && !focused_icon.IsOutOfReach()) )
            {
                if( m_Entity.GetInventory().CanAddAttachmentEx( selected_item, selected_slot ) )
                {
                    stack_max = InventorySlots.GetStackMaxForSlotId( selected_slot );
                    float quantity = selected_item.GetQuantity();
                    if( stack_max == 0 || stack_max >= quantity || !selected_item.CanBeSplit() )
                    {
                        return true;
                    }
                    else
                    {
                        return true;
                    }
                }
                else if( selected_slot != -1 )
                {
                    if( prev_item )
                    {
                        InventoryLocation inv_loc = new InventoryLocation;
                        prev_item.GetInventory().GetCurrentInventoryLocation( inv_loc );
                        stack_max = InventorySlots.GetStackMaxForSlotId( inv_loc.GetSlot() );
                        quantity = prev_item.GetQuantity();
                        if( prev_item.CanBeCombined( ItemBase.Cast( selected_item ) ) )
                        {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }

Перекрестные ссылки GetFocusedSlot(), GetGame(), InventorySlots::GetStackMaxForSlotId() и m_Entity.

Используется в Combine().

CanCombineAmmo()

override bool CanCombineAmmo ( )

inlineprotected

    {
        return false;
    }

CanSplitEx()

override bool CanSplitEx ( EntityAI focusedItem )

inlineprotected

    {
        return false;
    }

Combine()

override bool Combine ( )

inlineprotected

    {
        if (CanCombine())
        {
            Man player = GetGame().GetPlayer();
            ItemBase prev_item = ItemBase.Cast( GetFocusedItem() );
            ItemBase selected_item = ItemBase.Cast( player.GetHumanInventory().GetEntityInHands() );
            SlotsIcon focused_icon = GetFocusedSlotsIcon();
            
            if( selected_item )
            {
                int selected_slot = GetFocusedSlot();
                int stack_max;
                if( selected_item && selected_item.GetInventory().CanRemoveEntity() && (focused_icon && !focused_icon.IsOutOfReach()) )
                {
                    if( !prev_item && m_Entity.GetInventory().CanAddAttachmentEx( selected_item, selected_slot ) )
                    {
                        stack_max = InventorySlots.GetStackMaxForSlotId( selected_slot );
                        float quantity = selected_item.GetQuantity();
                        if( stack_max == 0 || stack_max >= quantity || !selected_item.CanBeSplit() )
                        {
                            player.PredictiveTakeEntityToTargetAttachmentEx( m_Entity, selected_item, selected_slot );
                            return true;
                        }
                        else
                        {
                            selected_item.SplitIntoStackMaxClient( m_Entity, selected_slot );
                            return true;
                        }
                    }
                    else if( selected_slot != -1 )
                    {
                        if( prev_item )
                        {
                            InventoryLocation inv_loc = new InventoryLocation;
                            prev_item.GetInventory().GetCurrentInventoryLocation( inv_loc );
                            stack_max = InventorySlots.GetStackMaxForSlotId( inv_loc.GetSlot() );
                            quantity = prev_item.GetQuantity();
                            if( prev_item.CanBeCombined( ItemBase.Cast( selected_item ) ) )
                            {
                                prev_item.CombineItemsClient( selected_item, true );
                                return true;
                            }
                            else if( stack_max == 0 && GameInventory.CanSwapEntitiesEx( prev_item, selected_item ) )
                            {
                                player.PredictiveSwapEntities( selected_item, prev_item );
                                return true;
                            }
                            else if( m_AttachmentCargos.Contains( inv_loc.GetSlot() ) )
                            {
                                if( prev_item.GetInventory().CanAddEntityInCargo( selected_item, selected_item.GetInventory().GetFlipCargo() ) )
                                {
                                    SplitItemUtils.TakeOrSplitToInventory( PlayerBase.Cast( player ), prev_item, selected_item );
                                    return true;
                                }
                            }
                        }
                    }
                }
            }
        }
        return false;
    }

Перекрестные ссылки CanCombine(), GameInventory::CanSwapEntitiesEx(), GetFocusedSlot(), GetGame(), InventorySlots::GetStackMaxForSlotId(), m_AttachmentCargos, m_Entity и SplitItemUtils::TakeOrSplitToInventory().

DoubleClick()

void DoubleClick ( Widget w, int x, int y, int button )

inlineprotected

    {
        if (button == MouseState.LEFT && !g_Game.IsLeftCtrlDown())
        {
            ItemPreviewWidget iw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
            if (!iw)
            {
              string name = w.GetName();
              name.Replace("PanelWidget", "Render");
              iw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
            }
            
            if (!iw)
              iw = ItemPreviewWidget.Cast(w);
            
            SlotsIcon icon;
            w.GetUserData(icon);
            
            if (icon && m_Entity.GetInventory().GetSlotLock(iw.GetUserID()))
                return;
            
            if (icon.IsOutOfReach())
                return;
            
            ItemBase item = ItemBase.Cast(iw.GetItem());
            if (item)
            {
                if (!item.GetInventory().CanRemoveEntity())
                    return;
                
                PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
                if (controlledPlayer.GetInventory().HasEntityInInventory(item) && controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
                {
                    controlledPlayer.PredictiveTakeEntityToHands(item);
                }
                else
                {
                    if (controlledPlayer.GetInventory().CanAddEntityToInventory(item) && item.GetInventory().CanRemoveEntity())
                    {
                        if (item.GetTargetQuantityMax() < item.GetQuantity())
                            item.SplitIntoStackMaxClient(controlledPlayer, -1);
                        else
                            controlledPlayer.PredictiveTakeEntityToInventory(FindInventoryLocationType.ANY, item);
                    }
                    else
                    {
                        if (controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
                        {
                            if (item.GetTargetQuantityMax() < item.GetQuantity())
                                item.SplitIntoStackMaxHandsClient(controlledPlayer);
                            else
                                controlledPlayer.PredictiveTakeEntityToHands(item);
                        }
                    }
                }
                
                HideOwnedTooltip();
                
                name = w.GetName();
                name.Replace("PanelWidget", "Temperature");
                w.FindAnyWidget(name).Show(false);
            }
        }
    }

Перекрестные ссылки g_Game, GetGame(), GetPlayer(), m_Entity и name.

DraggingOverGrid()

bool DraggingOverGrid ( Widget w, int x, int y, Widget reciever, CargoContainer cargo )

inlineprotected

    {
        if( w == null )
        {
            return false;
        }
        
        EntityAI item = GetItemPreviewItem( w );
        
        if( !item )
        {
            return false;
        }
 
        int color;
        int idx = 0;
        int c_x, c_y;
        
        EntityAI target_entity;
        CargoBase target_cargo;
        
        target_entity       =  cargo.GetEntity() ;
        if( target_entity )
        {
            target_cargo    = target_entity.GetInventory().GetCargo();
        }
        else
            return false;
        
        if( target_cargo && target_entity )
        {
            c_x = target_cargo.GetHeight();
            c_y = target_cargo.GetWidth();
        }
        else
            return false;
        
        if( c_x > x && c_y > y && target_entity.GetInventory().CanAddEntityInCargoEx( item, idx, x, y, item.GetInventory().GetFlipCargo() ) )
        {
            color = ColorManager.GREEN_COLOR;
        }
        else
        {
            color = ColorManager.RED_COLOR;
        }
 
        if( w.FindAnyWidget("Cursor") )
        {
            w.FindAnyWidget("Cursor").SetColor( color );
        }
        else
        {
            string name = w.GetName();
            name.Replace( "PanelWidget", "Cursor" );
            if( w.FindAnyWidget( name ) )
            {
                w.FindAnyWidget( name ).SetColor( color );
            }
        }
 
        return true;
    }

Перекрестные ссылки GetItemPreviewItem(), ColorManager::GREEN_COLOR, name, ColorManager::RED_COLOR, x и y.

DraggingOverHeader()

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

inlineprotected

    {
        if( w == null )
        {
            return;
        }
        ItemPreviewWidget iw = ItemPreviewWidget.Cast( w.FindAnyWidget("Render") );
        if(!iw)
        {
          string name = w.GetName();
          name.Replace("PanelWidget", "Render");
          iw = ItemPreviewWidget.Cast( w.FindAnyWidget(name) );
        }
        if(!iw)
        {
          iw = ItemPreviewWidget.Cast( w );
        }
        
        if( !iw || !iw.GetItem() || (iw.GetItem() == m_Entity) )
        {
            return;
        }
        
        ItemBase item;
        ItemBase receiver_item;
        name = receiver.GetName();
        name.Replace("PanelWidget", "Render");
        ItemPreviewWidget receiver_iw = ItemPreviewWidget.Cast( receiver.FindAnyWidget(name) );
        if(receiver_iw)
            receiver_item = ItemBase.Cast( receiver_iw.GetItem() );
        
        SlotsIcon slots_icon;
        receiver.GetUserData(slots_icon);
        
        if( receiver_item )
        {
            int stack_max = InventorySlots.GetStackMaxForSlotId( receiver_item.GetInventory().GetSlotId(0) );
            //int quantity = receiver_item.GetQuantity();
            //bool combinable = ( quantity < stack_max ) && ( ItemBase.Cast( receiver_item ).CanBeCombined( ItemBase.Cast( iw.GetItem() ) ) );
            if( receiver_item.CanBeCombined( ItemBase.Cast( iw.GetItem() ) ) )
            {
                ItemManager.GetInstance().HideDropzones();
                ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
                ColorManager.GetInstance().SetColor( w, ColorManager.COMBINE_COLOR );
            }
            else if( stack_max == 0 && GameInventory.CanSwapEntitiesEx( receiver_item, iw.GetItem() ) )
            {
                ItemManager.GetInstance().HideDropzones();
                ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
                ColorManager.GetInstance().SetColor( w, ColorManager.SWAP_COLOR );
            }
            else
            {
                ItemManager.GetInstance().ShowSourceDropzone( iw.GetItem() );
                ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
            }
        }
        else if( slots_icon && slots_icon.GetSlotID() != -1 )
        {
            item = ItemBase.Cast( iw.GetItem() );
            
            if( item && m_Entity.GetInventory().CanAddAttachmentEx( item, slots_icon.GetSlotID() ) )
            {
                ItemManager.GetInstance().HideDropzones();
                ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
                ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
            }
            else
            {
                ItemManager.GetInstance().ShowSourceDropzone( iw.GetItem() );
                ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
            }
        }
        else
        {
            ItemManager.GetInstance().ShowSourceDropzone( iw.GetItem() );
            ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
        }
    }

Перекрестные ссылки GameInventory::CanSwapEntitiesEx(), ColorManager::COMBINE_COLOR, ColorManager::GetInstance(), ItemManager::GetInstance(), InventorySlots::GetStackMaxForSlotId(), ColorManager::GREEN_COLOR, m_Entity, name, ColorManager::RED_COLOR и ColorManager::SWAP_COLOR.

DropReceived()

void DropReceived ( Widget w, int x, int y, CargoContainer cargo )

inlineprotected

    {
        EntityAI item = GetItemPreviewItem( w );
        if( !item )
        {
            return;
        }
 
        int idx = 0;
        int c_x, c_y;
        
        EntityAI target_entity;
        CargoBase target_cargo;
        
        target_entity   = cargo.GetEntity();
        if( target_entity )
        {
            target_cargo    = target_entity.GetInventory().GetCargo();
        }
        else
            return;
        
        if( target_cargo && target_entity )
        {
            c_x = target_cargo.GetHeight();
            c_y = target_cargo.GetWidth();
        }
        else
            return;
        
        InventoryLocation dst = new InventoryLocation;      
        dst.SetCargoAuto(target_cargo, item, x, y, item.GetInventory().GetFlipCargo());
            
        if( c_x > x && c_y > y && target_entity.GetInventory().LocationCanAddEntity(dst))
        {
            PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 
            SplitItemUtils.TakeOrSplitToInventoryLocation( player, dst);
 
            Icon icon = cargo.GetIcon( item );
            
            if( icon )
            {
                icon.GetCursorWidget().SetColor( ColorManager.BASE_COLOR );
                icon.RefreshPos( x, y );
                icon.Refresh();
                Refresh();
            }
        }
    }

Перекрестные ссылки ColorManager::BASE_COLOR, GetGame(), GetItemPreviewItem(), GetPlayer(), Refresh(), SplitItemUtils::TakeOrSplitToInventoryLocation(), x и y.

EquipItem()

override bool EquipItem ( )

inlineprotected

    {
        return false;
    }

GetCategoryIdentifier()

string GetCategoryIdentifier ( )

inlineprotected

    {
        return m_CategoryIdentifier;
    }

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

GetFocusedSlot()

int GetFocusedSlot ( )

inlineprotected

    {
        SlotsIcon icon = GetFocusedSlotsIcon();
        if (icon)
        {
            return icon.GetSlotID();
        }
        return -1;
    }

Используется в CanCombine() и Combine().

GetItemPreviewItem()

EntityAI GetItemPreviewItem ( Widget w )

inlineprotected

    {
        ItemPreviewWidget ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( "Render" ) );
        if( !ipw )
        {
          string name = w.GetName();
          name.Replace( "PanelWidget", "Render" );
          ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( name ) );
        }
        if( !ipw )
        {
          ipw = ItemPreviewWidget.Cast( w );
        }
        if( !ipw || !ipw.IsInherited( ItemPreviewWidget ) )
        {
            return null;
        }
        return ipw.GetItem();
    }

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

Используется в DraggingOverGrid(), DropReceived() и OnDropReceivedFromHeader().

Init()

void Init ( int attachments_categories_count, int i, string attachment_category, string config_path_attachment_categories, EntityAI entity, int parent_m_Body_count )

inlineprotected

    {
        m_Entity = entity;
        Header header = GetHeader();
        
        m_CategoryIdentifier = attachment_category;
        
        array<string> player_ghosts_slots2 = new array<string>();
        string categoryName;
        
        m_RowConfigPath = config_path_attachment_categories + " " + attachment_category + " attachmentSlots";
        string config_path_category_name = config_path_attachment_categories + " " + attachment_category + " name";
        GetGame().ConfigGetTextArray(m_RowConfigPath, player_ghosts_slots2);
        GetGame().ConfigGetText(config_path_category_name, categoryName);
        header.SetName(categoryName);
        
        m_AttachmentsContainer.SetHeader(header);
        SetHeader(null);
        
        int count = player_ghosts_slots2.Count();
        int lastRow = count / ITEMS_IN_ROW;
        SlotsContainer slotsContainer;
        
        for ( int j = 0; j < count; j++ )
        {
            string slotName = player_ghosts_slots2.Get(j);
            string iconName; //must be in format "set:<setname> image:<imagename>"
            string path = "CfgSlots" + " Slot_" + slotName;
            
            int slotId  = InventorySlots.GetSlotIdFromString(slotName);
                
            GetGame().ConfigGetText(path + " ghostIcon", iconName);
            GetGame().ConfigGetText(path + " name", slotName);
                
            int row = j / ITEMS_IN_ROW;
            int column = j % ITEMS_IN_ROW;
            if (column == 0)
            {
                slotsContainer = new SlotsContainer(m_AttachmentsContainer, m_Entity);
                slotsContainer.GetRootWidget().SetAlpha(0.7);
                if (row == lastRow)
                    slotsContainer.SetColumnCount(count % ITEMS_IN_ROW);
                else
                    slotsContainer.SetColumnCount(ITEMS_IN_ROW);
 
                m_AttachmentsContainer.Insert(slotsContainer);
                slotsContainer.GetRootWidget().SetSort(row);
            } 
                
            SlotsIcon icon = slotsContainer.GetSlotIcon(column);
            WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetMainWidget(), this, "OnDropReceivedFromHeader");
            WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetGhostSlot(), this, "OnDropReceivedFromHeader");
            WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetPanelWidget(), this, "OnDropReceivedFromHeader");
                    
            WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetMainWidget(), this, "DraggingOverHeader");
            WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetGhostSlot(), this, "DraggingOverHeader");
            WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetPanelWidget(), this, "DraggingOverHeader");
                    
            WidgetEventHandler.GetInstance().RegisterOnDrop(icon.GetMainWidget(), this, "OnIconDrop");
            WidgetEventHandler.GetInstance().RegisterOnDrop(icon.GetPanelWidget(), this, "OnIconDrop");
 
            WidgetEventHandler.GetInstance().RegisterOnDoubleClick(icon.GetPanelWidget(), this, "DoubleClick");
            WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(), this, "MouseClick");
            
            icon.GetGhostSlot().LoadImageFile(0, StaticGUIUtils.VerifyIconImageString(StaticGUIUtils.IMAGESETGROUP_INVENTORY, iconName));
            icon.SetSlotID(slotId);
            icon.SetSlotDisplayName(InventorySlots.GetSlotDisplayName(slotId));
            
            icon.Clear();
        }
        RefreshAllSlots();
    }

Перекрестные ссылки GetGame(), GetHeader(), WidgetEventHandler::GetInstance(), InventorySlots::GetSlotDisplayName(), InventorySlots::GetSlotIdFromString(), StaticGUIUtils::IMAGESETGROUP_INVENTORY, ITEMS_IN_ROW, m_AttachmentsContainer, m_CategoryIdentifier, m_Entity, m_RowConfigPath, path, RefreshAllSlots(), slotName и StaticGUIUtils::VerifyIconImageString().

IsItemActive()

override bool IsItemActive ( )

inlineprotected

    {
        SlotsIcon icon = GetFocusedSlotsIcon();
        return GetFocusedItem() != null && (!icon || !icon.IsOutOfReach());
    }

IsItemWithQuantityActive()

override bool IsItemWithQuantityActive ( )

inlineprotected

    {
        ItemBase item = ItemBase.Cast(GetFocusedItem());
        SlotsIcon icon = GetFocusedSlotsIcon();
        return item && ( !icon || !icon.IsOutOfReach()) && item.CanBeSplit();
    }

MouseClick()

void MouseClick ( Widget w, int x, int y, int button )

inlineprotected

    {
        ItemBase selectedItem;
        SlotsIcon icon; 
        w.GetUserData(icon);
        if (icon)
            selectedItem = ItemBase.Cast(icon.GetEntity());
 
        if (selectedItem)
        {
            switch (button)
            {
                case MouseState.RIGHT:
                    #ifdef DIAG_DEVELOPER
                    if (g_Game.IsLeftCtrlDown())
                        ShowActionMenu(selectedItem);
                    #endif
 
                    break;
            
                case MouseState.MIDDLE:
                    InspectItem(selectedItem);
                    break;
                
                case MouseState.LEFT:
                    PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
                    if (g_Game.IsLeftCtrlDown())
                    {
                        if (icon.IsOutOfReach())
                            return;
 
                        if (controlledPlayer.CanDropEntity(selectedItem))
                        {
                            if (selectedItem.GetTargetQuantityMax() < selectedItem.GetQuantity())
                                selectedItem.SplitIntoStackMaxClient(null, -1);
                            else
                                controlledPlayer.PhysicalPredictiveDropItem(selectedItem);
                        }
                        else
                        {
                            bool draggable = !controlledPlayer.GetInventory().HasInventoryReservation(selectedItem, null ) && !controlledPlayer.GetInventory().IsInventoryLocked() && selectedItem.GetInventory().CanRemoveEntity() && !controlledPlayer.IsItemsToDelete();
                            ItemManager.GetInstance().SetWidgetDraggable(w, draggable);
                        }
                    }
                    else
                    {
                        ClosableContainer c = ClosableContainer.Cast(icon.GetContainer());
                        if (c)
                            c.Toggle();
                    }
 
                    break;
            }
        }
    }

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

OnDropReceivedFromHeader()

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

inlineprotected

    {
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().SetIsDragging( false );
        SlotsIcon slots_icon;
        EntityAI receiver_item;
        int slot_id = -1;
        bool is_reserved = false;
        EntityAI attached_entity;
        receiver.GetUserData(slots_icon);
        float stackable = 0.0;
        InventoryLocation il = new InventoryLocation;
        
        if( slots_icon )
        {
            receiver_item   = slots_icon.GetEntity();
            slot_id         = slots_icon.GetSlotID();
            attached_entity = slots_icon.GetSlotParent();
            is_reserved     = slots_icon.IsReserved();
        }
        
        EntityAI item = GetItemPreviewItem( w );
        if( !item )
        {
            return;
        }
        ItemBase item_base  = ItemBase.Cast( item );
        
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        if( !item.GetInventory().CanRemoveEntity() || !player.CanManipulateInventory() )
            return;
        
        EntityAI target_att_entity = m_Entity;
        Weapon_Base wpn;
        Magazine mag;
        if( Class.CastTo(wpn,  m_Entity ) && Class.CastTo(mag,  item ) )
        {
            if( player.GetWeaponManager().CanAttachMagazine( wpn, mag ) )
            {
                player.GetWeaponManager().AttachMagazine( mag );
            }
        }
        else if( receiver_item && !is_reserved )
        {
            if( ( ItemBase.Cast( receiver_item ) ).CanBeCombined( ItemBase.Cast( item ) ) )
            {
                ( ItemBase.Cast( receiver_item ) ).CombineItemsClient( ItemBase.Cast( item ) );
            }
            else if( GameInventory.CanSwapEntitiesEx( receiver_item, item ) )
            {
                if( !receiver_item.GetInventory().CanRemoveEntity() )
                    return;
                GetGame().GetPlayer().PredictiveSwapEntities( receiver_item, item );
            }
            else if( receiver_item.GetInventory().CanAddAttachment( item ) )
            {
                player.PredictiveTakeEntityToTargetAttachment(receiver_item, item);
            }
        }
        else if( attached_entity && slot_id != -1 &&  attached_entity.GetInventory().CanAddAttachmentEx( item, slot_id ) )
        {
            item_base   = ItemBase.Cast( item );
            stackable   = item_base.GetTargetQuantityMax( slot_id );
            
            if( stackable == 0 || stackable >= item_base.GetQuantity() )
            {
                player.PredictiveTakeEntityToTargetAttachmentEx(attached_entity, item, slot_id);
            }
            else if( stackable != 0 && stackable < item_base.GetQuantity() )
            {
                item_base.SplitIntoStackMaxClient( m_Entity, slot_id );
            }
        }
        else if(attached_entity && slot_id == -1 && attached_entity.GetInventory().FindFreeLocationFor(item,FindInventoryLocationType.ATTACHMENT,il))
        {
            item_base   = ItemBase.Cast( item );
            stackable   = item_base.GetTargetQuantityMax( il.GetSlot() );
            
            if( stackable == 0 || stackable >= item_base.GetQuantity() )
            {
                player.PredictiveTakeEntityToTargetAttachmentEx(attached_entity, item, il.GetSlot());
            }
            else if( stackable != 0 && stackable < item_base.GetQuantity() )
            {
                item_base.SplitIntoStackMaxClient( m_Entity, il.GetSlot() );
            }
        }
        /*else if( ( m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() ) && ( !player.GetInventory().HasEntityInInventory( item ) || !m_Entity.GetInventory().HasEntityInCargo( item )) ) )
        {
            SplitItemUtils.TakeOrSplitToInventory( PlayerBase.Cast( GetGame().GetPlayer() ), m_Entity, item );
        }*/
    }

Перекрестные ссылки GameInventory::CanSwapEntitiesEx(), Class::CastTo(), CombineItemsClient(), GetGame(), ItemManager::GetInstance(), GetItemPreviewItem(), GetPlayer() и m_Entity.

Refresh()

override void Refresh ( )

inlineprotected

    {
        if (!m_Refreshing)
        {
            if( !m_Closed )
            {
                super.Refresh();
                RefreshAllSlots();
            }
        }
    }

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

Используется в DropReceived().

RefreshAllSlots()

void RefreshAllSlots ( )

inlineprotected

    {
        m_Refreshing = true;
        int row_count = m_AttachmentsContainer.GetRowCount();
        int row;
        for (row = 0; row < row_count; row++)
        {
            int col_count = m_AttachmentsContainer.GetColumnCountForRow(row);
            int col;
            for (col = 0; col < col_count; col++)
            {
                RefreshSlot(row, col, -1, "");
            }
        }
        m_Refreshing = false;
    }

Перекрестные ссылки m_AttachmentsContainer, m_Refreshing и RefreshSlot().

Используется в Init(), Refresh() и UpdateInterval().

RefreshSlot()

void RefreshSlot ( int row, int column, int slot_id, string slot_name )

inlineprotected

    {
        SlotsIcon icon = m_AttachmentsContainer.GetSlotsIcon(row, column);
        int slot_id_ = icon.GetSlotID();
        EntityAI item = m_Entity.GetInventory().FindAttachment( slot_id_ );
        ContainerWithCargo cont;
        
        if (!m_Entity.CanDisplayAttachmentSlot(slot_id_))
        {
            icon.Clear();
            icon.GetMainWidget().Show( false );
        }
        else if (!item)
        {
            if (icon.GetEntity())
            {
                icon.ClearRemainSelected();
                
                cont = m_AttachmentCargos.Get(slot_id_);
                if (cont)
                {
                    m_AttachmentCargos.Remove(slot_id_);
                    this.Remove(cont);
                    ( Container.Cast( cont.m_Parent ) ).Remove( cont );
                }
            }
            icon.GetMainWidget().Show(true);
        }
        else
        {
            icon.GetMainWidget().Show( true );
            if (icon.GetEntity() != item)
            {
                icon.Init( item );
            }
            else
            {
                icon.Refresh();
            }
            
            cont = m_AttachmentCargos.Get(slot_id_);
            if( cont && cont.GetEntity() != item)
            {
                m_AttachmentCargos.Remove(slot_id_);
                ( Container.Cast( cont.m_Parent ) ).Remove( cont );
                this.Remove(cont);
                cont = null;
            }
            
            if( !cont )
            {
                if( item.GetInventory().GetCargo() && m_AttachmentCargos )
                {
                    cont = new ContainerWithCargo( this, true );
                    cont.GetRootWidget().SetSort( m_AttachmentCargos.Count() + 10 );
                    cont.SetEntity( item );
                    cont.SetSlotIcon( icon );
                    
                    m_AttachmentCargos.Insert( slot_id_, cont );
                    icon.SetContainer(cont);
                    
                    SetOpenForSlotIcon(cont.IsOpened(),icon);
                }
            }
            
            if (cont)
            {
                icon.GetRadialIconPanel().Show( cont.IsDisplayable() );
            }
                
            string slot_name_           = InventorySlots.GetSlotName(slot_id_);
            bool draggable              = true;
            bool can_be_removed         = item.GetInventory().CanRemoveEntity();
            bool in_hands_condition     = m_Entity.GetHierarchyRoot() == GetGame().GetPlayer();
            bool in_vicinity_condition  = AttachmentsOutOfReach.IsAttachmentReachable( m_Entity, slot_name_ );
            if( m_Entity.GetInventory().GetSlotLock( slot_id_ ) && ItemManager.GetInstance().GetDraggedItem() != item )
            {
                icon.GetMountedWidget().Show( true );
                draggable = false;
            }
            else
            {
                icon.GetMountedWidget().Show( false );
            }
            
            if( !m_Entity.CanReleaseAttachment( item ) )
            {
                draggable = false;
            }
            
            if ((in_hands_condition || in_vicinity_condition) && can_be_removed)
            {
                icon.GetOutOfReachWidget().Show( false );
            }
            else
            {
                icon.GetOutOfReachWidget().Show( true );
                draggable = false;
            }
            
            if( draggable )
            {
                icon.GetRender().GetParent().SetFlags( WidgetFlags.DRAGGABLE );
            }
            else
            {
                icon.GetRender().GetParent().ClearFlags( WidgetFlags.DRAGGABLE );
            }
        }
    }

Перекрестные ссылки ClosableContainer::ContainerWithCargo(), GetGame(), ItemManager::GetInstance(), InventorySlots::GetSlotName(), AttachmentsOutOfReach::IsAttachmentReachable(), m_AttachmentCargos, m_AttachmentsContainer, m_Entity и Remove().

Используется в RefreshAllSlots().

Select()

override bool Select ( )

inlineprotected

    {
        Man player = GetGame().GetPlayer();
        SlotsIcon focused_icon = GetFocusedSlotsIcon();
        EntityAI focused_item = GetFocusedItem();
        Container focused_cont = GetFocusedContainer();
        ItemBase selected_item = ItemBase.Cast( ItemManager.GetInstance().GetSelectedItem() ); // == dragged item 
        
        if( selected_item && focused_item != selected_item)//dropping from micromanagement
        {
            if( selected_item.GetInventory().CanRemoveEntity() )
            {
                int stack_max;
                
                if (!focused_icon)
                {
                    if (focused_cont)
                    {
                        focused_cont.Select();
                    }
                }
                else if( !focused_item && m_Entity && m_Entity.GetInventory().CanAddAttachmentEx( selected_item, focused_icon.GetSlotID() ) )
                {
                    stack_max = InventorySlots.GetStackMaxForSlotId( focused_icon.GetSlotID() );
                    float quantity = selected_item.GetQuantity();
                    if( stack_max == 0 || stack_max >= quantity || !selected_item.CanBeSplit() )
                    {
                        player.PredictiveTakeEntityToTargetAttachmentEx( m_Entity, selected_item, focused_icon.GetSlotID() );
                        return true;
                    }
                    else
                    {
                        selected_item.SplitIntoStackMaxClient( m_Entity, focused_icon.GetSlotID() );
                        return true;
                    }
                }
                else if (focused_icon.GetSlotID() != -1)
                {
                    if (focused_item && focused_item.GetHierarchyParent() && focused_item.GetHierarchyParent().GetInventory().CanAddAttachment(selected_item))
                    {
                        InventoryLocation inv_loc = new InventoryLocation;
                        focused_item.GetInventory().GetCurrentInventoryLocation( inv_loc );
                        stack_max = InventorySlots.GetStackMaxForSlotId( inv_loc.GetSlot() );
                        quantity = focused_item.GetQuantity();
                        if( focused_item.CanBeCombined( ItemBase.Cast( selected_item ) ) )
                        {
                            focused_item.CombineItemsClient( selected_item, true );
                            return true;
                        }
                        else if( stack_max == 0 && GameInventory.CanSwapEntitiesEx( focused_item, selected_item ) )
                        {
                            player.PredictiveSwapEntities( selected_item, focused_item );
                            return true;
                        }
                        else if( m_AttachmentCargos.Contains( inv_loc.GetSlot() ) )
                        {
                            if( focused_item.GetInventory().CanAddEntityInCargo( selected_item, selected_item.GetInventory().GetFlipCargo() ) )
                            {
                                SplitItemUtils.TakeOrSplitToInventory( PlayerBase.Cast( player ), focused_item, selected_item );
                                return true;
                            }
                        }
                    }
                }
            }
        }
        else //clicking
        {
            if( focused_item && focused_item.GetInventory().CanRemoveEntity() && (!focused_icon || !focused_icon.IsOutOfReach()) )
            {
                EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
                if( item_in_hands && item_in_hands.GetInventory().CanRemoveEntity() )
                {
                    if( GameInventory.CanSwapEntitiesEx( item_in_hands, focused_item ) )
                    {
                        player.PredictiveSwapEntities( item_in_hands, focused_item );
                        return true;
                    }
                }
                else
                {
                    if( player.GetHumanInventory().CanAddEntityInHands( focused_item ) )
                    {
                        player.PredictiveTakeEntityToHands( focused_item );
                        return true;
                    }
                }
            }
        }
        
        return false;
    }

Перекрестные ссылки GameInventory::CanSwapEntitiesEx(), GetGame(), ItemManager::GetInstance(), InventorySlots::GetStackMaxForSlotId(), m_AttachmentCargos, m_Entity и SplitItemUtils::TakeOrSplitToInventory().

SplitItem()

override bool SplitItem ( )

inlineprotected

    {
        return false;
    }

TransferItem()

override bool TransferItem ( )

inlineprotected

    {
        if (CanTakeToInventory())
        {
            EntityAI entity = GetFocusedItem();
            SlotsIcon focused_icon = GetFocusedSlotsIcon();
            if( entity && !entity.IsLockedInSlot() && (!focused_icon || !focused_icon.IsOutOfReach()) )
            {
                PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
                GetGame().GetPlayer().PredictiveTakeEntityToInventory( FindInventoryLocationType.CARGO, entity );
                return true;
            }
        }
        return false;
    }

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

TransferItemToVicinity()

override bool TransferItemToVicinity ( )

inlineprotected

    {
        if (CanDrop())
        {
            ItemBase item = ItemBase.Cast(GetFocusedItem());
            PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
            SlotsIcon focused_icon = GetFocusedSlotsIcon();
            
            if (item && !item.IsLockedInSlot() && (focused_icon && !focused_icon.IsOutOfReach()))
            {
                if (item.GetTargetQuantityMax() < item.GetQuantity())
                    item.SplitIntoStackMaxClient( null, -1 );
                else
                    player.PhysicalPredictiveDropItem( item );
                return true;
            }
        }
        return false;
    }

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

UnfocusAll()

override void UnfocusAll ( )

inlineprotected

    {
        int i;
        for ( i = 1; i < Count(); i++ )
        {
            for ( int j = 0; j < ITEMS_IN_ROW; j++ )
            {
                Widget w = Get( i ).GetMainWidget().FindAnyWidget( "Cursor" + j );
                if( w )
                    w.Show( false );
            }
        }
        for ( i = 0; i < m_AttachmentCargos.Count(); i++ )
        {
            m_AttachmentCargos.GetElement( i ).Unfocus();
            m_AttachmentCargos.GetElement( i ).SetActive( false );
        }
    }

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

UpdateInterval()

override void UpdateInterval ( )

inlineprotected

    {
        super.UpdateInterval();
        RefreshAllSlots();
    }

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

Поля

m_AttachmentCargos

ref map<int, ref ContainerWithCargo> m_AttachmentCargos

protected

Используется в AttachmentCategoriesRow(), Combine(), RefreshSlot(), Select() и UnfocusAll().

m_AttachmentsContainer

ref AttachmentsGroupContainer m_AttachmentsContainer

protected

Используется в AttachmentCategoriesRow(), Init(), RefreshAllSlots() и RefreshSlot().

m_CategoryIdentifier

string m_CategoryIdentifier

protected

Используется в GetCategoryIdentifier() и Init().

m_Refreshing

bool m_Refreshing

protected

Используется в AttachmentCategoriesRow(), Refresh() и RefreshAllSlots().

m_RowConfigPath

string m_RowConfigPath

protected

Используется в Init().

---

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

• D:/Ishodniki/scripts/5_Mission/GUI/InventoryNew/Inherited/AttachmentCategoriesRow.c