containerwithcargoandattachments.c

Go to the documentation of this file.

class ContainerWithCargoAndAttachments extends ClosableContainer
{
 protected ref Attachments m_Atts;
 protected ref CargoContainer m_CargoGrid;
 
 protected ref map<EntityAI, ref CargoContainer> m_AttachmentCargos;
 protected ref map<EntityAI, ref AttachmentsWrapper> m_AttachmentAttachmentsContainers;
 protected ref map<EntityAI, ref Attachments> m_AttachmentAttachments;
 protected ref array<int> m_AttachmentSlotsSorted;
 
 void ContainerWithCargoAndAttachments( LayoutHolder parent, int sort = -1 )
 {
 WidgetEventHandler.GetInstance().RegisterOnDraggingOver( m_MainWidget, this, "DraggingOverHeader2" );
 }
 
 void ~ContainerWithCargoAndAttachments()
 {
 if ( m_Entity )
 {
 m_Entity.GetOnItemAttached().Remove( AttachmentAdded );
 m_Entity.GetOnItemDetached().Remove( AttachmentRemoved );
 }
 
 if ( m_Atts )
 delete m_Atts;
 
 foreach ( EntityAI e, Attachments att : m_AttachmentAttachments )
 {
 delete att;
 }
 
 if ( m_AttachmentAttachments )
 m_AttachmentAttachments.Clear();
 
 if ( m_AttachmentAttachmentsContainers )
 m_AttachmentAttachmentsContainers.Clear();
 
 if ( m_AttachmentCargos )
 m_AttachmentCargos.Clear();
 }
 
 void RecomputeContainers()
 {
 m_Body.Clear();
 
 if(m_Atts)
 {
 m_Body.Insert(m_Atts.GetWrapper());
 }
 
 if(m_CargoGrid)
 {
 m_Body.Insert(m_CargoGrid);
 }
 
 GameInventory inv = m_Entity.GetInventory();
 for (int i = 0; i < inv.AttachmentCount(); i++)
 {
 EntityAI ent = inv.GetAttachmentFromIndex(i);
 if(ent)
 {
 AttachmentsWrapper att = m_AttachmentAttachmentsContainers.Get(ent);
 if(att)
 {
 m_Body.Insert(att);
 }
 
 CargoContainer cargo = m_AttachmentCargos.Get(ent);
 if(cargo)
 {
 m_Body.Insert(cargo);
 }
 }
 }
 }
 
 void AttachmentAddedEx(EntityAI item, string slot, EntityAI parent, bool immedUpdate = true)
 {
 int slot_id = InventorySlots.GetSlotIdFromString( slot );
 int sort = -1;
 bool updateNeeded = false;
 ref Attachments att_cont = null;
 ref CargoContainer cont = null;
 
 if ( item.GetInventory().GetAttachmentSlotsCount() > 0 && item.CanDisplayAnyAttachmentSlot() )
 {
 updateNeeded = true;
 
 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 ( item.GetInventory().GetCargo() )
 {
 updateNeeded = true;
 
 cont = new CargoContainer( this, true );
 sort = (m_AttachmentSlotsSorted.Find( slot_id ) * 2) + SORT_CARGO_NEXT_OFFSET;
 cont.GetRootWidget().SetSort( sort );
 cont.SetEntity( item, false );
 Insert( cont, m_Atts.GetAttachmentHeight() + m_AttachmentCargos.Count() + 1 );
 
 m_AttachmentCargos.Insert( item, cont );
 }
 
 if (updateNeeded)
 {
 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..
 }
 
 RecomputeContainers();
 RecomputeOpenedContainers();
 
 Inventory.GetInstance().UpdateConsoleToolbar();
 
 if (m_Parent && immedUpdate)
 m_Parent.Refresh();
 }
 }
 
