handscontainer.c

Go to the documentation of this file.

class HandsContainer: Container
{
    protected bool                                          m_Hidden;
    protected ref HandsHeader                               m_CollapsibleHeader;
    protected ref HandsPreview                              m_HandsPreview;
    
    protected ref Attachments                               m_Atts;
    protected ref CargoContainer                            m_CargoGrid;
    
    protected ref map<EntityAI, ref CargoContainer>         m_AttachmentCargos;
    protected ref map<EntityAI, AttachmentsWrapper>         m_AttachmentAttachmentsContainers;
    protected ref map<EntityAI, ref Attachments>            m_AttachmentAttachments;
    protected ref array<int>                                m_AttachmentSlotsSorted;
    
    protected int                                           m_StaticAttCount = 0;
    protected int                                           m_StaticCargoCount = 0;
    
    protected ScrollWidget                                  m_ScrollWidget;
 
    void HandsContainer( LayoutHolder parent )
    {
        m_AttachmentCargos                  = new map<EntityAI, ref CargoContainer>;
        m_AttachmentAttachmentsContainers   = new map<EntityAI, AttachmentsWrapper>;
        m_AttachmentAttachments             = new map<EntityAI, ref Attachments>;
        
        m_CollapsibleHeader = new HandsHeader( this, "CollapseButtonOnMouseButtonDown" );
        GetMainWidget().SetFlags( WidgetFlags.IGNOREPOINTER );
        m_MainWidget = m_MainWidget.FindWidget( "body" );
        GetMainWidget().SetFlags( WidgetFlags.IGNOREPOINTER );
        m_Body = new array<ref LayoutHolder>;
        m_HandsPreview = new HandsPreview( this );
        ItemManager.GetInstance().SetHandsPreview( m_HandsPreview );
        m_Body.Insert( m_HandsPreview );
        
        ItemBase hands_item = ItemBase.Cast( GetGame().GetPlayer().GetHumanInventory().GetEntityInHands() );
        if ( hands_item )
            m_HandsPreview.CreateNewIcon( hands_item );
        
        m_ScrollWidget                      = ScrollWidget.Cast( m_RootWidget.GetParent().GetParent() );
        RecomputeOpenedContainers();
    }
    
    void ~HandsContainer()
    {
        if ( m_Entity )
        {
            m_Entity.GetOnItemAttached().Remove( AttachmentAdded );
            m_Entity.GetOnItemDetached().Remove( AttachmentRemoved );
        }
        
        m_AttachmentCargos.Clear();
        m_AttachmentAttachmentsContainers.Clear();
        m_AttachmentAttachments.Clear();
    }
    
    void ResetContainer()
    {
        m_Body.Clear();
        m_Body.Insert( m_HandsPreview );
    }
    
    override Header GetHeader()
    {
        return m_CollapsibleHeader;
    }
    
    override bool IsLastIndex()
    {
        return m_ActiveIndex == m_OpenedContainers.Count() - 1;
    }
    
    void SetFocusToIndex()
    {
        int index = m_ActiveIndex - 1;
        int attachment_start_index = -1;
        int cargo_start_index = -1;
        int attachment_end_index = -1;
        int cargo_end_index = -1;
        
        if ( m_Atts || m_AttachmentAttachments.Count() > 0 )
        {
            attachment_start_index = 0;
            if ( m_Atts )
                attachment_end_index++;
            attachment_end_index += m_AttachmentAttachments.Count();
        }
        
        if ( m_CargoGrid || m_AttachmentCargos.Count() > 0 )
        {
            cargo_start_index = attachment_end_index + 1;
            if ( m_CargoGrid )
                cargo_end_index++;
            cargo_end_index += cargo_start_index + m_AttachmentCargos.Count();
        }
        
        if ( m_ActiveIndex > m_OpenedContainers.Count() )
        {
            m_ActiveIndex = m_OpenedContainers.Count();
        }
        
        if ( index == -1 )
        {
            #ifdef PLATFORM_CONSOLE
            if ( m_MainWidget.FindAnyWidget("Cursor") )
                m_MainWidget.FindAnyWidget("Cursor").Show( true );
            #endif
            m_ScrollWidget.VScrollToPos01( 0 );
        }
        else
        {
            if( index.InRange( 0, attachment_end_index ) )
            {
                if( m_Atts )
                {
                    if( index == 0 )
                    {
                        m_Atts.SetDefaultFocus();
                        SetFocusedContainer( m_Atts.GetWrapper() );
                    }
                    else
                    {
                        m_AttachmentAttachments.GetElement( index - 1 ).SetDefaultFocus();
                        SetFocusedContainer( m_AttachmentAttachments.GetElement( index - 1 ).GetWrapper() );
                    }
                }
                else
                {
                    m_AttachmentAttachments.GetElement( index ).SetDefaultFocus();
                    SetFocusedContainer( m_AttachmentAttachments.GetElement( index ).GetWrapper() );
                }
            }
            else if( index.InRange( cargo_start_index, cargo_end_index ) )
            {
                if( m_CargoGrid )
                {
                    if( index == cargo_start_index )
                    {
                        m_CargoGrid.SetDefaultFocus();
                        SetFocusedContainer( m_CargoGrid );
                    }
                    else
                    {
                        m_AttachmentCargos.GetElement( index - 1 - cargo_start_index ).SetDefaultFocus();
                        SetFocusedContainer( m_AttachmentCargos.GetElement( index - 1 - cargo_start_index ) );
                    }
                }
                else
                {
                    m_AttachmentCargos.GetElement( index - cargo_start_index ).SetDefaultFocus();
                    SetFocusedContainer( m_AttachmentCargos.GetElement( index - cargo_start_index ) );
                }
            }
            
            if( m_MainWidget.FindAnyWidget("Cursor") )
                m_MainWidget.FindAnyWidget("Cursor").Show( false );
            ScrollToActiveContainer( GetFocusedContainer() );
        }
    }
    
