containerwithcargo.c

Go to the documentation of this file.

class ContainerWithCargo extends ClosableContainer
{
 protected ref CargoContainer m_CargoGrid;
 protected int m_CargoIndex = -1;
 
 void ContainerWithCargo( Container parent, int sort = -1 )
 {
 m_LockCargo = false;
 m_Parent = parent;
 
 m_CargoGrid = new CargoContainer( this );
 Insert( m_CargoGrid );
 
 m_CargoGrid.GetRootWidget().SetSort( 1 );
 
 WidgetEventHandler.GetInstance().RegisterOnDraggingOver( m_MainWidget, this, "DraggingOverGrid" );
 RecomputeOpenedContainers();
 }
 
 override bool IsDisplayable()
 {
 if (m_Entity)
 return m_Entity.CanDisplayCargo();
 return false;
 }
 
 override bool IsEmpty()
 {
 return m_CargoGrid.IsEmpty();
 }
 
 override bool IsItemActive()
 {
 return m_CargoGrid.IsItemActive();
 }
 
 override bool CanCombine()
 {
 return m_CargoGrid.CanCombine();
 }
 
 override bool CanCombineAmmo()
 {
 return m_CargoGrid.CanCombineAmmo();
 }
 
 override bool IsItemWithQuantityActive()
 {
 return m_CargoGrid.IsItemWithQuantityActive();
 }
 
 void LockCargo(bool value)
 {
 if( value != m_LockCargo )
 {
 if( value )
 {
 m_LockCargo = true;
 OnHide();
 }
 else
 {
 m_LockCargo = false;
 SetOpenState(!m_Closed);
 }
 } 
 }
 
 override void Open()
 {
 if( !m_LockCargo )
 {
 ItemManager.GetInstance().SetDefaultOpenState( m_Entity.GetType(), true );
 m_Closed = false;
 SetOpenForSlotIcon(true);
 OnShow();
 m_Parent.m_Parent.Refresh();
 }
 
 if ( m_SlotIcon )
 {
 m_SlotIcon.GetRadialIconPanel().Show( !m_LockCargo );
 }
 }
 
 override void Close()
 {
 if( !m_LockCargo )
 {
 ItemManager.GetInstance().SetDefaultOpenState( m_Entity.GetType(), false );
 m_Closed = true;
 SetOpenForSlotIcon(false);
 OnHide();
 m_Parent.m_Parent.Refresh();
 }
 
 if ( m_SlotIcon )
 {
 m_SlotIcon.GetRadialIconPanel().Show( !m_LockCargo );
 }
 }
 
 override bool IsOpened()
 {
 return !m_Closed && !m_LockCargo;
 }
 
 override void UpdateInterval()
 {
 if ( m_Entity )
 {
 if ( m_Entity.GetInventory().IsInventoryLockedForLockType( HIDE_INV_FROM_SCRIPT ) || !m_Entity.CanDisplayCargo() )
 {
 LockCargo(true);
 if ( m_CargoGrid.IsVisible() )
 {
 RecomputeOpenedContainers();
 }
 }
 else
 {
 LockCargo(false);
 if ( !m_CargoGrid.IsVisible() )
 {
 RecomputeOpenedContainers();
 }
 }
 
 super.UpdateInterval();
 m_CargoGrid.UpdateInterval();
 
 bool hide = m_LockCargo || ItemManager.GetInstance().GetDraggedItem() == m_Entity;
 if (!hide)
 {
 SetOpenForSlotIcon(IsOpened());
 }
 
 if ( m_SlotIcon )
 {
 m_SlotIcon.GetRadialIconPanel().Show( !hide );
 }
 }
 }
 
 override bool IsFirstContainerFocused()
 {
 return m_CargoGrid.IsFirstContainerFocused();
 }
 
 override bool IsLastContainerFocused()
 {
 return m_CargoGrid.IsLastContainerFocused();
 }
 
 override void SetDefaultFocus( bool while_micromanagment_mode = false )
 {
 m_CargoGrid.SetDefaultFocus( while_micromanagment_mode );
 }
 
 override void UnfocusAll()
 {
 m_CargoGrid.Unfocus();
 }
 
 override bool SplitItem()
 {
 return m_CargoGrid.SplitItem();
 }
 
 override bool EquipItem()
 {
 return m_CargoGrid.EquipItem();
 }
 
 override bool TransferItem()
 {
 return m_CargoGrid.TransferItem();
 }
 
 override bool TransferItemToVicinity()
 {
 return m_CargoGrid.TransferItemToVicinity();
 }
 
 override bool InspectItem()
 {
 return m_CargoGrid.InspectItem();
 }
 
 void SetEntity( EntityAI entity, int cargo_index = 0, bool immedUpdate = true )
 {
 m_Entity = entity;
 m_CargoIndex = cargo_index;
 
 SetOpenState( true );
 
 m_CargoGrid.SetEntity( entity, immedUpdate );
 m_CargoGrid.UpdateHeaderText();
 m_ClosableHeader.SetItemPreview( entity );
 CheckHeaderDragability();
 ( Container.Cast( m_Parent ) ).Insert( this, -1, false );
 
 if ( m_Entity.GetInventory().IsInventoryLockedForLockType( HIDE_INV_FROM_SCRIPT ) || !m_Entity.CanDisplayCargo() )
 LockCargo(true);
 else
 LockCargo(false);
 
 if ( immedUpdate )
 {
 Refresh();
 GetMainWidget().Update();
 }
 }
 
 EntityAI GetEntity()
 {
 return m_Entity;
 }
 
