attachmentcategoriesrow.c

Go to the documentation of this file.

class AttachmentCategoriesRow: ClosableContainer
{
    protected string                                m_CategoryIdentifier;
    protected string                                m_RowConfigPath;
    protected bool                                  m_Refreshing;
    
    protected ref AttachmentsGroupContainer         m_AttachmentsContainer;
    protected ref map<int, ref ContainerWithCargo>  m_AttachmentCargos;
    
    void AttachmentCategoriesRow( LayoutHolder parent, int sort = -1 )
    {
        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();
    }
    
    string GetCategoryIdentifier()
    {
        return m_CategoryIdentifier;
    }
    
    int GetFocusedSlot()
    {
        SlotsIcon icon = GetFocusedSlotsIcon();
        if (icon)
        {
            return icon.GetSlotID();
        }
        return -1;
    }
    
    override bool Select()
    {
        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;
    }
    
    override bool TransferItem()
    {
        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;
    }
    
    override bool TransferItemToVicinity()
    {
        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;
    }
    
    override bool Combine()
    {
        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;
    }
    
    override bool CanSplitEx(EntityAI focusedItem)
    {
        return false;
    }
 
    override bool SplitItem()
    {
        return false;
    }
    
    override bool EquipItem() //TODO: may be possible, but the hint doesn't reflect it anyway
    {
        return false;
    }
    
    override bool 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( 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;
    }
    
    override bool CanCombineAmmo()
    {
        return false;
    }
    
    override bool IsItemActive()
    {
        SlotsIcon icon = GetFocusedSlotsIcon();
        return GetFocusedItem() != null && (!icon || !icon.IsOutOfReach());
    }
 
    override bool IsItemWithQuantityActive()
    {
        ItemBase item = ItemBase.Cast(GetFocusedItem());
        SlotsIcon icon = GetFocusedSlotsIcon();
        return item && ( !icon || !icon.IsOutOfReach()) && item.CanBeSplit();
    }
    
    override void OnDropReceivedFromHeader( Widget w, int x, int y, Widget receiver )
    {
        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 );
        }*/
    }
 
    override void UnfocusAll()
    {
        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 );
        }
    }
 
    override void DraggingOverHeader( Widget w, int x, int y, Widget receiver )
    {
        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 );
        }
    }
    
    bool DraggingOverGrid( Widget w,  int x, int y, Widget reciever, CargoContainer cargo )
    {
        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;
    }
 
    void DropReceived( Widget w, int x, int y, CargoContainer cargo )
    {
        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();
            }
        }
    }
    
    EntityAI GetItemPreviewItem( Widget w )
    {
        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();
    }
    
    override void Refresh()
    {
        if (!m_Refreshing)
        {
            if( !m_Closed )
            {
                super.Refresh();
                RefreshAllSlots();
            }
        }
    }
    
    void RefreshAllSlots()
    {
        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;
    }
    
    //slot_id and slot_name parametr is not used
    void RefreshSlot( int row, int column, int slot_id, string slot_name )
    {
        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 );
            }
        }
    }
    
    void DoubleClick(Widget w, int x, int y, int button)
    {
        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);
            }
        }
    }
    
    void MouseClick(Widget w, int x, int y, int button)
    {
        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;
            }
        }
    }
    
    void Init(int attachments_categories_count, int i, string attachment_category, string config_path_attachment_categories, EntityAI entity, int parent_m_Body_count )
    {
        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();
    }
    
    override void UpdateInterval()
    {
        super.UpdateInterval();
        RefreshAllSlots();
    }
}