    void ScrollToActiveContainer( Container active_container )
    {
        if( !active_container )
            return;
        float x, y, y_s;
        m_ScrollWidget.GetScreenPos( x, y );
        m_ScrollWidget.GetScreenSize( x, y_s );
        float amount;
        float next_pos  = active_container.GetFocusedContainerYScreenPos( true ) + active_container.GetFocusedContainerHeight( true );
            
        if( next_pos > ( y + y_s ) )
        {
            amount  = y + active_container.GetFocusedContainerYScreenPos( true );
            m_ScrollWidget.VScrollToPos( m_ScrollWidget.GetVScrollPos() + active_container.GetFocusedContainerHeight( true ) + 2 );
        }
        else if( active_container.GetFocusedContainerYScreenPos( true ) < y )
        {
            amount = active_container.GetFocusedContainerYScreenPos( true ) - y;
            m_ScrollWidget.VScrollToPos( m_ScrollWidget.GetVScrollPos() + amount - 2 );
        }
    }
    
    override void Insert( LayoutHolder container, int pos = -1, bool immedUpdate = true )
    {
        super.Insert( container, pos, immedUpdate );
    }
 
    override bool TransferItem()
    {
        if (m_ActiveIndex == 0)
        {
            if (CanTakeToInventory())
            {
                EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
                if (item_in_hands && GetGame().GetPlayer().GetHumanInventory().CanRemoveEntityInHands() && !GetGame().GetPlayer().GetInventory().HasInventoryReservation(item_in_hands, null))
                {
                    if (GetGame().GetPlayer().PredictiveTakeEntityToInventory( FindInventoryLocationType.CARGO, item_in_hands ))
                    {
                        m_MainWidget.FindAnyWidget("Cursor").Show( false );
                        m_MainWidget.FindAnyWidget("hands_preview_root").SetAlpha( 0.7 );
                        return true;
                    }
                }
            }
        }
        else if (GetFocusedContainer())
        {
            return GetFocusedContainer().TransferItem();
        }
        return false;
    }
    
    override bool SplitItem()
    {
        if (CanSplit())
        {
            if (m_ActiveIndex == 0)
            {
                ItemBase item_in_hands = ItemBase.Cast( GetGame().GetPlayer().GetHumanInventory().GetEntityInHands() );
                if ( item_in_hands )
                {
                    if ( item_in_hands.CanBeSplit() )
                    {
                        item_in_hands.OnRightClick();
                    }
                }
            }
            else if( GetFocusedContainer() )
            {
                return GetFocusedContainer().SplitItem();
            }
        }
        return false;
    }
    
    override bool EquipItem()
    {
        if (CanEquip())
        {   
            if (m_ActiveIndex == 0)
            {
                ItemBase item_in_hands = ItemBase.Cast( GetGame().GetPlayer().GetHumanInventory().GetEntityInHands() );
                if ( item_in_hands )
                {
                    if ( GetGame().GetPlayer().GetHumanInventory().CanRemoveEntityInHands() && !GetGame().GetPlayer().GetInventory().HasInventoryReservation(item_in_hands, null)  )
                    {
                        if ( GetGame().GetPlayer().PredictiveTakeEntityToInventory( FindInventoryLocationType.ATTACHMENT, item_in_hands ) )
                        {
                            m_MainWidget.FindAnyWidget("Cursor").Show( false );
                            m_MainWidget.FindAnyWidget("hands_preview_root").SetAlpha( 0.7 );
                            return true;
                        }
                    }
                }
            }
            else if (GetFocusedContainer())
            {
                return GetFocusedContainer().EquipItem();
            }
        }
        return false;
    }
    
    override void SetActive( bool active )
    {
        super.SetActive(active);
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        EntityAI item_in_hands = player.GetHumanInventory().GetEntityInHands();
 
        if( item_in_hands )
        {
            if( m_MainWidget.FindAnyWidget( "Cursor" ) )
            {
                m_MainWidget.FindAnyWidget( "Cursor" ).Show( active );
            }
            
            if( active )
            {
                float x, y;
                GetMainWidget().GetScreenPos( x, y );
                PrepareOwnedTooltip( item_in_hands, -1, y );
            }
        }
        else
        {
            if (active)
                m_MainWidget.FindAnyWidget( "hands_preview_root" ).SetAlpha( 0.85 );
            else
                m_MainWidget.FindAnyWidget( "hands_preview_root" ).SetAlpha( 0.7 );
        }
    }
    
    override void SetLastActive()
    {
        super.SetLastActive();
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        EntityAI item_in_hands = player.GetHumanInventory().GetEntityInHands();
 
        if( item_in_hands )
        {
            if ( m_ActiveIndex == 0)
            {
                if( m_MainWidget.FindAnyWidget( "Cursor" ) )
                {
                    m_MainWidget.FindAnyWidget( "Cursor" ).Show( true );
                }
            
                float x, y;
                GetMainWidget().GetScreenPos( x, y );
                PrepareOwnedTooltip( item_in_hands, x, y );
            }
        }
        else
        {
            m_MainWidget.FindAnyWidget( "hands_preview_root" ).SetAlpha( 0.85 );
        }
    }
    
    override void Refresh()
    {
        super.Refresh();
        SetActive( m_IsActive );
    }
    
    override bool IsItemActive()
    {
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        ItemBase item = ItemBase.Cast( player.GetHumanInventory().GetEntityInHands() );
        if( item == null )
        {
            return false;
        }
        return !IsEmpty() && ( !QuantityConversions.HasItemQuantity( item )  || ( QuantityConversions.HasItemQuantity( item ) && !item.CanBeSplit() ) );
    }
    
    override bool IsItemWithQuantityActive()
    {
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        ItemBase item = ItemBase.Cast( player.GetHumanInventory().GetEntityInHands() );
        if( item == null )
        {
            return false;
        }
        return !IsEmpty() && QuantityConversions.HasItemQuantity( item ) && item.CanBeSplit();
    }
    
    override bool IsEmpty()
    {
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        return player.GetHumanInventory().GetEntityInHands() == null;
    }
    