 override EntityAI GetFocusedContainerEntity()
 {
 return m_Entity;
 }
 
 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();
 }
 
 bool DraggingOverGrid( Widget w, int x, int y, Widget reciever )
 {
 if( w == null )
 {
 return false;
 }
 
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if( !player.CanManipulateInventory() )
 {
 return false;
 }
 
 EntityAI item = GetItemPreviewItem( w );
 
 if( !item )
 {
 return false;
 }
 
 if( !item.GetInventory().CanRemoveEntity() )
 {
 return false;
 } 
 
 int color, c_x, c_y;
 
 #ifdef PLATFORM_CONSOLE
 int idx = -1;
 #else
 int idx = 0;
 #endif
 
 CargoBase cargo = m_Entity.GetInventory().GetCargoFromIndex(m_CargoIndex);
 if( cargo )
 {
 c_x = cargo.GetHeight();
 c_y = cargo.GetWidth();
 }
 
 InventoryLocation dst = new InventoryLocation;
 #ifdef PLATFORM_CONSOLE
 x = 0;
 y = cargo.GetItemCount();
 m_Entity.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.CARGO, dst );
 #else
 dst.SetCargoAuto(cargo, item, x, y, item.GetInventory().GetFlipCargo());
 #endif
 
 #ifdef PLATFORM_CONSOLE
 if( dst.IsValid() && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
 #else
 if( m_Entity && c_x > x && c_y > y && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
 #endif
 {
 ItemManager.GetInstance().HideDropzones();
 if( m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
 {
 ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
 }
 else
 {
 ItemManager.GetInstance().GetLeftDropzone().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" );
 if( w.FindAnyWidget( name ) )
 {
 w.FindAnyWidget( name ).SetColor( color );
 }
 }
 
 return true;
 }
 
 void DropReceived( Widget w, int x, int y )
 {
 float xx, yy;
 GetMainWidget().Update();
 GetMainWidget().GetScreenSize( xx, yy );
 if( GetMainWidget().FindAnyWidget("Background") )
 {
 GetMainWidget().FindAnyWidget("Background").Show( true );
 GetMainWidget().FindAnyWidget("Background").SetSize( xx, yy );
 }
 EntityAI item = GetItemPreviewItem( w );
 if( !item )
 {
 return;
 }
 
 #ifdef PLATFORM_CONSOLE
 if( m_CargoGrid.HasItem( item ) )
 {
 return;
 }
 #endif
 
 #ifdef PLATFORM_CONSOLE
 int idx = -1;
 #else
 int idx = 0;
 #endif
 int c_x, c_y;
 
 CargoBase cargo = m_Entity.GetInventory().GetCargoFromIndex(m_CargoIndex);
 
 if( cargo )
 {
 c_x = cargo.GetHeight();
 c_y = cargo.GetWidth();
 }
 
 InventoryLocation dst = new InventoryLocation;
 #ifdef PLATFORM_CONSOLE
 x = 0;
 y = cargo.GetItemCount();
 m_Entity.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.CARGO, dst );
 #else
 dst.SetCargoAuto(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() && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
 #else
 if( c_x > x && c_y > y && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
 #endif
 {
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 
 SplitItemUtils.TakeOrSplitToInventoryLocation( player, dst );
 
 Icon icon = m_CargoGrid.GetIcon( item );
 
 if( icon && w && w.FindAnyWidget("Cursor") )
 {
 w.FindAnyWidget("Cursor").SetColor( ColorManager.BASE_COLOR );
 icon.Refresh();
 Refresh();
 }
 }
 
 ItemManager.GetInstance().HideDropzones();
 ItemManager.GetInstance().SetIsDragging( false );
 }
 
 void TakeIntoHands( notnull PlayerBase player, notnull EntityAI item )
 {
 ItemBase item_base = ItemBase.Cast( item );
 
 if( !item.GetInventory().CanRemoveEntity() || !player.CanManipulateInventory() )
 return;
 
 float stackable = item_base.GetTargetQuantityMax();
 
 if( stackable == 0 || stackable >= item_base.GetQuantity() )
 {
 player.PredictiveTakeEntityToHands( item );
 }
 else if( stackable != 0 && stackable < item_base.GetQuantity() )
 {
 item_base.SplitIntoStackMaxHandsClient( player );
 }
 }
 
 override void DraggingOverHeader( Widget w, int x, int y, Widget receiver )
 {
 DraggingOver( w, x, y, receiver );
 }
 
 override void DraggingOver( Widget w, int x, int y, Widget receiver )
 {
 if( !w )
 return;
 EntityAI item = GetItemPreviewItem( w );
 if( !item )
 return;
 
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if( item.GetInventory().CanRemoveEntity() && player.CanManipulateInventory() && m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() ) && !m_Entity.GetInventory().HasEntityInCargo( item ) )
 {
 ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
 ItemManager.GetInstance().HideDropzones();
 if( m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
 {
 ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
 }
 else
 {
 ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
 }
 }
 else
 {
 ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
 ItemManager.GetInstance().ShowSourceDropzone( item );
 }
 }
 
 override void OnDropReceivedFromHeader( Widget w, int x, int y, Widget receiver )
 {
 EntityAI item = GetItemPreviewItem( w );
 if( !item )
 {
 return;
 }
 
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 InventoryLocation src = new InventoryLocation();
 if( GetEntity() && item.GetInventory().GetCurrentInventoryLocation(src))
 {
 InventoryLocation dst = new InventoryLocation();
 if (m_Entity.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ATTACHMENT, dst))
 {
 player.PredictiveTakeToDst(src, dst);
 }
 
 bool can_add = m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() );
 bool in_cargo = !player.GetInventory().HasEntityInInventory( item ) || !m_Entity.GetInventory().HasEntityInCargo( item );
 if( can_add && in_cargo )
 {
 SplitItemUtils.TakeOrSplitToInventory( player, m_Entity, item );
 }
 }
 }
}