 void AttachmentAdded(EntityAI item, string slot, EntityAI parent)
 {
 AttachmentAddedEx(item, slot, parent);
 }
 
 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_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 );
 delete old_att_cont;
 
 if( m_Parent )
 m_Parent.Refresh();
 Inventory.GetInstance().UpdateConsoleToolbar();
 }
 
 RecomputeContainers();
 RecomputeOpenedContainers();
 }
 
 override void 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_SlotIcon )
 {
 bool hide = m_LockCargo || ItemManager.GetInstance().GetDraggedItem() == m_Entity;
 if (!hide)
 {
 SetOpenForSlotIcon(IsOpened());
 }
 m_SlotIcon.GetRadialIconPanel().Show( !hide );
 
 }
 
 super.UpdateInterval();
 }
 }
 
 override EntityAI GetFocusedContainerEntity()
 {
 return m_Entity;
 }
 
 override void UnfocusAll()
 {
 if( m_Atts )
 {
 m_Atts.UnfocusAll();
 }
 
 if( m_CargoGrid )
 {
 m_CargoGrid.UnfocusAll();
 }
 
 foreach( EntityAI e1, CargoContainer cargo : m_AttachmentCargos )
 {
 cargo.UnfocusAll();
 
 }
 
 foreach( EntityAI e2, Attachments att : m_AttachmentAttachments )
 {
 att.UnfocusAll();
 }
 }
 
 override bool IsLastIndex()
 {
 return m_ActiveIndex == ( m_OpenedContainers.Count() - 1 );
 }
 
 override bool IsFirstContainerFocused()
 {
 return IsFirstIndex();
 }
 
 override bool IsLastContainerFocused()
 {
 return IsLastIndex();
 }
 
 override void MoveGridCursor( int direction )
 {
 Container c = GetFocusedContainer();
 if ( c )
 {
 c.MoveGridCursor( direction );
 Inventory.GetInstance().UpdateConsoleToolbar();
 }
 }
 
 void SetEntity( EntityAI entity, bool immedUpdate = true )
 {
 m_Entity = entity;
 
 m_Atts = new Attachments( this, m_Entity );
 m_Atts.InitAttachmentGrid( SORT_ATTACHMENTS_OWN );
 m_AttachmentSlotsSorted = m_Atts.GetSlotsSorted();
 
 m_Entity.GetOnItemAttached().Insert( AttachmentAdded );
 m_Entity.GetOnItemDetached().Insert( AttachmentRemoved );
 
 m_ClosableHeader.SetItemPreview( m_Entity );
 CheckHeaderDragability();
 
 if ( m_Entity.GetInventory().GetCargo() )
 {
 m_CargoGrid = new CargoContainer( this, false );
 m_CargoGrid.GetRootWidget().SetSort( SORT_CARGO_OWN );
 m_CargoGrid.SetEntity( m_Entity, 0, immedUpdate );
 m_CargoGrid.UpdateHeaderText(); // TODO: refresh?
 Insert( m_CargoGrid );
 }
 else
 {
 string name = m_Entity.GetDisplayName();
 name.ToUpper();
 m_ClosableHeader.SetName( name );
 }
 
 m_AttachmentCargos = new map<EntityAI, ref CargoContainer>;
 m_AttachmentAttachmentsContainers = new map<EntityAI, ref AttachmentsWrapper>;
 m_AttachmentAttachments = new map<EntityAI, ref Attachments>;
 
 (Container.Cast( m_Parent )).Insert( this );
 
 foreach ( int slot_id : m_AttachmentSlotsSorted )
 {
 EntityAI item = m_Entity.GetInventory().FindAttachment( slot_id );
 if ( item )
 AttachmentAddedEx( item, InventorySlots.GetSlotName( slot_id ), m_Entity, false );
 }
 
 RecomputeContainers();
 
 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();
 }
 }
 
 if( IsDisplayable() )
 SetOpenState( true );
 else
 SetOpenState( false );
 
 if (immedUpdate)
 m_Parent.m_Parent.Refresh();
 
 RecomputeOpenedContainers();
 }
 
 void HideCargo()
 {
 if( m_CargoGrid )
 {
 if(m_CargoGrid.IsVisible())
 {
 m_CargoGrid.OnHide();
 RecomputeOpenedContainers();
 }
 }
 }
 
 void ShowCargo()
 {
 if( m_CargoGrid )
 {
 if(!m_CargoGrid.IsVisible())
 {
 m_CargoGrid.OnShow();
 RecomputeOpenedContainers();
 }
 }
 }
 
 EntityAI GetEntity()
 {
 return m_Entity;
 }
 
 ItemPreviewWidget GetItemPreviewWidgetDragOrDrop( Widget w )
 {
 string name = w.GetName();
 name.Replace( "PanelWidget", "Render" );
 return ItemPreviewWidget.Cast( w.FindAnyWidget( name ) );
 }
 
 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();
 }
 
 Widget GetItemPreviewWidget( 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 );
 }
 return ipw;
 }
 
 void MouseClick2(Widget w, int x, int y, int button)
 {
 SlotsIcon icon;
 w.GetUserData(icon);
 
 ItemBase selectedItem;
 if (icon)
 selectedItem = ItemBase.Cast(icon.GetEntity());
 
 if (selectedItem)
 {
 bool isReserved = icon.IsReserved();
 
 switch (button)
 {
 case MouseState.RIGHT:
 #ifdef DIAG_DEVELOPER
 if (GetDayZGame().IsLeftCtrlDown())
 ShowActionMenu(selectedItem);
 #endif
 
 if (isReserved)
 {
 EntityAI attachmentParent = icon.GetSlotParent();
 GetGame().GetPlayer().GetHumanInventory().ClearUserReservedLocationSynced(selectedItem);
 attachmentParent.GetOnAttachmentReleaseLock().Invoke(selectedItem, icon.GetSlotID());
 }
 
 break;
 
 case MouseState.MIDDLE:
 if (!isReserved)
 InspectItem(selectedItem);
 
 break;
 
 case MouseState.LEFT:
 if (!isReserved)
 {
 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 DropReceived(Widget w, int x, int y, CargoContainer cargo)
 {
 EntityAI item = GetItemPreviewItem(w);
 if (!item)
 return;
 
 #ifndef PLATFORM_CONSOLE
 int c_x, c_y;
 #endif
 
 EntityAI targetEntity = m_Entity;
 CargoBase targetCargo;
 
 if (cargo != m_CargoGrid)
 {
 targetEntity = m_AttachmentCargos.GetKeyByValue(cargo);
 }
 
 if (targetEntity)
 {
 targetCargo = targetEntity.GetInventory().GetCargo();
 #ifdef PLATFORM_CONSOLE
 if (m_CargoGrid && m_CargoGrid.HasItem(item))
 return;
 #endif
 }
 
 if (!targetCargo || !targetEntity)
 return;
 
 InventoryLocation dst = new InventoryLocation();
 #ifdef PLATFORM_CONSOLE
 x = 0;
 y = targetCargo.GetItemCount();
 targetEntity.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.CARGO, dst);
 #else
 c_x = targetCargo.GetHeight();
 c_y = targetCargo.GetWidth();
 
 dst.SetCargoAuto(targetCargo, 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() && targetEntity.GetInventory().LocationCanAddEntity(dst))
 #else
 if (c_x > x && c_y > y && targetEntity.GetInventory().LocationCanAddEntity(dst))
 #endif
 {
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
 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);
 }
 
 void TakeAsAttachment( Widget w, 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);
 //string name = receiver.GetName();
 //name.Replace("PanelWidget", "Render");
 
 //ItemPreviewWidget receiver_iw = ItemPreviewWidget.Cast( receiver.FindAnyWidget(name) );
 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 );
 InventoryLocation il = new InventoryLocation;
 float stackable;
 
 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 && attached_entity.GetInventory().CanAddAttachmentEx( item, slot_id ) )
 {
 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( attached_entity, slot_id );
 }
 }
 else if(attached_entity && attached_entity.GetInventory().CanAddAttachment(item))
 {
 attached_entity.GetInventory().FindFreeLocationFor(item,FindInventoryLocationType.ATTACHMENT,il);
 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( attached_entity, il.GetSlot() );
 }
 }
 else if( m_Entity.GetInventory().CanAddAttachment(item) )
 {
 m_Entity.GetInventory().FindFreeLocationFor(item,FindInventoryLocationType.ATTACHMENT,il);
 stackable = item_base.GetTargetQuantityMax(il.GetSlot());
 if( stackable == 0 || stackable >= item_base.GetQuantity() )
 {
 player.PredictiveTakeEntityToTargetAttachmentEx(m_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() ) && !m_Entity.GetInventory().HasEntityInCargo( 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 );
 }*/
 }
 
 override void OnDropReceivedFromHeader( Widget w, int x, int y, Widget receiver )
 {
 TakeAsAttachment( w, receiver );
 }
 
 void OnDropReceivedFromHeader2( Widget w, int x, int y, Widget receiver )
 {
 TakeAsAttachment( w, receiver );
 }
 
 void DoubleClick(Widget w, int x, int y, int button)
 {
 if( button == MouseState.LEFT && !g_Game.IsLeftCtrlDown())
 {
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if( w == NULL || player.GetInventory().IsInventoryLocked() )
 {
 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 );
 }
 
 EntityAI item = iw.GetItem();
 
 if( !item )
 {
 return;
 }
 
 SlotsIcon icon;
 iw.GetUserData(icon);
 
 if(icon && icon.IsReserved())
 {
 return;
 }
 
 if( !item.GetInventory().CanRemoveEntity() || !player.CanManipulateInventory() )
 return;
 
 if( player.GetInventory().HasEntityInInventory( item ) && player.GetHumanInventory().CanAddEntityInHands( item ) )
 {
 player.PredictiveTakeEntityToHands( item );
 }
 else
 {
 if(player.GetInventory().CanAddEntityToInventory( item ) && item.GetInventory().CanRemoveEntity())
 {
 player.PredictiveTakeEntityToInventory( FindInventoryLocationType.ANY, InventoryItem.Cast( item ) );
 }
 else
 {
 if( player.GetHumanInventory().CanAddEntityInHands( item ) )
 {
 player.PredictiveTakeEntityToHands( item );
 }
 }
 }
 
 HideOwnedTooltip();
 
 name = w.GetName();
 name.Replace( "PanelWidget", "Temperature" );
 w.FindAnyWidget( name ).Show( false );
 }
 }
 
 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;
 
 if( cargo == m_CargoGrid )
 {
 target_entity = m_Entity;
 target_cargo = m_Entity.GetInventory().GetCargo();
 }
 else
 {
 target_entity = m_AttachmentCargos.GetKeyByValue( cargo );
 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;
 if( target_entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
 {
 ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
 }
 else
 {
 ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
 }
 }
 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;
 }
 
 override void DraggingOver( Widget w, int x, int y, Widget receiver )
 {
 DraggingOverHeader( w, x, y, receiver );
 }
 
 override void DraggingOverHeader( Widget w, int x, int y, Widget receiver )
 {
 if( w == NULL )
 {
 return;
 }
 EntityAI item = GetItemPreviewItem( w );
 if( !item )
 {
 return;
 }
 
 SlotsIcon slots_icon;
 receiver.GetUserData(slots_icon);
 
 EntityAI attached_entity;
 EntityAI receiver_item;
 bool is_reserved = false;
 int slot_id = -1;
 
 if(slots_icon)
 {
 attached_entity = slots_icon.GetSlotParent();
 slot_id = slots_icon.GetSlotID();
 receiver_item = slots_icon.GetEntity();
 is_reserved = slots_icon.IsReserved();
 }
 
 
 Weapon_Base wpn;
 Magazine mag;
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if( m_Entity )
 {
 if( Class.CastTo(wpn, m_Entity ) && Class.CastTo(mag, item ) )
 {
 if( player.GetWeaponManager().CanAttachMagazine( wpn, mag ) )
 {
 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.GREEN_COLOR );
 }
 }
 else if( receiver_item && !is_reserved )
 {
 ItemBase receiver_itemIB = ItemBase.Cast( receiver_item );
 ItemBase itemIB = ItemBase.Cast( 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 if( GameInventory.CanSwapEntitiesEx( receiver_item, item ) )
 {
 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( item ) )
 {
 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( attached_entity && attached_entity.GetInventory().CanAddAttachmentEx( item, slot_id ) )
 {
 ItemManager.GetInstance().HideDropzones();
 if( attached_entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
 {
 ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
 }
 else
 {
 ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
 }
 ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
 }
 else if( m_Entity.GetInventory().CanAddAttachment( item ) )
 {
 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.GREEN_COLOR );
 }
 else if( ( m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() ) && !m_Entity.GetInventory().HasEntityInCargo( item ) ) /*|| player.GetHumanInventory().HasEntityInHands( item )*/ )
 {
 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.GREEN_COLOR );
 }
 else
 {
 ItemManager.GetInstance().ShowSourceDropzone( item );
 ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
 }
 }
 }
}