    override bool TransferItemToVicinity()
    {
        if (CanDrop())
        {
            if (m_ActiveIndex == 0)
            {
                PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
                ItemBase item_in_hands = ItemBase.Cast(player.GetHumanInventory().GetEntityInHands());
                if ( item_in_hands && player.CanDropEntity( item_in_hands ) && GetGame().GetPlayer().GetHumanInventory().CanRemoveEntityInHands() && !player.GetInventory().HasInventoryReservation(item_in_hands, null) )
                {
                    if ( item_in_hands.GetTargetQuantityMax() < item_in_hands.GetQuantity() )
                        item_in_hands.SplitIntoStackMaxClient( null, -1 );
                    else
                        player.PhysicalPredictiveDropItem( item_in_hands );
                    m_MainWidget.FindAnyWidget("Cursor").Show( false );
                    m_MainWidget.FindAnyWidget("hands_preview_root").SetAlpha( 0.7 );
                    return true;
                }
            }
            else if ( GetFocusedContainer() )
            {
                    return GetFocusedContainer().TransferItemToVicinity();
            }
        }
        return false;
    }
    
    override bool InspectItem()
    {
        if(m_ActiveIndex == 0)
        {
            PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
            EntityAI item_in_hands = player.GetHumanInventory().GetEntityInHands();
            if( item_in_hands )
            {
                InspectItem( item_in_hands );
                return true;
            }
        }
        else if( GetFocusedContainer() )
        {
            return GetFocusedContainer().InspectItem();
        }
        return false;
    }
    
