class ZombieContainer: CollapsibleContainer
{
	protected ref AttachmentsGroupContainer		m_Container;
	protected ref ContainerWithCargo			m_CargoGrid;
	protected ref map<int, SlotsIcon>			m_InventorySlots;
	protected ref map<EntityAI, ref Container>	m_ShowedItems = new map<EntityAI, ref Container>;
	protected EntityAI							m_ZombieEntity;
	
	void ZombieContainer( LayoutHolder parent, int sort = -1 )
	{
		m_InventorySlots = new map<int, SlotsIcon>;
		m_Container = new AttachmentsGroupContainer(this);
		
		m_Container.SetHeader(GetHeader());
		SetHeaderName();
		SetHeader(null);
		m_Body.Insert( m_Container );
		
		m_MainWidget = m_RootWidget.FindAnyWidget( "body" );
		
		WidgetEventHandler.GetInstance().RegisterOnChildAdd( m_MainWidget, this, "OnChildAdd" );
		WidgetEventHandler.GetInstance().RegisterOnChildRemove( m_MainWidget, this, "OnChildRemove" );
		
		
		RecomputeOpenedContainers();
	}
	
	void ~ZombieContainer()
	{
		if( m_ZombieEntity )
		{
			m_ZombieEntity.GetOnItemAttached().Remove(ItemAttached);
			m_ZombieEntity.GetOnItemDetached().Remove(ItemDetached);
		}
	}
	
	void SetEntity( EntityAI zombie_entity )
	{
		m_ZombieEntity = zombie_entity;
		m_ZombieEntity.GetOnItemAttached().Insert(ItemAttached);
		m_ZombieEntity.GetOnItemDetached().Insert(ItemDetached);
		InitGhostSlots();
		m_Parent.Refresh();
	}
	
	override void UpdateRadialIcon()
	{
		if ( m_SlotIcon )
		{
			bool show_radial_icon;
			show_radial_icon = IsHidden();
			Widget rip = m_SlotIcon.GetRadialIconPanel();
			Widget icon_open = m_SlotIcon.GetRadialIcon();
			Widget icon_closed = m_SlotIcon.GetRadialIconClosed();
			rip.Show( !m_ZombieEntity.GetInventory().IsInventoryLockedForLockType( HIDE_INV_FROM_SCRIPT ) && m_ZombieEntity.CanDisplayCargo());
			icon_open.Show( show_radial_icon );
			icon_closed.Show( !show_radial_icon );
		}
	}
	
	override bool IsItemWithQuantityActive()
	{
		EntityAI ent = GetFocusedItem();
		return ent && QuantityConversions.HasItemQuantity( ent ) && ent.CanBeSplit();
	}
	
	bool IsContainerWithCargoActive()
	{
		return GetFocusedContainer().IsInherited( ContainerWithCargo );
	}
	
	bool IsItemWithAttachmentsActive()
	{
		return GetFocusedContainer().IsInherited( ContainerWithCargoAndAttachments );
	}
	
	bool IsZombieEquipmentActive()
	{
		return GetFocusedContainer() == m_Container;
	}
	
	bool IsItemWithContainerActive()
	{
		EntityAI ent = GetFocusedItem();
		return ent && ( ent.GetInventory().GetCargo() || ent.GetSlotsCountCorrect() > 0 );
	}
	
	bool IsEmptyItemActive()
	{
		return !GetFocusedItem();
	}
	
	override void ExpandCollapseContainer()
	{
		if( IsZombieEquipmentActive() )
		{
			ItemPreviewWidget item_preview = GetFocusedSlotsIcon().GetRender();
			ToggleContainer( item_preview.GetParent() );
		}
	}
	
	override void OnDropReceivedFromHeader( Widget w, int x, int y, Widget receiver )
	{
		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.IsInherited( ItemPreviewWidget ) )
		{
			return;	
		}
		
		EntityAI item = ipw.GetItem();
		
		if( !item.GetInventory().CanRemoveEntity() )
			return;
		