    override bool OnSelectButton()
    {
        if(m_ActiveIndex == 0)
        {
            if (ItemManager.GetInstance().IsMicromanagmentMode())
            {
                EntityAI selectedItem = ItemManager.GetInstance().GetSelectedItem();
                if( selectedItem == GetFocusedItem() )
                {
                    Inventory.GetInstance().DisableMicromanagement();
                    return true;
                }
                else
                {
                    return Select();
                }
            }
            else
            {
                Inventory.GetInstance().EnableMicromanagement();
                return true;
            }
        }
        else
        {
            if( GetFocusedContainer() )
            {
                return GetFocusedContainer().OnSelectButton();
            }
        }
        return false;
    }
    
    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 )
        {
            return null;
        }
        
        return ipw.GetItem();
    }
 
    override void DraggingOverHeader( Widget w, int x, int y, Widget receiver )
    {
        if( w == null )
        {
            return;
        }
        EntityAI receiver_item;
        EntityAI slot_owner;
        int slot_id = -1;
        
        string name = w.GetName();
        name.Replace( "PanelWidget", "Render" );
 
        ItemPreviewWidget w_ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( name ) );
        if( w_ipw == null )
        {
            w_ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( "Render" ) );
        }
        if( w_ipw == null )
        {
            return;
        }
        
        SlotsIcon slots_icon;
        receiver.GetUserData(slots_icon);
        
        if(slots_icon)
        {
            receiver_item   = slots_icon.GetEntity();
            slot_id         = slots_icon.GetSlotID();
            slot_owner      = slots_icon.GetSlotParent();
        }
        
 
        PlayerBase p = PlayerBase.Cast( GetGame().GetPlayer() );
        InventoryItem receiver_entity = InventoryItem.Cast( p.GetHumanInventory().GetEntityInHands() );
        InventoryItem w_entity = InventoryItem.Cast( w_ipw.GetItem() );
        if( !w_entity )
        {
            return;
        }
 
        if( receiver_entity )
        {
            if( receiver_item )
            {
                ItemBase receiver_itemIB    = ItemBase.Cast( receiver_item );
                ItemBase itemIB             = ItemBase.Cast( receiver_item );
                if( receiver_itemIB && itemIB && receiver_itemIB.CanBeCombined( itemIB ) )
                {
                    ItemManager.GetInstance().HideDropzones();
                    if( m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
                    {
                        ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
                    }
                    else
                    {
                        ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
                    }
                    ColorManager.GetInstance().SetColor( w, ColorManager.COMBINE_COLOR );
                }
                else 
                {
                    PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
                    Magazine mag = Magazine.Cast(receiver_item);
                    Weapon_Base wpn = Weapon_Base.Cast(receiver_item.GetHierarchyParent());
                
                    if( wpn && mag )
                    {
                        if( player.GetWeaponManager().CanSwapMagazine( wpn,  Magazine.Cast(w_entity) ) )
                        {
                            ColorManager.GetInstance().SetColor( w, ColorManager.SWAP_COLOR );
                            if( w_entity.GetHierarchyRootPlayer() == player )
                            {
                                ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
                            }
                            else
                            {
                                ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
                            }
                        }
                        else
                        {
                            ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
                            ItemManager.GetInstance().ShowSourceDropzone( w_entity );
                        }
                    }
                    else
                    {
                        if( GameInventory.CanSwapEntitiesEx( receiver_item, w_entity ) )
                        {
                            ItemManager.GetInstance().HideDropzones();
                            if( m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
                            {
                                ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
                            }
                            else
                            {
                                ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
                            }
                            ColorManager.GetInstance().SetColor( w, ColorManager.SWAP_COLOR );
                        }
                        else if( receiver_itemIB.GetInventory().CanAddAttachment( w_entity ) )
                        {
                            ItemManager.GetInstance().HideDropzones();
                            if( receiver_itemIB.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
                            {
                                ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
                            }
                            else
                            {
                                ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
                            }
                            ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
                        }
                    }
                }
            }
            else if( slot_owner && slot_owner.GetInventory().CanAddAttachment( w_entity ) )
            {
                ItemManager.GetInstance().HideDropzones();
                ItemManager.GetInstance().GetCenterDropzone().SetAlpha( 1 );
                ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
            }
            else if( receiver_entity.GetInventory().CanAddAttachment( w_entity ) )
            {
                ItemManager.GetInstance().HideDropzones();
                if( receiver_entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
                {
                    ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
                }
                else
                {
                    ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
                }
                ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
            }
            else
            {
                ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
                ItemManager.GetInstance().ShowSourceDropzone( w_entity );
            }
        }
        else
        {
            /*if( m_HandsIcon )
            {
                ColorManager.GetInstance().SetColor( w, ColorManager.SWAP_COLOR );
                ItemManager.GetInstance().HideDropzones();
                ItemManager.GetInstance().GetCenterDropzone().SetAlpha( 1 );
            }
            
            else
            {*/
                ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
                ItemManager.GetInstance().ShowSourceDropzone( w_entity );
            //}
        }
    }
 
    void OnDropReceivedFromHeader2( Widget w, int x, int y, Widget receiver )
    {
        TakeAsAttachment( w, receiver );
    }
    
    void OnPerformCombination(int combinationFlags)
    {
        PlayerBase m_player = PlayerBase.Cast( GetGame().GetPlayer() );
        if ( m_am_entity1 == null || m_am_entity2 == null ) return;
 
        if ( combinationFlags == InventoryCombinationFlags.NONE ) return;
 
        if ( combinationFlags & InventoryCombinationFlags.LOAD_CHAMBER )
        {
            Magazine mag;
            if ( Class.CastTo(mag,  m_am_entity2 ) )
            {
                m_player.GetWeaponManager().LoadBullet( mag );
                return;
            }
        }
 
        if ( combinationFlags & InventoryCombinationFlags.ADD_AS_ATTACHMENT )
        {
            if( m_Atts )
            {
                m_Body.RemoveItem( m_Atts.GetWrapper() );
                delete m_Atts;
            }
            if( m_am_entity2.GetSlotsCountCorrect() > 0 )
            {
                m_Atts = new Attachments( this, m_am_entity2 );
                m_Atts.InitAttachmentGrid( 1 );
 
            }
 
            Refresh();
            m_Parent.Refresh();
 
            Weapon_Base wpn1;
            Magazine mag1;
            if ( Class.CastTo(wpn1,  m_am_entity1 ) && Class.CastTo(mag1,  m_am_entity2 ) )
            {
                if( m_player.GetWeaponManager().CanAttachMagazine(wpn1, mag1) )
                {
                    m_player.GetWeaponManager().AttachMagazine(mag1);
                    return;
                }
            }
            
            SplitItemUtils.TakeOrSplitToInventory(m_player, m_am_entity1, m_am_entity2);
            //m_player.PredictiveTakeEntityToTargetAttachment( m_am_entity1, m_am_entity2 );
        }
 
        if ( combinationFlags & InventoryCombinationFlags.ADD_AS_CARGO )
        {
            m_player.PredictiveTakeEntityToTargetCargo( m_am_entity1, m_am_entity2 );
        }
 
        if ( combinationFlags & InventoryCombinationFlags.SWAP )
        {
            Magazine swapmag1;
            Magazine swapmag2;
            if (Class.CastTo(swapmag1,  m_am_entity1) && Class.CastTo(swapmag2,  m_am_entity2 ) )
            {
                if( m_player.GetWeaponManager().CanSwapMagazine( Weapon_Base.Cast( swapmag1.GetParent() ), Magazine.Cast( swapmag2 ) ) )
                {
                    m_player.GetWeaponManager().SwapMagazine(swapmag2);
                    return;
                }
 
                if( m_player.GetWeaponManager().CanSwapMagazine(Weapon_Base.Cast( swapmag2.GetParent() ), Magazine.Cast( swapmag1 )) )
                {
                    m_player.GetWeaponManager().SwapMagazine(swapmag1);
                    return;
                }
            }
            if ( !m_player.PredictiveSwapEntities( m_am_entity1, m_am_entity2 ) && m_player.GetHumanInventory().CanAddEntityInHands( m_am_entity1 ) )
            {
                m_player.PredictiveTakeEntityToHands( m_am_entity1 );
            }
        }
 
        if ( combinationFlags & InventoryCombinationFlags.TAKE_TO_HANDS )
        {
            if ( m_Atts )
            {
                m_Body.RemoveItem( m_Atts.GetWrapper() );
                delete m_Atts;
            }
 
            if ( m_am_entity2.GetSlotsCountCorrect() > 0 )
            {
                m_Atts = new Attachments( this, m_am_entity2 );
                m_Atts.InitAttachmentGrid( 1 );
 
            }
            Refresh();
            m_Parent.Refresh();
            
            if ( m_player.GetHumanInventory().CanAddEntityInHands( m_am_entity2 ) )
            {
                m_player.PredictiveTakeEntityToHands( m_am_entity2 );
            }
        }
    }
 
    void ShowActionMenuCombine( EntityAI entity1, EntityAI entity2, int combinationFlags )
    {
        if ( entity1 && entity2 ) PrintString( "Showing action menu for " + entity1.GetDisplayName() + " and " + entity2.GetDisplayName() );
 
        ContextMenu cmenu = ContextMenu.Cast(GetGame().GetUIManager().GetMenu().GetContextMenu());
        m_am_entity1 = entity1;
        m_am_entity2 = entity2;
        cmenu.Hide();
        cmenu.Clear();
 
        if( combinationFlags & InventoryCombinationFlags.COMBINE_QUANTITY2 )
        {
            ItemBase entity = ItemBase.Cast( entity1 );
            entity.CombineItemsClient( ItemBase.Cast( entity2 ) );
            return;
        }
 
        if ( entity1 == null || entity2 == null ) return;
 
        if ( combinationFlags == InventoryCombinationFlags.NONE ) return;
 
        if ( combinationFlags & InventoryCombinationFlags.ADD_AS_ATTACHMENT )
        {
            cmenu.Add( "#inv_context_add_as_attachment", this, "OnPerformCombination", new Param1<int>( InventoryCombinationFlags.ADD_AS_ATTACHMENT ) );
        }
        if ( combinationFlags & InventoryCombinationFlags.LOAD_CHAMBER )
        {
            cmenu.Add( "#inv_context_load_chamber", this, "OnPerformCombination", new Param1<int>( InventoryCombinationFlags.LOAD_CHAMBER ) );
        }
 
        if ( combinationFlags & InventoryCombinationFlags.ADD_AS_CARGO )
        {
            cmenu.Add( "#inv_context_add_as_cargo", this, "OnPerformCombination", new Param1<int>( InventoryCombinationFlags.ADD_AS_CARGO ) );
        }
 
        if ( combinationFlags & InventoryCombinationFlags.SWAP )
        {
            cmenu.Add( "#inv_context_swap", this, "OnPerformCombination", new Param1<int>( InventoryCombinationFlags.SWAP ) );
        }
 
        if ( combinationFlags & InventoryCombinationFlags.TAKE_TO_HANDS )
        {
            cmenu.Add( "#inv_context_take_to_hands", this, "OnPerformCombination", new Param1<int>( InventoryCombinationFlags.TAKE_TO_HANDS ) );
        }
 
        if ( combinationFlags & InventoryCombinationFlags.COMBINE_QUANTITY2 )
        {
            cmenu.Add( "#inv_context_combine", this, "OnPerformCombination", new Param1<int>( InventoryCombinationFlags.COMBINE_QUANTITY2 ) );
        }
 
        int m_am_pos_x,  m_am_pos_y;
        GetMousePos( m_am_pos_x, m_am_pos_y );
        m_am_pos_x -= 5;
        m_am_pos_y -= 5;
 
        cmenu.Show( m_am_pos_x, m_am_pos_y );
    }
 
 
    override void OnDropReceivedFromHeader( Widget w, int x, int y, Widget receiver )
    {
        TakeAsAttachment( w, receiver );
    }
 
    int GetCombinationFlags( EntityAI entity1, EntityAI entity2 )
    {
        int flags = 0;
        PlayerBase m_player = PlayerBase.Cast( GetGame().GetPlayer() );
        EntityAI entity_in_hands = m_player.GetHumanInventory().GetEntityInHands();
 
        if (!entity1 || !entity2) return flags;
 
        Magazine swapmag1;
        Magazine swapmag2;
        bool skipSwap = false;
 
        if (Class.CastTo(swapmag1, entity1) && Class.CastTo(swapmag2, entity2))
        {
            Weapon_Base parentWpn;
 
            if (Class.CastTo(parentWpn, swapmag1.GetHierarchyParent()))
            {
                skipSwap = true;
                if (m_player.GetWeaponManager().CanSwapMagazine(parentWpn,swapmag2))
                    flags = flags | InventoryCombinationFlags.SWAP;
            }
 
            if (Class.CastTo(parentWpn, swapmag2.GetHierarchyParent()))
            {
                skipSwap = true;
                if (m_player.GetWeaponManager().CanSwapMagazine(parentWpn,swapmag1))
                    flags = flags | InventoryCombinationFlags.SWAP;
 
            }
        }
 
        if ( !skipSwap )
        {
            if (entity1 == m_player.GetHumanInventory().GetEntityInHands() ) flags = flags | InventoryCombinationFlags.TAKE_TO_HANDS;
            else if (GameInventory.CanSwapEntitiesEx( entity1, entity2 ))
            {
                if (!entity1.IsInherited( ZombieBase ) && !entity1.IsInherited( Car ))
                {
                    flags = flags | InventoryCombinationFlags.SWAP;
                }
            }
        }
 
        if (entity1.IsInherited( ItemBase) && entity2.IsInherited( ItemBase ))
        {
            ItemBase ent1 = ItemBase.Cast( entity1 );
            if (ent1.CanBeCombined( ItemBase.Cast( entity2 ) )) flags = flags | InventoryCombinationFlags.COMBINE_QUANTITY2;
        }
 
        else if (entity1.GetInventory().CanAddAttachment( entity2 ))
        {
            if (!entity1.IsInherited( ZombieBase ) && !entity1.IsInherited( Car ) && !entity2.IsInherited( ZombieBase ) && !entity2.IsInherited( Car ))
            {
                flags = flags | InventoryCombinationFlags.ADD_AS_ATTACHMENT;
            }
        }
        if (!entity1.GetInventory().HasEntityInInventory(entity2) && entity1.GetInventory().CanAddEntityInCargo( entity2, entity2.GetInventory().GetFlipCargo() )) flags = flags | InventoryCombinationFlags.ADD_AS_CARGO;
 
        if (entity1 == m_player.GetHumanInventory().GetEntityInHands() || entity2 == m_player.GetHumanInventory().GetEntityInHands())
        {
            ActionManagerClient amc;
            Class.CastTo(amc, m_player.GetActionManager());
            if (entity1 == m_player.GetHumanInventory().GetEntityInHands())
            {
                if (amc.CanSetActionFromInventory( ItemBase.Cast( entity1 ), ItemBase.Cast( entity2 ) ))
                {
                    flags = flags | InventoryCombinationFlags.SET_ACTION;
                }
            }
            else
            {
                if (amc.CanSetActionFromInventory( ItemBase.Cast( entity2 ), ItemBase.Cast( entity1 ) ))
                {
                    flags = flags | InventoryCombinationFlags.SET_ACTION;
                }
            }
        }
 
        if (GetRecipeCount( true, entity1, entity2 ) > 0)
        {
            flags = flags | InventoryCombinationFlags.RECIPE_ANYWHERE;
        }
        return flags;
    }
 
    int GetRecipeCount( bool recipe_anywhere, EntityAI entity1, EntityAI entity2 )
    {
        PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast( GetPlugin( PluginRecipesManager ) );
        return plugin_recipes_manager.GetValidRecipes( ItemBase.Cast( entity1 ), ItemBase.Cast( entity2 ), null, PlayerBase.Cast( GetGame().GetPlayer() ) );
    }
    
    void RemoveItem()
    {
        m_Entity = null;
        m_CollapsibleHeader.ShowCollapseButtons( false, true );
    }
    
    void DestroyAtt()
    {
        if( m_Atts )
        {
            m_Body.RemoveItem( m_Atts.GetWrapper() );
            delete m_Atts;
            
            if( m_Entity )
            {
                m_Entity.GetOnItemAttached().Remove( AttachmentAdded );
                m_Entity.GetOnItemDetached().Remove( AttachmentRemoved );
            }
        }
        
        if( m_AttachmentAttachmentsContainers )
        {
            foreach( EntityAI ent, AttachmentsWrapper att : m_AttachmentAttachmentsContainers )
            {
                m_Body.RemoveItem( att );
                m_AttachmentAttachments.Remove( ent );
                delete att;
            }
        }
        
        m_AttachmentAttachmentsContainers.Clear();
        Refresh();
        m_Parent.Refresh();
        RecomputeOpenedContainers();
    }
    
    override void UnfocusGrid()
    {
        if( m_Atts )
        {
            m_Atts.UnfocusAll();
        }
            
        if( m_CargoGrid )
        {
            m_CargoGrid.UnfocusAll();
        }
        
        if( m_AttachmentCargos )
        {
            foreach( EntityAI e1, CargoContainer cargo : m_AttachmentCargos )
            {
                cargo.UnfocusAll();
                    
            }
        }
        
        if( m_AttachmentCargos )
        {
            foreach( EntityAI e2, Attachments att : m_AttachmentAttachments )
            {
                att.UnfocusAll();
            }
        }
    }
    
    override void UnfocusAll()
    {
        UnfocusGrid();
    }
    
    void DestroyCargo()
    {
        if( m_CargoGrid )
        {
            m_Body.RemoveItem( m_CargoGrid );
            delete m_CargoGrid;
        }
        
        if( m_AttachmentCargos )
        {
            foreach( CargoContainer cargo : m_AttachmentCargos )
            {
                m_Body.RemoveItem( cargo );
                delete cargo;
            }
        }
 
        m_AttachmentCargos.Clear();
        Refresh();
        m_Parent.Refresh();
        RecomputeOpenedContainers();
    }
    
    void DropReceived( Widget w,  int x, int y, CargoContainer cargo )
    {
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        EntityAI item_in_hands = player.GetHumanInventory().GetEntityInHands();
        
        EntityAI item = GetItemPreviewItem( w );
        if( !item )
        {
            return;
        }
 
        int idx = 0;
        int c_x, c_y;
        
        EntityAI target_entity;
        CargoBase target_cargo;
        
        if( cargo == m_CargoGrid )
        {
            target_entity   = m_Entity;
            target_cargo    = m_Entity.GetInventory().GetCargo();
            #ifdef PLATFORM_CONSOLE
            if( m_CargoGrid.HasItem( item ) )
            {
                return;
            }
            #endif
        }
        else
        {
            target_entity   = m_AttachmentCargos.GetKeyByValue( cargo );
            if( target_entity )
            {
                target_cargo    = target_entity.GetInventory().GetCargo();
                #ifdef PLATFORM_CONSOLE
                if( cargo.HasItem( item ) )
                {
                    return;
                }
                #endif
            }
            else
                return;
        }
        
        if( target_cargo && target_entity )
        {
            c_x = target_cargo.GetHeight();
            c_y = target_cargo.GetWidth();
        }
        else
            return;
 
        InventoryLocation dst = new InventoryLocation;
        #ifdef PLATFORM_CONSOLE
        x = 0;
        y = target_cargo.GetItemCount();
        target_entity.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.CARGO, dst );
        #else
        dst.SetCargoAuto(target_cargo, item, x, y, item.GetInventory().GetFlipCargo());
        #endif
        
        InventoryLocation src = new InventoryLocation;
        item.GetInventory().GetCurrentInventoryLocation(src);
        if(src.CompareLocationOnly(dst) && src.GetFlip() == dst.GetFlip())
            return;
        
        #ifdef PLATFORM_CONSOLE
        if(dst.IsValid() && target_entity.GetInventory().LocationCanAddEntity(dst))
        #else
        if( c_x > x && c_y > y && target_entity.GetInventory().LocationCanAddEntity(dst))
        #endif
        {
            SplitItemUtils.TakeOrSplitToInventoryLocation( player, dst );
 
            Icon icon = cargo.GetIcon( item );
            
            if( icon )
            {
                if( w && w.FindAnyWidget("Cursor") )
                    w.FindAnyWidget("Cursor").SetColor( ColorManager.BASE_COLOR );
                icon.Refresh();
                Refresh();
            }
        }
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().SetIsDragging( false );
    }
    
    bool DraggingOverGrid( Widget w,  int x, int y, Widget reciever, CargoContainer cargo )
    {
        EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
        if( w == null )
        {
            return false;
        }
        EntityAI item = GetItemPreviewItem( w );
        if( !item || !item_in_hands )
        {
            return false;
        }
 
        int color;
        int idx = 0;
        int c_x, c_y;
        
        if( item_in_hands.GetInventory().GetCargo() )
        {
            c_x = item_in_hands.GetInventory().GetCargo().GetHeight();
            c_y = item_in_hands.GetInventory().GetCargo().GetWidth();
        }
        
        if( c_x > x && c_y > y && item_in_hands.GetInventory().CanAddEntityInCargoEx( item, 0, x, y, item.GetInventory().GetFlipCargo() ) )
        {
            ItemManager.GetInstance().HideDropzones();
            ItemManager.GetInstance().GetCenterDropzone().SetAlpha( 1 );
            color = ColorManager.GREEN_COLOR;
        }
        else
        {
            color = ColorManager.RED_COLOR;
            ItemManager.GetInstance().ShowSourceDropzone( item );
        }
 
        if( w.FindAnyWidget("Cursor") )
        {
            w.FindAnyWidget("Cursor").SetColor( color );
        }
        else
        {
            string name = w.GetName();
            name.Replace( "PanelWidget", "Cursor" );
            w.FindAnyWidget( name ).SetColor( color );
        }
 
        return true;
    }
    
    void TakeAsAttachment( Widget w, Widget receiver )
    {
        EntityAI receiver_item;
        EntityAI slot_owner;
        int slot_id = -1;
 
        SlotsIcon slots_icon; 
        receiver.GetUserData(slots_icon);
        if( slots_icon )
        {
            receiver_item   = slots_icon.GetEntity();
            slot_id         = slots_icon.GetSlotID();
            slot_owner      = slots_icon.GetSlotParent();
        }
        
        EntityAI item = GetItemPreviewItem( w );
        if( !item )
        {
            return;
        }
        
        ItemBase item_base  = ItemBase.Cast( item );
        float stack_max = item_base.GetTargetQuantityMax(slot_id);
        
        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(player.GetWeaponManager().CanSwapMagazine( wpn, mag ))
            {
                player.GetWeaponManager().SwapMagazine( mag );
            }
        }
        else if( receiver_item )
        {
            if( receiver_item != item )
            {
                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( item, receiver_item );
                }
            }
        }
        else if( slot_owner && slot_owner.GetInventory().CanAddAttachmentEx( item, slot_id ) )
        {
            if( stack_max == 0 || stack_max >= item_base.GetQuantity() )
            {
                player.PredictiveTakeEntityToTargetAttachmentEx(slot_owner, item, slot_id);
            }
            else if( stack_max != 0 && stack_max < item_base.GetQuantity() )
            {
                item_base.SplitIntoStackMaxClient( m_Entity, slot_id );
            }
        }
        else if( slot_owner && slot_owner.GetInventory().CanAddAttachment( item ) )
        {
            if( stack_max == 0 || stack_max >= item_base.GetQuantity() )
            {
                player.PredictiveTakeEntityToTargetAttachment(slot_owner, item);
            }
            else if( stack_max != 0 && stack_max < item_base.GetQuantity() )
            {
                item_base.SplitIntoStackMaxClient( m_Entity, -1 );
            }
        }
        else if( m_Entity.GetInventory().CanAddAttachment( item ) )
        {
            if( stack_max == 0 || stack_max >= item_base.GetQuantity() )
            {
                player.PredictiveTakeEntityToTargetAttachment(m_Entity, item);
            }
            else if( stack_max != 0 && stack_max < item_base.GetQuantity() )
            {
                item_base.SplitIntoStackMaxClient( m_Entity, -1 );
            }
        }
        else if( ( m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() ) && ( !player.GetInventory().HasEntityInInventory( item ) || !m_Entity.GetInventory().HasEntityInCargo( item )) ) || player.GetHumanInventory().HasEntityInHands( item ) )
        {
            SplitItemUtils.TakeOrSplitToInventory( PlayerBase.Cast( GetGame().GetPlayer() ), m_Entity, item );
        }
        /*else if( !player.GetInventory().HasEntityInInventory( item ) || !m_Entity.GetInventory().HasEntityInCargo( item ) )
        {
            SplitItemUtils.TakeOrSplitToInventory( PlayerBase.Cast( GetGame().GetPlayer() ), m_Entity, item );
        }*/
        
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().SetIsDragging( false );
    }
 
    void ShowAtt( EntityAI entity )
    {
        ResetContainer();
        m_StaticCargoCount = 0;
        m_Entity = entity;
        m_ActiveIndex = 0;
        if( entity.GetSlotsCountCorrect() > 0 )
        {
            m_Atts = new Attachments( this, entity );
            m_Atts.InitAttachmentGrid( 1 );
            m_AttachmentSlotsSorted = m_Atts.GetSlotsSorted();
            m_StaticAttCount = m_Atts.GetAttachmentHeight();
            m_Entity.GetOnItemAttached().Insert( AttachmentAdded );
            m_Entity.GetOnItemDetached().Insert( AttachmentRemoved );
        }
        else
        {
            m_StaticAttCount = 0;
        }
        
        if( entity.GetInventory().GetCargo() )
        {
            m_CargoGrid = new CargoContainer( this, false );
            m_CargoGrid.SetEntity( entity );
            m_CargoGrid.GetRootWidget().SetSort( 1 );
            Insert( m_CargoGrid );
            m_StaticCargoCount++;
        }
        
        if (m_AttachmentSlotsSorted)
        {
            foreach( int slot_id : m_AttachmentSlotsSorted )
            {
                EntityAI item = m_Entity.GetInventory().FindAttachment( slot_id );
                if( item )
                    AttachmentAdded( item, InventorySlots.GetSlotName( slot_id ), m_Entity );
            }
        }
 
        if (m_CargoGrid)
        {
            bool hideCargo = m_Entity.GetInventory().IsInventoryLockedForLockType( HIDE_INV_FROM_SCRIPT ) || !m_Entity.CanDisplayCargo() || m_ForcedHide;
            if (m_CargoGrid.IsVisible() && hideCargo)
            {
                HideCargo();
            }
            else if (!m_CargoGrid.IsVisible() && !hideCargo)
            {
                ShowCargo();
            }
        }
        
        m_CollapsibleHeader.ShowCollapseButtons(false);
        //m_CollapsibleHeader.ShowCollapseButtons( m_Atts || m_CargoGrid, m_Atts || m_CargoGrid );
        RecomputeOpenedContainers();
        Refresh();
        m_Parent.Refresh();
    }
    
    void RefreshHands()
    {
        for (int i = 0; i < m_Body.Count(); i++)
        {
            m_Body.Get( i ).OnShow();
        }
        Refresh();
        m_Parent.Refresh();
    }
    
    void AttachmentAdded(EntityAI item, string slot, EntityAI parent)
    {
        int slot_id = InventorySlots.GetSlotIdFromString( slot );
        int sort = -1;
        Attachments att_cont = null;
        CargoContainer cont = null;
        
        if( item.GetInventory().GetAttachmentSlotsCount() > 0  )
        {
            att_cont = new Attachments( this, item );
            sort = (m_AttachmentSlotsSorted.Find( slot_id ) * 2) + SORT_ATTACHMENTS_NEXT_OFFSET;
            att_cont.InitAttachmentGrid( sort );
            
            m_AttachmentAttachments.Insert( item, att_cont );
            m_AttachmentAttachmentsContainers.Insert( item, att_cont.GetWrapper() );
            
            att_cont.UpdateInterval();
            if( m_Parent )
                m_Parent.Refresh();
            Inventory.GetInstance().UpdateConsoleToolbar();
        }
        
        if( item.GetInventory().GetCargo() )
        {
            cont = new CargoContainer( this, true );
            sort = (m_AttachmentSlotsSorted.Find( slot_id ) * 2) + SORT_CARGO_NEXT_OFFSET; //m_AttachmentSlotsSorted.Find( slot_id ) + 50
            cont.GetRootWidget().SetSort( sort );
            cont.SetEntity( item );
            
            Insert(cont, -1);
            
            m_AttachmentCargos.Insert( item, cont );
            if( m_Parent )
                m_Parent.Refresh();
            Inventory.GetInstance().UpdateConsoleToolbar();
        }
        
        if (att_cont)
        {
            att_cont.ShowFalseAttachmentsHeader(true);
            if (cont)
            {
                cont.ShowFalseCargoHeader(false);
                cont.UpdateSize();
                cont.SetAlternateFalseTextHeaderWidget(att_cont.GetFalseHeaderTextWidget());
            }
        }
        else if (cont)
        {
            cont.SetAlternateFalseTextHeaderWidget(null); //just to be safe..
        }
        
        RecomputeOpenedContainers();
    }
    
    void AttachmentRemoved(EntityAI item, string slot, EntityAI parent)
    {
        int slot_id = InventorySlots.GetSlotIdFromString( slot );
        
        CargoContainer old_cont = m_AttachmentCargos.Get( item );
        if( old_cont )
        {
            m_Body.RemoveItem( old_cont );
            m_AttachmentCargos.Remove( item );
            delete old_cont;
            if( m_Parent )
                m_Parent.Refresh();
            Inventory.GetInstance().UpdateConsoleToolbar();
        }
        
        AttachmentsWrapper old_att_cont = m_AttachmentAttachmentsContainers.Get( item );
        if( old_att_cont )
        {
            m_AttachmentAttachmentsContainers.Remove( item );
            m_AttachmentAttachments.Remove( item );
            m_Body.RemoveItem( old_att_cont );
            delete old_att_cont;
            if( m_Parent )
                m_Parent.Refresh();
            Inventory.GetInstance().UpdateConsoleToolbar();
        }
        RecomputeOpenedContainers();
    }
 
    override void UpdateInterval()
    {
        super.UpdateInterval();
        
        if ( m_Entity )
        {
            if (m_CargoGrid)
            {
                bool hideCargo = m_Entity.GetInventory().IsInventoryLockedForLockType( HIDE_INV_FROM_SCRIPT ) || !m_Entity.CanDisplayCargo() || m_ForcedHide;
                if (m_CargoGrid.IsVisible() && hideCargo)
                {
                    HideCargo();
                }
                else if (!m_CargoGrid.IsVisible() && !hideCargo)
                {
                    ShowCargo();
                }
                
                m_CargoGrid.UpdateInterval();
            }
            
            if ( m_Atts )
            {
                m_Atts.UpdateInterval();
            }
            
            for ( int i = 0; i < m_AttachmentCargos.Count(); i++ )
            {
                m_AttachmentCargos.GetElement( i ).UpdateInterval();
            }
        }
        
        ElectricityIcon();
        m_CollapsibleHeader.UpdateInterval();
    }
 
    override void SetLayoutName()
    {
        m_LayoutName = WidgetLayoutName.ClosableContainer;
    }
 
    override void OnShow()
    {
        super.OnShow();
 
        for ( int i = 0; i < m_Body.Count(); i++ )
        {
            m_Body.Get( i ).OnShow();
        }
    }
 
    void MouseClick2(Widget w, int x, int y, int button)
    {
        string name = w.GetName();
        name.Replace("PanelWidget", "Render");
        ItemPreviewWidget itemPreview = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
        
        if (itemPreview)
        {
            ItemBase selectedItem = ItemBase.Cast(itemPreview.GetItem());
            
            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 (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);
                            }
                        }
 
                        break;
                }
            }
        }
    }
        
    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);
    
            ItemBase item = ItemBase.Cast(iw.GetItem());
            if (item)
            {
                PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
                EntityAI itemInHands = controlledPlayer.GetHumanInventory().GetEntityInHands();
        
                if (!item.GetInventory().CanRemoveEntity())
                    return;
                
                if (controlledPlayer.GetInventory().HasEntityInInventory(item) && controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
                {
                    controlledPlayer.PredictiveTakeEntityToHands(item);
                }
                else
                {
                    if (controlledPlayer.GetInventory().CanAddEntityToInventory(item) && controlledPlayer.GetHumanInventory().CanRemoveEntityInHands())
                    {
                        controlledPlayer.PredictiveTakeEntityToInventory(FindInventoryLocationType.ANY, item);
                    }
                    else
                    {
                        if (controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
                            controlledPlayer.PredictiveTakeEntityToHands(item);
                    }
                }
        
                HideOwnedTooltip();
        
                name = w.GetName();
                name.Replace("PanelWidget", "Temperature");
                w.FindAnyWidget(name).Show(false);
            }
        }
    }
 
    void DraggingOverHeader2(Widget w, int x, int y, Widget receiver )
    {
        DraggingOverHeader(w, x, y, receiver );
    }
    
    void ElectricityIcon()
    {
        EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
        if( item_in_hands && item_in_hands.GetCompEM() )
        {
            if( GetRootWidget().FindAnyWidget( "electricity" ) )
            {
                bool show_electricity_icon = item_in_hands.GetCompEM().HasElectricityIcon();
                GetRootWidget().FindAnyWidget( "electricity" ).Show( show_electricity_icon );
            }
            
            if( GetRootWidget().FindAnyWidget( "electricity_can_work" ) )
            {
                bool show_electricity_can_work_icon = item_in_hands.GetCompEM().CanWork() && !item_in_hands.IsRuined();
                GetRootWidget().FindAnyWidget( "electricity_can_work" ).Show( show_electricity_can_work_icon );
            }
        }
        else
        {
            GetRootWidget().FindAnyWidget( "electricity" ).Show( false );
        }
    }
 
    void CollapseButtonOnMouseButtonDown( Widget w )
    {
        int i;
        if( !m_Hidden )
        {
            for (i = 0; i < m_Body.Count(); i++)
            {
                m_Body.Get( i ).OnHide();
            }
            m_Hidden = true;
        }
        else
        {
            for (i = 0; i < m_Body.Count(); i++)
            {
                m_Body.Get( i ).OnShow();
            }
            m_Hidden = false;
        }
 
        w.FindAnyWidget("opened").Show(m_Hidden);
        w.FindAnyWidget("closed").Show(!m_Hidden);
        
        m_Parent.Refresh();
    }
    
    void HideCargo()
    {
        if( m_CargoGrid )
        {
            m_CargoGrid.OnHide();
            RecomputeOpenedContainers();
        }   
    }
    
    void ShowCargo()
    {
        if( m_CargoGrid )
        {
            m_CargoGrid.OnShow();
            RecomputeOpenedContainers();
        }
    }
}