		if (m_ZombieEntity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() ))
			GetGame().GetPlayer().PredictiveTakeEntityToTargetCargo( m_ZombieEntity, item );
		else if( m_ZombieEntity.GetInventory().CanAddEntityToInventory( item ) )
		{
			GetGame().GetPlayer().PredictiveTakeEntityToTargetInventory( m_ZombieEntity, FindInventoryLocationType.CARGO, item );
		}
	}
	
	override void DraggingOverHeader(Widget w, int x, int y, Widget receiver)
	{
		ItemPreviewWidget ipw = ItemPreviewWidget.Cast(w.FindAnyWidget( "Render" ));
		string name = receiver.GetName();
		name.Replace("PanelWidget", "Render");
		ItemPreviewWidget receiver_iw = ItemPreviewWidget.Cast( receiver.FindAnyWidget( name ) );
		EntityAI receiver_item;
		if (receiver_iw)
		{
			receiver_item = receiver_iw.GetItem();
		}
		
		if(!ipw)
		{
			name = w.GetName();
			name.Replace("PanelWidget", "Render");
			ipw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
		}
		if(!ipw)
		{
		  ipw = ItemPreviewWidget.Cast(w);
		}
		
		if( !ipw.IsInherited(ItemPreviewWidget))
		{
			return;	
		}
		
		EntityAI item = ipw.GetItem();
		PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
		
		if(!item.GetInventory().CanRemoveEntity())
			return;
	}
	
	void OnDropReceivedFromGhostArea(Widget w, int x, int y, Widget receiver)
	{
		ItemPreviewWidget ipw = ItemPreviewWidget.Cast( w.FindAnyWidget("Render"));
		string name = receiver.GetName();
		name.Replace("PanelWidget", "Render");
		ItemPreviewWidget receiver_iw = ItemPreviewWidget.Cast( receiver.FindAnyWidget(name));
		EntityAI receiver_item;
		if (receiver_iw)
		{
			receiver_item = receiver_iw.GetItem();
		}
		
		if( !ipw )
		{
			name = w.GetName();
			name.Replace( "PanelWidget", "Render" );
			ipw = ItemPreviewWidget.Cast( w.FindAnyWidget(name));
		}
		if(!ipw)
		{
		  ipw = ItemPreviewWidget.Cast(w);
		}
		
		if(!ipw.IsInherited(ItemPreviewWidget))
		{
			return;	
		}
		
		EntityAI item = ipw.GetItem();
		PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
		
		if(!item.GetInventory().CanRemoveEntity())
		{
			return;
		}
		
		if(receiver_item)
		{
			if(receiver_item.GetInventory().CanAddAttachment(item))
			{
				player.PredictiveTakeEntityToTargetAttachment(receiver_item, item);
				return;
			}
			else if(receiver_item.GetInventory().CanAddEntityInCargo(item, item.GetInventory().GetFlipCargo()) && !receiver_item.GetInventory().HasEntityInCargo(item))
			{
				player.PredictiveTakeEntityToTargetInventory(receiver_item, FindInventoryLocationType.ANY, item);
				return;
			}
		}
		
		if(item)
		{
			if(m_ZombieEntity.GetInventory().CanAddAttachment(item))
			{
				player.PredictiveTakeEntityToTargetAttachment(m_ZombieEntity, item);
			}
			else if(m_ZombieEntity.GetInventory().CanAddEntityToInventory(item))
			{
				player.PredictiveTakeEntityToTargetInventory(m_ZombieEntity, FindInventoryLocationType.ANY, item);
			}
		}
		
		if( item )
		{
			if( m_ZombieEntity.GetInventory().CanAddEntityInto(item, FindInventoryLocationType.CARGO ))
			{
				player.PredictiveTakeEntityToTargetInventory(m_ZombieEntity, FindInventoryLocationType.CARGO, item);
			}
		}
	}

	void SetHeaderName()
	{
		m_CollapsibleHeader.SetName( "#container_inventory" );
	}
	
	void ItemAttached(EntityAI item, string slot_name)
	{
		int slot = InventorySlots.GetSlotIdFromString( slot_name );
		SlotsIcon icon = m_InventorySlots.Get( slot );
		if( icon )
		{
			icon.Init( item );

			if( m_ShowedItems.Contains( item ) == false )
			{
				string name;
				
				if( item.GetSlotsCountCorrect() > 0 )
				{
					ContainerWithCargoAndAttachments iwca = new ContainerWithCargoAndAttachments( this, false );
					iwca.SetEntity( item );
					WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp( icon.GetPanelWidget(),  this, "ToggleContainer" );

					icon.GetRadialIconPanel().Show( true );
					m_ShowedItems.Insert( item, iwca );
					
					Refresh();
				}
				else if( item.GetInventory().GetCargo() )
				{
					ContainerWithCargo iwc = new ContainerWithCargo( this, false );
					iwc.SetEntity( item );
					iwc.UpdateInterval();
					WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp( icon.GetPanelWidget(),  this, "ToggleContainer" );
					m_ShowedItems.Insert( item, iwc );
					icon.GetRadialIconPanel().Show(true);
					
					Refresh();
				}
			}
			
			ClosableContainer conta = ClosableContainer.Cast( m_ShowedItems.Get( item ) );
			string config = "CfgVehicles " + item.GetType() + " GUIInventoryAttachmentsProps";
			if( conta && conta.IsInherited( ClosableContainer ) )
			{
				bool show_radial_icon = ( item.GetInventory().GetCargo() || item.GetSlotsCountCorrect() > 0 ) && !GetGame().ConfigIsExisting( config );
				Widget rip = icon.GetRadialIconPanel();
				Widget icon_open = icon.GetRadialIcon();
				Widget icon_closed = icon.GetRadialIconClosed();				
				rip.Show( show_radial_icon );
				icon_open.Show( conta.IsOpened() );
				icon_closed.Show( !conta.IsOpened() );
			}
			RecomputeOpenedContainers();
		}
	}
	
	void ItemDetached(EntityAI item, string slot_name)
	{
		int slot = InventorySlots.GetSlotIdFromString( slot_name );
		SlotsIcon icon = m_InventorySlots.Get( slot );
		
		if( icon )
		{
			Container con = m_ShowedItems.Get( item );
			if( con )
			{
				( Container.Cast( con.m_Parent ) ).Remove( con );
				RecomputeOpenedContainers();
				GetMainWidget().Update();
				Refresh();
				m_ShowedItems.Remove( item );
			}
			
			icon.Clear();
			Inventory in = Inventory.Cast( GetRoot() );
			if( in )
				in.UpdateConsoleToolbar();
		}
	}
	
	override bool CanOpenCloseContainerEx(EntityAI focusedEntity)
	{
		ClosableContainer c;
		if (focusedEntity)
		{
			c = ClosableContainer.Cast( m_ShowedItems.Get( focusedEntity ) );
		}
		else
		{
			SlotsIcon icon = GetFocusedSlotsIcon();
			if (icon)
			{
				c = ClosableContainer.Cast(icon.GetContainer());
			}
		}
		
		if (c && c.IsDisplayable())	
		{	
			return true;
		}

		return false;
	}

	// mouse button UP or call from ExpandCollapseContainer
	void ToggleContainer(Widget w)
	{
		EntityAI item;
		SlotsIcon icon; 
		ClosableContainer c;
		w.GetUserData(icon);
		if (icon)
			item = icon.GetEntity();

		if (item)
			c = ClosableContainer.Cast(m_ShowedItems.Get(item));
		else
			c = ClosableContainer.Cast(icon.GetContainer());
		
		
		if (c)
			c.Toggle();

		RecomputeOpenedContainers();
	}
	
	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 (GetDayZGame().IsLeftCtrlDown())
						ShowActionMenu(selectedItem);
					#endif
					break;

				case MouseState.MIDDLE:
					InspectItem(selectedItem);
					break;

				case MouseState.LEFT:
					if (g_Game.IsLeftCtrlDown())
					{
						PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
						if (controlledPlayer.CanDropEntity(selectedItem))
						{
							if (selectedItem.GetTargetQuantityMax() < selectedItem.GetQuantity())
								selectedItem.SplitIntoStackMaxClient(null, -1);
							else
								controlledPlayer.PhysicalPredictiveDropItem(selectedItem);
	
							ItemManager.GetInstance().SetWidgetDraggable(w, false);
						}
					}
					break;
			}
		}
	}
	
	SlotsIcon GetSlotsIcon( int row, int column )
	{
		return SlotsContainer.Cast( m_Container.Get( row ) ).GetSlotIcon( column );
	}

	void InitGhostSlots()
	{
		int row, column;
		SlotsIcon icon;
		bool has_cargo = m_ZombieEntity.GetInventory().GetCargo() != null;
		
		string config_path_ghosts_slots = "CfgVehicles ZombieBase InventoryEquipment playerSlots";
		array<string> player_ghosts_slots = new array<string>();
		GetGame().ConfigGetTextArray( config_path_ghosts_slots, player_ghosts_slots );
		
		for ( int i = 0; i < player_ghosts_slots.Count(); i++ )
		{
			string slot_name = player_ghosts_slots.Get ( i );
			string path = "CfgSlots" + " " + slot_name;

			if ( GetGame().ConfigIsExisting( path ) )
			{
				string icon_name; //icon_name must be in format "set:<setname> image:<imagename>"
				GetGame().ConfigGetText( path + " ghostIcon", icon_name );
				column = i % ITEMS_IN_ROW;

				//START - GetWidgetSlot
				row = i / ITEMS_IN_ROW;
				if( row >= m_Container.Count() )
				{
					if ( has_cargo )
					{
						if( row < ( (player_ghosts_slots.Count() + 1 )/ ITEMS_IN_ROW ) )
							AddSlotsContainer( ITEMS_IN_ROW );
						else
							AddSlotsContainer( ( player_ghosts_slots.Count() + 1 ) % ITEMS_IN_ROW );
					
					}
					else
					{
						if ( row < ( player_ghosts_slots.Count() / ITEMS_IN_ROW ) )
							AddSlotsContainer( ITEMS_IN_ROW );
						else
							AddSlotsContainer( player_ghosts_slots.Count() % ITEMS_IN_ROW );
					}

				}
		
				icon = GetSlotsIcon( row, column );
				
				icon.GetMainWidget().Show( true );
				icon.Clear();
				
				WidgetEventHandler.GetInstance().RegisterOnDoubleClick( icon.GetPanelWidget(),  this, "DoubleClick" );
				
				//END - GetWidgetSlot
				WidgetEventHandler.GetInstance().RegisterOnDropReceived( icon.GetPanelWidget(),  this, "OnDropReceivedFromGhostArea" );
				WidgetEventHandler.GetInstance().RegisterOnDropReceived( icon.GetGhostSlot(),  this, "OnDropReceivedFromGhostArea" );
				WidgetEventHandler.GetInstance().RegisterOnDraggingOver( icon.GetPanelWidget(),  this, "DraggingOver" );
				WidgetEventHandler.GetInstance().RegisterOnDraggingOver( icon.GetGhostSlot(),  this, "DraggingOver" );
				WidgetEventHandler.GetInstance().RegisterOnDraggingOver( icon.GetPanelWidget(),  this, "DraggingOver" );
				WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown( icon.GetPanelWidget(),  this, "MouseClick" );
				
				icon.GetGhostSlot().LoadImageFile( 0, StaticGUIUtils.VerifyIconImageString(StaticGUIUtils.IMAGESETGROUP_INVENTORY,icon_name) );
				//END - LoadIconIntoWidgetSlot

				GetGame().ConfigGetText( path + " name", slot_name );
				int slot_id = InventorySlots.GetSlotIdFromString( slot_name );
				icon.SetSlotID( slot_id );
				icon.SetSlotDisplayName(InventorySlots.GetSlotDisplayName(slot_id));
				m_InventorySlots.Set( slot_id, icon );
				
				int slot = InventorySlots.GetSlotIdFromString( slot_name );
				ItemBase item = ItemBase.Cast( m_ZombieEntity.GetInventory().FindAttachment( slot ) );
				
				if( item )
					ItemAttached( item, slot_name );
			}
		}
		
		if( m_ZombieEntity.GetInventory().GetCargo() )
		{
			row = player_ghosts_slots.Count() / ITEMS_IN_ROW;
			column = player_ghosts_slots.Count() % ITEMS_IN_ROW;
			if( row >= m_Container.Count() )
			{
				if( row < ( player_ghosts_slots.Count() + 1 / ITEMS_IN_ROW ) )
					AddSlotsContainer( ITEMS_IN_ROW );
				else
					AddSlotsContainer( ( player_ghosts_slots.Count() + 1 ) % ITEMS_IN_ROW );
			}
			
			icon = GetSlotsIcon( row, column );
			icon.GetMainWidget().Show( true );
			icon.Clear();
			icon.GetGhostSlot().LoadImageFile( 0, StaticGUIUtils.VerifyIconImageString(StaticGUIUtils.IMAGESETGROUP_INVENTORY,m_ZombieEntity.ConfigGetString("GUIInventoryCargoIcon")) );
			icon.SetSlotDisplayName( m_ZombieEntity.ConfigGetString("GUIInventoryCargoName") );
			icon.GetRadialIconPanel().Show( true );
			icon.GetRadialIcon().Show( true );
			
			WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp( icon.GetGhostSlot(), this, "ToggleContainer" );
			m_CargoGrid = new ContainerWithCargo( this, false );
			m_CargoGrid.SetEntity( m_ZombieEntity );
			m_CargoGrid.GetHeader().GetMainWidget().ClearFlags( WidgetFlags.DRAGGABLE );
			m_ShowedItems.Insert( m_ZombieEntity, m_CargoGrid );
			icon.SetContainer(m_CargoGrid);
		}
		
		RecomputeOpenedContainers();
	}

	void AddSlotsContainer( int row_count )
	{
		ref SlotsContainer s_cont = new SlotsContainer( m_Container, m_ZombieEntity );
		s_cont.SetColumnCount( row_count );
		m_Container.Insert( s_cont );
	}

	Widget GetWidgetSlot( int slot_number )
	{
		int row = slot_number / ITEMS_IN_ROW;
		int column = slot_number % ITEMS_IN_ROW;

		return m_Container.Get( row ).GetMainWidget().FindAnyWidget( "Render" + column );
	}
	
	void DoubleClick(Widget w, int x, int y, int button)
	{
		if( button == MouseState.LEFT && !g_Game.IsLeftCtrlDown())
		{
			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 );
			}
			
			ItemBase item = ItemBase.Cast( iw.GetItem() );
			if( !item )
			{
				return;
			}
			
			PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
			
			if( player.GetInventory().HasInventoryReservation( item, null ) || player.IsItemsToDelete() )
			{
				return;
			}
			
			if( !item.GetInventory().CanRemoveEntity() )
				return;
					
			if ( player.GetInventory().HasEntityInInventory( item ) && GetGame().GetPlayer().GetHumanInventory().CanAddEntityInHands( item ) )
			{
				player.PredictiveTakeEntityToHands( item );
			}
			else
			{
				InventoryLocation il = new InventoryLocation;
				if( player.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.ANY, il) )
				{
					if( item.GetTargetQuantityMax(il.GetSlot()) < item.GetQuantity() )
						item.SplitIntoStackMaxToInventoryLocationClient( il );
					else
						player.PredictiveTakeEntityToInventory( FindInventoryLocationType.ANY, item );
				}
				else if( GetGame().GetPlayer().GetHumanInventory().CanAddEntityInHands( item ) )
				{
					if( item.GetTargetQuantityMax() < item.GetQuantity() )
						item.SplitIntoStackMaxHandsClient( player );
					else
						player.PredictiveTakeEntityToHands( item );
				}
			}
			
			HideOwnedTooltip();
			InventoryMenu menu = InventoryMenu.Cast( GetGame().GetUIManager().FindMenu( MENU_INVENTORY ) );
			if( menu )
			{
				menu.RefreshQuickbar();
			}
		}
	}

	override void CollapseButtonOnMouseButtonDown(Widget w)
	{
		super.CollapseButtonOnMouseButtonDown(w);
	}
	
	override bool EquipItem()
	{
		if (CanEquip())
		{	
			if ( GetFocusedContainer().IsInherited( ContainerWithCargo ) || GetFocusedContainer().IsInherited( ContainerWithCargoAndAttachments ) )
			{
				return GetFocusedContainer().EquipItem();
			}
			else
			{
				EntityAI item = GetFocusedItem();
				if( item )
				{
					GetGame().GetPlayer().PredictiveTakeEntityToInventory( FindInventoryLocationType.ATTACHMENT, item );
					return true;
				}
			}
		}
		return false;
	}
	
	override bool TransferItem()
	{
		LeftArea left_area = LeftArea.Cast( GetParent() );
		EntityAI item;
		if (CanTakeToInventory())
		{
			
			if (left_area)
			{
				if (GetFocusedContainer().IsInherited( ContainerWithCargo ) || GetFocusedContainer().IsInherited( ContainerWithCargoAndAttachments ))
				{
					return GetFocusedContainer().TransferItem();
				}
				else
				{
					item = GetFocusedItem();
					if( item )
					{
						GetGame().GetPlayer().PredictiveTakeEntityToInventory( FindInventoryLocationType.CARGO, item );
						return true;
					}
				}
			}
			else
			{
				if (!GetFocusedContainer().IsInherited( ContainerWithCargo ) && !GetFocusedContainer().IsInherited( ContainerWithCargoAndAttachments ))
				{
					item = GetFocusedItem();
					if (item)
					{
						GetGame().GetPlayer().PredictiveTakeEntityToInventory( FindInventoryLocationType.CARGO, item );
						return true;
					}
				}
			}
		}
		return false;
	}
	
	override bool Select()
	{
		if( GetFocusedContainer().IsInherited( ContainerWithCargo ) || GetFocusedContainer().IsInherited( ContainerWithCargoAndAttachments ) )
		{
			return GetFocusedContainer().Select();
		}
		else
		{
			SlotsIcon selected_slot = ItemManager.GetInstance().GetSelectedIcon();
			EntityAI focused_item = GetFocusedItem();
			EntityAI selected_item = ItemManager.GetInstance().GetSelectedItem();
			if( !(selected_slot && selected_slot.IsOutOfReach() ) )
			{
				if( selected_item )
				{
					if( selected_item != focused_item)
					{
						if( selected_item.GetInventory().CanRemoveEntity() )
						{
							GetGame().GetPlayer().PredictiveTakeEntityToTargetInventory( m_ZombieEntity, FindInventoryLocationType.ANY, selected_item );
							ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
							return true;
						}
					}
				}
				else
				{
					if( focused_item && focused_item.GetInventory().CanRemoveEntity() )
					{
						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 ) )
							{
								GetGame().GetPlayer().PredictiveSwapEntities( item_in_hands, focused_item );
								return true;
							}
							else
							{
								InventoryLocation il_hands_dst = new InventoryLocation;
								if( GetGame().GetPlayer().GetHumanInventory().FindFreeLocationFor( item_in_hands, FindInventoryLocationType.ANY, il_hands_dst ) )
								{
									InventoryMode invMode = InventoryMode.PREDICTIVE;
						
									if ( GetGame().GetPlayer().NeedInventoryJunctureFromServer(item_in_hands, item_in_hands.GetHierarchyParent(), il_hands_dst.GetParent()) || GetGame().GetPlayer().NeedInventoryJunctureFromServer(focused_item, focused_item.GetHierarchyParent(), GetGame().GetPlayer()) )
										invMode = InventoryMode.JUNCTURE;
									
									GetGame().GetPlayer().GetHumanInventory().ForceSwapEntities( InventoryMode.JUNCTURE, focused_item, item_in_hands, il_hands_dst );
									return true;
								}
							}
						}
						else
						{
							if( GetGame().GetPlayer().GetHumanInventory().CanAddEntityInHands( focused_item ) )
							{
								GetGame().GetPlayer().PredictiveTakeEntityToHands( focused_item );
								return true;
							}
						}
					}
				}
			}
		}
		return false;
	}
	
	override bool TransferItemToVicinity()
	{
		if (CanDrop())
		{
			if ( GetFocusedContainer().IsInherited( ContainerWithCargo ) || GetFocusedContainer().IsInherited( ContainerWithCargoAndAttachments ) )
			{
				return GetFocusedContainer().TransferItemToVicinity();
			}
			else
			{
				Man player = GetGame().GetPlayer();
				ItemBase item = ItemBase.Cast( GetFocusedItem() );
				if( item && player.CanDropEntity( item ) )
				{
					if( item.GetTargetQuantityMax() < item.GetQuantity() )
						item.SplitIntoStackMaxClient( null, -1 );
					else
						player.PhysicalPredictiveDropItem( item );
					return true;
				}
			}
		}
		return false;
	}
}
